void Com_PrintLogfile( const char *msg )
{
Sys_EnterCriticalSection(5);
if ( com_logfile && com_logfile->integer ) {
// TTimo: only open the qconsole.log if the filesystem is in an initialized state
// also, avoid recursing in the qconsole.log opening (i.e. if fs_debug is on)
if ( !logfile && FS_Initialized()) {
struct tm *newtime;
time_t aclock;
time( &aclock );
newtime = localtime( &aclock );
logfile = FS_FOpenFileWrite( "qconsole.log" );
if ( com_logfile->integer > 1 && logfile ) {
// force it to not buffer so we get valid
// data even if we are crashing
FS_ForceFlush(logfile);
}
if ( logfile ) FS_Write(va("\nLogfile opened on %s\n", asctime( newtime )), strlen(va("\nLogfile opened on %s\n", asctime( newtime ))), logfile);
}
if ( logfile && FS_Initialized())
{
FS_Write(msg, strlen(msg), logfile);
}
}
Sys_LeaveCriticalSection(5);
}
/*
=============
Com_Printf
Both client and server can use this, and it will output
to the apropriate place.
A raw string should NEVER be passed as fmt, because of "%f" type crashers.
=============
*/
void QDECL Com_Printf( const char *fmt, ... ) {
va_list argptr;
char msg[MAXPRINTMSG];
va_start (argptr,fmt);
vsprintf (msg,fmt,argptr);
va_end (argptr);
if ( rd_buffer ) {
if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1)) {
rd_flush(rd_buffer);
*rd_buffer = 0;
}
Q_strcat(rd_buffer, rd_buffersize, msg);
rd_flush(rd_buffer);
*rd_buffer = 0;
return;
}
// echo to console if we're not a dedicated server
if ( com_dedicated && !com_dedicated->integer ) {
CL_ConsolePrint( msg );
}
// echo to dedicated console and early console
Sys_Print( msg );
// logfile
#ifndef _XBOX
if ( com_logfile && com_logfile->integer ) {
if ( !logfile && FS_Initialized() ) {
struct tm *newtime;
time_t aclock;
time( &aclock );
newtime = localtime( &aclock );
logfile = FS_FOpenFileWrite( "qconsole.log" );
Com_Printf( "logfile opened on %s\n", asctime( newtime ) );
if ( com_logfile->integer > 1 ) {
// force it to not buffer so we get valid
// data even if we are crashing
FS_ForceFlush(logfile);
}
}
if ( logfile && FS_Initialized()) {
FS_Write(msg, strlen(msg), logfile);
}
}
#endif
#if defined(_WIN32) && defined(_DEBUG) && !defined(_XBOX)
if ( *msg )
{
OutputDebugString ( Q_CleanStr(msg) );
OutputDebugString ("\n");
}
#endif
}
/*
==================
CL_WriteClientChatLog
==================
*/
void CL_WriteClientChatLog( char *text )
{
if ( cl_logs && cl_logs->integer )
{
if ( LogFileOpened == qfalse || !LogFileHandle )
{
CL_OpenClientLog();
}
if ( FS_Initialized() && LogFileOpened == qtrue )
{
if( cl.serverTime > 0 )
{
// varibles
char NoColorMsg[MAXPRINTMSG];
char Timestamp[ 60 ];
char LogText[ 60 + MAXPRINTMSG ];
if( cl_logs->integer == 1 )
{
//just do 3 stars to seperate from normal logging stuff
Q_strncpyz( Timestamp, "***", sizeof( Timestamp ) );
}
else if ( cl_logs->integer == 2 )
{
//just game time
//do timestamp prep
sprintf( Timestamp, "[%d:%02d]", cl.serverTime / 60000, ( cl.serverTime / 1000 ) % 60 ); //server Time
}
else if ( cl_logs->integer == 3 )
{
//just system time
//do timestamp prep
//get current time/date info
qtime_t now;
Com_RealTime( &now );
sprintf( Timestamp, "[%d:%02d]", now.tm_hour, now.tm_min ); //server Time
}
else if( cl_logs->integer == 4 )
{
//all the data
//do timestamp prep
//get current time/date info
qtime_t now;
Com_RealTime( &now );
sprintf( Timestamp, "[%d:%02d][%d:%02d]", now.tm_hour, now.tm_min, cl.serverTime / 60000, ( cl.serverTime / 1000 ) % 60 ); //server Time
}
//decolor the string
Q_strncpyz( NoColorMsg, text, sizeof(NoColorMsg) );
Q_CleanStr( NoColorMsg );
//prepare text for log
sprintf( LogText, "%s%s\n", Timestamp, NoColorMsg ); //thing to write to log
//write to the file
FS_Write( LogText, strlen( LogText ), LogFileHandle );
//flush the file so we can see the data
FS_ForceFlush( LogFileHandle );
}
}
}
}
void QDECL Com_PrintfAlways( const char *fmt, ... ) {
va_list argptr;
char msg[MAXPRINTMSG];
va_start (argptr,fmt);
vsprintf (msg,fmt,argptr);
va_end (argptr);
#ifndef _XBOX
if ( rd_buffer ) {
if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1)) {
rd_flush(rd_buffer);
*rd_buffer = 0;
}
strcat (rd_buffer, msg);
return;
}
#endif
CL_ConsolePrint( msg );
// echo to dedicated console and early console
#ifndef FINAL_BUILD
Sys_Print( msg );
#ifdef OUTPUT_TO_BUILD_WINDOW
OutputDebugString(msg);
#endif
#endif
#ifndef _XBOX
// logfile
if ( com_logfile && com_logfile->integer ) {
if ( !logfile ) {
logfile = FS_FOpenFileWrite( "qconsole.log" );
if ( com_logfile->integer > 1 ) {
// force it to not buffer so we get valid
// data even if we are crashing
FS_ForceFlush(logfile);
}
}
if ( logfile ) {
FS_Write(msg, strlen(msg), logfile);
}
}
#endif
}
void Com_FlushCamFile()
{
if (!camerafile)
{
// nothing to flush, right?
Com_Printf("No cam file available\n");
return;
}
FS_ForceFlush(camerafile);
FS_FCloseFile (camerafile);
camerafile = 0;
static char flushedMapname[MAX_QPATH];
extern cvar_t *sv_mapname;
Com_sprintf( flushedMapname, MAX_QPATH, "maps/%s_cam.map", sv_mapname->string );
Com_Printf("flushed all cams to %s\n", flushedMapname);
}
/*
=============
Com_Printf
Both client and server can use this, and it will output
to the apropriate place.
A raw string should NEVER be passed as fmt, because of "%f" type crashers.
=============
*/
void QDECL Com_Printf( const char *fmt, ... ) {
va_list argptr;
char msg[MAXPRINTMSG];
va_start (argptr,fmt);
Q_vsnprintf (msg, sizeof(msg), fmt, argptr);
va_end (argptr);
if ( rd_buffer ) {
if ((strlen (msg) + strlen(rd_buffer)) > (unsigned)(rd_buffersize - 1)) {
rd_flush(rd_buffer);
*rd_buffer = 0;
}
Q_strcat (rd_buffer, strlen(rd_buffer), msg);
return;
}
CL_ConsolePrint( msg );
// Strip out color codes because these aren't needed in the log/viewlog or in the output window --eez
Q_StripColor( msg );
// echo to dedicated console and early console
Sys_Print( msg );
#ifdef OUTPUT_TO_BUILD_WINDOW
OutputDebugString(msg);
#endif
// logfile
if ( com_logfile && com_logfile->integer ) {
if ( !logfile ) {
logfile = FS_FOpenFileWrite( "qconsole.log" );
if ( com_logfile->integer > 1 ) {
// force it to not buffer so we get valid
// data even if we are crashing
FS_ForceFlush(logfile);
}
}
if ( logfile ) {
FS_Write(msg, strlen(msg), logfile);
}
}
}
/*
==================
CL_WriteClientLog
==================
*/
void CL_WriteClientLog( char *text ) {
if( cl_logs && cl_logs->integer ) {
if( LogFileOpened == qfalse || !LogFileHandle ) {
CL_OpenClientLog();
}
if( FS_Initialized() && LogFileOpened == qtrue ) {
// varibles
char NoColorMsg[MAXPRINTMSG];
//decolor the string
Q_strncpyz( NoColorMsg, text, sizeof(NoColorMsg) );
Q_CleanStr( NoColorMsg );
//write to the file
FS_Write( NoColorMsg, strlen( NoColorMsg ), LogFileHandle );
//flush the file so we can see the data
FS_ForceFlush( LogFileHandle );
}
}
}
void QDECL SV_EnterLeaveLog( const char *fmt, ... ) {
Sys_EnterCriticalSection(5);
va_list argptr;
char msg[MAXPRINTMSG];
char inputmsg[MAXPRINTMSG];
struct tm *newtime;
char* ltime;
time_t realtime;
// logfile
if ( com_logfile && com_logfile->integer ) {
// TTimo: only open the qconsole.log if the filesystem is in an initialized state
// also, avoid recursing in the qconsole.log opening (i.e. if fs_debug is on)
va_start (argptr,fmt);
Q_vsnprintf (inputmsg, sizeof(inputmsg), fmt, argptr);
va_end (argptr);
Com_UpdateRealtime();
realtime = Com_GetRealtime();
newtime = localtime( &realtime );
ltime = asctime( newtime );
ltime[strlen(ltime)-1] = 0;
if ( !enterleavelogfile && FS_Initialized()) {
enterleavelogfile = FS_FOpenFileAppend( "enterleave.log" );
// force it to not buffer so we get valid
if ( enterleavelogfile ){
FS_ForceFlush(enterleavelogfile);
FS_Write(va("\nLogfile opened on %s\n\n", ltime), strlen(va("\nLogfile opened on %s\n\n", ltime)), enterleavelogfile);
}
}
if ( enterleavelogfile && FS_Initialized()) {
Com_sprintf(msg, sizeof(msg), "%s: %s\n", ltime, inputmsg);
FS_Write(msg, strlen(msg), enterleavelogfile);
}
}
Sys_LeaveCriticalSection(5);
}
void QDECL Com_PrintAdministrativeLog( const char *msg ) {
Sys_EnterCriticalSection(5);
struct tm *newtime;
char* ltime;
time_t realtime;
// logfile
if ( com_logfile && com_logfile->integer ) {
// TTimo: only open the qconsole.log if the filesystem is in an initialized state
// also, avoid recursing in the qconsole.log opening (i.e. if fs_debug is on)
if ( !adminlogfile && FS_Initialized()) {
Com_UpdateRealtime();
realtime = Com_GetRealtime();
newtime = localtime( &realtime );
ltime = asctime( newtime );
ltime[strlen(ltime)-1] = 0;
adminlogfile = FS_FOpenFileAppend( "adminactions.log" );
// force it to not buffer so we get valid
if ( adminlogfile ){
FS_ForceFlush(adminlogfile);
FS_Write(va("\nLogfile opened on %s\n\n", ltime), strlen(va("\nLogfile opened on %s\n\n", ltime)), adminlogfile);
}
}
if ( adminlogfile && FS_Initialized())
{
FS_Write(msg, strlen(msg), adminlogfile);
}
}
Sys_LeaveCriticalSection(5);
}
/*
=============
Com_Printf
Both client and server can use this, and it will output
to the apropriate place.
A raw string should NEVER be passed as fmt, because of "%f" type crashers.
=============
*/
void QDECL Com_Printf( const char *fmt, ... ) {
va_list argptr;
char msg[MAXPRINTMSG];
va_start (argptr,fmt);
vsprintf (msg,fmt,argptr);
va_end (argptr);
if ( rd_buffer ) {
if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1)) {
rd_flush(rd_buffer);
*rd_buffer = 0;
}
strcat (rd_buffer, msg);
return;
}
CL_ConsolePrint( msg );
// echo to dedicated console and early console
Sys_Print( msg );
// logfile
if ( com_logfile && com_logfile->integer ) {
if ( !logfile ) {
logfile = FS_FOpenFileWrite( "qconsole.log" );
if ( com_logfile->integer > 1 ) {
// force it to not buffer so we get valid
// data even if we are crashing
FS_ForceFlush(logfile);
}
}
if ( logfile ) {
FS_Write(msg, strlen(msg), logfile);
}
}
}
void Com_Frame( void ) {
try
{
int timeBeforeFirstEvents = 0, timeBeforeServer = 0, timeBeforeEvents = 0, timeBeforeClient = 0, timeAfter = 0;
int msec, minMsec;
static int lastTime = 0;
// write config file if anything changed
Com_WriteConfiguration();
//
// main event loop
//
if ( com_speeds->integer ) {
timeBeforeFirstEvents = Sys_Milliseconds ();
}
// we may want to spin here if things are going too fast
if ( com_maxfps->integer > 0 ) {
minMsec = 1000 / com_maxfps->integer;
} else {
minMsec = 1;
}
do {
com_frameTime = Com_EventLoop();
if ( lastTime > com_frameTime ) {
lastTime = com_frameTime; // possible on first frame
}
msec = com_frameTime - lastTime;
} while ( msec < minMsec );
Cbuf_Execute ();
lastTime = com_frameTime;
// mess with msec if needed
com_frameMsec = msec;
float fractionMsec=0.0f;
msec = Com_ModifyMsec( msec, fractionMsec);
//
// server side
//
if ( com_speeds->integer ) {
timeBeforeServer = Sys_Milliseconds ();
}
SV_Frame (msec, fractionMsec);
//
// client system
//
// if ( !com_dedicated->integer )
{
//
// run event loop a second time to get server to client packets
// without a frame of latency
//
if ( com_speeds->integer ) {
timeBeforeEvents = Sys_Milliseconds ();
}
Com_EventLoop();
Cbuf_Execute ();
//
// client side
//
if ( com_speeds->integer ) {
timeBeforeClient = Sys_Milliseconds ();
}
CL_Frame (msec, fractionMsec);
if ( com_speeds->integer ) {
timeAfter = Sys_Milliseconds ();
}
}
//
// report timing information
//
if ( com_speeds->integer ) {
int all, sv, ev, cl;
all = timeAfter - timeBeforeServer;
sv = timeBeforeEvents - timeBeforeServer;
ev = timeBeforeServer - timeBeforeFirstEvents + timeBeforeClient - timeBeforeEvents;
cl = timeAfter - timeBeforeClient;
sv -= time_game;
cl -= time_frontend + time_backend;
Com_Printf("fr:%i all:%3i sv:%3i ev:%3i cl:%3i gm:%3i tr:%3i pvs:%3i rf:%3i bk:%3i\n",
com_frameNumber, all, sv, ev, cl, time_game, timeInTrace, timeInPVSCheck, time_frontend, time_backend);
// speedslog
if ( com_speedslog && com_speedslog->integer )
{
if(!speedslog)
{
speedslog = FS_FOpenFileWrite("speeds.log");
FS_Write("data={\n", strlen("data={\n"), speedslog);
bComma=false;
if ( com_speedslog->integer > 1 )
{
// force it to not buffer so we get valid
// data even if we are crashing
FS_ForceFlush(logfile);
}
}
if (speedslog)
{
char msg[MAXPRINTMSG];
if(bComma)
{
FS_Write(",\n", strlen(",\n"), speedslog);
bComma=false;
}
FS_Write("{", strlen("{"), speedslog);
Com_sprintf(msg,sizeof(msg),
"%8.4f,%8.4f,%8.4f,%8.4f,%8.4f,%8.4f,",corg[0],corg[1],corg[2],cangles[0],cangles[1],cangles[2]);
FS_Write(msg, strlen(msg), speedslog);
Com_sprintf(msg,sizeof(msg),
"%i,%3i,%3i,%3i,%3i,%3i,%3i,%3i,%3i,%3i}",
com_frameNumber, all, sv, ev, cl, time_game, timeInTrace, timeInPVSCheck, time_frontend, time_backend);
FS_Write(msg, strlen(msg), speedslog);
bComma=true;
}
}
timeInTrace = timeInPVSCheck = 0;
}
//
// trace optimization tracking
//
if ( com_showtrace->integer ) {
extern int c_traces, c_brush_traces, c_patch_traces;
extern int c_pointcontents;
/*
Com_Printf( "%4i non-sv_traces, %4i sv_traces, %4i ms, ave %4.2f ms\n", c_traces - numTraces, numTraces, timeInTrace, (float)timeInTrace/(float)numTraces );
timeInTrace = numTraces = 0;
c_traces = 0;
*/
Com_Printf ("%4i traces (%ib %ip) %4i points\n", c_traces,
c_brush_traces, c_patch_traces, c_pointcontents);
c_traces = 0;
c_brush_traces = 0;
c_patch_traces = 0;
c_pointcontents = 0;
}
if ( com_affinity->modified )
{
com_affinity->modified = qfalse;
Sys_SetProcessorAffinity();
}
com_frameNumber++;
}
catch ( int code )
{
Com_CatchError (code);
Com_Printf ("%s\n", Com_ErrorString (code));
return;
}
#ifdef G2_PERFORMANCE_ANALYSIS
if (com_G2Report && com_G2Report->integer)
{
re.G2Time_ReportTimers();
}
re.G2Time_ResetTimers();
#endif
}
/*
=============
Com_Printf
Both client and server can use this, and it will output
to the apropriate place.
A raw string should NEVER be passed as fmt, because of "%f" type crashers.
=============
*/
void QDECL Com_Printf( const char *fmt, ... ) {
va_list argptr;
char msg[MAXPRINTMSG];
static qboolean opening_qconsole = qfalse;
va_start (argptr,fmt);
Q_vsnprintf (msg, sizeof(msg), fmt, argptr);
va_end (argptr);
if ( rd_buffer ) {
if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1)) {
rd_flush(rd_buffer);
*rd_buffer = 0;
}
Q_strcat(rd_buffer, rd_buffersize, msg);
// TTimo nooo .. that would defeat the purpose
//rd_flush(rd_buffer);
//*rd_buffer = 0;
return;
}
// echo to console if we're not a dedicated server
if ( com_dedicated && !com_dedicated->integer ) {
CL_ConsolePrint( msg );
}
// echo to dedicated console and early console
Sys_Print( msg );
// logfile
if ( com_logfile && com_logfile->integer ) {
// TTimo: only open the qconsole.log if the filesystem is in an initialized state
// also, avoid recursing in the qconsole.log opening (i.e. if fs_debug is on)
if ( !logfile && FS_Initialized() && !opening_qconsole ) {
struct tm *newtime;
time_t aclock;
opening_qconsole = qtrue;
time( &aclock );
newtime = localtime( &aclock );
logfile = FS_FOpenFileWrite( "qconsole.log" );
if ( logfile ) {
Com_Printf( "logfile opened on %s\n", asctime( newtime ) );
if ( com_logfile->integer > 1 ) {
// force it to not buffer so we get valid
// data even if we are crashing
FS_ForceFlush(logfile);
}
}
else {
Com_Printf( "Opening qconsole.log failed!\n" );
Cvar_SetValue( "logfile", 0 );
}
}
opening_qconsole = qfalse;
if ( logfile && FS_Initialized()) {
FS_Write(msg, strlen(msg), logfile);
}
}
#if defined(_WIN32) && defined(_DEBUG)
if ( *msg )
{
OutputDebugString ( Q_CleanStr(msg) );
OutputDebugString ("\n");
}
#endif
}
