/* * 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; }