/*
* CL_ShutdownInput
*/
void CL_ShutdownInput( void )
{
if( !in_initialized )
return;
Cmd_RemoveCommand( "in_restart" );
IN_Shutdown();
Cmd_RemoveCommand( "centerview" );
Cmd_RemoveCommand( "+moveup" );
Cmd_RemoveCommand( "-moveup" );
Cmd_RemoveCommand( "+movedown" );
Cmd_RemoveCommand( "-movedown" );
Cmd_RemoveCommand( "+left" );
Cmd_RemoveCommand( "-left" );
Cmd_RemoveCommand( "+right" );
Cmd_RemoveCommand( "-right" );
Cmd_RemoveCommand( "+forward" );
Cmd_RemoveCommand( "-forward" );
Cmd_RemoveCommand( "+back" );
Cmd_RemoveCommand( "-back" );
Cmd_RemoveCommand( "+lookup" );
Cmd_RemoveCommand( "-lookup" );
Cmd_RemoveCommand( "+lookdown" );
Cmd_RemoveCommand( "-lookdown" );
Cmd_RemoveCommand( "+strafe" );
Cmd_RemoveCommand( "-strafe" );
Cmd_RemoveCommand( "+moveleft" );
Cmd_RemoveCommand( "-moveleft" );
Cmd_RemoveCommand( "+moveright" );
Cmd_RemoveCommand( "-moveright" );
Cmd_RemoveCommand( "+speed" );
Cmd_RemoveCommand( "-speed" );
Cmd_RemoveCommand( "+attack" );
Cmd_RemoveCommand( "-attack" );
Cmd_RemoveCommand( "+use" );
Cmd_RemoveCommand( "-use" );
Cmd_RemoveCommand( "+klook" );
Cmd_RemoveCommand( "-klook" );
// wsw
Cmd_RemoveCommand( "+special" );
Cmd_RemoveCommand( "-special" );
Cmd_RemoveCommand( "+zoom" );
Cmd_RemoveCommand( "-zoom" );
Dynvar_Destroy( Dynvar_Lookup( "m_filterBufferDecay" ) );
Dynvar_Destroy( Dynvar_Lookup( "m_filterBufferSize" ) );
Mem_ZoneFree( buf_x );
Mem_ZoneFree( buf_y );
in_initialized = true;
}
void Irc_Disconnect_f( void )
{
if( irc_libhandle )
{
bool *c;
if( !irc_server )
irc_server = Cvar_Get( "irc_server", "", 0 );
if( !irc_connected )
irc_connected = Dynvar_Lookup( "irc_connected" );
assert( irc_connected );
assert( irc_server );
Dynvar_GetValue( irc_connected, (void **) &c );
if( *c )
{
// still connected, proceed
if( irc_wakelock )
{
Sys_ReleaseWakeLock( irc_wakelock );
irc_wakelock = NULL;
}
irc_export->Disconnect();
Dynvar_RemoveListener( irc_connected, Irc_ConnectedListener_f );
}
else
Com_Printf( "Not connected.\n" );
}
else
Com_Printf( "IRC module not loaded. Connect first.\n" );
}
/*
* Com_Quit
*
* Both client and server can use this, and it will
* do the apropriate things.
*/
void Com_Quit( void )
{
if( dynvars_initialized )
{
dynvar_t *quit = Dynvar_Lookup( "quit" );
if( quit )
{
// wsw : aiwa : added "quit" event for pluggable clean-up (e.g. IRC shutdown)
Dynvar_CallListeners( quit, NULL );
}
Dynvar_Destroy( quit );
}
SV_Shutdown( "Server quit\n" );
CL_Shutdown();
MM_Shutdown();
if( log_file )
{
FS_FCloseFile( log_file );
log_file = 0;
}
Sys_Quit();
}
static void Dynvar_Set_f( void )
{
if( Cmd_Argc() == 3 )
{
dynvar_t *dynvar;
dynvar = Dynvar_Lookup( Cmd_Argv( 1 ) );
if( dynvar )
{
if( dynvar->console )
{
dynvar_set_status_t status = Dynvar_SetValue( dynvar, Cmd_Argv( 2 ) );
switch( status )
{
case DYNVAR_SET_OK:
break;
case DYNVAR_SET_READONLY:
Com_Printf( (char *) DYNVAR_SET_READONLY_MSG, Dynvar_GetName( dynvar ) );
break;
case DYNVAR_SET_INVALID:
Com_Printf( (char *) DYNVAR_SET_INVALID_MSG, Cmd_Argv( 2 ), Dynvar_GetName( dynvar ) );
break;
case DYNVAR_SET_TRANSIENT:
Com_Printf( (char *) DYNVAR_TRANSIENT_MSG, Dynvar_GetName( dynvar ) );
break;
}
}
else
Com_Printf( (char *) DYNVAR_NOT_FOUND_MSG, Dynvar_GetName( dynvar ) );
}
else
Com_Printf( (char *) DYNVAR_NOT_FOUND_MSG, Cmd_Argv( 1 ) );
}
else
Com_Printf( "usage: setdyn <dynvar> <value>\n" );
}
static void Irc_UnloadLibrary( void )
{
assert( irc_libhandle );
if( irc_initialized )
{
dynvar_t *const quit = Dynvar_Lookup( "quit" );
bool *c;
if( !irc_connected )
irc_connected = Dynvar_Lookup( "irc_connected" );
Dynvar_GetValue( irc_connected, (void **) &c );
if( *c )
irc_export->Disconnect();
irc_export->Shutdown();
Cmd_RemoveCommand( "irc_unload" );
if( quit )
Dynvar_RemoveListener( quit, Irc_Quit_f );
irc_initialized = false;
}
Com_UnloadLibrary( &irc_libhandle );
assert( !irc_libhandle );
Com_Printf( "IRC module unloaded.\n" );
}
bool Irc_IsConnected( void )
{
if( irc_libhandle ) {
bool *c;
if( !irc_connected )
irc_connected = Dynvar_Lookup( "irc_connected" );
assert( irc_connected );
Dynvar_GetValue( irc_connected, (void **) &c );
if( *c ) {
return true;
}
}
return false;
}
qboolean Dynvar_Command( void )
{
dynvar_t *dynvar = Dynvar_Lookup( Cmd_Argv( 0 ) );
if( dynvar && dynvar->console )
{
// dynvar exists and is console-accessible
if( Cmd_Argc() == 1 )
{
void *value;
dynvar_get_status_t status = Dynvar_GetValue( dynvar, &value );
switch( status )
{
case DYNVAR_GET_OK:
Com_Printf( "\"%s\" is \"%s\"\n", Dynvar_GetName( dynvar ), (char *) value );
break;
case DYNVAR_GET_WRITEONLY:
Com_Printf( (char *) DYNVAR_GET_WRITEONLY_MSG, Dynvar_GetName( dynvar ) );
break;
case DYNVAR_GET_TRANSIENT:
Com_Printf( (char *) DYNVAR_TRANSIENT_MSG, Dynvar_GetName( dynvar ) );
break;
}
}
else
{
dynvar_set_status_t status = Dynvar_SetValue( dynvar, Cmd_Argv( 1 ) );
switch( status )
{
case DYNVAR_SET_OK:
break;
case DYNVAR_SET_READONLY:
Com_Printf( (char *) DYNVAR_SET_READONLY_MSG, Dynvar_GetName( dynvar ) );
break;
case DYNVAR_SET_INVALID:
Com_Printf( (char *) DYNVAR_SET_INVALID_MSG, Cmd_Argv( 1 ), Dynvar_GetName( dynvar ) );
break;
case DYNVAR_SET_TRANSIENT:
Com_Printf( (char *) DYNVAR_TRANSIENT_MSG, Dynvar_GetName( dynvar ) );
break;
}
}
return qtrue;
}
else
// dynvar does not exist or is inaccessible
return qfalse;
}
void Irc_Connect_f( void )
{
const int argc = Cmd_Argc();
if( argc <= 3 )
{
if( !irc_libhandle )
Irc_LoadLibrary(); // load IRC library if not already loaded
if( irc_libhandle )
{
// library loaded, check for connection status
bool *c;
if( !irc_server )
irc_server = Cvar_Get( "irc_server", "irc.quakenet.org", CVAR_ARCHIVE );
if( !irc_connected )
irc_connected = Dynvar_Lookup( "irc_connected" );
assert( irc_server );
assert( irc_connected );
Dynvar_GetValue( irc_connected, (void **) &c );
if( !*c )
{
// not connected yet
if( argc >= 2 )
Cvar_Set( "irc_server", Cmd_Argv( 1 ) );
if( argc >= 3 )
Cvar_Set( "irc_port", Cmd_Argv( 2 ) );
Dynvar_AddListener( irc_connected, Irc_ConnectedListener_f );
irc_export->Connect();
Dynvar_GetValue( irc_connected, (void **) &c );
if( *c )
{
irc_wakelock = Sys_AcquireWakeLock();
}
else
{
// connect failed
Com_Printf( "Could not connect to %s (%s).\n", Cvar_GetStringValue( irc_server ), irc_export->ERROR_MSG );
Dynvar_RemoveListener( irc_connected, Irc_ConnectedListener_f );
}
}
else
Com_Printf( "Already connected.\n" );
}
}
else
Com_Printf( "usage: irc_connect [<server>] [<port>]" );
}
static void Irc_LoadLibrary( void )
{
static irc_import_t import;
dllfunc_t funcs[2];
GetIrcAPI_t GetIrcAPI_f;
assert( !irc_libhandle );
import.Printf = Irc_Print;
import.CL_GetKeyDest = CL_GetKeyDest;
import.CL_GetClientState = CL_GetClientState;
import.Key_DelegatePush = Key_DelegatePush;
import.Key_DelegatePop = Key_DelegatePop;
import.SCR_RegisterFont = SCR_RegisterFont;
import.SCR_DrawString = SCR_DrawString;
import.SCR_DrawStringWidth = SCR_DrawStringWidth;
import.SCR_DrawRawChar = SCR_DrawRawChar;
import.SCR_strHeight = SCR_FontHeight;
import.SCR_strWidth = SCR_strWidth;
import.SCR_StrlenForWidth = SCR_StrlenForWidth;
import.SCR_GetScreenWidth = SCR_GetScreenWidth;
import.SCR_GetScreenHeight = SCR_GetScreenHeight;
import.R_RegisterPic = SCR_RegisterPic;
import.R_DrawStretchPic = SCR_DrawStretchPic;
import.Sys_Milliseconds = Sys_Milliseconds;
import.Sys_Microseconds = Sys_Microseconds;
import.Mem_AllocPool = Irc_MemAllocPool;
import.Mem_Alloc = Irc_MemAlloc;
import.Mem_Free = Irc_MemFree;
import.Mem_FreePool = Irc_MemFreePool;
import.Mem_EmptyPool = Irc_MemEmptyPool;
import.Dynvar_Create = Dynvar_Create;
import.Dynvar_Destroy = Dynvar_Destroy;
import.Dynvar_Lookup = Dynvar_Lookup;
import.Dynvar_GetName = Dynvar_GetName;
import.Dynvar_GetValue = Dynvar_GetValue;
import.Dynvar_SetValue = Dynvar_SetValue;
import.Dynvar_CallListeners = Dynvar_CallListeners;
import.Dynvar_AddListener = Dynvar_AddListener;
import.Dynvar_RemoveListener = Dynvar_RemoveListener;
import.DYNVAR_WRITEONLY = DYNVAR_WRITEONLY;
import.DYNVAR_READONLY = DYNVAR_READONLY;
import.Cvar_Get = Cvar_Get;
import.Cvar_Set = Cvar_Set;
import.Cvar_SetValue = Cvar_SetValue;
import.Cvar_ForceSet = Cvar_ForceSet;
import.Cvar_Integer = Cvar_Integer;
import.Cvar_Value = Cvar_Value;
import.Cvar_String = Cvar_String;
import.Cmd_Argc = Cmd_Argc;
import.Cmd_Argv = Cmd_Argv;
import.Cmd_Args = Cmd_Args;
import.Cmd_AddCommand = Cmd_AddCommand;
import.Cmd_RemoveCommand = Cmd_RemoveCommand;
import.Cmd_ExecuteString = Cmd_ExecuteString;
import.Com_BeginRedirect = Com_BeginRedirect;
import.Com_EndRedirect = Com_EndRedirect;
import.Cmd_SetCompletionFunc = Cmd_SetCompletionFunc;
import.Cbuf_AddText = Cbuf_AddText;
import.Trie_Create = Trie_Create;
import.Trie_Destroy = Trie_Destroy;
import.Trie_Clear = Trie_Clear;
import.Trie_GetSize = Trie_GetSize;
import.Trie_Insert = Trie_Insert;
import.Trie_Remove = Trie_Remove;
import.Trie_Replace = Trie_Replace;
import.Trie_Find = Trie_Find;
import.Trie_FindIf = Trie_FindIf;
import.Trie_NoOfMatches = Trie_NoOfMatches;
import.Trie_NoOfMatchesIf = Trie_NoOfMatchesIf;
import.Trie_Dump = Trie_Dump;
import.Trie_DumpIf = Trie_DumpIf;
import.Trie_FreeDump = Trie_FreeDump;
// load dynamic library
Com_Printf( "Loading IRC module... " );
funcs[0].name = "GetIrcAPI";
funcs[0].funcPointer = (void **) &GetIrcAPI_f;
funcs[1].name = NULL;
irc_libhandle = Com_LoadLibrary( LIB_DIRECTORY "/" LIB_PREFIX "irc_" ARCH LIB_SUFFIX, funcs );
if( irc_libhandle )
{
// load succeeded
int api_version;
irc_export = GetIrcAPI_f( &import );
irc_pool = Mem_AllocPool( NULL, "IRC Module" );
api_version = irc_export->API();
if( api_version == IRC_API_VERSION )
{
if( irc_export->Init() )
{
dynvar_t *const quit = Dynvar_Lookup( "quit" );
if( quit )
Dynvar_AddListener( quit, Irc_Quit_f );
irc_initialized = true;
Cmd_AddCommand( "irc_unload", Irc_UnloadLibrary );
Com_Printf( "Success.\n" );
}
else
{
// initialization failed
Mem_FreePool( &irc_pool );
Com_Printf( "Initialization failed.\n" );
Irc_UnloadLibrary();
}
}
else
{
// wrong version
Mem_FreePool( &irc_pool );
Com_Printf( "Wrong version: %i, not %i.\n", api_version, IRC_API_VERSION );
Irc_UnloadLibrary();
}
}
else
{
Com_Printf( "Not found.\n" );
}
Mem_DebugCheckSentinelsGlobal();
}
/*
* Qcommon_Frame
*/
void Qcommon_Frame( unsigned int realmsec )
{
static dynvar_t *frametick = NULL;
static quint64 fc = 0;
char *s;
int time_before = 0, time_between = 0, time_after = 0;
static unsigned int gamemsec;
if( setjmp( abortframe ) )
return; // an ERR_DROP was thrown
if( log_stats->modified )
{
log_stats->modified = qfalse;
if( log_stats->integer && !log_stats_file )
{
if( FS_FOpenFile( "stats.log", &log_stats_file, FS_WRITE ) != -1 )
{
FS_Printf( log_stats_file, "entities,dlights,parts,frame time\n" );
}
else
{
log_stats_file = 0;
}
}
else if( log_stats_file )
{
FS_FCloseFile( log_stats_file );
log_stats_file = 0;
}
}
if( fixedtime->integer > 0 )
{
gamemsec = fixedtime->integer;
}
else if( timescale->value >= 0 )
{
static float extratime = 0.0f;
gamemsec = extratime + (float)realmsec * timescale->value;
extratime = ( extratime + (float)realmsec * timescale->value ) - (float)gamemsec;
}
else
{
gamemsec = realmsec;
}
if( com_showtrace->integer )
{
Com_Printf( "%4i traces %4i brush traces %4i points\n",
c_traces, c_brush_traces, c_pointcontents );
c_traces = 0;
c_brush_traces = 0;
c_pointcontents = 0;
}
wswcurl_perform();
FS_Frame();
Steam_RunFrame();
if( dedicated->integer )
{
do
{
s = Sys_ConsoleInput();
if( s )
Cbuf_AddText( va( "%s\n", s ) );
}
while( s );
Cbuf_Execute();
}
// keep the random time dependent
rand();
if( host_speeds->integer )
time_before = Sys_Milliseconds();
SV_Frame( realmsec, gamemsec );
if( host_speeds->integer )
time_between = Sys_Milliseconds();
CL_Frame( realmsec, gamemsec );
if( host_speeds->integer )
time_after = Sys_Milliseconds();
if( host_speeds->integer )
{
int all, sv, gm, cl, rf;
all = time_after - time_before;
sv = time_between - time_before;
cl = time_after - time_between;
gm = time_after_game - time_before_game;
rf = time_after_ref - time_before_ref;
sv -= gm;
cl -= rf;
Com_Printf( "all:%3i sv:%3i gm:%3i cl:%3i rf:%3i\n",
all, sv, gm, cl, rf );
}
MM_Frame( realmsec );
// wsw : aiwa : generic observer pattern to plug in arbitrary functionality
if( !frametick )
frametick = Dynvar_Lookup( "frametick" );
Dynvar_CallListeners( frametick, &fc );
++fc;
}
