/* =========================================================================== Copyright (C) 1999-2005 Id Software, Inc. Copyright (C) 2002-2009 Q3Rally Team (Per Thormann - perle@q3rally.com) This file is part of q3rally source code. q3rally source code is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. q3rally source code is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with q3rally; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA =========================================================================== */ // #include "g_local.h" level_locals_t level; typedef struct { vmCvar_t *vmCvar; char *cvarName; char *defaultString; int cvarFlags; int modificationCount; // for tracking changes qboolean trackChange; // track this variable, and announce if changed qboolean teamShader; // track and if changed, update shader state } cvarTable_t; gentity_t g_entities[MAX_GENTITIES]; gclient_t g_clients[MAX_CLIENTS]; vmCvar_t g_gametype; vmCvar_t g_dmflags; vmCvar_t g_fraglimit; // STONELANCE vmCvar_t g_laplimit; // END vmCvar_t g_timelimit; vmCvar_t g_capturelimit; vmCvar_t g_friendlyFire; vmCvar_t g_password; vmCvar_t g_needpass; vmCvar_t g_maxclients; vmCvar_t g_maxGameClients; vmCvar_t g_dedicated; vmCvar_t g_speed; vmCvar_t g_gravity; vmCvar_t g_cheats; vmCvar_t g_knockback; vmCvar_t g_quadfactor; vmCvar_t g_forcerespawn; vmCvar_t g_inactivity; vmCvar_t g_debugMove; vmCvar_t g_debugDamage; vmCvar_t g_debugAlloc; vmCvar_t g_weaponRespawn; vmCvar_t g_weaponTeamRespawn; vmCvar_t g_motd; vmCvar_t g_synchronousClients; vmCvar_t g_warmup; vmCvar_t g_doWarmup; vmCvar_t g_restarted; vmCvar_t g_log; vmCvar_t g_logSync; vmCvar_t g_blood; vmCvar_t g_podiumDist; vmCvar_t g_podiumDrop; vmCvar_t g_allowVote; vmCvar_t g_teamAutoJoin; vmCvar_t g_teamForceBalance; vmCvar_t g_banIPs; vmCvar_t g_filterBan; vmCvar_t g_smoothClients; vmCvar_t pmove_fixed; vmCvar_t pmove_msec; vmCvar_t g_rankings; vmCvar_t g_listEntity; #ifdef MISSIONPACK vmCvar_t g_obeliskHealth; vmCvar_t g_obeliskRegenPeriod; vmCvar_t g_obeliskRegenAmount; vmCvar_t g_obeliskRespawnDelay; vmCvar_t g_cubeTimeout; vmCvar_t g_redteam; vmCvar_t g_blueteam; vmCvar_t g_singlePlayer; vmCvar_t g_enableDust; vmCvar_t g_enableBreath; vmCvar_t g_proxMineTimeout; #endif // STONELANCE vmCvar_t g_forceEngineStart; vmCvar_t g_finishRaceDelay; vmCvar_t g_trackReversed; vmCvar_t g_trackLength; vmCvar_t g_developer; vmCvar_t g_damageScale; vmCvar_t g_humanplayers; // car variables vmCvar_t car_spring; vmCvar_t car_shock_up; vmCvar_t car_shock_down; vmCvar_t car_swaybar; vmCvar_t car_wheel; vmCvar_t car_wheel_damp; vmCvar_t car_frontweight_dist; vmCvar_t car_IT_xScale; vmCvar_t car_IT_yScale; vmCvar_t car_IT_zScale; vmCvar_t car_body_elasticity; vmCvar_t car_air_cof; vmCvar_t car_air_frac_to_df; vmCvar_t car_friction_scale; // END // bk001129 - made static to avoid aliasing static cvarTable_t gameCvarTable[] = { // don't override the cheat state set by the system { &g_cheats, "sv_cheats", "", 0, 0, qfalse }, // noset vars { NULL, "gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, { NULL, "gamedate", __DATE__ , CVAR_ROM, 0, qfalse }, { &g_restarted, "g_restarted", "0", CVAR_ROM, 0, qfalse }, { NULL, "sv_mapname", "", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, // latched vars // STONELANCE - change default // { &g_gametype, "g_gametype", "0", CVAR_SERVERINFO | CVAR_USERINFO | CVAR_LATCH, 0, qfalse }, { &g_gametype, "g_gametype", "1", CVAR_SERVERINFO | CVAR_LATCH, 0, qfalse }, // END { &g_maxclients, "sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qfalse }, { &g_maxGameClients, "g_maxGameClients", "0", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qfalse }, // change anytime vars { &g_dmflags, "dmflags", "0", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue }, { &g_fraglimit, "fraglimit", "20", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, // STONELANCE { &g_laplimit, "laplimit", "5", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, // END { &g_timelimit, "timelimit", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, { &g_capturelimit, "capturelimit", "8", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, { &g_synchronousClients, "g_synchronousClients", "0", CVAR_SYSTEMINFO, 0, qfalse }, { &g_friendlyFire, "g_friendlyFire", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_teamAutoJoin, "g_teamAutoJoin", "0", CVAR_ARCHIVE }, { &g_teamForceBalance, "g_teamForceBalance", "0", CVAR_ARCHIVE }, { &g_warmup, "g_warmup", "20", CVAR_ARCHIVE, 0, qtrue }, { &g_doWarmup, "g_doWarmup", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_log, "g_log", "games.log", CVAR_ARCHIVE, 0, qfalse }, { &g_logSync, "g_logSync", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_password, "g_password", "", CVAR_USERINFO, 0, qfalse }, { &g_banIPs, "g_banIPs", "", CVAR_ARCHIVE, 0, qfalse }, { &g_filterBan, "g_filterBan", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_needpass, "g_needpass", "0", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, { &g_dedicated, "dedicated", "0", 0, 0, qfalse }, { &g_speed, "g_speed", "320", 0, 0, qtrue }, // STONELANCE // { &g_gravity, "g_gravity", "800", 0, 0, qtrue }, { &g_gravity, "g_gravity", "1100", 0, 0, qtrue }, // END { &g_knockback, "g_knockback", "1000", 0, 0, qtrue }, { &g_quadfactor, "g_quadfactor", "3", 0, 0, qtrue }, { &g_weaponRespawn, "g_weaponrespawn", "5", 0, 0, qtrue }, { &g_weaponTeamRespawn, "g_weaponTeamRespawn", "30", 0, 0, qtrue }, { &g_forcerespawn, "g_forcerespawn", "20", 0, 0, qtrue }, { &g_inactivity, "g_inactivity", "0", 0, 0, qtrue }, { &g_debugMove, "g_debugMove", "0", 0, 0, qfalse }, { &g_debugDamage, "g_debugDamage", "0", 0, 0, qfalse }, { &g_debugAlloc, "g_debugAlloc", "0", 0, 0, qfalse }, { &g_motd, "g_motd", "", 0, 0, qfalse }, { &g_blood, "com_blood", "1", 0, 0, qfalse }, { &g_podiumDist, "g_podiumDist", "80", 0, 0, qfalse }, { &g_podiumDrop, "g_podiumDrop", "70", 0, 0, qfalse }, { &g_allowVote, "g_allowVote", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_listEntity, "g_listEntity", "0", 0, 0, qfalse }, #ifdef MISSIONPACK { &g_obeliskHealth, "g_obeliskHealth", "2500", 0, 0, qfalse }, { &g_obeliskRegenPeriod, "g_obeliskRegenPeriod", "1", 0, 0, qfalse }, { &g_obeliskRegenAmount, "g_obeliskRegenAmount", "15", 0, 0, qfalse }, { &g_obeliskRespawnDelay, "g_obeliskRespawnDelay", "10", CVAR_SERVERINFO, 0, qfalse }, { &g_cubeTimeout, "g_cubeTimeout", "30", 0, 0, qfalse }, { &g_redteam, "g_redteam", "Stroggs", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO , 0, qtrue, qtrue }, { &g_blueteam, "g_blueteam", "Pagans", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO , 0, qtrue, qtrue }, { &g_singlePlayer, "ui_singlePlayerActive", "", 0, 0, qfalse, qfalse }, { &g_enableDust, "g_enableDust", "0", CVAR_SERVERINFO, 0, qtrue, qfalse }, { &g_enableBreath, "g_enableBreath", "0", CVAR_SERVERINFO, 0, qtrue, qfalse }, { &g_proxMineTimeout, "g_proxMineTimeout", "20000", 0, 0, qfalse }, #endif { &g_smoothClients, "g_smoothClients", "1", 0, 0, qfalse}, // STONELANCE // { &pmove_fixed, "pmove_fixed", "0", CVAR_SYSTEMINFO, 0, qfalse}, // { &pmove_msec, "pmove_msec", "8", CVAR_SYSTEMINFO, 0, qfalse}, { &pmove_fixed, "pmove_fixed", "1", CVAR_SYSTEMINFO, 0, qfalse}, { &pmove_msec, "pmove_msec", "18", CVAR_SYSTEMINFO, 0, qfalse}, // UPDATE : needs to be server info? { &g_trackReversed, "g_trackReversed", "0", CVAR_LATCH, 0, qfalse }, { &g_trackLength, "g_trackLength", "0", CVAR_LATCH, 0, qfalse }, { &g_forceEngineStart, "g_forceEngineStart", "60", CVAR_ARCHIVE, 0, qfalse }, { &g_finishRaceDelay, "g_finishRaceDelay", "30", CVAR_ARCHIVE, 0, qfalse }, { &g_developer, "developer", "0", 0, 0, qfalse }, { &g_humanplayers, "g_humanplayers", "0", CVAR_ROM | CVAR_NORESTART, 0, qfalse }, // car variables // FIXME: should really be serverinfo so there are no client prediction problems { &car_spring, "car_spring", "120", 0, 0, qfalse }, { &car_shock_up, "car_shock_up", "12", 0, 0, qfalse }, { &car_shock_down, "car_shock_down", "11", 0, 0, qfalse }, { &car_swaybar, "car_swaybar", "20", 0, 0, qfalse }, { &car_wheel, "car_wheel", "2400", 0, 0, qfalse }, { &car_wheel_damp, "car_wheel_damp", "140", 0, 0, qfalse }, { &car_frontweight_dist, "car_frontweight_dist", "0.5", 0, 0, qfalse }, { &car_IT_xScale, "car_IT_xScale", "1.0", 0, 0, qfalse }, { &car_IT_yScale, "car_IT_yScale", "1.0", 0, 0, qfalse }, { &car_IT_zScale, "car_IT_zScale", "1.0", 0, 0, qfalse }, { &car_body_elasticity, "car_body_elasticity", "0.05", 0, 0, qfalse }, { &car_air_cof, "car_air_cof", "0.31", 0, 0, qfalse }, { &car_air_frac_to_df, "car_air_frac_to_df", "0.5", 0, 0, qfalse }, { &car_friction_scale, "car_friction_scale", "1.1", 0, 0, qfalse }, { &g_damageScale, "g_damageScale", "0.3", CVAR_ARCHIVE, 0, qfalse }, // END { &g_rankings, "g_rankings", "0", 0, 0, qfalse} }; static int gameCvarTableSize = ARRAY_LEN( gameCvarTable ); void G_InitGame( int levelTime, int randomSeed, int restart ); void G_RunFrame( int levelTime ); void G_ShutdownGame( int restart ); void CheckExitRules( void ); /* ================ vmMain This is the only way control passes into the module. This must be the very first function compiled into the .q3vm file ================ */ Q_EXPORT intptr_t vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11 ) { switch ( command ) { case GAME_INIT: // STONELANCE // G_DebugLogPrintf("INIT\n"); // END G_InitGame( arg0, arg1, arg2 ); return 0; case GAME_SHUTDOWN: // STONELANCE // G_DebugLogPrintf("SHUTDOWN\n"); // END G_ShutdownGame( arg0 ); return 0; case GAME_CLIENT_CONNECT: // STONELANCE // G_DebugLogPrintf("CLIENT CONNECT\n"); // END return (intptr_t)ClientConnect( arg0, arg1, arg2 ); case GAME_CLIENT_THINK: // STONELANCE // if (level.intermissiontime) // G_DebugLogPrintf("CLIENT THINK %d\n", arg0); // END ClientThink( arg0 ); return 0; case GAME_CLIENT_USERINFO_CHANGED: // STONELANCE // G_DebugLogPrintf("USERINFO_CHANGED\n"); // END ClientUserinfoChanged( arg0 ); return 0; case GAME_CLIENT_DISCONNECT: // STONELANCE // G_DebugLogPrintf("DISCONNECT\n"); // END ClientDisconnect( arg0 ); return 0; case GAME_CLIENT_BEGIN: // STONELANCE // G_DebugLogPrintf("CLIENT BEGIN\n"); // END ClientBegin( arg0 ); return 0; case GAME_CLIENT_COMMAND: // STONELANCE // G_DebugLogPrintf("CLIENT COMMAND\n"); // END ClientCommand( arg0 ); return 0; case GAME_RUN_FRAME: G_RunFrame( arg0 ); return 0; case GAME_CONSOLE_COMMAND: // STONELANCE // G_DebugLogPrintf("CONSOLE COMMAND\n"); // END return ConsoleCommand(); case BOTAI_START_FRAME: // STONELANCE // if (level.intermissiontime) // G_DebugLogPrintf("BOTAI FRAME\n"); // END return BotAIStartFrame( arg0 ); } return -1; } void QDECL G_Printf( const char *fmt, ... ) { va_list argptr; char text[1024]; va_start (argptr, fmt); Q_vsnprintf (text, sizeof(text), fmt, argptr); va_end (argptr); trap_Printf( text ); } void QDECL G_Error( const char *fmt, ... ) { va_list argptr; char text[1024]; va_start (argptr, fmt); Q_vsnprintf (text, sizeof(text), fmt, argptr); va_end (argptr); trap_Error( text ); } /* ================ G_FindTeams Chain together all entities with a matching team field. Entity teams are used for item groups and multi-entity mover groups. All but the first will have the FL_TEAMSLAVE flag set and teammaster field set All but the last will have the teamchain field set to the next one ================ */ void G_FindTeams( void ) { gentity_t *e, *e2; int i, j; int c, c2; c = 0; c2 = 0; for ( i=1, e=g_entities+i ; i < level.num_entities ; i++,e++ ){ if (!e->inuse) continue; if (!e->team) continue; if (e->flags & FL_TEAMSLAVE) continue; e->teammaster = e; c++; c2++; for (j=i+1, e2=e+1 ; j < level.num_entities ; j++,e2++) { if (!e2->inuse) continue; if (!e2->team) continue; if (e2->flags & FL_TEAMSLAVE) continue; if (!strcmp(e->team, e2->team)) { c2++; e2->teamchain = e->teamchain; e->teamchain = e2; e2->teammaster = e; e2->flags |= FL_TEAMSLAVE; // make sure that targets only point at the master if ( e2->targetname ) { e->targetname = e2->targetname; e2->targetname = NULL; } } } } G_Printf ("%i teams with %i entities\n", c, c2); } void G_RemapTeamShaders( void ) { #ifdef MISSIONPACK char string[1024]; float f = level.time * 0.001; Com_sprintf( string, sizeof(string), "team_icon/%s_red", g_redteam.string ); AddRemap("textures/ctf2/redteam01", string, f); AddRemap("textures/ctf2/redteam02", string, f); Com_sprintf( string, sizeof(string), "team_icon/%s_blue", g_blueteam.string ); AddRemap("textures/ctf2/blueteam01", string, f); AddRemap("textures/ctf2/blueteam02", string, f); trap_SetConfigstring(CS_SHADERSTATE, BuildShaderStateConfig()); #endif } /* ================= G_RegisterCvars ================= */ void G_RegisterCvars( void ) { int i; cvarTable_t *cv; qboolean remapped = qfalse; for ( i = 0, cv = gameCvarTable ; i < gameCvarTableSize ; i++, cv++ ) { trap_Cvar_Register( cv->vmCvar, cv->cvarName, cv->defaultString, cv->cvarFlags ); if ( cv->vmCvar ) cv->modificationCount = cv->vmCvar->modificationCount; if (cv->teamShader) { remapped = qtrue; } } if (remapped) { G_RemapTeamShaders(); } // check some things if ( g_gametype.integer < 0 || g_gametype.integer >= GT_MAX_GAME_TYPE ) { // STONELANCE /* G_Printf( "g_gametype %i is out of range, defaulting to 0\n", g_gametype.integer ); trap_Cvar_Set( "g_gametype", "0" ); */ G_Printf( "g_gametype %i is out of range, defaulting to 1\n", g_gametype.integer ); trap_Cvar_Set( "g_gametype", "1" ); // END } level.warmupModificationCount = g_warmup.modificationCount; } /* ================= G_UpdateCvars ================= */ void G_UpdateCvars( void ) { int i; cvarTable_t *cv; qboolean remapped = qfalse; for ( i = 0, cv = gameCvarTable ; i < gameCvarTableSize ; i++, cv++ ) { if ( cv->vmCvar ) { trap_Cvar_Update( cv->vmCvar ); if ( cv->modificationCount != cv->vmCvar->modificationCount ) { cv->modificationCount = cv->vmCvar->modificationCount; if ( cv->trackChange ) { trap_SendServerCommand( -1, va("print \"Server: %s changed to %s\n\"", cv->cvarName, cv->vmCvar->string ) ); } if (cv->teamShader) { remapped = qtrue; } } } } if (remapped) { G_RemapTeamShaders(); } } /* ============ G_InitGame ============ */ void G_InitGame( int levelTime, int randomSeed, int restart ) { int i; G_Printf ("------- Game Initialization -------\n"); G_Printf ("gamename: %s\n", GAMEVERSION); G_Printf ("gamedate: %s\n", __DATE__); srand( randomSeed ); G_RegisterCvars(); G_ProcessIPBans(); G_InitMemory(); // set some level globals memset( &level, 0, sizeof( level ) ); level.time = levelTime; level.startTime = levelTime; level.snd_fry = G_SoundIndex("sound/player/fry.wav"); // FIXME standing in lava / slime if ( g_gametype.integer != GT_SINGLE_PLAYER && g_log.string[0] ) { if ( g_logSync.integer ) { trap_FS_FOpenFile( g_log.string, &level.logFile, FS_APPEND_SYNC ); } else { trap_FS_FOpenFile( g_log.string, &level.logFile, FS_APPEND ); } if ( !level.logFile ) { G_Printf( "WARNING: Couldn't open logfile: %s\n", g_log.string ); } else { char serverinfo[MAX_INFO_STRING]; trap_GetServerinfo( serverinfo, sizeof( serverinfo ) ); G_LogPrintf("------------------------------------------------------------\n" ); G_LogPrintf("InitGame: %s\n", serverinfo ); } } else { G_Printf( "Not logging to disk.\n" ); } G_InitWorldSession(); // initialize all entities for this game memset( g_entities, 0, MAX_GENTITIES * sizeof(g_entities[0]) ); level.gentities = g_entities; // initialize all clients for this game level.maxclients = g_maxclients.integer; memset( g_clients, 0, MAX_CLIENTS * sizeof(g_clients[0]) ); level.clients = g_clients; // set client fields on player ents for ( i=0 ; i= GT_TEAM ) { G_CheckTeamItems(); } SaveRegisteredItems(); G_Printf ("-----------------------------------\n"); if( g_gametype.integer == GT_SINGLE_PLAYER || trap_Cvar_VariableIntegerValue( "com_buildScript" ) ) { G_ModelIndex( SP_PODIUM_MODEL ); } if ( trap_Cvar_VariableIntegerValue( "bot_enable" ) ) { BotAISetup( restart ); BotAILoadMap( restart ); G_InitBots( restart ); } G_RemapTeamShaders(); // STONELANCE /* { gentity_t *ent; vec3_t origin; VectorClear( origin ); ent = G_Spawn(); G_SetOrigin( ent, origin ); level.testModelID = ent->s.number; ent->classname = "testmodel"; ent->r.svFlags = SVF_BROADCAST; ent->s.eType = ET_GENERAL; ent->s.modelindex = G_ModelIndex( "models/test/sphere01.md3" ); trap_LinkEntity( ent ); } */ // END } /* ================= G_ShutdownGame ================= */ void G_ShutdownGame( int restart ) { G_Printf ("==== ShutdownGame ====\n"); if ( level.logFile ) { G_LogPrintf("ShutdownGame:\n" ); G_LogPrintf("------------------------------------------------------------\n" ); trap_FS_FCloseFile( level.logFile ); level.logFile = 0; } // write all the client session data so we can get it back G_WriteSessionData(); if ( trap_Cvar_VariableIntegerValue( "bot_enable" ) ) { BotAIShutdown( restart ); } } //=================================================================== #ifndef GAME_HARD_LINKED // this is only here so the functions in q_shared.c and bg_*.c can link void QDECL Com_Error ( int level, const char *error, ... ) { va_list argptr; char text[1024]; va_start (argptr, error); Q_vsnprintf (text, sizeof(text), error, argptr); va_end (argptr); G_Error( "%s", text); } void QDECL Com_Printf( const char *msg, ... ) { va_list argptr; char text[1024]; va_start (argptr, msg); Q_vsnprintf (text, sizeof(text), msg, argptr); va_end (argptr); G_Printf ("%s", text); } #endif /* ======================================================================== PLAYER COUNTING / SCORE SORTING ======================================================================== */ /* ============= AddTournamentPlayer If there are less than two tournament players, put a spectator in the game and restart ============= */ void AddTournamentPlayer( void ) { int i; gclient_t *client; gclient_t *nextInLine; if ( level.numPlayingClients >= 2 ) { return; } // never change during intermission if ( level.intermissiontime ) { return; } nextInLine = NULL; for ( i = 0 ; i < level.maxclients ; i++ ) { client = &level.clients[i]; if ( client->pers.connected != CON_CONNECTED ) { continue; } if ( client->sess.sessionTeam != TEAM_SPECTATOR ) { continue; } // never select the dedicated follow or scoreboard clients if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD || client->sess.spectatorClient < 0 ) { continue; } if(!nextInLine || client->sess.spectatorNum > nextInLine->sess.spectatorNum) nextInLine = client; } if ( !nextInLine ) { return; } level.warmupTime = -1; // set them to free-for-all team SetTeam( &g_entities[ nextInLine - level.clients ], "f" ); } /* ======================= AddTournamentQueue Add client to end of tournament queue ======================= */ void AddTournamentQueue(gclient_t *client) { int index; gclient_t *curclient; for(index = 0; index < level.maxclients; index++) { curclient = &level.clients[index]; if(curclient->pers.connected != CON_DISCONNECTED) { if(curclient == client) curclient->sess.spectatorNum = 0; else if(curclient->sess.sessionTeam == TEAM_SPECTATOR) curclient->sess.spectatorNum++; } } } /* ======================= RemoveTournamentLoser Make the loser a spectator at the back of the line ======================= */ void RemoveTournamentLoser( void ) { int clientNum; if ( level.numPlayingClients != 2 ) { return; } clientNum = level.sortedClients[1]; if ( level.clients[ clientNum ].pers.connected != CON_CONNECTED ) { return; } // make them a spectator SetTeam( &g_entities[ clientNum ], "s" ); } /* ======================= RemoveTournamentWinner ======================= */ void RemoveTournamentWinner( void ) { int clientNum; if ( level.numPlayingClients != 2 ) { return; } clientNum = level.sortedClients[0]; if ( level.clients[ clientNum ].pers.connected != CON_CONNECTED ) { return; } // make them a spectator SetTeam( &g_entities[ clientNum ], "s" ); } /* ======================= AdjustTournamentScores ======================= */ void AdjustTournamentScores( void ) { int clientNum; clientNum = level.sortedClients[0]; if ( level.clients[ clientNum ].pers.connected == CON_CONNECTED ) { level.clients[ clientNum ].sess.wins++; ClientUserinfoChanged( clientNum ); } clientNum = level.sortedClients[1]; if ( level.clients[ clientNum ].pers.connected == CON_CONNECTED ) { level.clients[ clientNum ].sess.losses++; ClientUserinfoChanged( clientNum ); } } /* ============= SortRanks ============= */ int QDECL SortRanks( const void *a, const void *b ) { gclient_t *ca, *cb; // STONELANCE gentity_t *ea, *eb; ea = &g_entities[*(int *)a]; eb = &g_entities[*(int *)b]; // END ca = &level.clients[*(int *)a]; cb = &level.clients[*(int *)b]; // sort special clients last if ( ca->sess.spectatorState == SPECTATOR_SCOREBOARD || ca->sess.spectatorClient < 0 ) { return 1; } if ( cb->sess.spectatorState == SPECTATOR_SCOREBOARD || cb->sess.spectatorClient < 0 ) { return -1; } // then connecting clients if ( ca->pers.connected == CON_CONNECTING ) { return 1; } if ( cb->pers.connected == CON_CONNECTING ) { return -1; } // then spectators if ( ca->sess.sessionTeam == TEAM_SPECTATOR && cb->sess.sessionTeam == TEAM_SPECTATOR ) { if ( ca->sess.spectatorNum > cb->sess.spectatorNum ) { return -1; } if ( ca->sess.spectatorNum < cb->sess.spectatorNum ) { return 1; } return 0; } if ( ca->sess.sessionTeam == TEAM_SPECTATOR ) { return 1; } if ( cb->sess.sessionTeam == TEAM_SPECTATOR ) { return -1; } // STONELANCE /* // then sort by score if ( ca->ps.persistant[PERS_SCORE] > cb->ps.persistant[PERS_SCORE] ) { return -1; } if ( ca->ps.persistant[PERS_SCORE] < cb->ps.persistant[PERS_SCORE] ) { return 1; } */ // sort by position if race if (isRallyRace()){ if ( ca->ps.stats[STAT_POSITION] < cb->ps.stats[STAT_POSITION] ) { return -1; } if ( ca->ps.stats[STAT_POSITION] > cb->ps.stats[STAT_POSITION] ) { return 1; } } // sort by finish time if derby else if (g_gametype.integer == GT_DERBY){ if ( ca->finishRaceTime && cb->finishRaceTime ) { if (ca->finishRaceTime < cb->finishRaceTime) return 1; else if (ca->finishRaceTime > cb->finishRaceTime) return -1; } else if ( ca->finishRaceTime ) { return 1; } else if ( cb->finishRaceTime ) { return -1; } else { // if still alive sort by health if ( ca->ps.stats[STAT_HEALTH] > cb->ps.stats[STAT_HEALTH] ) { return -1; } if ( ca->ps.stats[STAT_HEALTH] < cb->ps.stats[STAT_HEALTH] ) { return 1; } } } // then sort by score else { if ( ca->ps.persistant[PERS_SCORE] > cb->ps.persistant[PERS_SCORE] ) { return -1; } if ( ca->ps.persistant[PERS_SCORE] < cb->ps.persistant[PERS_SCORE] ) { return 1; } } // END return 0; } /* ============ CalculateRanks Recalculates the score ranks of all players This will be called on every client connect, begin, disconnect, death, and team change. ============ */ void CalculateRanks( void ) { int i; int rank; int score; int newScore; int humanplayers; gclient_t *cl; level.follow1 = -1; level.follow2 = -1; level.numConnectedClients = 0; level.numNonSpectatorClients = 0; level.numPlayingClients = 0; humanplayers = 0; //level.numVotingClients = 0; // don't count bots for (i = 0; i < ARRAY_LEN(level.numteamVotingClients); i++) level.numteamVotingClients[i] = 0; for ( i = 0 ; i < level.maxclients ; i++ ) { if ( level.clients[i].pers.connected != CON_DISCONNECTED ) { level.sortedClients[level.numConnectedClients] = i; level.numConnectedClients++; if ( level.clients[i].sess.sessionTeam != TEAM_SPECTATOR ) { level.numNonSpectatorClients++; // decide if this should be auto-followed if ( level.clients[i].pers.connected == CON_CONNECTED ) { level.numPlayingClients++; if ( !(g_entities[i].r.svFlags & SVF_BOT) ) { level.numVotingClients++; if ( level.clients[i].sess.sessionTeam == TEAM_RED ) level.numteamVotingClients[0]++; else if ( level.clients[i].sess.sessionTeam == TEAM_BLUE ) level.numteamVotingClients[1]++; } if ( level.follow1 == -1 ) { level.follow1 = i; } else if ( level.follow2 == -1 ) { level.follow2 = i; } } } } } qsort( level.sortedClients, level.numConnectedClients, sizeof(level.sortedClients[0]), SortRanks ); // set the rank value for all clients that are connected and not spectators // STONELANCE - FIXME: this stuff needed anymore? (I think its for tournament stuff) if ( g_gametype.integer >= GT_TEAM ) { // in team games, rank is just the order of the teams, 0=red, 1=blue, 2=tied for ( i = 0; i < level.numConnectedClients; i++ ) { cl = &level.clients[ level.sortedClients[i] ]; if ( level.teamScores[TEAM_RED] == level.teamScores[TEAM_BLUE] ) { cl->ps.persistant[PERS_RANK] = 2; } else if ( level.teamScores[TEAM_RED] > level.teamScores[TEAM_BLUE] ) { cl->ps.persistant[PERS_RANK] = 0; } else { cl->ps.persistant[PERS_RANK] = 1; } } } else { rank = -1; score = 0; for ( i = 0; i < level.numPlayingClients; i++ ) { cl = &level.clients[ level.sortedClients[i] ]; newScore = cl->ps.persistant[PERS_SCORE]; if ( i == 0 || newScore != score ) { rank = i; // assume we aren't tied until the next client is checked level.clients[ level.sortedClients[i] ].ps.persistant[PERS_RANK] = rank; } else { // we are tied with the previous client level.clients[ level.sortedClients[i-1] ].ps.persistant[PERS_RANK] = rank | RANK_TIED_FLAG; level.clients[ level.sortedClients[i] ].ps.persistant[PERS_RANK] = rank | RANK_TIED_FLAG; } score = newScore; if ( g_gametype.integer == GT_SINGLE_PLAYER && level.numPlayingClients == 1 ) { level.clients[ level.sortedClients[i] ].ps.persistant[PERS_RANK] = rank | RANK_TIED_FLAG; } } } // set the CS_SCORES1/2 configstrings, which will be visible to everyone if ( g_gametype.integer >= GT_TEAM ) { trap_SetConfigstring( CS_SCORES1, va("%i", level.teamScores[TEAM_RED] ) ); trap_SetConfigstring( CS_SCORES2, va("%i", level.teamScores[TEAM_BLUE] ) ); // STONELANCE trap_SetConfigstring( CS_SCORES3, va("%i", level.teamScores[TEAM_GREEN] ) ); trap_SetConfigstring( CS_SCORES4, va("%i", level.teamScores[TEAM_YELLOW] ) ); // END } else { if ( level.numConnectedClients == 0 ) { trap_SetConfigstring( CS_SCORES1, va("%i", SCORE_NOT_PRESENT) ); trap_SetConfigstring( CS_SCORES2, va("%i", SCORE_NOT_PRESENT) ); } else if ( level.numConnectedClients == 1 ) { trap_SetConfigstring( CS_SCORES1, va("%i", level.clients[ level.sortedClients[0] ].ps.persistant[PERS_SCORE] ) ); trap_SetConfigstring( CS_SCORES2, va("%i", SCORE_NOT_PRESENT) ); } else { trap_SetConfigstring( CS_SCORES1, va("%i", level.clients[ level.sortedClients[0] ].ps.persistant[PERS_SCORE] ) ); trap_SetConfigstring( CS_SCORES2, va("%i", level.clients[ level.sortedClients[1] ].ps.persistant[PERS_SCORE] ) ); } } // see if it is time to end the level CheckExitRules(); // if we are at the intermission, send the new info to everyone if ( level.intermissiontime ) { SendScoreboardMessageToAllClients(); } if(g_humanplayers.integer != humanplayers) //Presume all spectators are humans! trap_Cvar_Set( "g_humanplayers", va("%i", humanplayers) ); } /* ======================================================================== MAP CHANGING ======================================================================== */ /* ======================== SendScoreboardMessageToAllClients Do this at BeginIntermission time and whenever ranks are recalculated due to enters/exits/forced team changes ======================== */ void SendScoreboardMessageToAllClients( void ) { int i; for ( i = 0 ; i < level.maxclients ; i++ ) { if ( level.clients[ i ].pers.connected == CON_CONNECTED ) { DeathmatchScoreboardMessage( g_entities + i ); } } } /* ======================== MoveClientToIntermission When the intermission starts, this will be called for all players. If a new client connects, this will be called after the spawn function. ======================== */ void MoveClientToIntermission( gentity_t *ent ) { // take out of follow mode if needed // STONELANCE // if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) { if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW || ent->client->sess.spectatorState == SPECTATOR_OBSERVE ) { // END StopFollowing( ent ); } FindIntermissionPoint(); // move to the spot VectorCopy( level.intermission_origin, ent->s.origin ); VectorCopy( level.intermission_origin, ent->client->ps.origin ); // STONELANCE (used for viewing angles client side) // VectorCopy (level.intermission_angle, ent->client->ps.viewangles); VectorCopy( level.intermission_angle, ent->s.angles2 ); // FIXME: need this? ent->client->ps.damagePitch = ANGLE2SHORT(ent->s.angles2[PITCH]); ent->client->ps.damageYaw = ANGLE2SHORT(ent->s.angles2[YAW]); // END ent->client->ps.pm_type = PM_INTERMISSION; // clean up powerup info memset( ent->client->ps.powerups, 0, sizeof(ent->client->ps.powerups) ); ent->client->ps.eFlags = 0; ent->s.eFlags = 0; ent->s.eType = ET_GENERAL; ent->s.modelindex = 0; ent->s.loopSound = 0; ent->s.event = 0; ent->r.contents = 0; } /* ================== FindIntermissionPoint This is also used for spectator spawns ================== */ void FindIntermissionPoint( void ) { gentity_t *ent, *target; vec3_t dir; // find the intermission spot ent = G_Find (NULL, FOFS(classname), "info_player_intermission"); if ( !ent ) { // the map creator forgot to put in an intermission point... SelectSpawnPoint ( vec3_origin, level.intermission_origin, level.intermission_angle, qfalse ); } else { VectorCopy (ent->s.origin, level.intermission_origin); // STONELANCE // VectorCopy (ent->s.angles, level.intermission_angle); VectorCopy (ent->s.angles2, level.intermission_angle); // END // if it has a target, look towards it if ( ent->target ) { target = G_PickTarget( ent->target ); if ( target ) { VectorSubtract( target->s.origin, level.intermission_origin, dir ); vectoangles( dir, level.intermission_angle ); } } } } /* ================== BeginIntermission ================== */ void BeginIntermission( void ) { int i; gentity_t *client; if ( level.intermissiontime ) { return; // already active } // if in tournement mode, change the wins / losses // STONELANCE - removed gametype /* if ( g_gametype.integer == GT_TOURNAMENT ) { AdjustTournamentScores(); } */ // END level.intermissiontime = level.time; // move all clients to the intermission point for (i=0 ; i< level.maxclients ; i++) { client = g_entities + i; if (!client->inuse) continue; // respawn if dead if (client->health <= 0) { ClientRespawn(client); } MoveClientToIntermission( client ); } #ifdef MISSIONPACK if (g_singlePlayer.integer) { trap_Cvar_Set("ui_singlePlayerActive", "0"); UpdateTournamentInfo(); } #else // if single player game if ( g_gametype.integer == GT_SINGLE_PLAYER ) { UpdateTournamentInfo(); SpawnModelsOnVictoryPads(); } #endif // send the current scoring to all clients SendScoreboardMessageToAllClients(); } /* ============= ExitLevel When the intermission has been exited, the server is either killed or moved to a new level based on the "nextmap" cvar ============= */ void ExitLevel (void) { int i; gclient_t *cl; char nextmap[MAX_STRING_CHARS]; char d1[MAX_STRING_CHARS]; //bot interbreeding BotInterbreedEndMatch(); // if we are running a tournement map, kick the loser to spectator status, // which will automatically grab the next spectator and restart // STONELANCE - removed gametype /* if ( g_gametype.integer == GT_TOURNAMENT ) { if ( !level.restarted ) { RemoveTournamentLoser(); trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" ); level.restarted = qtrue; level.changemap = NULL; level.intermissiontime = 0; } return; } */ // END trap_Cvar_VariableStringBuffer( "nextmap", nextmap, sizeof(nextmap) ); trap_Cvar_VariableStringBuffer( "d1", d1, sizeof(d1) ); if( !Q_stricmp( nextmap, "map_restart 0" ) && Q_stricmp( d1, "" ) ) { trap_Cvar_Set( "nextmap", "vstr d2" ); trap_SendConsoleCommand( EXEC_APPEND, "vstr d1\n" ); } else { trap_SendConsoleCommand( EXEC_APPEND, "vstr nextmap\n" ); } level.changemap = NULL; level.intermissiontime = 0; // reset all the scores so we don't enter the intermission again level.teamScores[TEAM_RED] = 0; level.teamScores[TEAM_BLUE] = 0; // STONELANCE level.teamScores[TEAM_GREEN] = 0; level.teamScores[TEAM_YELLOW] = 0; // END for ( i=0 ; i< g_maxclients.integer ; i++ ) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } cl->ps.persistant[PERS_SCORE] = 0; } // we need to do this here before chaning to CON_CONNECTING G_WriteSessionData(); // change all client states to connecting, so the early players into the // next level will know the others aren't done reconnecting for (i=0 ; i< g_maxclients.integer ; i++) { if ( level.clients[i].pers.connected == CON_CONNECTED ) { level.clients[i].pers.connected = CON_CONNECTING; } } } /* ================= G_LogPrintf Print to the logfile with a time stamp if it is open ================= */ void QDECL G_LogPrintf( const char *fmt, ... ) { va_list argptr; char string[1024]; int min, tens, sec; sec = ( level.time - level.startTime ) / 1000; min = sec / 60; sec -= min * 60; tens = sec / 10; sec -= tens * 10; Com_sprintf( string, sizeof(string), "%3i:%i%i ", min, tens, sec ); va_start( argptr, fmt ); Q_vsnprintf(string + 7, sizeof(string) - 7, fmt, argptr); va_end( argptr ); if ( g_dedicated.integer ) { G_Printf( "%s", string + 7 ); } if ( !level.logFile ) { return; } trap_FS_Write( string, strlen( string ), level.logFile ); } // STONELANCE /* ================= G_DebugLogPrintf Print to the logfile with a time stamp if it is open ================= */ void QDECL G_DebugLogPrintf( const char *fmt, ... ) { va_list argptr; char string[1024]; fileHandle_t logFile; va_start( argptr, fmt ); Q_vsnprintf (string, sizeof(string), fmt, argptr); va_end( argptr ); if ( g_dedicated.integer ) { G_Printf( "%s", string + 7 ); } trap_FS_FOpenFile( "q3r_game.log", &logFile, FS_APPEND ); if ( !logFile ) { return; } trap_FS_Write( string, strlen( string ), logFile ); trap_FS_FCloseFile( logFile ); } // END /* ================ LogExit Append information about this game to the log file ================ */ void LogExit( const char *string ) { int i, numSorted; gclient_t *cl; #ifdef MISSIONPACK qboolean won = qtrue; #endif G_LogPrintf( "Exit: %s\n", string ); level.intermissionQueued = level.time; // this will keep the clients from playing any voice sounds // that will get cut off when the queued intermission starts trap_SetConfigstring( CS_INTERMISSION, "1" ); // don't send more than 32 scores (FIXME?) numSorted = level.numConnectedClients; if ( numSorted > 32 ) { numSorted = 32; } if ( g_gametype.integer >= GT_TEAM ) { // STONELANCE // G_LogPrintf( "red:%i blue:%i\n", // level.teamScores[TEAM_RED], level.teamScores[TEAM_BLUE] ); G_LogPrintf( "red:%i blue:%i green:%i yellow:%i\n", level.teamScores[TEAM_RED], level.teamScores[TEAM_BLUE], level.teamScores[TEAM_GREEN], level.teamScores[TEAM_YELLOW]); // END } for (i=0 ; i < numSorted ; i++) { int ping; cl = &level.clients[level.sortedClients[i]]; if ( cl->sess.sessionTeam == TEAM_SPECTATOR ) { continue; } if ( cl->pers.connected == CON_CONNECTING ) { continue; } ping = cl->ps.ping < 999 ? cl->ps.ping : 999; G_LogPrintf( "score: %i ping: %i client: %i %s\n", cl->ps.persistant[PERS_SCORE], ping, level.sortedClients[i], cl->pers.netname ); #ifdef MISSIONPACK if (g_singlePlayer.integer && g_gametype.integer == GT_TOURNAMENT) { if (g_entities[cl - level.clients].r.svFlags & SVF_BOT && cl->ps.persistant[PERS_RANK] == 0) { won = qfalse; } } #endif } #ifdef MISSIONPACK if (g_singlePlayer.integer) { if (g_gametype.integer >= GT_CTF) { won = level.teamScores[TEAM_RED] > level.teamScores[TEAM_BLUE]; } trap_SendConsoleCommand( EXEC_APPEND, (won) ? "spWin\n" : "spLose\n" ); } #endif } /* ================= CheckIntermissionExit The level will stay at the intermission for a minimum of 5 seconds If all players wish to continue, the level will then exit. If one or more players have not acknowledged the continue, the game will wait 10 seconds before going on. ================= */ void CheckIntermissionExit( void ) { int ready, notReady; int i; gclient_t *cl; int readyMask; if ( g_gametype.integer == GT_SINGLE_PLAYER ) { return; } // see which players are ready ready = 0; notReady = 0; readyMask = 0; for (i=0 ; i< g_maxclients.integer ; i++) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } if ( g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT ) { continue; } if ( cl->readyToExit ) { ready++; if ( i < 16 ) { readyMask |= 1 << i; } } else { notReady++; } } // copy the readyMask to each player's stats so // it can be displayed on the scoreboard for (i=0 ; i< g_maxclients.integer ; i++) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } cl->ps.stats[STAT_CLIENTS_READY] = readyMask; } // never exit in less than five seconds if ( level.time < level.intermissiontime + 5000 ) { return; } // if nobody wants to go, clear timer if ( !ready ) { level.readyToExit = qfalse; return; } // if everyone wants to go, go now if ( !notReady ) { ExitLevel(); return; } // the first person to ready starts the ten second timeout if ( !level.readyToExit ) { level.readyToExit = qtrue; level.exitTime = level.time; } // if we have waited ten seconds since at least one player // wanted to exit, go ahead if ( level.time < level.exitTime + 10000 ) { return; } ExitLevel(); } /* ============= ScoreIsTied ============= */ qboolean ScoreIsTied( void ) { int a, b; if ( level.numPlayingClients < 2 ) { return qfalse; } // STONELANCE // races or rallys can never be tied, otherwise then the level will not end if ( g_gametype.integer == GT_DERBY || isRallyRace() ) { /* a = level.clients[level.sortedClients[0]].finishRaceTime; b = level.clients[level.sortedClients[1]].finishRaceTime; return a == b; */ return qfalse; } // END if ( g_gametype.integer >= GT_TEAM ) { // STONELANCE // return level.teamScores[TEAM_RED] == level.teamScores[TEAM_BLUE]; int i, winner; qboolean tied; tied = qfalse; winner = GetTeamAtRank(1) - TEAM_RED; for (i = 0; i < 4; i++){ if (i == winner) continue; if (!TeamCount(-1, TEAM_RED + i)) continue; if ((isRallyRace() && level.teamTimes[winner] == level.teamTimes[i]) || (!isRallyRace() && level.teamScores[winner] == level.teamScores[i])){ tied = qtrue; break; } } return tied; // END } a = level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE]; b = level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE]; return a == b; } /* ================= CheckExitRules There will be a delay between the time the exit is qualified for and the time everyone is moved to the intermission spot, so you can see the last frag. ================= */ void CheckExitRules( void ) { int i; gclient_t *cl; // STONELANCE int count; // END // if at the intermission, wait for all non-bots to // signal ready, then go to next level if ( level.intermissiontime ) { CheckIntermissionExit (); return; } if ( level.intermissionQueued ) { #ifdef MISSIONPACK int time = (g_singlePlayer.integer) ? SP_INTERMISSION_DELAY_TIME : INTERMISSION_DELAY_TIME; if ( level.time - level.intermissionQueued >= time ) { level.intermissionQueued = 0; BeginIntermission(); } #else if ( level.time - level.intermissionQueued >= INTERMISSION_DELAY_TIME ) { level.intermissionQueued = 0; BeginIntermission(); } #endif return; } // check for sudden death if ( ScoreIsTied() ) { // always wait for sudden death return; } if ( g_timelimit.integer && !level.warmupTime ) { if ( level.time - level.startTime >= g_timelimit.integer*60000 ) { trap_SendServerCommand( -1, "print \"Timelimit hit.\n\""); LogExit( "Timelimit hit." ); return; } } // STONELANCE if (g_gametype.integer == GT_DERBY && level.startRaceTime && !level.finishRaceTime) { gclient_t *winner = NULL; for ( i=0, count = 0 ; i< g_maxclients.integer ; i++ ) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) continue; if ( cl->sess.sessionTeam == TEAM_SPECTATOR ) continue; if ( isRaceObserver( cl->ps.clientNum ) ) continue; if ( cl->ps.stats[STAT_HEALTH] <= 0 ) continue; count++; winner = cl; } if (winner && count == 1) { level.winnerNumber = winner->ps.clientNum; level.finishRaceTime = level.time; trap_SendServerCommand( -1, va("print \"%s won the demolition derby!\n\"", winner->pers.netname )); trap_SendServerCommand( level.winnerNumber, "cp \"You won the demolition derby!\n\""); } return; } for ( i = 0, count = 0 ; i< g_maxclients.integer ; i++ ) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) continue; if ( cl->sess.sessionTeam == TEAM_SPECTATOR ) continue; if ( isRaceObserver( cl->ps.clientNum ) ) continue; // if ( cl->ps.stats[STAT_HEALTH] <= 0 ) continue; count++; break; } // if its a race and the race has started if no players left playing // or everyone is a spectator then end the race. if ( isRallyRace() && level.startRaceTime && !count ){ LogExit( "Race finished." ); return; } if ( level.finishRaceTime && isRallyRace() ){ // if everyone has finished the race, or the finishRaceDelay time is up, then exit if ( (level.finishRaceTime + (g_finishRaceDelay.integer * 1000) < level.time) || !count ) { LogExit( "Race finished." ); return; } } if ( level.finishRaceTime && g_gametype.integer == GT_DERBY && level.finishRaceTime + 10000 < level.time ){ g_entities[ level.winnerNumber ].client->finishRaceTime = level.time; trap_SendServerCommand( -1, va("raceFinishTime %i %i", level.winnerNumber, level.time) ); LogExit( "Derby finished." ); return; } // END if ( level.numPlayingClients < 2 ) { return; } // STONELANCE // dont check frags or captures during a race or derby if ( isRallyRace() || g_gametype.integer == GT_DERBY ){ return; } // END if ( g_gametype.integer < GT_CTF && g_fraglimit.integer ) { if ( level.teamScores[TEAM_RED] >= g_fraglimit.integer ) { trap_SendServerCommand( -1, "print \"Red hit the fraglimit.\n\"" ); LogExit( "Fraglimit hit." ); return; } if ( level.teamScores[TEAM_BLUE] >= g_fraglimit.integer ) { trap_SendServerCommand( -1, "print \"Blue hit the fraglimit.\n\"" ); LogExit( "Fraglimit hit." ); return; } // STONELANCE if ( level.teamScores[TEAM_GREEN] >= g_fraglimit.integer ) { trap_SendServerCommand( -1, "print \"Green hit the fraglimit.\n\"" ); LogExit( "Fraglimit hit." ); return; } if ( level.teamScores[TEAM_YELLOW] >= g_fraglimit.integer ) { trap_SendServerCommand( -1, "print \"Yellow hit the fraglimit.\n\"" ); LogExit( "Fraglimit hit." ); return; } // END for ( i=0 ; i< g_maxclients.integer ; i++ ) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } if ( cl->sess.sessionTeam != TEAM_FREE ) { continue; } if ( cl->ps.persistant[PERS_SCORE] >= g_fraglimit.integer ) { LogExit( "Fraglimit hit." ); trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " hit the fraglimit.\n\"", cl->pers.netname ) ); return; } } } if ( g_gametype.integer >= GT_CTF && g_capturelimit.integer ) { if ( level.teamScores[TEAM_RED] >= g_capturelimit.integer ) { trap_SendServerCommand( -1, "print \"Red hit the capturelimit.\n\"" ); LogExit( "Capturelimit hit." ); return; } if ( level.teamScores[TEAM_BLUE] >= g_capturelimit.integer ) { trap_SendServerCommand( -1, "print \"Blue hit the capturelimit.\n\"" ); LogExit( "Capturelimit hit." ); return; } } } /* ======================================================================== FUNCTIONS CALLED EVERY FRAME ======================================================================== */ /* ============= CheckTournament Once a frame, check for changes in tournement player state ============= */ void CheckTournament( void ) { // check because we run 3 game frames before calling Connect and/or ClientBegin // for clients on a map_restart if ( level.numPlayingClients == 0 ) { return; } // STONELANCE - removed gametype /* if ( g_gametype.integer == GT_TOURNAMENT ) { // pull in a spectator if needed if ( level.numPlayingClients < 2 ) { AddTournamentPlayer(); } // if we don't have two players, go back to "waiting for players" if ( level.numPlayingClients != 2 ) { if ( level.warmupTime != -1 ) { level.warmupTime = -1; trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) ); G_LogPrintf( "Warmup:\n" ); } return; } if ( level.warmupTime == 0 ) { return; } // if the warmup is changed at the console, restart it if ( g_warmup.modificationCount != level.warmupModificationCount ) { level.warmupModificationCount = g_warmup.modificationCount; level.warmupTime = -1; } // if all players have arrived, start the countdown if ( level.warmupTime < 0 ) { if ( level.numPlayingClients == 2 ) { // fudge by -1 to account for extra delays level.warmupTime = level.time + ( g_warmup.integer - 1 ) * 1000; trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) ); } return; } // if the warmup time has counted down, restart if ( level.time > level.warmupTime ) { level.warmupTime += 10000; trap_Cvar_Set( "g_restarted", "1" ); trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" ); level.restarted = qtrue; return; } } else */ // END if ( g_gametype.integer != GT_SINGLE_PLAYER && level.warmupTime != 0 ) { int counts[TEAM_NUM_TEAMS]; qboolean notEnough = qfalse; if ( g_gametype.integer > GT_TEAM ) { counts[TEAM_BLUE] = TeamCount( -1, TEAM_BLUE ); counts[TEAM_RED] = TeamCount( -1, TEAM_RED ); if (counts[TEAM_RED] < 1 || counts[TEAM_BLUE] < 1) { notEnough = qtrue; } } else if ( level.numPlayingClients < 2 ) { notEnough = qtrue; } if ( notEnough ) { if ( level.warmupTime != -1 ) { level.warmupTime = -1; trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) ); G_LogPrintf( "Warmup:\n" ); } return; // still waiting for team members } if ( level.warmupTime == 0 ) { return; } // if the warmup is changed at the console, restart it if ( g_warmup.modificationCount != level.warmupModificationCount ) { level.warmupModificationCount = g_warmup.modificationCount; level.warmupTime = -1; } // if all players have arrived, start the countdown if ( level.warmupTime < 0 ) { // fudge by -1 to account for extra delays level.warmupTime = level.time + ( g_warmup.integer - 1 ) * 1000; trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) ); return; } // if the warmup time has counted down, restart if ( level.time > level.warmupTime ) { level.warmupTime += 10000; trap_Cvar_Set( "g_restarted", "1" ); trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" ); level.restarted = qtrue; return; } } } /* ================== CheckVote ================== */ void CheckVote( void ) { if ( level.voteExecuteTime && level.voteExecuteTime < level.time ) { level.voteExecuteTime = 0; trap_SendConsoleCommand( EXEC_APPEND, va("%s\n", level.voteString ) ); } if ( !level.voteTime ) { return; } if ( level.time - level.voteTime >= VOTE_TIME ) { trap_SendServerCommand( -1, "print \"Vote failed.\n\"" ); } else { if ( level.voteYes > level.numVotingClients/2 ) { // execute the command, then remove the vote trap_SendServerCommand( -1, "print \"Vote passed.\n\"" ); level.voteExecuteTime = level.time + 3000; } else if ( level.voteNo >= level.numVotingClients/2 ) { // same behavior as a timeout trap_SendServerCommand( -1, "print \"Vote failed.\n\"" ); } else { // still waiting for a majority return; } } level.voteTime = 0; trap_SetConfigstring( CS_VOTE_TIME, "" ); } /* ================== PrintTeam ================== */ void PrintTeam(int team, char *message) { int i; for ( i = 0 ; i < level.maxclients ; i++ ) { if (level.clients[i].sess.sessionTeam != team) continue; trap_SendServerCommand( i, message ); } } /* ================== SetLeader ================== */ void SetLeader(int team, int client) { int i; if ( level.clients[client].pers.connected == CON_DISCONNECTED ) { PrintTeam(team, va("print \"%s is not connected\n\"", level.clients[client].pers.netname) ); return; } if (level.clients[client].sess.sessionTeam != team) { PrintTeam(team, va("print \"%s is not on the team anymore\n\"", level.clients[client].pers.netname) ); return; } for ( i = 0 ; i < level.maxclients ; i++ ) { if (level.clients[i].sess.sessionTeam != team) continue; if (level.clients[i].sess.teamLeader) { level.clients[i].sess.teamLeader = qfalse; ClientUserinfoChanged(i); } } level.clients[client].sess.teamLeader = qtrue; ClientUserinfoChanged( client ); PrintTeam(team, va("print \"%s is the new team leader\n\"", level.clients[client].pers.netname) ); } /* ================== CheckTeamLeader ================== */ void CheckTeamLeader( int team ) { int i; for ( i = 0 ; i < level.maxclients ; i++ ) { if (level.clients[i].sess.sessionTeam != team) continue; if (level.clients[i].sess.teamLeader) break; } if (i >= level.maxclients) { for ( i = 0 ; i < level.maxclients ; i++ ) { if (level.clients[i].sess.sessionTeam != team) continue; if (!(g_entities[i].r.svFlags & SVF_BOT)) { level.clients[i].sess.teamLeader = qtrue; break; } } for ( i = 0 ; i < level.maxclients ; i++ ) { if (level.clients[i].sess.sessionTeam != team) continue; level.clients[i].sess.teamLeader = qtrue; break; } } } /* ================== CheckTeamVote ================== */ void CheckTeamVote( int team ) { int cs_offset; if ( team == TEAM_RED ) cs_offset = 0; else if ( team == TEAM_BLUE ) cs_offset = 1; else return; if ( !level.teamVoteTime[cs_offset] ) { return; } if ( level.time - level.teamVoteTime[cs_offset] >= VOTE_TIME ) { trap_SendServerCommand( -1, "print \"Team vote failed.\n\"" ); } else { if ( level.teamVoteYes[cs_offset] > level.numteamVotingClients[cs_offset]/2 ) { // execute the command, then remove the vote trap_SendServerCommand( -1, "print \"Team vote passed.\n\"" ); // if ( !Q_strncmp( "leader", level.teamVoteString[cs_offset], 6) ) { //set the team leader SetLeader(team, atoi(level.teamVoteString[cs_offset] + 7)); } else { trap_SendConsoleCommand( EXEC_APPEND, va("%s\n", level.teamVoteString[cs_offset] ) ); } } else if ( level.teamVoteNo[cs_offset] >= level.numteamVotingClients[cs_offset]/2 ) { // same behavior as a timeout trap_SendServerCommand( -1, "print \"Team vote failed.\n\"" ); } else { // still waiting for a majority return; } } level.teamVoteTime[cs_offset] = 0; trap_SetConfigstring( CS_TEAMVOTE_TIME + cs_offset, "" ); } /* ================== CheckCvars ================== */ void CheckCvars( void ) { static int lastMod = -1; if ( g_password.modificationCount != lastMod ) { lastMod = g_password.modificationCount; if ( *g_password.string && Q_stricmp( g_password.string, "none" ) ) { trap_Cvar_Set( "g_needpass", "1" ); } else { trap_Cvar_Set( "g_needpass", "0" ); } } } /* ============= G_RunThink Runs thinking code for this frame if necessary ============= */ void G_RunThink (gentity_t *ent) { float thinktime; thinktime = ent->nextthink; if (thinktime <= 0) { return; } if (thinktime > level.time) { return; } ent->nextthink = 0; if (!ent->think) { G_Error ( "NULL ent->think"); } ent->think (ent); } /* ================ G_RunFrame Advances the non-player objects in the world ================ */ void G_RunFrame( int levelTime ) { int i; gentity_t *ent; // if we are waiting for the level to restart, do nothing if ( level.restarted ) { // STONELANCE level.startRaceTime = 0; level.finishRaceTime = 0; level.winnerNumber = -1; // END return; } level.framenum++; level.previousTime = level.time; level.time = levelTime; // get any cvar changes G_UpdateCvars(); // STONELANCE // RunRallyPhysics(); // map object physics if ( !level.startRaceTime ){ // UPDATE: should this be done even before the race starts? CalculatePlayerPositions(); } // END // // go through all allocated objects // ent = &g_entities[0]; for (i=0 ; iinuse ) { continue; } // clear events that are too old if ( level.time - ent->eventTime > EVENT_VALID_MSEC ) { if ( ent->s.event ) { ent->s.event = 0; // &= EV_EVENT_BITS; if ( ent->client ) { ent->client->ps.externalEvent = 0; // predicted events should never be set to zero //ent->client->ps.events[0] = 0; //ent->client->ps.events[1] = 0; } } if ( ent->freeAfterEvent ) { // tempEntities or dropped items completely go away after their event G_FreeEntity( ent ); continue; } else if ( ent->unlinkAfterEvent ) { // items that will respawn will hide themselves after their pickup event ent->unlinkAfterEvent = qfalse; trap_UnlinkEntity( ent ); } } // temporary entities don't think if ( ent->freeAfterEvent ) { continue; } if ( !ent->r.linked && ent->neverFree ) { continue; } if ( ent->s.eType == ET_MISSILE ) { G_RunMissile( ent ); continue; } if ( ent->s.eType == ET_ITEM || ent->physicsObject ) { G_RunItem( ent ); continue; } if ( ent->s.eType == ET_MOVER ) { G_RunMover( ent ); continue; } if ( i < MAX_CLIENTS ) { G_RunClient( ent ); continue; } G_RunThink( ent ); } // perform final fixups on the players ent = &g_entities[0]; for (i=0 ; i < level.maxclients ; i++, ent++ ) { if ( ent->inuse ) { ClientEndFrame( ent ); } } // see if it is time to do a tournement restart CheckTournament(); // see if it is time to end the level CheckExitRules(); // update to team status? CheckTeamStatus(); // cancel vote if timed out CheckVote(); // check team votes CheckTeamVote( TEAM_RED ); CheckTeamVote( TEAM_BLUE ); // for tracking changes CheckCvars(); if (g_listEntity.integer) { for (i = 0; i < MAX_GENTITIES; i++) { G_Printf("%4i: %s\n", i, g_entities[i].classname); } trap_Cvar_Set("g_listEntity", "0"); } }