codemp/game/g_main.c File Reference

#include "g_local.h"
#include "g_ICARUScb.h"
#include "g_nav.h"
#include "bg_saga.h"
#include "../namespace_begin.h"
#include "../namespace_end.h"

Go to the source code of this file.

Data Structures
struct	cvarTable_t
Defines
#define	JETPACK_DEFUEL_RATE   200
#define	JETPACK_REFUEL_RATE   150
#define	CLOAK_DEFUEL_RATE   200
#define	CLOAK_REFUEL_RATE   150
Functions
void	G_InitGame (int levelTime, int randomSeed, int restart)
void	G_RunFrame (int levelTime)
void	G_ShutdownGame (int restart)
void	CheckExitRules (void)
void	G_ROFF_NotetrackCallback (gentity_t *cent, const char *notetrack)
qboolean	G_ParseSpawnVars (qboolean inSubBSP)
void	G_SpawnGEntityFromSpawnVars (qboolean inSubBSP)
qboolean	NAV_ClearPathToPoint (gentity_t *self, vec3_t pmins, vec3_t pmaxs, vec3_t point, int clipmask, int okToHitEntNum)
qboolean	NPC_ClearLOS2 (gentity_t *ent, const vec3_t end)
int	NAVNEW_ClearPathBetweenPoints (vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, int ignore, int clipmask)
qboolean	NAV_CheckNodeFailedForEnt (gentity_t *ent, int nodeNum)
qboolean	G_EntIsUnlockedDoor (int entityNum)
qboolean	G_EntIsDoor (int entityNum)
qboolean	G_EntIsBreakable (int entityNum)
qboolean	G_EntIsRemovableUsable (int entNum)
void	CP_FindCombatPointWaypoints (void)
int	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)
void QDECL	G_Printf (const char *fmt,...)
void QDECL	G_Error (const char *fmt,...)
void	G_FindTeams (void)
void	G_RemapTeamShaders (void)
void	G_RegisterCvars (void)
void	G_UpdateCvars (void)
void	WP_SaberLoadParms (void)
void	BG_VehicleLoadParms (void)
void	RemoveAllWP (void)
void	BG_ClearVehicleParseParms (void)
void QDECL	Com_Error (int level, const char *error,...)
void QDECL	Com_Printf (const char *msg,...)
void	AddTournamentPlayer (void)
void	RemoveTournamentLoser (void)
void	G_PowerDuelCount (int *loners, int *doubles, qboolean countSpec)
void	AddPowerDuelPlayers (void)
void	RemovePowerDuelLosers (void)
void	RemoveDuelDrawLoser (void)
void	RemoveTournamentWinner (void)
void	AdjustTournamentScores (void)
int QDECL	SortRanks (const void *a, const void *b)
qboolean	G_CanResetDuelists (void)
void	G_ResetDuelists (void)
void	CalculateRanks (void)
void	SendScoreboardMessageToAllClients (void)
void	MoveClientToIntermission (gentity_t *ent)
void	FindIntermissionPoint (void)
qboolean	DuelLimitHit (void)
void	BeginIntermission (void)
void	DuelResetWinsLosses (void)
void	SiegeDoTeamAssign (void)
void	ExitLevel (void)
void QDECL	G_LogPrintf (const char *fmt,...)
void	LogExit (const char *string)
void	CheckIntermissionExit (void)
qboolean	ScoreIsTied (void)
void	G_RemoveDuelist (int team)
void	CheckTournament (void)
void	G_KickAllBots (void)
void	CheckVote (void)
void	PrintTeam (int team, char *message)
void	SetLeader (int team, int client)
void	CheckTeamLeader (int team)
void	CheckTeamVote (int team)
void	CheckCvars (void)
void	G_RunThink (gentity_t *ent)
void	NAV_CheckCalcPaths (void)
int	BG_GetTime (void)
void	ClearNPCGlobals (void)
void	AI_UpdateGroups (void)
void	ClearPlayerAlertEvents (void)
void	SiegeCheckTimers (void)
void	WP_SaberStartMissileBlockCheck (gentity_t *self, usercmd_t *ucmd)
void	Jedi_Decloak (gentity_t *self)
qboolean	G_PointInBounds (vec3_t point, vec3_t mins, vec3_t maxs)
const char *	G_GetStringEdString (char *refSection, char *refName)
Variables
level_locals_t	level
int	eventClearTime = 0
int	fatalErrors
int	killPlayerTimer = 0
gentity_t	g_entities [MAX_GENTITIES]
gclient_t	g_clients [MAX_CLIENTS]
qboolean	gDuelExit = qfalse
vmCvar_t	g_trueJedi
vmCvar_t	g_gametype
vmCvar_t	g_MaxHolocronCarry
vmCvar_t	g_ff_objectives
vmCvar_t	g_autoMapCycle
vmCvar_t	g_dmflags
vmCvar_t	g_maxForceRank
vmCvar_t	g_forceBasedTeams
vmCvar_t	g_privateDuel
vmCvar_t	g_allowNPC
vmCvar_t	g_armBreakage
vmCvar_t	g_saberLocking
vmCvar_t	g_saberLockFactor
vmCvar_t	g_saberTraceSaberFirst
vmCvar_t	d_saberKickTweak
vmCvar_t	d_powerDuelPrint
vmCvar_t	d_saberGhoul2Collision
vmCvar_t	g_saberBladeFaces
vmCvar_t	d_saberAlwaysBoxTrace
vmCvar_t	d_saberBoxTraceSize
vmCvar_t	d_siegeSeekerNPC
vmCvar_t	g_debugMelee
vmCvar_t	g_stepSlideFix
vmCvar_t	g_noSpecMove
vmCvar_t	d_perPlayerGhoul2
vmCvar_t	d_projectileGhoul2Collision
vmCvar_t	g_g2TraceLod
vmCvar_t	g_optvehtrace
vmCvar_t	g_locationBasedDamage
vmCvar_t	g_allowHighPingDuelist
vmCvar_t	g_logClientInfo
vmCvar_t	g_slowmoDuelEnd
vmCvar_t	g_saberDamageScale
vmCvar_t	g_useWhileThrowing
vmCvar_t	g_RMG
vmCvar_t	g_svfps
vmCvar_t	g_forceRegenTime
vmCvar_t	g_spawnInvulnerability
vmCvar_t	g_forcePowerDisable
vmCvar_t	g_weaponDisable
vmCvar_t	g_duelWeaponDisable
vmCvar_t	g_allowDuelSuicide
vmCvar_t	g_fraglimitVoteCorrection
vmCvar_t	g_fraglimit
vmCvar_t	g_duel_fraglimit
vmCvar_t	g_timelimit
vmCvar_t	g_capturelimit
vmCvar_t	d_saberInterpolate
vmCvar_t	g_friendlyFire
vmCvar_t	g_friendlySaber
vmCvar_t	g_password
vmCvar_t	g_needpass
vmCvar_t	g_maxclients
vmCvar_t	g_maxGameClients
vmCvar_t	g_dedicated
vmCvar_t	g_developer
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_siegeRespawn
vmCvar_t	g_inactivity
vmCvar_t	g_debugMove
vmCvar_t	g_debugDamage
vmCvar_t	g_debugAlloc
vmCvar_t	g_debugServerSkel
vmCvar_t	g_weaponRespawn
vmCvar_t	g_weaponTeamRespawn
vmCvar_t	g_adaptRespawn
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_statLog
vmCvar_t	g_statLogFile
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_debugForward
vmCvar_t	g_debugRight
vmCvar_t	g_debugUp
vmCvar_t	g_smoothClients
vmCvar_t	pmove_fixed
vmCvar_t	pmove_msec
vmCvar_t	g_listEntity
vmCvar_t	g_singlePlayer
vmCvar_t	g_enableBreath
vmCvar_t	g_dismember
vmCvar_t	g_forceDodge
vmCvar_t	g_timeouttospec
vmCvar_t	g_saberDmgVelocityScale
vmCvar_t	g_saberDmgDelay_Idle
vmCvar_t	g_saberDmgDelay_Wound
vmCvar_t	g_saberDebugPrint
vmCvar_t	g_siegeTeamSwitch
vmCvar_t	bg_fighterAltControl
vmCvar_t	g_saberDebugBox
vmCvar_t	d_altRoutes
vmCvar_t	d_patched
vmCvar_t	g_saberRealisticCombat
vmCvar_t	g_saberRestrictForce
vmCvar_t	d_saberSPStyleDamage
vmCvar_t	g_debugSaberLocks
vmCvar_t	g_saberLockRandomNess
vmCvar_t	g_saberWallDamageScale
vmCvar_t	d_saberStanceDebug
vmCvar_t	debugNPCAI
vmCvar_t	debugNPCFreeze
vmCvar_t	debugNPCAimingBeam
vmCvar_t	debugBreak
vmCvar_t	debugNoRoam
vmCvar_t	d_saberCombat
vmCvar_t	d_JediAI
vmCvar_t	d_noGroupAI
vmCvar_t	d_asynchronousGroupAI
vmCvar_t	d_slowmodeath
vmCvar_t	d_noIntermissionWait
vmCvar_t	g_spskill
vmCvar_t	g_siegeTeam1
vmCvar_t	g_siegeTeam2
vmCvar_t	g_austrian
vmCvar_t	g_powerDuelStartHealth
vmCvar_t	g_powerDuelEndHealth
vmCvar_t	g_showDuelHealths
stringID_table_t	setTable []
char	gSharedBuffer [MAX_G_SHARED_BUFFER_SIZE]
qboolean	g_duelAssigning = qfalse
qboolean	g_dontFrickinCheck = qfalse
qboolean	gQueueScoreMessage = qfalse
int	gQueueScoreMessageTime = 0
qboolean	g_noPDuelCheck = qfalse
qboolean	gSiegeRoundBegun
qboolean	gSiegeRoundEnded
qboolean	gSiegeRoundWinningTeam
siegePers_t	g_siegePersistant
qboolean	gDidDuelStuff = qfalse
qboolean	g_endPDuel = qfalse
int	g_duelPrintTimer = 0
int	g_LastFrameTime = 0
int	g_TimeSinceLastFrame = 0
qboolean	gDoSlowMoDuel = qfalse
int	gSlowMoDuelTime = 0
int	g_siegeRespawnCheck = 0

---

Define Documentation

#define CLOAK_DEFUEL_RATE   200

Referenced by G_RunFrame().

#define CLOAK_REFUEL_RATE   150

Referenced by G_RunFrame().

#define JETPACK_DEFUEL_RATE   200

Referenced by G_RunFrame().

#define JETPACK_REFUEL_RATE   150

Referenced by G_RunFrame().

---

Function Documentation

void AddPowerDuelPlayers (  void   )

Definition at line 1330 of file g_main.c. References client, level_locals_t::clients, CON_CONNECTED, clientPersistant_t::connected, clientSession_t::duelTeam, DUELTEAM_DOUBLE, DUELTEAM_FREE, DUELTEAM_LONE, g_entities, G_PowerDuelCount(), gclient_t, level, level_locals_t::maxclients, NULL, level_locals_t::numPlayingClients, gclient_s::pers, qfalse, qtrue, gclient_s::sess, clientSession_t::sessionTeam, SetTeam(), SPECTATOR_SCOREBOARD, clientSession_t::spectatorClient, clientSession_t::spectatorState, clientSession_t::spectatorTime, TEAM_SPECTATOR, and level_locals_t::warmupTime. Referenced by CheckIntermissionExit(), and CheckTournament(). { int i; int loners = 0; int doubles = 0; int nonspecLoners = 0; int nonspecDoubles = 0; gclient_t *client; gclient_t *nextInLine; if ( level.numPlayingClients >= 3 ) { return; } nextInLine = NULL; G_PowerDuelCount(&nonspecLoners, &nonspecDoubles, qfalse); if (nonspecLoners >= 1 && nonspecDoubles >= 2) { //we have enough people, stop return; } //Could be written faster, but it's not enough to care I suppose. G_PowerDuelCount(&loners, &doubles, qtrue); if (loners < 1 || doubles < 2) { //don't bother trying to spawn anyone yet if the balance is not even set up between spectators return; } //Count again, with only in-game clients in mind. loners = nonspecLoners; doubles = nonspecDoubles; // G_PowerDuelCount(&loners, &doubles, qfalse); 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; } if (client->sess.duelTeam == DUELTEAM_FREE) { continue; } if (client->sess.duelTeam == DUELTEAM_LONE && loners >= 1) { continue; } if (client->sess.duelTeam == DUELTEAM_DOUBLE && doubles >= 2) { continue; } // never select the dedicated follow or scoreboard clients if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD || client->sess.spectatorClient < 0 ) { continue; } if ( !nextInLine || client->sess.spectatorTime < nextInLine->sess.spectatorTime ) { nextInLine = client; } } if ( !nextInLine ) { return; } level.warmupTime = -1; // set them to free-for-all team SetTeam( &g_entities[ nextInLine - level.clients ], "f" ); //Call recursively until everyone is in AddPowerDuelPlayers(); }

void AddTournamentPlayer (  void   )

Definition at line 1232 of file g_main.c. References client, level_locals_t::clients, CON_CONNECTED, clientPersistant_t::connected, g_allowHighPingDuelist, g_entities, gclient_t, vmCvar_t::integer, level, level_locals_t::maxclients, NULL, level_locals_t::numPlayingClients, gclient_s::pers, playerState_s::ping, gclient_s::ps, gclient_s::sess, clientSession_t::sessionTeam, SetTeam(), SPECTATOR_SCOREBOARD, clientSession_t::spectatorClient, clientSession_t::spectatorState, clientSession_t::spectatorTime, TEAM_SPECTATOR, and level_locals_t::warmupTime. Referenced by CheckIntermissionExit(), and CheckTournament(). { 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 (!g_allowHighPingDuelist.integer && client->ps.ping >= 999) { //don't add people who are lagging out if cvar is not set to allow it. 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.spectatorTime < nextInLine->sess.spectatorTime ) { nextInLine = client; } } if ( !nextInLine ) { return; } level.warmupTime = -1; // set them to free-for-all team SetTeam( &g_entities[ nextInLine - level.clients ], "f" ); }

void AdjustTournamentScores (  void   )

Definition at line 1525 of file g_main.c. References level_locals_t::clients, ClientUserinfoChanged(), CON_CONNECTED, clientPersistant_t::connected, CS_CLIENT_DUELWINNER, level, clientSession_t::losses, gclient_s::pers, PERS_SCORE, gclient_s::sess, level_locals_t::sortedClients, STAT_ARMOR, STAT_HEALTH, trap_SetConfigstring(), va(), and clientSession_t::wins. Referenced by BeginIntermission(). { int clientNum; if (level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE] == level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE] && level.clients[level.sortedClients[0]].pers.connected == CON_CONNECTED && level.clients[level.sortedClients[1]].pers.connected == CON_CONNECTED) { int clFirst = level.clients[ level.sortedClients[0] ].ps.stats[STAT_HEALTH] + level.clients[ level.sortedClients[0] ].ps.stats[STAT_ARMOR]; int clSec = level.clients[ level.sortedClients[1] ].ps.stats[STAT_HEALTH] + level.clients[ level.sortedClients[1] ].ps.stats[STAT_ARMOR]; int clFailure = 0; int clSuccess = 0; if (clFirst > clSec) { clFailure = 1; clSuccess = 0; } else if (clSec > clFirst) { clFailure = 0; clSuccess = 1; } else { clFailure = 2; clSuccess = 2; } if (clFailure != 2) { clientNum = level.sortedClients[clSuccess]; level.clients[ clientNum ].sess.wins++; ClientUserinfoChanged( clientNum ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", clientNum ) ); clientNum = level.sortedClients[clFailure]; level.clients[ clientNum ].sess.losses++; ClientUserinfoChanged( clientNum ); } else { clSuccess = 0; clFailure = 1; clientNum = level.sortedClients[clSuccess]; level.clients[ clientNum ].sess.wins++; ClientUserinfoChanged( clientNum ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", clientNum ) ); clientNum = level.sortedClients[clFailure]; level.clients[ clientNum ].sess.losses++; ClientUserinfoChanged( clientNum ); } } else { clientNum = level.sortedClients[0]; if ( level.clients[ clientNum ].pers.connected == CON_CONNECTED ) { level.clients[ clientNum ].sess.wins++; ClientUserinfoChanged( clientNum ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", clientNum ) ); } clientNum = level.sortedClients[1]; if ( level.clients[ clientNum ].pers.connected == CON_CONNECTED ) { level.clients[ clientNum ].sess.losses++; ClientUserinfoChanged( clientNum ); } } }

void AI_UpdateGroups (  void   )

Definition at line 964 of file NPC_AI_Utils.c. References AI_RefreshGroup(), d_noGroupAI, level_locals_t::groups, vmCvar_t::integer, level, MAX_FRAME_GROUPS, memset(), AIGroupInfo_s::numGroup, and qfalse. Referenced by G_RunFrame(). { int i; if ( d_noGroupAI.integer ) { return; } //Clear all Groups for ( i = 0; i < MAX_FRAME_GROUPS; i++ ) { if ( !level.groups[i].numGroup || AI_RefreshGroup( &level.groups[i] ) == qfalse )//level.groups[i].enemy == NULL || { memset( &level.groups[i], 0, sizeof( level.groups[i] ) ); } } }

void BeginIntermission (  void   )

Definition at line 2019 of file g_main.c. References AdjustTournamentScores(), client, CS_CLIENT_DUELWINNER, DuelLimitHit(), FindIntermissionPoint(), g_entities, g_gametype, gDuelExit, gentity_t, GT_DUEL, GT_POWERDUEL, vmCvar_t::integer, level_locals_t::intermissiontime, level, level_locals_t::maxclients, MoveClientToIntermission(), qfalse, qtrue, respawn(), SendScoreboardMessageToAllClients(), gclient_s::sess, clientSession_t::sessionTeam, TEAM_SPECTATOR, level_locals_t::time, and trap_SetConfigstring(). Referenced by CheckExitRules(), and Cmd_LevelShot_f(). { int i; gentity_t *client; if ( level.intermissiontime ) { return; // already active } // if in tournement mode, change the wins / losses if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) { trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" ); if (g_gametype.integer != GT_POWERDUEL) { AdjustTournamentScores(); } if (DuelLimitHit()) { gDuelExit = qtrue; } else { gDuelExit = qfalse; } } level.intermissiontime = level.time; FindIntermissionPoint(); /* if (g_singlePlayer.integer) { trap_Cvar_Set("ui_singlePlayerActive", "0"); UpdateTournamentInfo(); } */ //what the? Well, I don't want this to happen. // 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) { if (g_gametype.integer != GT_POWERDUEL || !client->client || client->client->sess.sessionTeam != TEAM_SPECTATOR) { //don't respawn spectators in powerduel or it will mess the line order all up respawn(client); } } MoveClientToIntermission( client ); } // send the current scoring to all clients SendScoreboardMessageToAllClients(); }

void BG_ClearVehicleParseParms (  void   )

Definition at line 79 of file bg_vehicleLoad.c. References VehicleParms, and VehWeaponParms. Referenced by G_InitGame(). { //You can't strcat to these forever without clearing them! VehWeaponParms[0] = 0; VehicleParms[0] = 0; }

int BG_GetTime (  void   )

Definition at line 3543 of file g_main.c. References level, and level_locals_t::time. { return level.time; }

void BG_VehicleLoadParms (  void   )

void CalculateRanks (  void   )

Definition at line 1735 of file g_main.c. References CheckExitRules(), level_locals_t::clients, CON_CONNECTED, CON_DISCONNECTED, clientPersistant_t::connected, CS_CLIENT_DUELWINNER, CS_SCORES1, CS_SCORES2, level_locals_t::follow1, level_locals_t::follow2, g_entities, g_gametype, gclient_t, gQueueScoreMessage, gQueueScoreMessageTime, GT_DUEL, GT_POWERDUEL, GT_SINGLE_PLAYER, GT_TEAM, gclient_s::iAmALoser, vmCvar_t::integer, level_locals_t::intermissiontime, level, level_locals_t::maxclients, level_locals_t::numConnectedClients, level_locals_t::numNonSpectatorClients, level_locals_t::numPlayingClients, level_locals_t::numteamVotingClients, level_locals_t::numVotingClients, gclient_s::pers, PERS_RANK, PERS_SCORE, playerState_s::persistant, gclient_s::ps, qsort(), qtrue, gentity_s::r, RANK_TIED_FLAG, SCORE_NOT_PRESENT, gclient_s::sess, clientSession_t::sessionTeam, level_locals_t::sortedClients, SortRanks(), SVF_BOT, entityShared_t::svFlags, TEAM_BLUE, TEAM_NUM_TEAMS, TEAM_RED, TEAM_SPECTATOR, level_locals_t::teamScores, level_locals_t::time, trap_SetConfigstring(), va(), and level_locals_t::warmupTime. Referenced by AddScore(), ClientBegin(), ClientConnect(), ClientDisconnect(), RemovePowerDuelLosers(), Team_TouchOurFlag(), and UpdateTournamentInfo(). { int i; int rank; int score; int newScore; int preNumSpec = 0; //int nonSpecIndex = -1; gclient_t *cl; preNumSpec = level.numNonSpectatorClients; level.follow1 = -1; level.follow2 = -1; level.numConnectedClients = 0; level.numNonSpectatorClients = 0; level.numPlayingClients = 0; level.numVotingClients = 0; // don't count bots for ( i = 0; i < TEAM_NUM_TEAMS; 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 || g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) { if (level.clients[i].sess.sessionTeam != TEAM_SPECTATOR) { level.numNonSpectatorClients++; //nonSpecIndex = i; } // decide if this should be auto-followed if ( level.clients[i].pers.connected == CON_CONNECTED ) { if (level.clients[i].sess.sessionTeam != TEAM_SPECTATOR || level.clients[i].iAmALoser) { 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; } } } } } //if (!g_warmup.integer) if (1) { level.warmupTime = 0; } /* if (level.numNonSpectatorClients == 2 && preNumSpec < 2 && nonSpecIndex != -1 && g_gametype.integer == GT_DUEL && !level.warmupTime) { gentity_t *currentWinner = G_GetDuelWinner(&level.clients[nonSpecIndex]); if (currentWinner && currentWinner->client) { trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s %s\n\"", currentWinner->client->pers.netname, G_GetStringEdString("MP_SVGAME", "VERSUS"), level.clients[nonSpecIndex].pers.netname)); } } */ //NOTE: for now not doing this either. May use later if appropriate. qsort( level.sortedClients, level.numConnectedClients, sizeof(level.sortedClients[0]), SortRanks ); // set the rank value for all clients that are connected and not spectators 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] ) ); } 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] ) ); } if (g_gametype.integer != GT_DUEL || g_gametype.integer != GT_POWERDUEL) { //when not in duel, use this configstring to pass the index of the player currently in first place if ( level.numConnectedClients >= 1 ) { trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", level.sortedClients[0] ) ); } else { trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" ); } } } // see if it is time to end the level CheckExitRules(); // if we are at the intermission or in multi-frag Duel game mode, send the new info to everyone if ( level.intermissiontime || g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) { gQueueScoreMessage = qtrue; gQueueScoreMessageTime = level.time + 500; //SendScoreboardMessageToAllClients(); //rww - Made this operate on a "queue" system because it was causing large overflows } }

void CheckCvars (  void   )

Definition at line 3439 of file g_main.c. References g_password, MAX_INFO_STRING, vmCvar_t::modificationCount, Q_stricmp(), strcpy(), vmCvar_t::string, and trap_Cvar_Set(). Referenced by G_RunFrame(). { static int lastMod = -1; if ( g_password.modificationCount != lastMod ) { char password[MAX_INFO_STRING]; char *c = password; lastMod = g_password.modificationCount; strcpy( password, g_password.string ); while( *c ) { if ( *c == '%' ) { *c = '.'; } c++; } trap_Cvar_Set("g_password", password ); if ( *g_password.string && Q_stricmp( g_password.string, "none" ) ) { trap_Cvar_Set( "g_needpass", "1" ); } else { trap_Cvar_Set( "g_needpass", "0" ); } } }

void CheckExitRules (  void   )

void CheckIntermissionExit (  void   )

Definition at line 2301 of file g_main.c. References AddPowerDuelPlayers(), AddTournamentPlayer(), playerState_s::clientNum, level_locals_t::clients, CON_CONNECTED, clientPersistant_t::connected, CS_CLIENT_DUELISTS, CS_CLIENT_DUELWINNER, d_noIntermissionWait, DuelLimitHit(), ExitLevel(), level_locals_t::exitTime, g_austrian, g_entities, g_fraglimit, g_gametype, G_LogPrintf(), g_maxclients, gclient_t, gDidDuelStuff, gDuelExit, GT_DUEL, GT_POWERDUEL, vmCvar_t::integer, level_locals_t::intermissiontime, level, level_locals_t::numNonSpectatorClients, level_locals_t::numPlayingClients, gclient_s::pers, PERS_SCORE, gclient_s::ps, qfalse, qtrue, level_locals_t::readyToExit, gclient_s::readyToExit, RemoveDuelDrawLoser(), RemovePowerDuelLosers(), RemoveTournamentLoser(), level_locals_t::sortedClients, STAT_CLIENTS_READY, playerState_s::stats, SVF_BOT, level_locals_t::time, trap_SetConfigstring(), and va(). Referenced by CheckExitRules(). { int ready, notReady; int i; gclient_t *cl; int readyMask; // 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++; } } if ( (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) && !gDidDuelStuff && (level.time > level.intermissiontime + 2000) ) { gDidDuelStuff = qtrue; if ( g_austrian.integer && g_gametype.integer != GT_POWERDUEL ) { G_LogPrintf("Duel Results:\n"); //G_LogPrintf("Duel Time: %d\n", level.time ); G_LogPrintf("winner: %s, score: %d, wins/losses: %d/%d\n", level.clients[level.sortedClients[0]].pers.netname, level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE], level.clients[level.sortedClients[0]].sess.wins, level.clients[level.sortedClients[0]].sess.losses ); G_LogPrintf("loser: %s, score: %d, wins/losses: %d/%d\n", level.clients[level.sortedClients[1]].pers.netname, level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE], level.clients[level.sortedClients[1]].sess.wins, level.clients[level.sortedClients[1]].sess.losses ); } // if we are running a tournement map, kick the loser to spectator status, // which will automatically grab the next spectator and restart if (!DuelLimitHit()) { if (g_gametype.integer == GT_POWERDUEL) { RemovePowerDuelLosers(); AddPowerDuelPlayers(); } else { if (level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE] == level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE] && level.clients[level.sortedClients[0]].pers.connected == CON_CONNECTED && level.clients[level.sortedClients[1]].pers.connected == CON_CONNECTED) { RemoveDuelDrawLoser(); } else { RemoveTournamentLoser(); } AddTournamentPlayer(); } if ( g_austrian.integer ) { if (g_gametype.integer == GT_POWERDUEL) { G_LogPrintf("Power Duel Initiated: %s %d/%d vs %s %d/%d and %s %d/%d, kill limit: %d\n", level.clients[level.sortedClients[0]].pers.netname, level.clients[level.sortedClients[0]].sess.wins, level.clients[level.sortedClients[0]].sess.losses, level.clients[level.sortedClients[1]].pers.netname, level.clients[level.sortedClients[1]].sess.wins, level.clients[level.sortedClients[1]].sess.losses, level.clients[level.sortedClients[2]].pers.netname, level.clients[level.sortedClients[2]].sess.wins, level.clients[level.sortedClients[2]].sess.losses, g_fraglimit.integer ); } else { G_LogPrintf("Duel Initiated: %s %d/%d vs %s %d/%d, kill limit: %d\n", level.clients[level.sortedClients[0]].pers.netname, level.clients[level.sortedClients[0]].sess.wins, level.clients[level.sortedClients[0]].sess.losses, level.clients[level.sortedClients[1]].pers.netname, level.clients[level.sortedClients[1]].sess.wins, level.clients[level.sortedClients[1]].sess.losses, g_fraglimit.integer ); } } if (g_gametype.integer == GT_POWERDUEL) { if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" ); } } else { if (level.numPlayingClients >= 2) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" ); } } return; } if ( g_austrian.integer && g_gametype.integer != GT_POWERDUEL ) { G_LogPrintf("Duel Tournament Winner: %s wins/losses: %d/%d\n", level.clients[level.sortedClients[0]].pers.netname, level.clients[level.sortedClients[0]].sess.wins, level.clients[level.sortedClients[0]].sess.losses ); } if (g_gametype.integer == GT_POWERDUEL) { RemovePowerDuelLosers(); AddPowerDuelPlayers(); if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" ); } } else { //this means we hit the duel limit so reset the wins/losses //but still push the loser to the back of the line, and retain the order for //the map change if (level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE] == level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE] && level.clients[level.sortedClients[0]].pers.connected == CON_CONNECTED && level.clients[level.sortedClients[1]].pers.connected == CON_CONNECTED) { RemoveDuelDrawLoser(); } else { RemoveTournamentLoser(); } AddTournamentPlayer(); if (level.numPlayingClients >= 2) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" ); } } } if ((g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) && !gDuelExit) { //in duel, we have different behaviour for between-round intermissions if ( level.time > level.intermissiontime + 4000 ) { //automatically go to next after 4 seconds ExitLevel(); return; } for (i=0 ; i< g_maxclients.integer ; i++) { //being in a "ready" state is not necessary here, so clear it for everyone //yes, I also thinking holding this in a ps value uniquely for each player //is bad and wrong, but it wasn't my idea. cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } cl->ps.stats[STAT_CLIENTS_READY] = 0; } return; } // 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 (d_noIntermissionWait.integer) { //don't care who wants to go, just go. ExitLevel(); 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(); }

void CheckTeamLeader (  int  team  )

Definition at line 3361 of file g_main.c. References level_locals_t::clients, g_entities, level, level_locals_t::maxclients, qtrue, gentity_s::r, gclient_s::sess, clientSession_t::sessionTeam, SVF_BOT, entityShared_t::svFlags, and clientSession_t::teamLeader. Referenced by SetTeam(). { 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; } } }

void CheckTeamVote (  int  team  )

Definition at line 3393 of file g_main.c. References CS_TEAMVOTE_TIME, EXEC_APPEND, G_GetStringEdString(), level, level_locals_t::numteamVotingClients, Q_strncmp(), TEAM_BLUE, TEAM_RED, level_locals_t::teamVoteNo, level_locals_t::teamVoteString, level_locals_t::teamVoteTime, level_locals_t::teamVoteYes, level_locals_t::time, trap_SendConsoleCommand(), trap_SendServerCommand(), trap_SetConfigstring(), va(), and VOTE_TIME. Referenced by G_RunFrame(). { 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, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEFAILED")) ); } else { if ( level.teamVoteYes[cs_offset] > level.numteamVotingClients[cs_offset]/2 ) { // execute the command, then remove the vote trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEPASSED")) ); // 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, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEFAILED")) ); } else { // still waiting for a majority return; } } level.teamVoteTime[cs_offset] = 0; trap_SetConfigstring( CS_TEAMVOTE_TIME + cs_offset, "" ); }

void CheckTournament (  void   )

Definition at line 2932 of file g_main.c. References AddPowerDuelPlayers(), AddTournamentPlayer(), level_locals_t::clients, CS_CLIENT_DUELHEALTHS, CS_CLIENT_DUELISTS, CS_WARMUP, DUELTEAM_DOUBLE, DUELTEAM_LONE, EV_GLOBAL_DUEL, EXEC_APPEND, g_austrian, G_CanResetDuelists(), g_dontFrickinCheck, g_duelPrintTimer, g_fraglimit, g_gametype, G_GetStringEdString(), G_LogPrintf(), G_PowerDuelCount(), G_RemoveDuelist(), G_ResetDuelists(), g_showDuelHealths, G_TempEntity(), g_warmup, gentity_t, entityState_s::groundEntityNum, GT_DUEL, GT_POWERDUEL, GT_TEAM, vmCvar_t::integer, level_locals_t::intermissionQueued, level_locals_t::intermissiontime, level, vmCvar_t::modificationCount, level_locals_t::numConnectedClients, level_locals_t::numNonSpectatorClients, level_locals_t::numPlayingClients, entityState_s::otherEntityNum, entityState_s::otherEntityNum2, playerState_t, qboolean, qfalse, qtrue, gentity_s::r, level_locals_t::restarted, gentity_s::s, level_locals_t::sortedClients, STAT_HEALTH, playerState_s::stats, SVF_BROADCAST, entityShared_t::svFlags, TEAM_BLUE, TEAM_NUM_TEAMS, TEAM_RED, TeamCount(), level_locals_t::time, trap_Cvar_Set(), trap_SendConsoleCommand(), trap_SendServerCommand(), trap_SetConfigstring(), va(), vec3_origin, level_locals_t::warmupModificationCount, and level_locals_t::warmupTime. Referenced by G_RunFrame(). { // check because we run 3 game frames before calling Connect and/or ClientBegin // for clients on a map_restart // if ( level.numPlayingClients == 0 && (g_gametype.integer != GT_POWERDUEL) ) { // return; // } if (g_gametype.integer == GT_POWERDUEL) { if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) ); } } else { if (level.numPlayingClients >= 2) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) ); } } if ( g_gametype.integer == GT_DUEL ) { // pull in a spectator if needed if ( level.numPlayingClients < 2 && !level.intermissiontime && !level.intermissionQueued ) { AddTournamentPlayer(); if (level.numPlayingClients >= 2) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) ); } } if (level.numPlayingClients >= 2) { // nmckenzie: DUEL_HEALTH if ( g_showDuelHealths.integer >= 1 ) { playerState_t *ps1, *ps2; ps1 = &level.clients[level.sortedClients[0]].ps; ps2 = &level.clients[level.sortedClients[1]].ps; trap_SetConfigstring ( CS_CLIENT_DUELHEALTHS, va("%i|%i|!", ps1->stats[STAT_HEALTH], ps2->stats[STAT_HEALTH])); } } //rww - It seems we have decided there will be no warmup in duel. //if (!g_warmup.integer) { //don't care about any of this stuff then, just add people and leave me alone level.warmupTime = 0; return; } #if 0 // 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; if (level.warmupTime < (level.time + 3000)) { //rww - this is an unpleasent hack to keep the level from resetting completely on the client (this happens when two map_restarts are issued rapidly) level.warmupTime = level.time + 3000; } 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; } #endif } else if (g_gametype.integer == GT_POWERDUEL) { if (level.numPlayingClients < 2) { //hmm, ok, pull more in. g_dontFrickinCheck = qfalse; } if (level.numPlayingClients > 3) { //umm..yes..lets take care of that then. int lone = 0, dbl = 0; G_PowerDuelCount(&lone, &dbl, qfalse); if (lone > 1) { G_RemoveDuelist(DUELTEAM_LONE); } else if (dbl > 2) { G_RemoveDuelist(DUELTEAM_DOUBLE); } } else if (level.numPlayingClients < 3) { //hmm, someone disconnected or something and we need em int lone = 0, dbl = 0; G_PowerDuelCount(&lone, &dbl, qfalse); if (lone < 1) { g_dontFrickinCheck = qfalse; } else if (dbl < 1) { g_dontFrickinCheck = qfalse; } } // pull in a spectator if needed if (level.numPlayingClients < 3 && !g_dontFrickinCheck) { AddPowerDuelPlayers(); if (level.numPlayingClients >= 3 && G_CanResetDuelists()) { gentity_t *te = G_TempEntity(vec3_origin, EV_GLOBAL_DUEL); te->r.svFlags |= SVF_BROADCAST; //this is really pretty nasty, but.. te->s.otherEntityNum = level.sortedClients[0]; te->s.otherEntityNum2 = level.sortedClients[1]; te->s.groundEntityNum = level.sortedClients[2]; trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) ); G_ResetDuelists(); g_dontFrickinCheck = qtrue; } else if (level.numPlayingClients > 0 || level.numConnectedClients > 0) { if (g_duelPrintTimer < level.time) { //print once every 10 seconds int lone = 0, dbl = 0; G_PowerDuelCount(&lone, &dbl, qtrue); if (lone < 1) { trap_SendServerCommand( -1, va("cp \"%s\n\"", G_GetStringEdString("MP_SVGAME", "DUELMORESINGLE")) ); } else { trap_SendServerCommand( -1, va("cp \"%s\n\"", G_GetStringEdString("MP_SVGAME", "DUELMOREPAIRED")) ); } g_duelPrintTimer = level.time + 10000; } } if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3) { //pulled in a needed person if (G_CanResetDuelists()) { gentity_t *te = G_TempEntity(vec3_origin, EV_GLOBAL_DUEL); te->r.svFlags |= SVF_BROADCAST; //this is really pretty nasty, but.. te->s.otherEntityNum = level.sortedClients[0]; te->s.otherEntityNum2 = level.sortedClients[1]; te->s.groundEntityNum = level.sortedClients[2]; trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) ); if ( g_austrian.integer ) { G_LogPrintf("Duel Initiated: %s %d/%d vs %s %d/%d and %s %d/%d, kill limit: %d\n", level.clients[level.sortedClients[0]].pers.netname, level.clients[level.sortedClients[0]].sess.wins, level.clients[level.sortedClients[0]].sess.losses, level.clients[level.sortedClients[1]].pers.netname, level.clients[level.sortedClients[1]].sess.wins, level.clients[level.sortedClients[1]].sess.losses, level.clients[level.sortedClients[2]].pers.netname, level.clients[level.sortedClients[2]].sess.wins, level.clients[level.sortedClients[2]].sess.losses, g_fraglimit.integer ); } //trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" ); //FIXME: This seems to cause problems. But we'd like to reset things whenever a new opponent is set. } } } else { //if you have proper num of players then don't try to add again g_dontFrickinCheck = qtrue; } level.warmupTime = 0; return; } else if ( 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; } } }

void CheckVote (  void   )

Definition at line 3230 of file g_main.c. References CS_VOTE_TIME, EXEC_APPEND, g_fraglimitVoteCorrection, G_GetStringEdString(), G_KickAllBots(), G_RefreshNextMap(), GT_DUEL, GT_POWERDUEL, GT_SIEGE, vmCvar_t::integer, level, level_locals_t::numVotingClients, qfalse, qtrue, level_locals_t::time, trap_Cvar_VariableIntegerValue(), trap_SendConsoleCommand(), trap_SendServerCommand(), trap_SetConfigstring(), va(), VOTE_TIME, level_locals_t::voteExecuteTime, level_locals_t::voteNo, level_locals_t::voteString, level_locals_t::voteTime, level_locals_t::voteYes, level_locals_t::votingGametype, and level_locals_t::votingGametypeTo. Referenced by G_RunFrame(). { if ( level.voteExecuteTime && level.voteExecuteTime < level.time ) { level.voteExecuteTime = 0; trap_SendConsoleCommand( EXEC_APPEND, va("%s\n", level.voteString ) ); if (level.votingGametype) { if (trap_Cvar_VariableIntegerValue("g_gametype") != level.votingGametypeTo) { //If we're voting to a different game type, be sure to refresh all the map stuff const char *nextMap = G_RefreshNextMap(level.votingGametypeTo, qtrue); if (level.votingGametypeTo == GT_SIEGE) { //ok, kick all the bots, cause the aren't supported! G_KickAllBots(); //just in case, set this to 0 too... I guess...maybe? //trap_Cvar_Set("bot_minplayers", "0"); } if (nextMap && nextMap[0]) { trap_SendConsoleCommand( EXEC_APPEND, va("map %s\n", nextMap ) ); } } else { //otherwise, just leave the map until a restart G_RefreshNextMap(level.votingGametypeTo, qfalse); } if (g_fraglimitVoteCorrection.integer) { //This means to auto-correct fraglimit when voting to and from duel. const int currentGT = trap_Cvar_VariableIntegerValue("g_gametype"); const int currentFL = trap_Cvar_VariableIntegerValue("fraglimit"); const int currentTL = trap_Cvar_VariableIntegerValue("timelimit"); if ((level.votingGametypeTo == GT_DUEL || level.votingGametypeTo == GT_POWERDUEL) && currentGT != GT_DUEL && currentGT != GT_POWERDUEL) { if (currentFL > 3 || !currentFL) { //if voting to duel, and fraglimit is more than 3 (or unlimited), then set it down to 3 trap_SendConsoleCommand(EXEC_APPEND, "fraglimit 3\n"); } if (currentTL) { //if voting to duel, and timelimit is set, make it unlimited trap_SendConsoleCommand(EXEC_APPEND, "timelimit 0\n"); } } else if ((level.votingGametypeTo != GT_DUEL && level.votingGametypeTo != GT_POWERDUEL) && (currentGT == GT_DUEL || currentGT == GT_POWERDUEL)) { if (currentFL && currentFL < 20) { //if voting from duel, an fraglimit is less than 20, then set it up to 20 trap_SendConsoleCommand(EXEC_APPEND, "fraglimit 20\n"); } } } level.votingGametype = qfalse; level.votingGametypeTo = 0; } } if ( !level.voteTime ) { return; } if ( level.time - level.voteTime >= VOTE_TIME ) { trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEFAILED")) ); } else { if ( level.voteYes > level.numVotingClients/2 ) { // execute the command, then remove the vote trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEPASSED")) ); level.voteExecuteTime = level.time + 3000; } else if ( level.voteNo >= level.numVotingClients/2 ) { // same behavior as a timeout trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEFAILED")) ); } else { // still waiting for a majority return; } } level.voteTime = 0; trap_SetConfigstring( CS_VOTE_TIME, "" ); }

void ClearNPCGlobals (  void   )

Definition at line 647 of file NPC.c. References client, NPC, NPCInfo, and NULL. Referenced by G_RunFrame(). { NPC = NULL; NPCInfo = NULL; client = NULL; }

void ClearPlayerAlertEvents (  void   )

Definition at line 660 of file NPC_senses.c. References ALERT_CLEAR_TIME, alertEvent_t, level_locals_t::alertEvents, eventClearTime, level, MAX_ALERT_EVENTS, memmove(), memset(), level_locals_t::numAlertEvents, level_locals_t::time, and alertEvent_s::timestamp. { int curNumAlerts = level.numAlertEvents; int i; //loop through them all (max 32) for ( i = 0; i < curNumAlerts; i++ ) { //see if the event is old enough to delete if ( level.alertEvents[i].timestamp && level.alertEvents[i].timestamp + ALERT_CLEAR_TIME < level.time ) {//this event has timed out //drop the count level.numAlertEvents--; //shift the rest down if ( level.numAlertEvents > 0 ) {//still have more in the array if ( (i+1) < MAX_ALERT_EVENTS ) { memmove( &level.alertEvents[i], &level.alertEvents[i+1], sizeof(alertEvent_t)*(MAX_ALERT_EVENTS-(i+1) ) ); } } else {//just clear this one... or should we clear the whole array? memset( &level.alertEvents[i], 0, sizeof( alertEvent_t ) ); } } } //make sure this never drops below zero... if it does, something very very bad happened assert( level.numAlertEvents >= 0 ); if ( eventClearTime < level.time ) {//this is just a 200ms debouncer so things that generate constant alerts (like corpses and missiles) add an alert every 200 ms eventClearTime = level.time + ALERT_CLEAR_TIME; } }

void QDECL Com_Error (  int  level, const char *  error, ...  )

Definition at line 1192 of file g_main.c. References G_Error(), QDECL, va_end, va_list, va_start, and vsprintf(). { va_list argptr; char text[1024]; va_start (argptr, error); vsprintf (text, error, argptr); va_end (argptr); G_Error( "%s", text); }

void QDECL Com_Printf (  const char *  msg, ...  )

Definition at line 1203 of file g_main.c. References G_Printf(), QDECL, va_end, va_list, va_start, and vsprintf(). { va_list argptr; char text[1024]; va_start (argptr, msg); vsprintf (text, msg, argptr); va_end (argptr); G_Printf ("%s", text); }

void CP_FindCombatPointWaypoints (  void   )

Definition at line 2548 of file NPC_combat.c. References Com_Printf(), level_locals_t::combatPoints, level, NAV_FindClosestWaypointForPoint2(), level_locals_t::numCombatPoints, combatPoint_t::origin, S_COLOR_RED, vtos(), combatPoint_t::waypoint, and WAYPOINT_NONE. Referenced by G_InitGame(), and vmMain(). { int i; for ( i = 0; i < level.numCombatPoints; i++ ) { level.combatPoints[i].waypoint = NAV_FindClosestWaypointForPoint2( level.combatPoints[i].origin ); #ifndef FINAL_BUILD if ( level.combatPoints[i].waypoint == WAYPOINT_NONE ) { Com_Printf( S_COLOR_RED"ERROR: Combat Point at %s has no waypoint!\n", vtos(level.combatPoints[i].origin) ); } #endif } }

qboolean DuelLimitHit (  void   )

Definition at line 2078 of file g_main.c. References level_locals_t::clients, CON_CONNECTED, clientPersistant_t::connected, g_duel_fraglimit, g_maxclients, gclient_t, vmCvar_t::integer, level, gclient_s::pers, qboolean, qfalse, qtrue, gclient_s::sess, and clientSession_t::wins. Referenced by BeginIntermission(), CheckIntermissionExit(), and ExitLevel(). { int i; gclient_t *cl; for ( i=0 ; i< g_maxclients.integer ; i++ ) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } if ( g_duel_fraglimit.integer && cl->sess.wins >= g_duel_fraglimit.integer ) { return qtrue; } } return qfalse; }

void DuelResetWinsLosses (  void   )

Definition at line 2098 of file g_main.c. References level_locals_t::clients, CON_CONNECTED, clientPersistant_t::connected, g_maxclients, gclient_t, vmCvar_t::integer, level, clientSession_t::losses, gclient_s::pers, gclient_s::sess, and clientSession_t::wins. Referenced by ExitLevel(). { int i; gclient_t *cl; for ( i=0 ; i< g_maxclients.integer ; i++ ) { cl = level.clients + i; if ( cl->pers.connected != CON_CONNECTED ) { continue; } cl->sess.wins = 0; cl->sess.losses = 0; } }

void ExitLevel (  void   )

Definition at line 2125 of file g_main.c. References siegePers_s::beatingTime, level_locals_t::changemap, level_locals_t::clients, CON_CONNECTED, CON_CONNECTING, clientPersistant_t::connected, DuelLimitHit(), DuelResetWinsLosses(), EXEC_APPEND, g_gametype, g_maxclients, g_siegePersistant, g_siegeTeamSwitch, G_WriteSessionData(), gclient_t, GT_DUEL, GT_POWERDUEL, GT_SIEGE, vmCvar_t::integer, level_locals_t::intermissiontime, level, NULL, gclient_s::pers, PERS_SCORE, playerState_s::persistant, gclient_s::ps, qtrue, level_locals_t::restarted, SiegeDoTeamAssign(), TEAM_BLUE, TEAM_RED, level_locals_t::teamScores, and trap_SendConsoleCommand(). Referenced by CheckIntermissionExit(). { int i; gclient_t *cl; // if we are running a tournement map, kick the loser to spectator status, // which will automatically grab the next spectator and restart if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) { if (!DuelLimitHit()) { if ( !level.restarted ) { trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" ); level.restarted = qtrue; level.changemap = NULL; level.intermissiontime = 0; } return; } DuelResetWinsLosses(); } if (g_gametype.integer == GT_SIEGE && g_siegeTeamSwitch.integer && g_siegePersistant.beatingTime) { //restart same map... trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" ); } else { trap_SendConsoleCommand( EXEC_APPEND, "vstr nextmap\n" ); } level.changemap = NULL; level.intermissiontime = 0; if (g_gametype.integer == GT_SIEGE && g_siegeTeamSwitch.integer) { //switch out now SiegeDoTeamAssign(); } // reset all the scores so we don't enter the intermission again level.teamScores[TEAM_RED] = 0; level.teamScores[TEAM_BLUE] = 0; 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; } } }

void FindIntermissionPoint (  void   )

Definition at line 1963 of file g_main.c. References entityState_s::angles, FOFS, G_Find(), g_gametype, G_PickTarget(), G_UseTargets2(), gentity_t, gSiegeRoundEnded, gSiegeRoundWinningTeam, GT_SIEGE, vmCvar_t::integer, level_locals_t::intermission_angle, level_locals_t::intermission_origin, level_locals_t::intermissiontime, level, NULL, entityState_s::origin, gentity_s::s, SelectSpawnPoint(), SIEGETEAM_TEAM1, SIEGETEAM_TEAM2, gentity_s::target, gentity_s::target2, TEAM_SPECTATOR, level_locals_t::time, vec3_origin, vec3_t, vectoangles(), VectorCopy, and VectorSubtract. Referenced by BeginIntermission(), and SelectSpectatorSpawnPoint(). { gentity_t *ent = NULL; gentity_t *target; vec3_t dir; // find the intermission spot if ( g_gametype.integer == GT_SIEGE && level.intermissiontime && level.intermissiontime <= level.time && gSiegeRoundEnded ) { if (gSiegeRoundWinningTeam == SIEGETEAM_TEAM1) { ent = G_Find (NULL, FOFS(classname), "info_player_intermission_red"); if ( ent && ent->target2 ) { G_UseTargets2( ent, ent, ent->target2 ); } } else if (gSiegeRoundWinningTeam == SIEGETEAM_TEAM2) { ent = G_Find (NULL, FOFS(classname), "info_player_intermission_blue"); if ( ent && ent->target2 ) { G_UseTargets2( ent, ent, ent->target2 ); } } } if ( !ent ) { 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, TEAM_SPECTATOR ); } else { VectorCopy (ent->s.origin, level.intermission_origin); VectorCopy (ent->s.angles, level.intermission_angle); // 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 ); } } } }

qboolean G_CanResetDuelists (  void   )

Definition at line 1679 of file g_main.c. References gentity_s::client, clientSession_t::duelTeam, DUELTEAM_FREE, g_entities, gentity_t, gentity_s::health, gentity_s::inuse, level, qboolean, qfalse, qtrue, gclient_s::sess, clientSession_t::sessionTeam, level_locals_t::sortedClients, and TEAM_SPECTATOR. Referenced by CheckTournament(). { int i; gentity_t *ent; i = 0; while (i < 3) { //precheck to make sure they are all respawnable ent = &g_entities[level.sortedClients[i]]; if (!ent->inuse || !ent->client || ent->health <= 0 || ent->client->sess.sessionTeam == TEAM_SPECTATOR || ent->client->sess.duelTeam <= DUELTEAM_FREE) { return qfalse; } i++; } return qtrue; }

qboolean G_EntIsBreakable (  int  entityNum  )

Definition at line 2817 of file g_mover.c. { gentity_t *ent; if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD ) { return qfalse; } ent = &g_entities[entityNum]; if ( (ent->r.svFlags & SVF_GLASS_BRUSH) ) { return qtrue; } /* if ( (ent->svFlags&SVF_BBRUSH) ) { return qtrue; } */ if ( !Q_stricmp( "func_breakable", ent->classname ) ) { return qtrue; } if ( !Q_stricmp( "misc_model_breakable", ent->classname ) ) { return qtrue; } if ( !Q_stricmp( "misc_maglock", ent->classname ) ) { return qtrue; } return qfalse; }

qboolean G_EntIsDoor (  int  entityNum  )

Definition at line 1212 of file g_mover.c. { gentity_t *ent; if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD ) { return qfalse; } ent = &g_entities[entityNum]; if ( ent && !Q_stricmp( "func_door", ent->classname ) ) {//blocked by a door return qtrue; } return qfalse; }

qboolean G_EntIsRemovableUsable (  int  entNum  )

Definition at line 3023 of file g_mover.c. { gentity_t *ent = &g_entities[entNum]; if ( ent->classname && !Q_stricmp( "func_usable", ent->classname ) ) { if ( !(ent->s.eFlags&EF_SHADER_ANIM) && !(ent->spawnflags&8) && ent->targetname ) {//not just a shader-animator and not ALWAYS_ON, so it must be removable somehow return qtrue; } } return qfalse; }

qboolean G_EntIsUnlockedDoor (  int  entityNum  )

Definition at line 1272 of file g_mover.c. { if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD ) { return qfalse; } if ( G_EntIsDoor( entityNum ) ) { gentity_t *ent = &g_entities[entityNum]; gentity_t *owner = NULL; if ( ent->flags & FL_TEAMSLAVE ) {//not the master door, get the master door while ( ent->teammaster && (ent->flags&FL_TEAMSLAVE)) { ent = ent->teammaster; } } if ( ent->targetname ) {//find out what is targetting it owner = NULL; //FIXME: if ent->targetname, check what kind of trigger/ent is targetting it? If a normal trigger (active, etc), then it's okay? while ( (owner = G_Find( owner, FOFS( target ), ent->targetname )) != NULL ) { if ( !Q_stricmp( "trigger_multiple", owner->classname ) )//FIXME: other triggers okay too? { if ( !(owner->flags & FL_INACTIVE) ) { return qtrue; } } } owner = NULL; while ( (owner = G_Find( owner, FOFS( target2 ), ent->targetname )) != NULL ) { if ( !Q_stricmp( "trigger_multiple", owner->classname ) )//FIXME: other triggers okay too? { if ( !(owner->flags & FL_INACTIVE) ) { return qtrue; } } } return qfalse; } else {//check the door's auto-created trigger instead owner = G_FindDoorTrigger( ent ); if ( owner && (owner->flags&FL_INACTIVE) ) {//owning auto-created trigger is inactive return qfalse; } } if ( !(ent->flags & FL_INACTIVE) && //assumes that the reactivate trigger isn't right next to the door! !ent->health && !(ent->spawnflags & MOVER_PLAYER_USE) && !(ent->spawnflags & MOVER_FORCE_ACTIVATE) && !(ent->spawnflags & MOVER_LOCKED)) //FIXME: what about MOVER_GOODIE? { return qtrue; } } return qfalse; }

void QDECL G_Error (  const char *  fmt, ...  )

Definition at line 702 of file g_main.c. References QDECL, trap_Error(), va_end, va_list, va_start, and vsprintf(). Referenced by Cmd_FollowCycle_f(), Com_Error(), G_AddSpawnVarToken(), G_Alloc(), G_ParseSpawnVars(), G_Spawn(), G_SpawnEntitiesFromString(), G_TryPushingEntity(), hyperspace_touch(), InitSiegeMode(), NPC_LoadParms(), Reached_BinaryMover(), RegisterItem(), RespawnItem(), SelectDuelSpawnPoint(), SelectRandomFurthestSpawnPoint(), shipboundary_touch(), SP_func_breakable(), SP_misc_siege_item(), SP_target_level_change(), SP_target_play_music(), SP_target_speaker(), SP_trigger_hyperspace(), SP_trigger_shipboundary(), and SP_worldspawn(). { va_list argptr; char text[1024]; va_start (argptr, fmt); vsprintf (text, fmt, argptr); va_end (argptr); trap_Error( text ); }

void G_FindTeams (  void   )

Definition at line 724 of file g_main.c. References CONTENTS_TRIGGER, FL_TEAMSLAVE, gentity_s::flags, g_entities, gentity_t, gentity_s::inuse, level, NULL, level_locals_t::num_entities, strcmp(), gentity_s::targetname, gentity_s::team, gentity_s::teamchain, and gentity_s::teammaster. Referenced by G_InitGame(). { 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; if (e->r.contents==CONTENTS_TRIGGER) continue;//triggers NEVER link up in teams! 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); }

const char* G_GetStringEdString (  char *  refSection, char *  refName )

Definition at line 4088 of file g_main.c. References Com_sprintf(). Referenced by BroadcastTeamChange(), CheatsOk(), CheckExitRules(), CheckTeamVote(), CheckTournament(), CheckVote(), ClientBegin(), ClientCommand(), ClientConnect(), ClientThink_real(), ClientUserinfoChanged(), Cmd_CallTeamVote_f(), Cmd_CallVote_f(), Cmd_DuelTeam_f(), Cmd_EngageDuel_f(), Cmd_ForceChanged_f(), Cmd_Kill_f(), Cmd_SetViewpos_f(), Cmd_SiegeClass_f(), Cmd_Team_f(), Cmd_TeamVote_f(), Cmd_Vote_f(), JMSaberTouch(), SetLeader(), and SetTeam(). { /* static char text[1024]={0}; trap_SP_GetStringTextString(va("%s_%s", refSection, refName), text, sizeof(text)); return text; */ //Well, it would've been lovely doing it the above way, but it would mean mixing //languages for the client depending on what the server is. So we'll mark this as //a stringed reference with @@@ and send the refname to the client, and when it goes //to print it will get scanned for the stringed reference indication and dealt with //properly. static char text[1024]={0}; Com_sprintf(text, sizeof(text), "@@@%s", refName); return text; }

void G_InitGame (  int  levelTime, int  randomSeed, int  restart )

Definition at line 884 of file g_main.c. References B_InitAlloc(), BG_ClearVehicleParseParms(), bg_customSiegeSoundNames, BG_InitAnimsets(), BG_VehicleLoadParms(), BotAILoadMap(), BotAISetup(), ClearRegisteredItems(), gentity_s::client, level_locals_t::clients, CP_FindCombatPointWaypoints(), CS_CLIENT_DUELHEALTHS, CS_CLIENT_DUELISTS, CS_CLIENT_DUELWINNER, CS_CLIENT_JEDIMASTER, CVAR_ROM, CVAR_SERVERINFO, FS_APPEND, FS_APPEND_SYNC, G_CheckTeamItems(), g_clients, g_duel_fraglimit, g_entities, G_FindTeams(), g_fraglimit, g_gametype, G_InitBots(), G_InitMemory(), G_InitWorldSession(), g_log, G_LogPrintf(), g_logSync, G_LogWeaponInit(), g_maxclients, G_ModelIndex(), G_Printf(), G_ProcessIPBans(), G_RegisterCvars(), G_RemapTeamShaders(), g_RMG, G_SoundIndex(), G_SpawnEntitiesFromString(), GAMEVERSION, level_locals_t::gentities, gentity_t, gSharedBuffer, GT_DUEL, GT_JEDIMASTER, GT_POWERDUEL, GT_SIEGE, GT_SINGLE_PLAYER, GT_TEAM, InitBodyQue(), InitSiegeMode(), vmCvar_t::integer, level, level_locals_t::logFile, MAX_CLIENTS, MAX_CUSTOM_SIEGE_SOUNDS, MAX_GENTITIES, MAX_INFO_STRING, level_locals_t::maxclients, memset(), navCalculatePaths, NPC_InitGame(), level_locals_t::num_entities, gclient_s::ps, qfalse, qtrue, RemoveAllWP(), SaveRegisteredItems(), level_locals_t::snd_fry, level_locals_t::snd_hack, level_locals_t::snd_medHealed, level_locals_t::snd_medSupplied, SP_PODIUM_MODEL, srand(), START_TIME_NAV_CALC, level_locals_t::startTime, vmCvar_t::string, level_locals_t::time, TIMER_Clear(), trap_Cvar_Register(), trap_Cvar_Set(), trap_Cvar_VariableIntegerValue(), trap_FS_FOpenFile(), trap_G2API_CleanEntAttachments(), trap_GetServerinfo(), trap_ICARUS_Init(), trap_LocateGameData(), trap_Nav_Load(), trap_Nav_SetPathsCalculated(), trap_SetConfigstring(), trap_SV_RegisterSharedMemory(), va(), and WP_SaberLoadParms(). Referenced by vmMain(). { int i; vmCvar_t mapname; vmCvar_t ckSum; #ifdef _XBOX if(restart) { BG_ClearVehicleParseParms(); RemoveAllWP(); } #endif //Init RMG to 0, it will be autoset to 1 if there is terrain on the level. trap_Cvar_Set("RMG", "0"); g_RMG.integer = 0; //Clean up any client-server ghoul2 instance attachments that may still exist exe-side trap_G2API_CleanEntAttachments(); BG_InitAnimsets(); //clear it out B_InitAlloc(); //make sure everything is clean trap_SV_RegisterSharedMemory(gSharedBuffer); //Load external vehicle data BG_VehicleLoadParms(); 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 level.snd_hack = G_SoundIndex("sound/player/hacking.wav"); level.snd_medHealed = G_SoundIndex("sound/player/supp_healed.wav"); level.snd_medSupplied = G_SoundIndex("sound/player/supp_supplied.wav"); //trap_SP_RegisterServer("mp_svgame"); #ifndef _XBOX if ( 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" ); } #endif G_LogWeaponInit(); 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<level.maxclients ; i++ ) { g_entities[i].client = level.clients + i; } // always leave room for the max number of clients, // even if they aren't all used, so numbers inside that // range are NEVER anything but clients level.num_entities = MAX_CLIENTS; // let the server system know where the entites are trap_LocateGameData( level.gentities, level.num_entities, sizeof( gentity_t ), &level.clients[0].ps, sizeof( level.clients[0] ) ); //Load sabers.cfg data WP_SaberLoadParms(); NPC_InitGame(); TIMER_Clear(); // //ICARUS INIT START // Com_Printf("------ ICARUS Initialization ------\n"); trap_ICARUS_Init(); // Com_Printf ("-----------------------------------\n"); //ICARUS INIT END // // reserve some spots for dead player bodies InitBodyQue(); ClearRegisteredItems(); //make sure saber data is loaded before this! (so we can precache the appropriate hilts) InitSiegeMode(); trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM ); trap_Cvar_Register( &ckSum, "sv_mapChecksum", "", CVAR_ROM ); navCalculatePaths = ( trap_Nav_Load( mapname.string, ckSum.integer ) == qfalse ); // parse the key/value pairs and spawn gentities G_SpawnEntitiesFromString(qfalse); // general initialization G_FindTeams(); // make sure we have flags for CTF, etc if( g_gametype.integer >= GT_TEAM ) { G_CheckTeamItems(); } else if ( g_gametype.integer == GT_JEDIMASTER ) { trap_SetConfigstring ( CS_CLIENT_JEDIMASTER, "-1" ); } if (g_gametype.integer == GT_POWERDUEL) { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("-1|-1|-1") ); } else { trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("-1|-1") ); } // nmckenzie: DUEL_HEALTH: Default. trap_SetConfigstring ( CS_CLIENT_DUELHEALTHS, va("-1|-1|!") ); trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("-1") ); SaveRegisteredItems(); //G_Printf ("-----------------------------------\n"); if( g_gametype.integer == GT_SINGLE_PLAYER || trap_Cvar_VariableIntegerValue( "com_buildScript" ) ) { G_ModelIndex( SP_PODIUM_MODEL ); G_SoundIndex( "sound/player/gurp1.wav" ); G_SoundIndex( "sound/player/gurp2.wav" ); } if ( trap_Cvar_VariableIntegerValue( "bot_enable" ) ) { BotAISetup( restart ); BotAILoadMap( restart ); G_InitBots( restart ); } G_RemapTeamShaders(); if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) { G_LogPrintf("Duel Tournament Begun: kill limit %d, win limit: %d\n", g_fraglimit.integer, g_duel_fraglimit.integer ); } if ( navCalculatePaths ) {//not loaded - need to calc paths navCalcPathTime = level.time + START_TIME_NAV_CALC;//make sure all ents are in and linked } else {//loaded //FIXME: if this is from a loadgame, it needs to be sure to write this //out whenever you do a savegame since the edges and routes are dynamic... //OR: always do a navigator.CheckBlockedEdges() on map startup after nav-load/calc-paths //navigator.pathsCalculated = qtrue;//just to be safe? Does this get saved out? No... assumed trap_Nav_SetPathsCalculated(qtrue); //need to do this, because combatpoint waypoints aren't saved out...? CP_FindCombatPointWaypoints(); navCalcPathTime = 0; /* if ( g_eSavedGameJustLoaded == eNO ) {//clear all the failed edges unless we just loaded the game (which would include failed edges) trap_Nav_ClearAllFailedEdges(); } */ //No loading games in MP. } if (g_gametype.integer == GT_SIEGE) { //just get these configstrings registered now... int i = 0; while (i < MAX_CUSTOM_SIEGE_SOUNDS) { if (!bg_customSiegeSoundNames[i]) { break; } G_SoundIndex((char *)bg_customSiegeSoundNames[i]); i++; } } }

void G_KickAllBots (  void   )

Definition at line 3202 of file g_main.c. References playerState_s::clientNum, level_locals_t::clients, CON_CONNECTED, clientPersistant_t::connected, EXEC_INSERT, g_entities, g_maxclients, gclient_t, vmCvar_t::integer, level, clientPersistant_t::netname, gclient_s::pers, gclient_s::ps, Q_CleanStr(), strcpy(), SVF_BOT, trap_SendConsoleCommand(), and va(). Referenced by CheckVote(). { int i; char netname[36]; gclient_t *cl; 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; } strcpy(netname, cl->pers.netname); Q_CleanStr(netname); trap_SendConsoleCommand( EXEC_INSERT, va("kick \"%s\"\n", netname) ); } }

void QDECL G_LogPrintf (  const char *  fmt, ...  )

Definition at line 2197 of file g_main.c. References Com_sprintf(), g_dedicated, G_Printf(), vmCvar_t::integer, level, level_locals_t::logFile, min, QDECL, strlen(), level_locals_t::time, trap_FS_Write(), va_end, va_list, va_start, and vsprintf(). Referenced by BroadcastTeamChange(), CheckIntermissionExit(), CheckTournament(), ClientBegin(), ClientConnect(), ClientDisconnect(), ClientUserinfoChanged(), G_CheckForDismemberment(), G_InitGame(), G_LogWeaponOutput(), G_Say(), G_ShutdownGame(), LogExit(), player_die(), and Touch_Item(). { va_list argptr; char string[1024]; int min, tens, sec; sec = level.time / 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 ); vsprintf( 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 ); }

qboolean G_ParseSpawnVars (  qboolean  inSubBSP  )

Definition at line 1018 of file g_spawn.c. References G_AddSpawnVarToken(), G_Error(), level, MAX_SPAWN_VARS, MAX_TOKEN_CHARS, level_locals_t::numSpawnVarChars, level_locals_t::numSpawnVars, qboolean, qfalse, qtrue, level_locals_t::spawnVars, and trap_GetEntityToken(). Referenced by G_SpawnEntitiesFromString(), and vmMain(). { char keyname[MAX_TOKEN_CHARS]; char com_token[MAX_TOKEN_CHARS]; level.numSpawnVars = 0; level.numSpawnVarChars = 0; // parse the opening brace if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) ) { // end of spawn string return qfalse; } if ( com_token[0] != '{' ) { G_Error( "G_ParseSpawnVars: found %s when expecting {",com_token ); } // go through all the key / value pairs while ( 1 ) { // parse key if ( !trap_GetEntityToken( keyname, sizeof( keyname ) ) ) { G_Error( "G_ParseSpawnVars: EOF without closing brace" ); } if ( keyname[0] == '}' ) { break; } // parse value if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) ) { G_Error( "G_ParseSpawnVars: EOF without closing brace" ); } if ( com_token[0] == '}' ) { G_Error( "G_ParseSpawnVars: closing brace without data" ); } if ( level.numSpawnVars == MAX_SPAWN_VARS ) { G_Error( "G_ParseSpawnVars: MAX_SPAWN_VARS" ); } level.spawnVars[ level.numSpawnVars ][0] = G_AddSpawnVarToken( keyname ); level.spawnVars[ level.numSpawnVars ][1] = G_AddSpawnVarToken( com_token ); level.numSpawnVars++; } if (inSubBSP) { HandleEntityAdjustment(); } return qtrue; }

qboolean G_PointInBounds (  vec3_t  point, vec3_t  mins, vec3_t  maxs )

Definition at line 1877 of file g_utils.c. { int i; for(i = 0; i < 3; i++ ) { if ( point[i] < mins[i] ) { return qfalse; } if ( point[i] > maxs[i] ) { return qfalse; } } return qtrue; }

void G_PowerDuelCount (  int *  loners, int *  doubles, qboolean  countSpec )

Definition at line 1305 of file g_main.c. References gentity_s::client, clientSession_t::duelTeam, DUELTEAM_DOUBLE, DUELTEAM_LONE, g_entities, gclient_t, gentity_s::inuse, MAX_CLIENTS, gclient_s::sess, clientSession_t::sessionTeam, and TEAM_SPECTATOR. Referenced by AddPowerDuelPlayers(), CheckTournament(), G_InitSessionData(), and G_PowerDuelCheckFail(). { int i = 0; gclient_t *cl; while (i < MAX_CLIENTS) { cl = g_entities[i].client; if (g_entities[i].inuse && cl && (countSpec || cl->sess.sessionTeam != TEAM_SPECTATOR)) { if (cl->sess.duelTeam == DUELTEAM_LONE) { (*loners)++; } else if (cl->sess.duelTeam == DUELTEAM_DOUBLE) { (*doubles)++; } } i++; } }

void QDECL G_Printf (  const char *  fmt, ...  )

Definition at line 691 of file g_main.c. References QDECL, trap_Printf(), va_end, va_list, va_start, and vsprintf(). Referenced by AcceptBotCommand(), B_Alloc(), B_Free(), BotUtilizePersonality(), BotWaypointRender(), ClientForString(), Com_Printf(), ConnectTrail(), CreateNewWP(), CreateNewWP_FromObject(), CreateNewWP_InsertUnder(), CreateNewWP_InTrail(), CTFTakesPriority(), FinishSpawningItem(), G_AddEvent(), G_Alloc(), G_CallSpawn(), G_CheckTeamItems(), G_Damage(), G_InitGame(), G_InitWorldSession(), G_LogPrintf(), G_PickTarget(), G_RegisterCvars(), G_RMGPathing(), G_RunFrame(), G_Say(), G_UseTargets2(), LoadPathData(), locateCamera(), ReadChatGroups(), RemoveWP_InTrail(), SavePathData(), SP_func_timer(), SP_func_train(), SP_info_siege_decomplete(), SP_info_siege_objective(), SP_misc_ammo_floor_unit(), SP_misc_holocron(), SP_misc_shield_floor_unit(), SP_path_corner(), SP_target_teleporter(), Svcmd_AddIP_f(), Svcmd_EntityList_f(), Svcmd_GameMem_f(), Svcmd_RemoveIP_f(), target_laser_start(), target_teleporter_use(), Team_CaptureFlagSound(), Team_ReturnFlagSound(), Team_TakeFlagSound(), TeleportToWP(), TransferWPData(), trigger_teleporter_touch(), UseSiegeTarget(), and WPFlagsModify(). { va_list argptr; char text[1024]; va_start (argptr, fmt); vsprintf (text, fmt, argptr); va_end (argptr); trap_Printf( text ); }

void G_RegisterCvars (  void   )

Definition at line 791 of file g_main.c. References g_gametype, G_Printf(), G_RemapTeamShaders(), g_warmup, GT_CTY, GT_HOLOCRON, GT_JEDIMASTER, GT_MAX_GAME_TYPE, vmCvar_t::integer, level, vmCvar_t::modificationCount, qboolean, qfalse, qtrue, trap_Cvar_Register(), trap_Cvar_Set(), and level_locals_t::warmupModificationCount. Referenced by G_InitGame(). { 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 ) { G_Printf( "g_gametype %i is out of range, defaulting to 0\n", g_gametype.integer ); trap_Cvar_Set( "g_gametype", "0" ); } else if (g_gametype.integer == GT_HOLOCRON) { G_Printf( "This gametype is not supported.\n" ); trap_Cvar_Set( "g_gametype", "0" ); } else if (g_gametype.integer == GT_JEDIMASTER) { G_Printf( "This gametype is not supported.\n" ); trap_Cvar_Set( "g_gametype", "0" ); } else if (g_gametype.integer == GT_CTY) { G_Printf( "This gametype is not supported.\n" ); trap_Cvar_Set( "g_gametype", "0" ); } level.warmupModificationCount = g_warmup.modificationCount; }

void G_RemapTeamShaders (  void   )

Definition at line 771 of file g_main.c. References AddRemap(), BuildShaderStateConfig(), Com_sprintf(), CS_SHADERSTATE, level, level_locals_t::time, and trap_SetConfigstring(). Referenced by G_InitGame(), G_RegisterCvars(), and G_UpdateCvars(). { #if 0 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 }

void G_RemoveDuelist (  int  team  )

Definition at line 2907 of file g_main.c. References gentity_s::client, clientSession_t::duelTeam, g_entities, gentity_t, gentity_s::inuse, MAX_CLIENTS, gclient_s::sess, clientSession_t::sessionTeam, SetTeam(), and TEAM_SPECTATOR. Referenced by CheckTournament(). { int i = 0; gentity_t *ent; while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent->inuse && ent->client && ent->client->sess.sessionTeam != TEAM_SPECTATOR && ent->client->sess.duelTeam == team) { SetTeam(ent, "s"); } i++; } }

void G_ResetDuelists (  void   )

Definition at line 1702 of file g_main.c. References gentity_s::client, entityState_s::clientNum, ClientSpawn(), EV_PLAYER_TELEPORT_IN, g_entities, g_noPDuelCheck, G_TempEntity(), gentity_t, level, MOD_SUICIDE, playerState_s::origin, player_die(), gclient_s::ps, qfalse, qtrue, gentity_s::s, level_locals_t::sortedClients, and trap_UnlinkEntity(). Referenced by CheckTournament(). { int i; gentity_t *ent; gentity_t *tent; i = 0; while (i < 3) { ent = &g_entities[level.sortedClients[i]]; g_noPDuelCheck = qtrue; player_die(ent, ent, ent, 999, MOD_SUICIDE); g_noPDuelCheck = qfalse; trap_UnlinkEntity (ent); ClientSpawn(ent); // add a teleportation effect tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN ); tent->s.clientNum = ent->s.clientNum; i++; } }

void G_ROFF_NotetrackCallback (  gentity_t *  cent, const char *  notetrack )

Definition at line 2039 of file g_utils.c. References entityState_s::angles2, entityState_s::apos, entityShared_t::currentAngles, entityShared_t::currentOrigin, gentity_t, entityState_s::number, entityState_s::origin2, entityState_s::pos, qfalse, gentity_s::r, gentity_s::roffid, gentity_s::s, strcmp(), trap_ROFF_Play(), trajectory_t::trBase, and VectorCopy. Referenced by vmMain(). { char type[256]; int i = 0; int addlArg = 0; if (!cent || !notetrack) { return; } while (notetrack[i] && notetrack[i] != ' ') { type[i] = notetrack[i]; i++; } type[i] = '\0'; if (!i || !type[0]) { return; } if (notetrack[i] == ' ') { addlArg = 1; } if (strcmp(type, "loop") == 0) { if (addlArg) //including an additional argument means reset to original position before loop { VectorCopy(cent->s.origin2, cent->s.pos.trBase); VectorCopy(cent->s.origin2, cent->r.currentOrigin); VectorCopy(cent->s.angles2, cent->s.apos.trBase); VectorCopy(cent->s.angles2, cent->r.currentAngles); } trap_ROFF_Play(cent->s.number, cent->roffid, qfalse); } }

void G_RunFrame (  int  levelTime  )

Definition at line 3566 of file g_main.c. References entityShared_t::absmax, entityShared_t::absmin, AI_UpdateGroups(), atof(), bgSiegeClasses, BOTH_CONSOLE1, BUTTON_USE, usercmd_s::buttons, CFL_STATVIEWER, CHAN_VOICE, CheckCvars(), CheckExitRules(), CheckTeamStatus(), CheckTeamVote(), CheckTournament(), CheckVote(), ClearNPCGlobals(), ClearPlayerAlertEvents(), gentity_s::client, ClientEndFrame(), CLOAK_DEFUEL_RATE, CLOAK_REFUEL_RATE, gclient_s::cloakDebRecharge, gclient_s::cloakDebReduce, playerState_s::cloakFuel, clientPersistant_t::cmd, Com_Printf(), d_altRoutes, DAMAGE_NO_ARMOR, EF_SOUNDTRACKER, entityState_s::eFlags, ENTITYNUM_NONE, ET_BODY, ET_ITEM, ET_MISSILE, ET_MOVER, ET_NPC, entityState_s::eType, entityState_s::event, EVENT_VALID_MSEC, entityState_s::eventParm, gentity_s::eventTime, playerState_s::externalEvent, playerState_s::forceHandExtend, playerState_s::forceHandExtendTime, level_locals_t::framenum, gentity_s::freeAfterEvent, g_allowNPC, G_CheckClientTimeouts(), G_Damage(), g_entities, G_EntitySound(), G_FreeEntity(), g_gametype, g_LastFrameTime, g_listEntity, G_PointInBounds(), G_Printf(), G_RunClient(), G_RunExPhys(), G_RunItem(), G_RunMissile(), G_RunMover(), G_RunThink(), G_SendG2KillQueue(), G_SetAnim(), G_SiegeClientExData(), g_siegeRespawn, g_siegeRespawnCheck, G_SoundIndex(), g_TimeSinceLastFrame, G_UpdateCvars(), gDoSlowMoDuel, gentity_t, gQueueScoreMessage, gQueueScoreMessageTime, gSlowMoDuelTime, GT_SIEGE, gclient_s::hackingAngles, playerState_s::hackingTime, HANDEXTEND_CHOKE, gentity_s::health, gclient_s::inSpaceIndex, gclient_s::inSpaceSuffocation, vmCvar_t::integer, level_locals_t::intermissiontime, gentity_s::inuse, gclient_s::isHacking, Jedi_Decloak(), JETPACK_DEFUEL_RATE, Jetpack_Off(), JETPACK_REFUEL_RATE, gclient_s::jetPackDebRecharge, gclient_s::jetPackDebReduce, playerState_s::jetpackFuel, gclient_s::jetPackOn, gentity_s::lastWaypoint, level, entityShared_t::linked, MAX_CLIENTS, MAX_GENTITIES, MAX_POWERUPS, level_locals_t::maxclients, MOD_SUICIDE, NAV_CheckCalcPaths(), NAV_FindPlayerWaypoint(), gentity_s::neverFree, gentity_s::noWaypointTime, NULL, level_locals_t::num_entities, entityState_s::number, playerState_s::origin, gclient_s::pers, gentity_s::physicsObject, playerState_s::pm_flags, PMF_FOLLOW, playerState_s::powerups, level_locals_t::previousTime, gclient_s::ps, PW_CLOAKED, Q_irand(), qfalse, gentity_s::r, respawn(), level_locals_t::restarted, gentity_s::s, SendScoreboardMessageToAllClients(), gclient_s::sess, clientSession_t::sessionTeam, SETANIM_FLAG_HOLD, SETANIM_FLAG_OVERRIDE, SETANIM_TORSO, SiegeCheckTimers(), gclient_s::siegeClass, gclient_s::siegeEDataSend, gentity_s::takedamage, TEAM_BLUE, TEAM_RED, TEAM_SPECTATOR, gclient_s::tempSpectate, level_locals_t::time, playerState_s::torsoAnim, playerState_s::torsoTimer, trap_Cvar_Set(), trap_Cvar_VariableStringBuffer(), trap_ICARUS_MaintainTaskManager(), trap_Nav_CheckAllFailedEdges(), trap_Nav_CheckFailedNodes(), trap_Nav_ClearCheckedNodes(), trap_PrecisionTimer_End(), trap_PrecisionTimer_Start(), trap_ROFF_UpdateEntities(), trap_UnlinkEntity(), gentity_s::unlinkAfterEvent, usercmd_s::upmove, va(), vec3_t, VectorSubtract, playerState_s::viewangles, gentity_s::waypoint, WAYPOINT_NONE, playerState_s::weaponTime, WP_ForcePowersUpdate(), WP_SaberPositionUpdate(), and WP_SaberStartMissileBlockCheck(). Referenced by vmMain(). { int i; gentity_t *ent; int msec; #ifdef _G_FRAME_PERFANAL int iTimer_ItemRun = 0; int iTimer_ROFF = 0; int iTimer_ClientEndframe = 0; int iTimer_GameChecks = 0; int iTimer_Queues = 0; void *timer_ItemRun; void *timer_ROFF; void *timer_ClientEndframe; void *timer_GameChecks; void *timer_Queues; #endif if (g_gametype.integer == GT_SIEGE && g_siegeRespawn.integer && g_siegeRespawnCheck < level.time) { //check for a respawn wave int i = 0; gentity_t *clEnt; while (i < MAX_CLIENTS) { clEnt = &g_entities[i]; if (clEnt->inuse && clEnt->client && clEnt->client->tempSpectate > level.time && clEnt->client->sess.sessionTeam != TEAM_SPECTATOR) { respawn(clEnt); clEnt->client->tempSpectate = 0; } i++; } g_siegeRespawnCheck = level.time + g_siegeRespawn.integer * 1000; } if (gDoSlowMoDuel) { if (level.restarted) { char buf[128]; float tFVal = 0; trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf)); tFVal = atof(buf); trap_Cvar_Set("timescale", "1"); if (tFVal == 1.0f) { gDoSlowMoDuel = qfalse; } } else { float timeDif = (level.time - gSlowMoDuelTime); //difference in time between when the slow motion was initiated and now float useDif = 0; //the difference to use when actually setting the timescale if (timeDif < 150) { trap_Cvar_Set("timescale", "0.1f"); } else if (timeDif < 1150) { useDif = (timeDif/1000); //scale from 0.1 up to 1 if (useDif < 0.1) { useDif = 0.1; } if (useDif > 1.0) { useDif = 1.0; } trap_Cvar_Set("timescale", va("%f", useDif)); } else { char buf[128]; float tFVal = 0; trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf)); tFVal = atof(buf); trap_Cvar_Set("timescale", "1"); if (timeDif > 1500 && tFVal == 1.0f) { gDoSlowMoDuel = qfalse; } } } } // if we are waiting for the level to restart, do nothing if ( level.restarted ) { return; } level.framenum++; level.previousTime = level.time; level.time = levelTime; msec = level.time - level.previousTime; if (g_allowNPC.integer) { NAV_CheckCalcPaths(); } AI_UpdateGroups(); if (g_allowNPC.integer) { if ( d_altRoutes.integer ) { trap_Nav_CheckAllFailedEdges(); } trap_Nav_ClearCheckedNodes(); //remember last waypoint, clear current one for ( i = 0; i < level.num_entities ; i++) { ent = &g_entities[i]; if ( !ent->inuse ) continue; if ( ent->waypoint != WAYPOINT_NONE && ent->noWaypointTime < level.time ) { ent->lastWaypoint = ent->waypoint; ent->waypoint = WAYPOINT_NONE; } if ( d_altRoutes.integer ) { trap_Nav_CheckFailedNodes( ent ); } } //Look to clear out old events ClearPlayerAlertEvents(); } g_TimeSinceLastFrame = (level.time - g_LastFrameTime); // get any cvar changes G_UpdateCvars(); #ifdef _G_FRAME_PERFANAL trap_PrecisionTimer_Start(&timer_ItemRun); #endif // // go through all allocated objects // ent = &g_entities[0]; for (i=0 ; i<level.num_entities ; i++, ent++) { if ( !ent->inuse ) { 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 if (ent->s.eFlags & EF_SOUNDTRACKER) { //don't trigger the event again.. ent->s.event = 0; ent->s.eventParm = 0; ent->s.eType = 0; ent->eventTime = 0; } else { 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 ) { #if 0 //use if body dragging enabled? if (ent->s.eType == ET_BODY) { //special case for bodies float grav = 3.0f; float mass = 0.14f; float bounce = 1.15f; G_RunExPhys(ent, grav, mass, bounce, qfalse, NULL, 0); } else { G_RunItem( ent ); } #else G_RunItem( ent ); #endif continue; } if ( ent->s.eType == ET_MOVER ) { G_RunMover( ent ); continue; } if ( i < MAX_CLIENTS ) { G_CheckClientTimeouts ( ent ); if (ent->client->inSpaceIndex && ent->client->inSpaceIndex != ENTITYNUM_NONE) { //we're in space, check for suffocating and for exiting gentity_t *spacetrigger = &g_entities[ent->client->inSpaceIndex]; if (!spacetrigger->inuse || !G_PointInBounds(ent->client->ps.origin, spacetrigger->r.absmin, spacetrigger->r.absmax)) { //no longer in space then I suppose ent->client->inSpaceIndex = 0; } else { //check for suffocation if (ent->client->inSpaceSuffocation < level.time) { //suffocate! if (ent->health > 0 && ent->takedamage) { //if they're still alive.. G_Damage(ent, spacetrigger, spacetrigger, NULL, ent->client->ps.origin, Q_irand(50, 70), DAMAGE_NO_ARMOR, MOD_SUICIDE); if (ent->health > 0) { //did that last one kill them? //play the choking sound G_EntitySound(ent, CHAN_VOICE, G_SoundIndex(va( "*choke%d.wav", Q_irand( 1, 3 ) ))); //make them grasp their throat ent->client->ps.forceHandExtend = HANDEXTEND_CHOKE; ent->client->ps.forceHandExtendTime = level.time + 2000; } } ent->client->inSpaceSuffocation = level.time + Q_irand(100, 200); } } } if (ent->client->isHacking) { //hacking checks gentity_t *hacked = &g_entities[ent->client->isHacking]; vec3_t angDif; VectorSubtract(ent->client->ps.viewangles, ent->client->hackingAngles, angDif); //keep him in the "use" anim if (ent->client->ps.torsoAnim != BOTH_CONSOLE1) { G_SetAnim( ent, NULL, SETANIM_TORSO, BOTH_CONSOLE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 ); } else { ent->client->ps.torsoTimer = 500; } ent->client->ps.weaponTime = ent->client->ps.torsoTimer; if (!(ent->client->pers.cmd.buttons & BUTTON_USE)) { //have to keep holding use ent->client->isHacking = 0; ent->client->ps.hackingTime = 0; } else if (!hacked || !hacked->inuse) { //shouldn't happen, but safety first ent->client->isHacking = 0; ent->client->ps.hackingTime = 0; } else if (!G_PointInBounds( ent->client->ps.origin, hacked->r.absmin, hacked->r.absmax )) { //they stepped outside the thing they're hacking, so reset hacking time ent->client->isHacking = 0; ent->client->ps.hackingTime = 0; } else if (VectorLength(angDif) > 10.0f) { //must remain facing generally the same angle as when we start ent->client->isHacking = 0; ent->client->ps.hackingTime = 0; } } #define JETPACK_DEFUEL_RATE 200 //approx. 20 seconds of idle use from a fully charged fuel amt #define JETPACK_REFUEL_RATE 150 //seems fair if (ent->client->jetPackOn) { //using jetpack, drain fuel if (ent->client->jetPackDebReduce < level.time) { if (ent->client->pers.cmd.upmove > 0) { //take more if they're thrusting ent->client->ps.jetpackFuel -= 2; } else { ent->client->ps.jetpackFuel--; } if (ent->client->ps.jetpackFuel <= 0) { //turn it off ent->client->ps.jetpackFuel = 0; Jetpack_Off(ent); } ent->client->jetPackDebReduce = level.time + JETPACK_DEFUEL_RATE; } } else if (ent->client->ps.jetpackFuel < 100) { //recharge jetpack if (ent->client->jetPackDebRecharge < level.time) { ent->client->ps.jetpackFuel++; ent->client->jetPackDebRecharge = level.time + JETPACK_REFUEL_RATE; } } #define CLOAK_DEFUEL_RATE 200 //approx. 20 seconds of idle use from a fully charged fuel amt #define CLOAK_REFUEL_RATE 150 //seems fair if (ent->client->ps.powerups[PW_CLOAKED]) { //using cloak, drain battery if (ent->client->cloakDebReduce < level.time) { ent->client->ps.cloakFuel--; if (ent->client->ps.cloakFuel <= 0) { //turn it off ent->client->ps.cloakFuel = 0; Jedi_Decloak(ent); } ent->client->cloakDebReduce = level.time + CLOAK_DEFUEL_RATE; } } else if (ent->client->ps.cloakFuel < 100) { //recharge cloak if (ent->client->cloakDebRecharge < level.time) { ent->client->ps.cloakFuel++; ent->client->cloakDebRecharge = level.time + CLOAK_REFUEL_RATE; } } if (g_gametype.integer == GT_SIEGE && ent->client->siegeClass != -1 && (bgSiegeClasses[ent->client->siegeClass].classflags & (1<<CFL_STATVIEWER))) { //see if it's time to send this guy an update of extended info if (ent->client->siegeEDataSend < level.time) { G_SiegeClientExData(ent); ent->client->siegeEDataSend = level.time + 1000; //once every sec seems ok } } if((!level.intermissiontime)&&!(ent->client->ps.pm_flags&PMF_FOLLOW) && ent->client->sess.sessionTeam != TEAM_SPECTATOR) { WP_ForcePowersUpdate(ent, &ent->client->pers.cmd ); WP_SaberPositionUpdate(ent, &ent->client->pers.cmd); WP_SaberStartMissileBlockCheck(ent, &ent->client->pers.cmd); } if (g_allowNPC.integer) { //This was originally intended to only be done for client 0. //Make sure it doesn't slow things down too much with lots of clients in game. NAV_FindPlayerWaypoint(i); } trap_ICARUS_MaintainTaskManager(ent->s.number); G_RunClient( ent ); continue; } else if (ent->s.eType == ET_NPC) { int j; // turn off any expired powerups for ( j = 0 ; j < MAX_POWERUPS ; j++ ) { if ( ent->client->ps.powerups[ j ] < level.time ) { ent->client->ps.powerups[ j ] = 0; } } WP_ForcePowersUpdate(ent, &ent->client->pers.cmd ); WP_SaberPositionUpdate(ent, &ent->client->pers.cmd); WP_SaberStartMissileBlockCheck(ent, &ent->client->pers.cmd); } G_RunThink( ent ); if (g_allowNPC.integer) { ClearNPCGlobals(); } } #ifdef _G_FRAME_PERFANAL iTimer_ItemRun = trap_PrecisionTimer_End(timer_ItemRun); #endif SiegeCheckTimers(); #ifdef _G_FRAME_PERFANAL trap_PrecisionTimer_Start(&timer_ROFF); #endif trap_ROFF_UpdateEntities(); #ifdef _G_FRAME_PERFANAL iTimer_ROFF = trap_PrecisionTimer_End(timer_ROFF); #endif #ifdef _G_FRAME_PERFANAL trap_PrecisionTimer_Start(&timer_ClientEndframe); #endif // perform final fixups on the players ent = &g_entities[0]; for (i=0 ; i < level.maxclients ; i++, ent++ ) { if ( ent->inuse ) { ClientEndFrame( ent ); } } #ifdef _G_FRAME_PERFANAL iTimer_ClientEndframe = trap_PrecisionTimer_End(timer_ClientEndframe); #endif #ifdef _G_FRAME_PERFANAL trap_PrecisionTimer_Start(&timer_GameChecks); #endif // 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"); } #ifdef _G_FRAME_PERFANAL iTimer_GameChecks = trap_PrecisionTimer_End(timer_GameChecks); #endif #ifdef _G_FRAME_PERFANAL trap_PrecisionTimer_Start(&timer_Queues); #endif //At the end of the frame, send out the ghoul2 kill queue, if there is one G_SendG2KillQueue(); if (gQueueScoreMessage) { if (gQueueScoreMessageTime < level.time) { SendScoreboardMessageToAllClients(); gQueueScoreMessageTime = 0; gQueueScoreMessage = 0; } } #ifdef _G_FRAME_PERFANAL iTimer_Queues = trap_PrecisionTimer_End(timer_Queues); #endif #ifdef _G_FRAME_PERFANAL Com_Printf("---------------\nItemRun: %i\nROFF: %i\nClientEndframe: %i\nGameChecks: %i\nQueues: %i\n---------------\n", iTimer_ItemRun, iTimer_ROFF, iTimer_ClientEndframe, iTimer_GameChecks, iTimer_Queues); #endif g_LastFrameTime = level.time; }

void G_RunThink (  gentity_t *  ent  )

Definition at line 3473 of file g_main.c. References gentity_t, gentity_s::inuse, level, gentity_s::nextthink, entityState_s::number, gentity_s::s, gentity_s::think, level_locals_t::time, and trap_ICARUS_MaintainTaskManager(). Referenced by G_RunFrame(), G_RunItem(), G_RunMissile(), G_RunMover(), and G_RunStuckMissile(). { float thinktime; thinktime = ent->nextthink; if (thinktime <= 0) { goto runicarus; } if (thinktime > level.time) { goto runicarus; } ent->nextthink = 0; if (!ent->think) { //G_Error ( "NULL ent->think"); goto runicarus; } ent->think (ent); runicarus: if ( ent->inuse ) { trap_ICARUS_MaintainTaskManager(ent->s.number); } }

void G_ShutdownGame (  int  restart  )

Definition at line 1113 of file g_main.c. References B_CleanupAlloc(), BG_ClearAnimsets(), BotAIShutdown(), gentity_s::client, g2SaberInstance, G_CleanAllFakeClients(), g_entities, G_LogPrintf(), G_LogWeaponOutput(), G_WriteSessionData(), gentity_t, gentity_s::ghoul2, level, level_locals_t::logFile, MAX_GENTITIES, MAX_SABERS, NULL, precachedKyle, TAG_Init(), trap_Cvar_VariableIntegerValue(), trap_FS_FCloseFile(), trap_G2_HaveWeGhoul2Models(), trap_G2API_CleanGhoul2Models(), trap_ICARUS_Shutdown(), trap_ROFF_Clean(), and gclient_s::weaponGhoul2. Referenced by vmMain(). { int i = 0; gentity_t *ent; // G_Printf ("==== ShutdownGame ====\n"); G_CleanAllFakeClients(); //get rid of dynamically allocated fake client structs. BG_ClearAnimsets(); //free all dynamic allocations made through the engine // Com_Printf("... Gameside GHOUL2 Cleanup\n"); while (i < MAX_GENTITIES) { //clean up all the ghoul2 instances ent = &g_entities[i]; if (ent->ghoul2 && trap_G2_HaveWeGhoul2Models(ent->ghoul2)) { trap_G2API_CleanGhoul2Models(&ent->ghoul2); ent->ghoul2 = NULL; } if (ent->client) { int j = 0; while (j < MAX_SABERS) { if (ent->client->weaponGhoul2[j] && trap_G2_HaveWeGhoul2Models(ent->client->weaponGhoul2[j])) { trap_G2API_CleanGhoul2Models(&ent->client->weaponGhoul2[j]); } j++; } } i++; } if (g2SaberInstance && trap_G2_HaveWeGhoul2Models(g2SaberInstance)) { trap_G2API_CleanGhoul2Models(&g2SaberInstance); g2SaberInstance = NULL; } if (precachedKyle && trap_G2_HaveWeGhoul2Models(precachedKyle)) { trap_G2API_CleanGhoul2Models(&precachedKyle); precachedKyle = NULL; } // Com_Printf ("... ICARUS_Shutdown\n"); trap_ICARUS_Shutdown (); //Shut ICARUS down // Com_Printf ("... Reference Tags Cleared\n"); TAG_Init(); //Clear the reference tags G_LogWeaponOutput(); if ( level.logFile ) { G_LogPrintf("ShutdownGame:\n" ); G_LogPrintf("------------------------------------------------------------\n" ); trap_FS_FCloseFile( level.logFile ); } // write all the client session data so we can get it back G_WriteSessionData(); trap_ROFF_Clean(); if ( trap_Cvar_VariableIntegerValue( "bot_enable" ) ) { BotAIShutdown( restart ); } B_CleanupAlloc(); //clean up all allocations made with B_Alloc }

void G_SpawnGEntityFromSpawnVars (  qboolean  inSubBSP  )

Definition at line 766 of file g_spawn.c. References BG_ParseField(), BSET_SPAWN, byte, gentity_s::classname, entityShared_t::currentOrigin, fields, G_ActivateBehavior(), G_CallSpawn(), G_FreeEntity(), g_gametype, G_Spawn(), G_SpawnInt(), G_SpawnString(), gentity_t, GT_FFA, GT_MAX_GAME_TYPE, GT_SINGLE_PLAYER, GT_TEAM, vmCvar_t::integer, level, NULL, level_locals_t::numSpawnVars, entityState_s::origin, entityState_s::pos, Q_strncmp(), gentity_s::r, gentity_s::s, level_locals_t::spawnVars, strstr(), trap_ICARUS_InitEnt(), trap_ICARUS_ValidEnt(), trajectory_t::trBase, and VectorCopy. Referenced by G_SpawnEntitiesFromString(), and vmMain(). { int i; gentity_t *ent; char *s, *value, *gametypeName; static char *gametypeNames[] = {"ffa", "holocron", "jedimaster", "duel", "powerduel", "single", "team", "siege", "ctf", "cty"}; // get the next free entity ent = G_Spawn(); for ( i = 0 ; i < level.numSpawnVars ; i++ ) { BG_ParseField( fields, level.spawnVars[i][0], level.spawnVars[i][1], (byte *)ent ); } // check for "notsingle" flag if ( g_gametype.integer == GT_SINGLE_PLAYER ) { G_SpawnInt( "notsingle", "0", &i ); if ( i ) { G_FreeEntity( ent ); return; } } // check for "notteam" flag (GT_FFA, GT_DUEL, GT_SINGLE_PLAYER) if ( g_gametype.integer >= GT_TEAM ) { G_SpawnInt( "notteam", "0", &i ); if ( i ) { G_FreeEntity( ent ); return; } } else { G_SpawnInt( "notfree", "0", &i ); if ( i ) { G_FreeEntity( ent ); return; } } G_SpawnInt( "notta", "0", &i ); if ( i ) { G_FreeEntity( ent ); return; } if( G_SpawnString( "gametype", NULL, &value ) ) { if( g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE ) { gametypeName = gametypeNames[g_gametype.integer]; s = strstr( value, gametypeName ); if( !s ) { G_FreeEntity( ent ); return; } } } // move editor origin to pos VectorCopy( ent->s.origin, ent->s.pos.trBase ); VectorCopy( ent->s.origin, ent->r.currentOrigin ); // if we didn't get a classname, don't bother spawning anything if ( !G_CallSpawn( ent ) ) { G_FreeEntity( ent ); } //Tag on the ICARUS scripting information only to valid recipients if ( trap_ICARUS_ValidEnt( ent ) ) { trap_ICARUS_InitEnt( ent ); if ( ent->classname && ent->classname[0] ) { if ( Q_strncmp( "NPC_", ent->classname, 4 ) != 0 ) {//Not an NPC_spawner (rww - probably don't even care for MP, but whatever) G_ActivateBehavior( ent, BSET_SPAWN ); } } } }

void G_UpdateCvars (  void   )

Definition at line 840 of file g_main.c. References G_RemapTeamShaders(), qboolean, qfalse, qtrue, trap_Cvar_Update(), trap_SendServerCommand(), and va(). Referenced by G_RunFrame(). { 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(); } }

void Jedi_Decloak (  gentity_t *  self  )

Definition at line 818 of file NPC_AI_Jedi.c. { if ( self ) { self->flags &= ~FL_NOTARGET; if ( self->client ) { if ( self->client->ps.powerups[PW_CLOAKED] ) {//Uncloak self->client->ps.powerups[PW_CLOAKED] = 0; G_Sound( self, CHAN_ITEM, G_SoundIndex("sound/chars/shadowtrooper/decloak.wav") ); } } } }

void LogExit (  const char *  string  )

Definition at line 2233 of file g_main.c. References level_locals_t::clients, CON_CONNECTING, clientPersistant_t::connected, CS_INTERMISSION, g_gametype, G_LogPrintf(), gclient_t, GT_TEAM, vmCvar_t::integer, level_locals_t::intermissionQueued, level, clientPersistant_t::netname, level_locals_t::numConnectedClients, gclient_s::pers, PERS_SCORE, playerState_s::persistant, playerState_s::ping, gclient_s::ps, gclient_s::sess, clientSession_t::sessionTeam, level_locals_t::sortedClients, TEAM_BLUE, TEAM_RED, TEAM_SPECTATOR, level_locals_t::teamScores, level_locals_t::time, and trap_SetConfigstring(). Referenced by CheckExitRules(), siegeEndUse(), SiegeRoundComplete(), and Use_Target_Escapetrig(). { int i, numSorted; gclient_t *cl; // qboolean won = qtrue; 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 ) { G_LogPrintf( "red:%i blue:%i\n", level.teamScores[TEAM_RED], level.teamScores[TEAM_BLUE] ); } 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 ); // if (g_singlePlayer.integer && (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)) { // if (g_entities[cl - level.clients].r.svFlags & SVF_BOT && cl->ps.persistant[PERS_RANK] == 0) { // won = qfalse; // } // } } //yeah.. how about not. /* 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" ); } */ }

void MoveClientToIntermission (  gentity_t *  ent  )

Definition at line 1927 of file g_main.c. References gentity_s::client, entityShared_t::contents, entityState_s::eFlags, playerState_s::eFlags, ET_GENERAL, entityState_s::eType, entityState_s::event, gentity_t, level_locals_t::intermission_angle, level_locals_t::intermission_origin, level, entityState_s::loopIsSoundset, entityState_s::loopSound, memset(), entityState_s::modelindex, playerState_s::origin, entityState_s::origin, PM_INTERMISSION, playerState_s::pm_type, playerState_s::powerups, gclient_s::ps, qfalse, gentity_s::r, gentity_s::s, gclient_s::sess, SPECTATOR_FOLLOW, clientSession_t::spectatorState, StopFollowing(), VectorCopy, and playerState_s::viewangles. Referenced by BeginIntermission(), and ClientSpawn(). { // take out of follow mode if needed if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) { StopFollowing( ent ); } // move to the spot VectorCopy( level.intermission_origin, ent->s.origin ); VectorCopy( level.intermission_origin, ent->client->ps.origin ); VectorCopy (level.intermission_angle, ent->client->ps.viewangles); 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->