/* =========================================================================== Copyright (C) 1999-2005 Id Software, Inc. Copyright (C) 2000-2006 Tim Angus This file is part of Tremulous. Tremulous is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. Tremulous is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Tremulous; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA =========================================================================== */ #include "g_local.h" level_locals_t level; typedef struct { vmCvar_t *vmCvar; char *cvarName; char *defaultString; int cvarFlags; int modificationCount; // for tracking changes qboolean trackChange; // track this variable, and announce if changed qboolean teamShader; // track and if changed, update shader state } cvarTable_t; gentity_t g_entities[ MAX_GENTITIES ]; gclient_t g_clients[ MAX_CLIENTS ]; vmCvar_t g_fraglimit; vmCvar_t g_timelimit; vmCvar_t g_suddenDeathTime; vmCvar_t g_suddenDeath; vmCvar_t g_suddenDeathMode; vmCvar_t g_vampireDeathTime; vmCvar_t g_vampireDeath; vmCvar_t g_vampireDeathInfo; vmCvar_t g_capturelimit; vmCvar_t g_friendlyFire; vmCvar_t g_friendlyFireAliens; vmCvar_t g_friendlyFireHumans; vmCvar_t g_friendlyFireMovementAttacks; vmCvar_t g_retribution; vmCvar_t g_friendlyBuildableFire; vmCvar_t g_password; vmCvar_t g_needpass; vmCvar_t g_maxclients; vmCvar_t g_maxGameClients; vmCvar_t g_dedicated; vmCvar_t g_speed; vmCvar_t g_gravity; vmCvar_t g_cheats; vmCvar_t g_knockback; vmCvar_t g_quadfactor; vmCvar_t g_inactivity; vmCvar_t g_inactivityMode; vmCvar_t g_debugMove; vmCvar_t g_debugDamage; vmCvar_t g_debugAlloc; vmCvar_t g_weaponRespawn; vmCvar_t g_weaponTeamRespawn; vmCvar_t g_motd; vmCvar_t g_synchronousClients; vmCvar_t g_warmup; vmCvar_t g_warmupMode; vmCvar_t g_doWarmup; vmCvar_t g_restarted; vmCvar_t g_lockTeamsAtStart; vmCvar_t g_logFile; vmCvar_t g_logFileSync; vmCvar_t g_blood; vmCvar_t g_podiumDist; vmCvar_t g_podiumDrop; vmCvar_t g_allowVote; vmCvar_t g_requireVoteReasons; vmCvar_t g_voteLimit; vmCvar_t g_pollVotes; vmCvar_t g_suddenDeathVotePercent; vmCvar_t g_suddenDeathVoteDelay; vmCvar_t g_extendVotesPercent; vmCvar_t g_extendVotesTime; vmCvar_t g_extendVotesCount; vmCvar_t g_kickVotesPercent; vmCvar_t g_customVote1; vmCvar_t g_customVote2; vmCvar_t g_customVote3; vmCvar_t g_customVote4; vmCvar_t g_customVote5; vmCvar_t g_customVote6; vmCvar_t g_customVote7; vmCvar_t g_customVote8; vmCvar_t g_customVotePercent; vmCvar_t g_mapVotesPercent; vmCvar_t g_mapRotationVote; vmCvar_t g_readyPercent; vmCvar_t g_designateVotes; vmCvar_t g_teamAutoJoin; vmCvar_t g_teamForceBalance; vmCvar_t g_popularMaps; vmCvar_t g_popularMapsVotePercent; vmCvar_t g_banIPs; vmCvar_t g_filterBan; vmCvar_t g_smoothClients; vmCvar_t g_outdatedClientMessage; vmCvar_t pmove_fixed; vmCvar_t pmove_msec; vmCvar_t g_rankings; vmCvar_t g_listEntity; vmCvar_t g_minCommandPeriod; vmCvar_t g_minNameChangePeriod; vmCvar_t g_maxNameChanges; vmCvar_t g_newbieNumbering; vmCvar_t g_newbieNamePrefix; vmCvar_t g_newbieNoBuild; vmCvar_t g_newbieNoBuildMessage; vmCvar_t g_humanBuildPoints; vmCvar_t g_alienBuildPoints; vmCvar_t g_humanStage; vmCvar_t g_humanKills; vmCvar_t g_humanMaxStage; vmCvar_t g_humanStage2Threshold; vmCvar_t g_humanStage3Threshold; vmCvar_t g_alienStage; vmCvar_t g_alienKills; vmCvar_t g_alienMaxStage; vmCvar_t g_alienStage2Threshold; vmCvar_t g_alienStage3Threshold; vmCvar_t g_teamImbalanceWarnings; vmCvar_t g_unlagged; vmCvar_t g_disabledEquipment; vmCvar_t g_disabledClasses; vmCvar_t g_disabledBuildables; vmCvar_t g_buildPointsRecoverRate; vmCvar_t g_dynamicBuildPoints; vmCvar_t g_instantBuild; vmCvar_t g_gradualFreeFunds; vmCvar_t g_markDeconstruct; vmCvar_t g_markDeconstructMode; vmCvar_t g_deconDead; vmCvar_t g_debugMapRotation; vmCvar_t g_currentMapRotation; vmCvar_t g_currentMap; vmCvar_t g_nextMap; vmCvar_t g_idleMapSwitch; vmCvar_t g_initialMapRotation; vmCvar_t g_shove; vmCvar_t g_mapConfigs; vmCvar_t g_chatTeamPrefix; vmCvar_t g_sayAreaRange; vmCvar_t g_actionPrefix; vmCvar_t g_floodMaxDemerits; vmCvar_t g_floodMinTime; vmCvar_t g_layouts; vmCvar_t g_layoutAuto; vmCvar_t g_admin; vmCvar_t g_report; vmCvar_t g_adminLog; vmCvar_t g_adminParseSay; vmCvar_t g_adminSayFilter; vmCvar_t g_adminNameProtect; vmCvar_t g_adminTempMute; vmCvar_t g_adminTempBan; vmCvar_t g_adminBanRepeatKicks; vmCvar_t g_adminMaxBan; vmCvar_t g_adminTempSpec; vmCvar_t g_adminMapLog; vmCvar_t g_adminRegisterLevel; vmCvar_t g_adminRegisterAdminPass; vmCvar_t g_adminRegisterAdminLevel; vmCvar_t g_minLevelToJoinTeam; vmCvar_t g_forceAutoSelect; vmCvar_t g_adminCurses; vmCvar_t g_adminAutobahnNotify; vmCvar_t g_privateMessages; vmCvar_t g_logPrivateMessages; vmCvar_t g_decolourLogfiles; vmCvar_t g_minLevelToSpecMM1; vmCvar_t g_publicSayadmins; vmCvar_t g_myStats; vmCvar_t g_teamStatus; vmCvar_t g_antiSpawnBlock; vmCvar_t g_killingSpree; vmCvar_t g_feedingSpree; vmCvar_t g_bleedingSpree; vmCvar_t g_bleedingSpreeKick; vmCvar_t g_autoRevert; vmCvar_t g_banNotice; vmCvar_t g_karma; vmCvar_t g_chat; vmCvar_t g_adminExpireTime; vmCvar_t g_devmapKillerHP; vmCvar_t g_killerHP; vmCvar_t g_nullifyTyrantKills; vmCvar_t g_buildLogMaxLength; vmCvar_t g_maxGhosts; vmCvar_t g_tag; vmCvar_t g_dretchPunt; vmCvar_t g_allowShare; vmCvar_t g_creditOverflow; vmCvar_t g_devmapNoGod; vmCvar_t g_devmapNoStructDmg; vmCvar_t g_slapKnockback; vmCvar_t g_slapDamage; vmCvar_t g_voteMinTime; vmCvar_t g_mapvoteMaxTime; vmCvar_t g_votableMaps; vmCvar_t g_defeatVoteMinTime; vmCvar_t g_practiceText; vmCvar_t g_practiceCount; vmCvar_t g_freeCredits; vmCvar_t g_msg; vmCvar_t g_msgTime; vmCvar_t g_welcomeMsg; vmCvar_t g_welcomeMsgTime; vmCvar_t g_turretAim; vmCvar_t g_modBuildableHealth; vmCvar_t g_modBuildableSpeed; vmCvar_t g_modBuildableCount; vmCvar_t g_modHumanStamina; vmCvar_t g_modHumanHealth; vmCvar_t g_modAlienHealth; vmCvar_t g_modAlienRegenRange; vmCvar_t g_modHumanRate; vmCvar_t g_modAlienRate; vmCvar_t g_modWeaponAmmo; vmCvar_t g_modWeaponReload; vmCvar_t g_modTurretAngle; vmCvar_t g_modStage3Strength; vmCvar_t g_modMainStrength; vmCvar_t mod_jetpackFuel; vmCvar_t mod_jetpackConsume; vmCvar_t mod_jetpackRegen; vmCvar_t g_maxReports; vmCvar_t g_maxUnregReports; vmCvar_t g_reportWelcomeComment; vmCvar_t g_reportAdminListMinLvl; vmCvar_t g_schachtmeisterClearThreshold; vmCvar_t g_schachtmeisterAutobahnThreshold; vmCvar_t g_schachtmeisterAutobahnMessage; vmCvar_t g_scrimMode; vmCvar_t g_revertCooldownTime; vmCvar_t g_antistack; vmCvar_t g_antistackBias; vmCvar_t g_antistackTimeThreshold; vmCvar_t g_antistackKillThreshold; vmCvar_t g_antistackBiasThreshold; vmCvar_t g_antistackHandicapMultiplier; vmCvar_t g_antistackHandicapOffset; vmCvar_t g_antistackInterval; static cvarTable_t gameCvarTable[ ] = { // don't override the cheat state set by the system { &g_cheats, "sv_cheats", "", 0, 0, qfalse }, // noset vars { NULL, "gamename", GAME_VERSION , CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, { NULL, "gamedate", __DATE__ , CVAR_ROM, 0, qfalse }, { &g_restarted, "g_restarted", "0", CVAR_ROM, 0, qfalse }, { &g_lockTeamsAtStart, "g_lockTeamsAtStart", "0", CVAR_ROM, 0, qfalse }, { NULL, "sv_mapname", "", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, { NULL, "P", "", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, { NULL, "ff", "0", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, { NULL, "qvm_version", PRODUCT_VERSION, CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, // latched vars { &g_maxclients, "sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qfalse }, { &g_maxGameClients, "g_maxGameClients", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, // change anytime vars { &g_timelimit, "timelimit", "45", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, { &g_suddenDeathTime, "g_suddenDeathTime", "30", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, { &g_suddenDeathMode, "g_suddenDeathMode", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, { &g_suddenDeath, "g_suddenDeath", "0", CVAR_SERVERINFO | CVAR_NORESTART, 0, qtrue }, { &g_vampireDeathTime, "g_vampireDeathTime", "0", CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue }, { &g_vampireDeath, "g_vampireDeath", "0", CVAR_NORESTART, 0, qtrue }, { &g_vampireDeathInfo, "g_vampireDeathInfo", "( !info vampire )", CVAR_ARCHIVE, 0, qtrue }, { &g_synchronousClients, "g_synchronousClients", "0", CVAR_SYSTEMINFO, 0, qfalse }, { &g_friendlyFire, "g_friendlyFire", "0", CVAR_ARCHIVE | CVAR_SERVERINFO, 0, qtrue }, { &g_friendlyFireAliens, "g_friendlyFireAliens", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_friendlyFireHumans, "g_friendlyFireHumans", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_retribution, "g_retribution", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_friendlyBuildableFire, "g_friendlyBuildableFire", "0", CVAR_ARCHIVE | CVAR_SERVERINFO, 0, qtrue }, { &g_friendlyFireMovementAttacks, "g_friendlyFireMovementAttacks", "1", CVAR_ARCHIVE, 0, qtrue }, { &g_devmapNoGod, "g_devmapNoGod", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_devmapNoStructDmg, "g_devmapNoStructDmg", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_slapKnockback, "g_slapKnockback", "200", CVAR_ARCHIVE, 0, qfalse}, { &g_slapDamage, "g_slapDamage", "5", CVAR_ARCHIVE, 0, qfalse}, { &g_teamAutoJoin, "g_teamAutoJoin", "0", CVAR_ARCHIVE }, { &g_teamForceBalance, "g_teamForceBalance", "1", CVAR_ARCHIVE }, { &g_popularMaps, "g_popularMaps", "arachnid2 atcs karith nexus6 niveus transit tremor", CVAR_ARCHIVE }, { &g_popularMapsVotePercent, "g_popularMapsVotePercent", "0", CVAR_ARCHIVE }, { &g_warmup, "g_warmup", "10", CVAR_ARCHIVE, 0, qtrue }, { &g_warmupMode, "g_warmupMode", "1", CVAR_ARCHIVE, 0, qtrue }, { &g_doWarmup, "g_doWarmup", "1", CVAR_ARCHIVE, 0, qtrue }, { &g_logFile, "g_logFile", "games.log", CVAR_ARCHIVE, 0, qfalse }, { &g_logFileSync, "g_logFileSync", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_password, "g_password", "", CVAR_USERINFO, 0, qfalse }, { &g_banIPs, "g_banIPs", "", CVAR_ARCHIVE, 0, qfalse }, { &g_filterBan, "g_filterBan", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_needpass, "g_needpass", "0", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse }, { &g_dedicated, "dedicated", "0", 0, 0, qfalse }, { &g_speed, "g_speed", "320", CVAR_SERVERINFO, 0, qtrue }, { &g_gravity, "g_gravity", "800", CVAR_SERVERINFO, 0, qtrue }, { &g_knockback, "g_knockback", "1000", CVAR_SERVERINFO, 0, qtrue }, { &g_quadfactor, "g_quadfactor", "3", 0, 0, qtrue }, { &g_weaponRespawn, "g_weaponrespawn", "5", 0, 0, qtrue }, { &g_weaponTeamRespawn, "g_weaponTeamRespawn", "30", 0, 0, qtrue }, { &g_inactivity, "g_inactivity", "0", 0, 0, qtrue }, { &g_inactivityMode, "g_inactivityMode", "0", 0, 0, qfalse }, { &g_debugMove, "g_debugMove", "0", 0, 0, qfalse }, { &g_debugDamage, "g_debugDamage", "0", 0, 0, qfalse }, { &g_debugAlloc, "g_debugAlloc", "0", 0, 0, qfalse }, { &g_motd, "g_motd", "", 0, 0, qfalse }, { &g_blood, "com_blood", "1", 0, 0, qfalse }, { &g_podiumDist, "g_podiumDist", "80", 0, 0, qfalse }, { &g_podiumDrop, "g_podiumDrop", "70", 0, 0, qfalse }, { &g_allowVote, "g_allowVote", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_requireVoteReasons, "g_requireVoteReasons", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_pollVotes, "g_pollVotes", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_voteLimit, "g_voteLimit", "5", CVAR_ARCHIVE, 0, qfalse }, { &g_voteMinTime, "g_voteMinTime", "120", CVAR_ARCHIVE, 0, qfalse }, { &g_mapvoteMaxTime, "g_mapvoteMaxTime", "240", CVAR_ARCHIVE, 0, qfalse }, { &g_votableMaps, "g_votableMaps", "", CVAR_ARCHIVE, 0, qtrue }, { &g_defeatVoteMinTime, "g_defeatVoteMinTime", "60", CVAR_ARCHIVE, 0, qfalse }, { &g_suddenDeathVotePercent, "g_suddenDeathVotePercent", "74", CVAR_ARCHIVE, 0, qfalse }, { &g_suddenDeathVoteDelay, "g_suddenDeathVoteDelay", "180", CVAR_ARCHIVE, 0, qfalse }, { &g_extendVotesPercent, "g_extendVotesPercent", "74", CVAR_ARCHIVE, 0, qfalse }, { &g_extendVotesTime, "g_extendVotesTime", "10", CVAR_ARCHIVE, 0, qfalse }, { &g_extendVotesCount, "g_extendVotesCount", "2", CVAR_ARCHIVE, 0, qfalse }, { &g_kickVotesPercent, "g_kickVotesPercent", "50", CVAR_ARCHIVE, 0, qtrue }, { &g_customVote1, "g_customVote1", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVote2, "g_customVote2", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVote3, "g_customVote3", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVote4, "g_customVote4", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVote5, "g_customVote5", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVote6, "g_customVote6", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVote7, "g_customVote7", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVote8, "g_customVote8", "", CVAR_ARCHIVE, 0, qfalse }, { &g_customVotePercent, "g_customVotePercent", "50", CVAR_ARCHIVE, 0, qfalse }, { &g_mapVotesPercent, "g_mapVotesPercent", "50", CVAR_ARCHIVE, 0, qfalse }, { &g_mapRotationVote, "g_mapRotationVote", "15", CVAR_ARCHIVE, 0, qfalse }, { &g_readyPercent, "g_readyPercent", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_designateVotes, "g_designateVotes", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_practiceText, "g_practiceText", "", 0, 0, qfalse}, { &g_practiceCount, "g_practiceCount", "0", 0, 0, qfalse}, { &g_freeCredits, "g_freeCredits", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_listEntity, "g_listEntity", "0", 0, 0, qfalse }, { &g_minCommandPeriod, "g_minCommandPeriod", "500", 0, 0, qfalse}, { &g_minNameChangePeriod, "g_minNameChangePeriod", "5", 0, 0, qfalse}, { &g_maxNameChanges, "g_maxNameChanges", "5", 0, 0, qfalse}, { &g_newbieNumbering, "g_newbieNumbering", "0", CVAR_ARCHIVE, 0, qfalse}, { &g_newbieNamePrefix, "g_newbieNamePrefix", "Newbie#", CVAR_ARCHIVE, 0, qfalse}, { &g_newbieNoBuild, "g_newbieNoBuild", "0", CVAR_ARCHIVE, 0, qfalse}, { &g_newbieNoBuildMessage, "g_newbieNoBuildMessage", "Set a name by pressing Escape and choosing Options", CVAR_ARCHIVE, 0, qfalse}, { &g_smoothClients, "g_smoothClients", "1", 0, 0, qfalse}, { &g_outdatedClientMessage, "g_outdatedClientMessage", "", CVAR_ARCHIVE, 0, qfalse}, { &pmove_fixed, "pmove_fixed", "0", CVAR_SYSTEMINFO, 0, qfalse}, { &pmove_msec, "pmove_msec", "8", CVAR_SYSTEMINFO, 0, qfalse}, { &g_humanBuildPoints, "g_humanBuildPoints", DEFAULT_HUMAN_BUILDPOINTS, CVAR_SERVERINFO, 0, qfalse }, { &g_alienBuildPoints, "g_alienBuildPoints", DEFAULT_ALIEN_BUILDPOINTS, CVAR_SERVERINFO, 0, qfalse }, { &g_humanStage, "g_humanStage", "0", 0, 0, qfalse }, { &g_humanKills, "g_humanKills", "0", 0, 0, qfalse }, { &g_humanMaxStage, "g_humanMaxStage", DEFAULT_HUMAN_MAX_STAGE, 0, 0, qfalse }, { &g_humanStage2Threshold, "g_humanStage2Threshold", DEFAULT_HUMAN_STAGE2_THRESH, 0, 0, qfalse }, { &g_humanStage3Threshold, "g_humanStage3Threshold", DEFAULT_HUMAN_STAGE3_THRESH, 0, 0, qfalse }, { &g_alienStage, "g_alienStage", "0", 0, 0, qfalse }, { &g_alienKills, "g_alienKills", "0", 0, 0, qfalse }, { &g_alienMaxStage, "g_alienMaxStage", DEFAULT_ALIEN_MAX_STAGE, 0, 0, qfalse }, { &g_alienStage2Threshold, "g_alienStage2Threshold", DEFAULT_ALIEN_STAGE2_THRESH, 0, 0, qfalse }, { &g_alienStage3Threshold, "g_alienStage3Threshold", DEFAULT_ALIEN_STAGE3_THRESH, 0, 0, qfalse }, { &g_teamImbalanceWarnings, "g_teamImbalanceWarnings", "30", CVAR_ARCHIVE, 0, qfalse }, { &g_unlagged, "g_unlagged", "1", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qfalse }, { &g_disabledEquipment, "g_disabledEquipment", "", CVAR_ROM, 0, qfalse }, { &g_disabledClasses, "g_disabledClasses", "", CVAR_ROM, 0, qfalse }, { &g_disabledBuildables, "g_disabledBuildables", "", CVAR_ROM, 0, qfalse }, { &g_buildPointsRecoverRate, "g_buildPointsRecoverRate", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_dynamicBuildPoints, "g_dynamicBuildPoints", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_instantBuild, "g_instantBuild", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_gradualFreeFunds, "g_gradualFreeFunds", "2", CVAR_ARCHIVE, 0, qtrue }, { &g_chatTeamPrefix, "g_chatTeamPrefix", "1", CVAR_ARCHIVE }, { &g_sayAreaRange, "g_sayAreaRange", "1000", CVAR_ARCHIVE, 0, qtrue }, { &g_actionPrefix, "g_actionPrefix", "* ", CVAR_ARCHIVE, 0, qfalse }, { &g_floodMaxDemerits, "g_floodMaxDemerits", "5000", CVAR_ARCHIVE, 0, qfalse }, { &g_floodMinTime, "g_floodMinTime", "2000", CVAR_ARCHIVE, 0, qfalse }, { &g_markDeconstruct, "g_markDeconstruct", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_markDeconstructMode, "g_markDeconstructMode", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_deconDead, "g_deconDead", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_debugMapRotation, "g_debugMapRotation", "0", 0, 0, qfalse }, { &g_currentMapRotation, "g_currentMapRotation", "-1", 0, 0, qfalse }, // -1 = NOT_ROTATING { &g_currentMap, "g_currentMap", "0", 0, 0, qfalse }, { &g_nextMap, "g_nextMap", "", 0 , 0, qtrue }, { &g_idleMapSwitch, "g_idleMapSwitch", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_initialMapRotation, "g_initialMapRotation", "", CVAR_ARCHIVE, 0, qfalse }, { &g_shove, "g_shove", "15", CVAR_ARCHIVE, 0, qfalse }, { &g_mapConfigs, "g_mapConfigs", "", CVAR_ARCHIVE, 0, qfalse }, { NULL, "g_mapConfigsLoaded", "0", CVAR_ROM, 0, qfalse }, { &g_layouts, "g_layouts", "", CVAR_LATCH, 0, qfalse }, { &g_layoutAuto, "g_layoutAuto", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_admin, "g_admin", "admin.dat", CVAR_ARCHIVE, 0, qfalse }, { &g_report, "g_report", "report.dat", CVAR_ARCHIVE, 0, qfalse }, { &g_adminLog, "g_adminLog", "admin.log", CVAR_ARCHIVE, 0, qfalse }, { &g_adminParseSay, "g_adminParseSay", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_adminSayFilter, "g_adminSayFilter", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_adminNameProtect, "g_adminNameProtect", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_adminTempMute, "g_adminTempMute", "5m", CVAR_ARCHIVE, 0, qfalse }, { &g_adminTempBan, "g_adminTempBan", "2m", CVAR_ARCHIVE, 0, qfalse }, { &g_adminBanRepeatKicks, "g_adminBanRepeatKicks", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_adminMaxBan, "g_adminMaxBan", "2w", CVAR_ARCHIVE, 0, qfalse }, { &g_adminTempSpec, "g_adminTempSpec", "2m", CVAR_ARCHIVE, 0, qfalse }, { &g_adminMapLog, "g_adminMapLog", "", CVAR_ROM, 0, qfalse }, { &g_adminRegisterLevel, "g_adminRegisterLevel", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_adminRegisterAdminPass, "g_adminRegisterAdminPass", "", CVAR_ARCHIVE, 0, qfalse }, { &g_adminRegisterAdminLevel, "g_adminRegisterAdminLevel", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_minLevelToJoinTeam, "g_minLevelToJoinTeam", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_forceAutoSelect, "g_forceAutoSelect", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_maxGhosts, "g_maxGhosts", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_privateMessages, "g_privateMessages", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_logPrivateMessages, "g_logPrivateMessages", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_decolourLogfiles, "g_decolourLogfiles", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_buildLogMaxLength, "g_buildLogMaxLength", "50", CVAR_ARCHIVE, 0, qfalse }, { &g_myStats, "g_myStats", "1", CVAR_ARCHIVE, 0, qtrue }, { &g_teamStatus, "g_teamStatus", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_publicSayadmins, "g_publicSayadmins", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_minLevelToSpecMM1, "g_minLevelToSpecMM1", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_antiSpawnBlock, "g_antiSpawnBlock", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_karma, "g_karma", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_chat, "g_chat", "chat.dat", CVAR_ARCHIVE, 0, qfalse }, { &g_adminExpireTime, "g_adminExpireTime", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_adminCurses, "g_adminCurses", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_adminAutobahnNotify, "g_adminAutobahnNotify", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_devmapKillerHP, "g_devmapKillerHP", "0", CVAR_ARCHIVE, 0, qtrue }, { &g_killerHP, "g_killerHP", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_tag, "g_tag", "main", CVAR_INIT, 0, qfalse }, { &g_dretchPunt, "g_dretchPunt", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_killingSpree, "g_killingSpree", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_feedingSpree, "g_feedingSpree", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_bleedingSpree, "g_bleedingSpree", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_bleedingSpreeKick, "g_bleedingSpreeKick", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_autoRevert, "g_autoRevert", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_msg, "g_msg", "", CVAR_ARCHIVE, 0, qfalse }, { &g_msgTime, "g_msgTime", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_welcomeMsg, "g_welcomeMsg", "", CVAR_ARCHIVE, 0, qfalse }, { &g_welcomeMsgTime, "g_welcomeMsgTime", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_turretAim, "g_turretAim", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modBuildableHealth, "g_modBuildableHealth", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modBuildableSpeed, "g_modBuildableSpeed", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modBuildableCount, "g_modBuildableCount", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modHumanStamina, "g_modHumanStamina", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modHumanHealth, "g_modHumanHealth", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modAlienHealth, "g_modAlienHealth", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modAlienRegenRange, "g_modAlienRegenRange", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modHumanRate, "g_modHumanRate", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modAlienRate, "g_modAlienRate", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modWeaponAmmo, "g_modWeaponAmmo", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modWeaponReload, "g_modWeaponReload", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modTurretAngle, "g_modTurretAngle", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modStage3Strength, "g_modStage3Strength", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_modMainStrength, "g_modMainStrength", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_rankings, "g_rankings", "0", 0, 0, qfalse }, { &g_allowShare, "g_allowShare", "0", CVAR_ARCHIVE | CVAR_SERVERINFO, 0, qfalse}, { &g_creditOverflow, "g_creditOverflow", "0", CVAR_ARCHIVE | CVAR_SERVERINFO, 0, qfalse}, { &g_banNotice, "g_banNotice", "", CVAR_ARCHIVE, 0, qfalse }, { &g_nullifyTyrantKills, "g_nullifyTyrantKills", "0", CVAR_ARCHIVE, 0, qfalse }, { &mod_jetpackFuel, "mod_jetpackFuel", "0", CVAR_ARCHIVE, 0, qfalse }, { &mod_jetpackConsume, "mod_jetpackConsume", "2", CVAR_ARCHIVE, 0, qfalse }, { &mod_jetpackRegen, "mod_jetpackRegen", "3", CVAR_ARCHIVE, 0, qfalse }, { &g_maxReports, "g_maxReports", "3", CVAR_ARCHIVE, 0, qfalse }, { &g_maxUnregReports, "g_maxUnregReports", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_reportWelcomeComment, "g_reportWelcomeComment", "", CVAR_ARCHIVE, 0, qfalse }, { &g_reportAdminListMinLvl, "g_reportAdminListMinLvl", "4", CVAR_ARCHIVE, 0, qfalse }, { &g_scrimMode, "g_scrimMode", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_schachtmeisterClearThreshold, "g_schachtmeisterClearThreshold", "-10", CVAR_ARCHIVE, 0, qfalse }, { &g_schachtmeisterAutobahnThreshold, "g_schachtmeisterAutobahnThreshold", "-30", CVAR_ARCHIVE, 0, qfalse }, { &g_schachtmeisterAutobahnMessage, "g_schachtmeisterAutobahnMessage", "Your host is blacklisted.", CVAR_ARCHIVE, 0, qfalse }, { &g_revertCooldownTime, "g_revertCooldownTime", "30", CVAR_ARCHIVE, 0, qfalse }, { &g_antistack, "g_antistack", "0", CVAR_ARCHIVE, 0, qfalse }, { &g_antistackBias, "g_antistackBias", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_antistackTimeThreshold, "g_antistackTimeThreshold", "120", CVAR_ARCHIVE, 0, qfalse }, { &g_antistackKillThreshold, "g_antistackKillThreshold", "10", CVAR_ARCHIVE, 0, qfalse }, { &g_antistackBiasThreshold, "g_antistackBiasThreshold", "2", CVAR_ARCHIVE, 0, qfalse }, { &g_antistackHandicapMultiplier, "g_antistackHandicapMultiplier", "1", CVAR_ARCHIVE, 0, qfalse }, { &g_antistackInterval, "g_antistackInterval", "60", CVAR_ARCHIVE, 0, qfalse }, }; static int gameCvarTableSize = sizeof( gameCvarTable ) / sizeof( gameCvarTable[ 0 ] ); void G_InitGame( int levelTime, int randomSeed, int restart ); void G_RunFrame( int levelTime ); void G_ShutdownGame( int restart ); void CheckExitRules( void ); void G_CountSpawns( void ); void G_CalculateBuildPoints( void ); /* ================ vmMain This is the only way control passes into the module. This must be the very first function compiled into the .q3vm file ================ */ Q_EXPORT intptr_t vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11 ) { switch( command ) { case GAME_INIT: G_InitGame( arg0, arg1, arg2 ); return 0; case GAME_SHUTDOWN: G_ShutdownGame( arg0 ); return 0; case GAME_CLIENT_CONNECT: return (intptr_t)ClientConnect( arg0, arg1, arg2 ); case GAME_CLIENT_THINK: ClientThink( arg0 ); return 0; case GAME_CLIENT_USERINFO_CHANGED: ClientUserinfoChanged( arg0, qfalse ); return 0; case GAME_CLIENT_DISCONNECT: ClientDisconnect( arg0 ); return 0; case GAME_CLIENT_BEGIN: ClientBegin( arg0 ); return 0; case GAME_CLIENT_COMMAND: ClientCommand( arg0 ); return 0; case GAME_RUN_FRAME: G_RunFrame( arg0 ); return 0; case GAME_CONSOLE_COMMAND: return ConsoleCommand( ); } return -1; } void QDECL G_Printf( const char *fmt, ... ) { va_list argptr; char text[ 1024 ]; va_start( argptr, fmt ); vsprintf( text, fmt, argptr ); va_end( argptr ); trap_Printf( text ); } void QDECL G_Error( const char *fmt, ... ) { va_list argptr; char text[ 1024 ]; va_start( argptr, fmt ); vsprintf( text, fmt, argptr ); va_end( argptr ); trap_Error( text ); } /* ================ G_FindTeams Chain together all entities with a matching team field. Entity teams are used for item groups and multi-entity mover groups. All but the first will have the FL_TEAMSLAVE flag set and teammaster field set All but the last will have the teamchain field set to the next one ================ */ void G_FindTeams( void ) { gentity_t *e, *e2; int i, j; int c, c2; c = 0; c2 = 0; for( i = 1, e = g_entities+i; i < level.num_entities; i++, e++ ) { if( !e->inuse ) continue; if( !e->team ) continue; if( e->flags & FL_TEAMSLAVE ) continue; e->teammaster = e; c++; c2++; for( j = i + 1, e2 = e + 1; j < level.num_entities; j++, e2++ ) { if( !e2->inuse ) continue; if( !e2->team ) continue; if( e2->flags & FL_TEAMSLAVE ) continue; if( !strcmp( e->team, e2->team ) ) { c2++; e2->teamchain = e->teamchain; e->teamchain = e2; e2->teammaster = e; e2->flags |= FL_TEAMSLAVE; // make sure that targets only point at the master if( e2->targetname ) { e->targetname = e2->targetname; e2->targetname = NULL; } } } } G_Printf( "%i teams with %i entities\n", c, c2 ); } void G_RemapTeamShaders( void ) { } /* ================= G_RegisterCvars ================= */ void G_RegisterCvars( void ) { int i; cvarTable_t *cv; qboolean remapped = qfalse; for( i = 0, cv = gameCvarTable; i < gameCvarTableSize; i++, cv++ ) { trap_Cvar_Register( cv->vmCvar, cv->cvarName, cv->defaultString, cv->cvarFlags ); if( cv->vmCvar ) cv->modificationCount = cv->vmCvar->modificationCount; if( cv->teamShader ) remapped = qtrue; } if( remapped ) G_RemapTeamShaders( ); } /* ================= G_UpdateCvars ================= */ void G_UpdateCvars( void ) { int i; cvarTable_t *cv; qboolean remapped = qfalse; for( i = 0, cv = gameCvarTable; i < gameCvarTableSize; i++, cv++ ) { if( cv->vmCvar ) { trap_Cvar_Update( cv->vmCvar ); if( cv->modificationCount != cv->vmCvar->modificationCount ) { cv->modificationCount = cv->vmCvar->modificationCount; if( cv->trackChange ) { trap_SendServerCommand( -1, va( "print \"Server: %s changed to %s\n\"", cv->cvarName, cv->vmCvar->string ) ); // update serverinfo in case this cvar is passed to clients indirectly CalculateRanks( ); } if( cv->teamShader ) remapped = qtrue; } } } if( remapped ) G_RemapTeamShaders( ); } static void G_InitModCvars( void ) { BG_MOD_set( MOD_BG_BUILDABLE_HEALTH, g_modBuildableHealth.integer ); BG_MOD_set( MOD_BG_BUILDABLE_SPEED, g_modBuildableSpeed.integer ); BG_MOD_set( MOD_BG_HUMAN_STAMINA, g_modHumanStamina.integer ); BG_MOD_set( MOD_BG_HUMAN_HEALTH, g_modHumanHealth.integer ); BG_MOD_set( MOD_BG_ALIEN_HEALTH, g_modAlienHealth.integer ); BG_MOD_set( MOD_BG_HUMAN_RATE, g_modHumanRate.integer ); BG_MOD_set( MOD_BG_ALIEN_RATE, g_modAlienRate.integer ); BG_MOD_set( MOD_BG_WEAPON_AMMO, g_modWeaponAmmo.integer ); BG_MOD_set( MOD_BG_WEAPON_RELOAD, g_modWeaponReload.integer ); BG_MOD_set( MOD_BG_TURRET_ANGLE, g_modTurretAngle.integer ); BG_MOD_set( MOD_BG_STAGE3_STRENGTH, g_modStage3Strength.integer ); BG_MOD_update( ); } /* ================= G_MapConfigs ================= */ void G_MapConfigs( const char *mapname ) { if( !g_mapConfigs.string[0] ) return; if( trap_Cvar_VariableIntegerValue( "g_mapConfigsLoaded" ) ) return; trap_SendConsoleCommand( EXEC_APPEND, va( "exec \"%s/default.cfg\"\n", g_mapConfigs.string ) ); trap_SendConsoleCommand( EXEC_APPEND, va( "exec \"%s/%s.cfg\"\n", g_mapConfigs.string, mapname ) ); trap_Cvar_Set( "g_mapConfigsLoaded", "1" ); } /* ============ G_InitGame ============ */ void G_InitGame( int levelTime, int randomSeed, int restart ) { int i; srand( randomSeed ); G_RegisterCvars( ); G_Printf( "------- Game Initialization -------\n" ); G_Printf( "gamename: %s\n", GAME_VERSION ); G_Printf( "gamedate: %s\n", __DATE__ ); G_ProcessIPBans( ); G_InitMemory( ); // set some level globals memset( &level, 0, sizeof( level ) ); level.time = levelTime; level.startTime = levelTime; level.alienStage2Time = level.alienStage3Time = level.humanStage2Time = level.humanStage3Time = level.startTime; level.snd_fry = G_SoundIndex( "sound/misc/fry.wav" ); // FIXME standing in lava / slime if( g_logFile.string[ 0 ] ) { if( g_logFileSync.integer ) trap_FS_FOpenFile( g_logFile.string, &level.logFile, FS_APPEND_SYNC ); else trap_FS_FOpenFile( g_logFile.string, &level.logFile, FS_APPEND ); if( !level.logFile ) G_Printf( "WARNING: Couldn't open logfile: %s\n", g_logFile.string ); else { char serverinfo[ MAX_INFO_STRING ]; qtime_t qt; trap_GetServerinfo( serverinfo, sizeof( serverinfo ) ); G_LogPrintf( "------------------------------------------------------------\n" ); G_LogPrintf( "InitGame: %s\n", serverinfo ); trap_RealTime( &qt ); G_LogPrintf("RealTime: %04i/%02i/%02i %02i:%02i:%02i\n", qt.tm_year+1900, qt.tm_mon+1, qt.tm_mday, qt.tm_hour, qt.tm_min, qt.tm_sec ); } } else G_Printf( "Not logging to disk\n" ); { char map[ MAX_CVAR_VALUE_STRING ] = {""}; trap_Cvar_VariableStringBuffer( "mapname", map, sizeof( map ) ); G_MapConfigs( map ); } // we're done with g_mapConfigs, so reset this for the next map trap_Cvar_Set( "g_mapConfigsLoaded", "0" ); if ( g_admin.string[ 0 ] ) { G_admin_readconfig( NULL, 0 ); } // 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 ] ) ); trap_SetConfigstring( CS_INTERMISSION, "0" ); // update maplog G_admin_maplog_update( ); // test to see if a custom buildable layout will be loaded G_LayoutSelect( ); // parse the key/value pairs and spawn gentities G_SpawnEntitiesFromString( ); // load up a custom building layout if there is one G_LayoutLoad( ); // load up nobuild zones nobuild_init( ); // the map might disable some things BG_InitAllowedGameElements( ); // practice counter if( g_practiceCount.integer > 0 ) { trap_Cvar_Set( "g_practiceCount", va( "%d", g_practiceCount.integer - 1 ) ); } // free credits expiration if( g_freeCredits.integer > 1 ) { trap_Cvar_Set( "g_freeCredits", va( "%d", ( g_freeCredits.integer > 2 ) ? g_freeCredits.integer - 1 : 0 ) ); } // syncronize mod cvars G_InitModCvars( ); // general initialization G_FindTeams( ); //TA: G_InitDamageLocations( ); G_InitMapRotations( ); G_InitSpawnQueue( &level.alienSpawnQueue ); G_InitSpawnQueue( &level.humanSpawnQueue ); if( g_debugMapRotation.integer ) G_PrintRotations( ); //reset stages trap_Cvar_Set( "g_alienStage", va( "%d", S1 ) ); trap_Cvar_Set( "g_humanStage", va( "%d", S1 ) ); trap_Cvar_Set( "g_alienKills", 0 ); trap_Cvar_Set( "g_humanKills", 0 ); trap_Cvar_Set( "g_suddenDeath", 0 ); level.suddenDeathBeginTime = g_suddenDeathTime.integer * 60000; trap_Cvar_Set( "g_vampireDeath", 0 ); G_Printf( "-----------------------------------\n" ); G_RemapTeamShaders( ); //TA: so the server counts the spawns without a client attached G_CountSpawns( ); G_ResetPTRConnections( ); if(g_lockTeamsAtStart.integer) { level.alienTeamLocked=qtrue; level.humanTeamLocked=qtrue; trap_Cvar_Set( "g_lockTeamsAtStart", "0" ); } level.antistackNextCheck = g_antistackTimeThreshold.integer * 1000; level.alienHandicap = 1.0f; level.humanHandicap = 1.0f; } /* ================== G_ClearVotes remove all currently active votes ================== */ static void G_ClearVotes( void ) { level.voteTime = 0; trap_SetConfigstring( CS_VOTE_TIME, "" ); trap_SetConfigstring( CS_VOTE_STRING, "" ); level.teamVoteTime[ 0 ] = 0; trap_SetConfigstring( CS_TEAMVOTE_TIME, "" ); trap_SetConfigstring( CS_TEAMVOTE_STRING, "" ); level.teamVoteTime[ 1 ] = 0; trap_SetConfigstring( CS_TEAMVOTE_TIME + 1, "" ); trap_SetConfigstring( CS_TEAMVOTE_STRING + 1, "" ); } /* ================= G_ShutdownGame ================= */ void G_ShutdownGame( int restart ) { // in case of a map_restart G_ClearVotes( ); G_Printf( "==== ShutdownGame ====\n" ); G_admin_chat_writeconfig(); 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( ); G_admin_cleanup( ); G_admin_namelog_cleanup( ); G_admin_adminlog_cleanup( ); G_admin_tklog_cleanup( ); level.restarted = qfalse; level.surrenderTeam = PTE_NONE; trap_SetConfigstring( CS_WINNER, "" ); } //=================================================================== void QDECL Com_Error( int level, const char *error, ... ) { 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, ... ) { va_list argptr; char text[ 1024 ]; va_start( argptr, msg ); vsprintf( text, msg, argptr ); va_end( argptr ); G_Printf( "%s", text ); } /* ======================================================================== PLAYER COUNTING / SCORE SORTING ======================================================================== */ /* ============= SortRanks ============= */ int QDECL SortRanks( const void *a, const void *b ) { gclient_t *ca, *cb; ca = &level.clients[ *(int *)a ]; cb = &level.clients[ *(int *)b ]; // then sort by score if( ca->pers.score > cb->pers.score ) return -1; else if( ca->pers.score < cb->pers.score ) return 1; else return 0; } /* ============ G_InitSpawnQueue Initialise a spawn queue ============ */ void G_InitSpawnQueue( spawnQueue_t *sq ) { int i; sq->back = sq->front = 0; sq->back = QUEUE_MINUS1( sq->back ); //0 is a valid clientNum, so use something else for( i = 0; i < MAX_CLIENTS; i++ ) sq->clients[ i ] = -1; } /* ============ G_GetSpawnQueueLength Return tha length of a spawn queue ============ */ int G_GetSpawnQueueLength( spawnQueue_t *sq ) { int length = sq->back - sq->front + 1; while( length < 0 ) length += MAX_CLIENTS; while( length >= MAX_CLIENTS ) length -= MAX_CLIENTS; return length; } /* ============ G_PopSpawnQueue Remove from front element from a spawn queue ============ */ int G_PopSpawnQueue( spawnQueue_t *sq ) { int clientNum = sq->clients[ sq->front ]; if( G_GetSpawnQueueLength( sq ) > 0 ) { sq->clients[ sq->front ] = -1; sq->front = QUEUE_PLUS1( sq->front ); g_entities[ clientNum ].client->ps.pm_flags &= ~PMF_QUEUED; return clientNum; } else return -1; } /* ============ G_PeekSpawnQueue Look at front element from a spawn queue ============ */ int G_PeekSpawnQueue( spawnQueue_t *sq ) { return sq->clients[ sq->front ]; } /* ============ G_SearchSpawnQueue Look to see if clientNum is already in the spawnQueue ============ */ qboolean G_SearchSpawnQueue( spawnQueue_t *sq, int clientNum ) { int i; for( i = 0; i < MAX_CLIENTS; i++ ) if( sq->clients[ i ] == clientNum ) return qtrue; return qfalse; } /* ============ G_PushSpawnQueue Add an element to the back of the spawn queue ============ */ qboolean G_PushSpawnQueue( spawnQueue_t *sq, int clientNum ) { // don't add the same client more than once if( G_SearchSpawnQueue( sq, clientNum ) ) return qfalse; sq->back = QUEUE_PLUS1( sq->back ); sq->clients[ sq->back ] = clientNum; g_entities[ clientNum ].client->ps.pm_flags |= PMF_QUEUED; return qtrue; } /* ============ G_RemoveFromSpawnQueue remove a specific client from a spawn queue ============ */ qboolean G_RemoveFromSpawnQueue( spawnQueue_t *sq, int clientNum ) { int i = sq->front; if( G_GetSpawnQueueLength( sq ) ) { do { if( sq->clients[ i ] == clientNum ) { //and this kids is why it would have //been better to use an LL for internal //representation do { sq->clients[ i ] = sq->clients[ QUEUE_PLUS1( i ) ]; i = QUEUE_PLUS1( i ); } while( i != QUEUE_PLUS1( sq->back ) ); sq->back = QUEUE_MINUS1( sq->back ); g_entities[ clientNum ].client->ps.pm_flags &= ~PMF_QUEUED; return qtrue; } i = QUEUE_PLUS1( i ); } while( i != QUEUE_PLUS1( sq->back ) ); } return qfalse; } /* ============ G_GetPosInSpawnQueue Get the position of a client in a spawn queue ============ */ int G_GetPosInSpawnQueue( spawnQueue_t *sq, int clientNum ) { int i = sq->front; if( G_GetSpawnQueueLength( sq ) ) { do { if( sq->clients[ i ] == clientNum ) { if( i < sq->front ) return i + MAX_CLIENTS - sq->front; else return i - sq->front; } i = QUEUE_PLUS1( i ); } while( i != QUEUE_PLUS1( sq->back ) ); } return -1; } /* ============ G_PrintSpawnQueue Print the contents of a spawn queue ============ */ void G_PrintSpawnQueue( spawnQueue_t *sq ) { int i = sq->front; int length = G_GetSpawnQueueLength( sq ); G_Printf( "l:%d f:%d b:%d :", length, sq->front, sq->back ); if( length > 0 ) { do { if( sq->clients[ i ] == -1 ) G_Printf( "*:" ); else G_Printf( "%d:", sq->clients[ i ] ); i = QUEUE_PLUS1( i ); } while( i != QUEUE_PLUS1( sq->back ) ); } G_Printf( "\n" ); } /* ============ G_SpawnClients Spawn queued clients ============ */ void G_SpawnClients( pTeam_t team ) { int clientNum; gentity_t *ent, *spawn; vec3_t spawn_origin, spawn_angles; spawnQueue_t *sq = NULL; int numSpawns = 0; if( g_doWarmup.integer && ( g_warmupMode.integer==1 || g_warmupMode.integer == 2 ) && level.time - level.startTime < g_warmup.integer * 1000 ) { return; } if( team == PTE_ALIENS ) { sq = &level.alienSpawnQueue; numSpawns = level.numAlienSpawns; } else if( team == PTE_HUMANS ) { sq = &level.humanSpawnQueue; numSpawns = level.numHumanSpawns; } if( G_GetSpawnQueueLength( sq ) > 0 && numSpawns > 0 ) { clientNum = G_PeekSpawnQueue( sq ); ent = &g_entities[ clientNum ]; if( ( spawn = G_SelectTremulousSpawnPoint( team, ent->client->pers.lastDeathLocation, spawn_origin, spawn_angles ) ) ) { clientNum = G_PopSpawnQueue( sq ); if( clientNum < 0 ) return; ent = &g_entities[ clientNum ]; ent->client->sess.sessionTeam = TEAM_FREE; ClientUserinfoChanged( clientNum, qfalse ); ClientSpawn( ent, spawn, spawn_origin, spawn_angles ); } } } /* ============ G_CountSpawns Counts the number of spawns for each team ============ */ void G_CountSpawns( void ) { int i; gentity_t *ent; level.numAlienSpawns = 0; level.numHumanSpawns = 0; for( i = 1, ent = g_entities + i ; i < level.num_entities ; i++, ent++ ) { if( !ent->inuse || ent->s.eType != ET_BUILDABLE || ( ent->spawned && ent->health <= 0 ) ) continue; if( ent->s.modelindex == BA_A_SPAWN ) level.numAlienSpawns++; if( ent->s.modelindex == BA_H_SPAWN ) level.numHumanSpawns++; } //let the client know how many spawns there are trap_SetConfigstring( CS_SPAWNS, va( "%d %d", level.numAlienSpawns, level.numHumanSpawns ) ); } /* ============ G_TimeTilSuddenDeath ============ */ int G_TimeTilSuddenDeath( void ) { if( (!g_suddenDeathTime.integer && level.suddenDeathBeginTime==0 ) || level.suddenDeathBeginTime<0 ) return 999999999; // Always some time away return ( ( level.suddenDeathBeginTime ) - ( level.time - level.startTime ) ); } int G_TimeTilVampireDeath( void ) { if( !g_vampireDeathTime.integer ) return 3600000; // Always some time away return ( g_vampireDeathTime.integer * 60000 ) - ( level.time - level.startTime ); } #define PLAYER_COUNT_MOD 5.0f /* ============ G_CalculateBuildPoints Recalculate the quantity of building points available to the teams ============ */ void G_CalculateBuildPoints( void ) { int i; buildable_t buildable; gentity_t *ent; int localHTP = g_humanBuildPoints.integer, localATP = g_alienBuildPoints.integer; // g_suddenDeath sets what state we want it to be. // level.suddenDeath says whether we've calculated BPs at the 'start' of SD or not // reset if SD was on, but now it's off if(!g_suddenDeath.integer && level.suddenDeath) { level.suddenDeath=qfalse; level.suddenDeathWarning=0; level.suddenDeathBeginTime = -1; if((level.time - level.startTime) < (g_suddenDeathTime.integer * 60000 ) ) level.suddenDeathBeginTime = g_suddenDeathTime.integer * 60000; else level.suddenDeathBeginTime = -1; } if(!level.suddenDeath) { if(g_suddenDeath.integer || G_TimeTilSuddenDeath( ) <= 0 ) //Conditions to enter SD { //begin sudden death if( level.suddenDeathWarning < TW_PASSED ) { trap_SendServerCommand( -1, "cp \"Sudden Death!\"" ); G_LogPrintf("Beginning Sudden Death (Mode %d)\n",g_suddenDeathMode.integer); localHTP = 0; localATP = 0; if( g_suddenDeathMode.integer == SDMODE_SELECTIVE ) { for( i = 1, ent = g_entities + i; i < level.num_entities; i++, ent++ ) { if( ent->s.eType != ET_BUILDABLE ) continue; if( BG_FindReplaceableTestForBuildable( ent->s.modelindex ) ) { int t = BG_FindTeamForBuildable( ent->s.modelindex ); if( t == BIT_HUMANS ) localHTP += BG_FindBuildPointsForBuildable( ent->s.modelindex ); else if( t == BIT_ALIENS ) localATP += BG_FindBuildPointsForBuildable( ent->s.modelindex ); } } } level.suddenDeathHBuildPoints = localHTP; level.suddenDeathABuildPoints = localATP; level.suddenDeathBeginTime = level.time; level.suddenDeath=qtrue; trap_Cvar_Set( "g_suddenDeath", "1" ); level.suddenDeathWarning = TW_PASSED; } } else { //warn about sudden death if( ( G_TimeTilSuddenDeath( ) <= 60000 ) && ( level.suddenDeathWarning < TW_IMMINENT ) ) { trap_SendServerCommand( -1, va("cp \"Sudden Death in %d seconds!\"", (int)(G_TimeTilSuddenDeath() / 1000 ) ) ); level.suddenDeathWarning = TW_IMMINENT; } } } //vampire death if( !g_vampireDeath.integer && level.vampireDeath ) { level.vampireDeath = 0; level.vampireDeathWarning = 0; } if( !level.vampireDeath ) { if( g_vampireDeath.integer || G_TimeTilVampireDeath( ) <= 0 ) //Conditions to enter VD { if( level.vampireDeathWarning < TW_PASSED ) { trap_SendServerCommand( -1, "cp \"^1Vampire Sudden Death!\"" ); level.vampireDeath = 1; level.vampireDeathBeginTime = level.time; level.vampireDeathWarning = TW_PASSED; g_vampireDeath.integer = 1; } } else if( G_TimeTilVampireDeath( ) <= 60000 && level.vampireDeathWarning < TW_IMMINENT ) { trap_SendServerCommand( -1, va( "cp \"^1Vampire\n^7Sudden Death in 60 seconds!%s%s\"", ( g_vampireDeathInfo.string[ 0 ] ) ? "\n\n" : "", g_vampireDeathInfo.string ) ); level.vampireDeathWarning = TW_IMMINENT; } else if( G_TimeTilVampireDeath( ) <= 300000 && level.vampireDeathWarning < TW_SOON ) { trap_SendServerCommand( -1, va ("cp \"^1Vampire\n^7Sudden Death in 5 minutes!%s%s\"", ( g_vampireDeathInfo.string[ 0 ] ) ? "\n\n" : "", g_vampireDeathInfo.string ) ); level.vampireDeathWarning = TW_SOON; } } //set BP at each cycle if( g_suddenDeath.integer ) { localHTP = level.suddenDeathHBuildPoints; localATP = level.suddenDeathABuildPoints; } else { localHTP = g_humanBuildPoints.integer; localATP = g_alienBuildPoints.integer; } // Build Point Recovery // each gained stage adds 50% delay if( g_buildPointsRecoverRate.integer ) { while( level.humanRecoverBuildPoints > 0 && level.humanRecoverTime < level.time ) { level.humanRecoverBuildPoints--; level.humanRecoverTime += ( 60000 + g_humanStage.integer * 30000 ) / g_buildPointsRecoverRate.integer; } while( level.alienRecoverBuildPoints > 0 && level.alienRecoverTime < level.time ) { level.alienRecoverBuildPoints--; level.alienRecoverTime += ( 60000 + g_alienStage.integer * 30000 ) / g_buildPointsRecoverRate.integer; } } else { // recover may have been turned off, reset level.humanRecoverBuildPoints = 0; level.alienRecoverBuildPoints = 0; } level.humanBuildPoints = level.humanBuildPointsPowered = localHTP - level.humanRecoverBuildPoints; level.alienBuildPoints = localATP - level.alienRecoverBuildPoints; level.reactorPresent = qfalse; level.overmindPresent = qfalse; for( i = 1, ent = g_entities + i ; i < level.num_entities ; i++, ent++ ) { if( !ent->inuse ) continue; if( ent->s.eType != ET_BUILDABLE ) continue; if( ent->s.eFlags & EF_DEAD ) continue; buildable = ent->s.modelindex; if( buildable != BA_NONE ) { if( buildable == BA_H_REACTOR && ent->spawned && ent->health > 0 ) level.reactorPresent = qtrue; if( buildable == BA_A_OVERMIND && ent->spawned && ent->health > 0 ) level.overmindPresent = qtrue; if( !g_suddenDeath.integer || BG_FindReplaceableTestForBuildable( buildable ) ) { if( BG_FindTeamForBuildable( buildable ) == BIT_HUMANS ) { level.humanBuildPoints -= BG_FindBuildPointsForBuildable( buildable ); if( ent->powered ) level.humanBuildPointsPowered -= BG_FindBuildPointsForBuildable( buildable ); } else { level.alienBuildPoints -= BG_FindBuildPointsForBuildable( buildable ); } } } } if( level.humanBuildPoints < 0 ) { localHTP -= level.humanBuildPoints; level.humanBuildPointsPowered -= level.humanBuildPoints; level.humanBuildPoints = 0; } if( level.alienBuildPoints < 0 ) { localATP -= level.alienBuildPoints; level.alienBuildPoints = 0; } trap_SetConfigstring( CS_BUILDPOINTS, va( "%d %d %d %d %d", level.alienBuildPoints, localATP, level.humanBuildPoints, localHTP, level.humanBuildPointsPowered ) ); //may as well pump the stages here too { float alienPlayerCountMod = level.averageNumAlienClients / PLAYER_COUNT_MOD; float humanPlayerCountMod = level.averageNumHumanClients / PLAYER_COUNT_MOD; int alienNextStageThreshold, humanNextStageThreshold; if( alienPlayerCountMod < 0.1f ) alienPlayerCountMod = 0.1f; if( humanPlayerCountMod < 0.1f ) humanPlayerCountMod = 0.1f; if( g_alienStage.integer == S1 && g_alienMaxStage.integer > S1 ) alienNextStageThreshold = (int)( ceil( (float)g_alienStage2Threshold.integer * alienPlayerCountMod ) ); else if( g_alienStage.integer == S2 && g_alienMaxStage.integer > S2 ) alienNextStageThreshold = (int)( ceil( (float)g_alienStage3Threshold.integer * alienPlayerCountMod ) ); else alienNextStageThreshold = -1; if( g_humanStage.integer == S1 && g_humanMaxStage.integer > S1 ) humanNextStageThreshold = (int)( ceil( (float)g_humanStage2Threshold.integer * humanPlayerCountMod ) ); else if( g_humanStage.integer == S2 && g_humanMaxStage.integer > S2 ) humanNextStageThreshold = (int)( ceil( (float)g_humanStage3Threshold.integer * humanPlayerCountMod ) ); else humanNextStageThreshold = -1; trap_SetConfigstring( CS_STAGES, va( "%d %d %d %d %d %d", g_alienStage.integer, g_humanStage.integer, g_alienKills.integer, g_humanKills.integer, alienNextStageThreshold, humanNextStageThreshold ) ); } } /* ============ G_CalculateStages ============ */ void G_CalculateStages( void ) { float alienPlayerCountMod = level.averageNumAlienClients / PLAYER_COUNT_MOD; float humanPlayerCountMod = level.averageNumHumanClients / PLAYER_COUNT_MOD; static int alienTriggerStage = 0; static int humanTriggerStage = 0; if( alienPlayerCountMod < 0.1f ) alienPlayerCountMod = 0.1f; if( humanPlayerCountMod < 0.1f ) humanPlayerCountMod = 0.1f; if( g_alienKills.integer >= (int)( ceil( (float)g_alienStage2Threshold.integer * alienPlayerCountMod ) ) && g_alienStage.integer == S1 && g_alienMaxStage.integer > S1 ) { trap_Cvar_Set( "g_alienStage", va( "%d", S2 ) ); g_alienStage.integer = S2; // update immediately } if( g_alienKills.integer >= (int)( ceil( (float)g_alienStage3Threshold.integer * alienPlayerCountMod ) ) && g_alienStage.integer == S2 && g_alienMaxStage.integer > S2 ) { trap_Cvar_Set( "g_alienStage", va( "%d", S3 ) ); g_alienStage.integer = S3; } if( g_humanKills.integer >= (int)( ceil( (float)g_humanStage2Threshold.integer * humanPlayerCountMod ) ) && g_humanStage.integer == S1 && g_humanMaxStage.integer > S1 ) { trap_Cvar_Set( "g_humanStage", va( "%d", S2 ) ); g_humanStage.integer = S2; } if( g_humanKills.integer >= (int)( ceil( (float)g_humanStage3Threshold.integer * humanPlayerCountMod ) ) && g_humanStage.integer == S2 && g_humanMaxStage.integer > S2 ) { trap_Cvar_Set( "g_humanStage", va( "%d", S3 ) ); g_humanStage.integer = S3; } while( alienTriggerStage < MIN( g_alienStage.integer, S3 ) ) { alienTriggerStage++; switch( alienTriggerStage ) { case S2: level.alienStage2Time = level.time; G_LogPrintf( "Stage: A 2: Aliens reached Stage 2\n" ); break; case S3: level.alienStage3Time = level.time; G_LogPrintf( "Stage: A 3: Aliens reached Stage 3\n" ); break; } G_Checktrigger_stages( PTE_ALIENS, alienTriggerStage ); } while( humanTriggerStage < MIN( g_humanStage.integer, S3 ) ) { humanTriggerStage++; switch( humanTriggerStage ) { case S2: level.humanStage2Time = level.time; G_LogPrintf( "Stage: H 2: Humans reached Stage 2\n" ); break; case S3: level.humanStage3Time = level.time; G_LogPrintf( "Stage: H 3: Humans reached Stage 3\n" ); break; } G_Checktrigger_stages( PTE_HUMANS, humanTriggerStage ); } } /* ============ CalculateAvgPlayers Calculates the average number of players playing this game ============ */ void G_CalculateAvgPlayers( void ) { //there are no clients or only spectators connected, so //reset the number of samples in order to avoid the situation //where the average tends to 0 if( !level.numAlienClients ) { level.numAlienSamples = 0; trap_Cvar_Set( "g_alienKills", "0" ); } if( !level.numHumanClients ) { level.numHumanSamples = 0; trap_Cvar_Set( "g_humanKills", "0" ); } //calculate average number of clients for stats level.averageNumAlienClients = ( ( level.averageNumAlienClients * level.numAlienSamples ) + level.numAlienClients ) / (float)( level.numAlienSamples + 1 ); level.numAlienSamples++; level.averageNumHumanClients = ( ( level.averageNumHumanClients * level.numHumanSamples ) + level.numHumanClients ) / (float)( level.numHumanSamples + 1 ); level.numHumanSamples++; } /* ============ CalculateRanks Recalculates the score ranks of all players This will be called on every client connect, begin, disconnect, death, and team change. ============ */ void CalculateRanks( void ) { int i; char P[ MAX_CLIENTS + 1 ] = {""}; int ff = 0; level.numConnectedClients = 0; level.numNonSpectatorClients = 0; level.numPlayingClients = 0; level.numVotingClients = 0; // don't count bots level.numAlienClients = 0; level.numHumanClients = 0; level.numLiveAlienClients = 0; level.numLiveHumanClients = 0; level.bleeders = 0; for( i = 0; i < level.maxclients; i++ ) { P[ i ] = '-'; if ( level.clients[ i ].pers.connected != CON_DISCONNECTED ) { level.sortedClients[ level.numConnectedClients ] = i; level.numConnectedClients++; P[ i ] = (char)'0' + level.clients[ i ].pers.teamSelection; if( level.clients[ i ].pers.connected != CON_CONNECTED ) continue; level.numVotingClients++; if( level.clients[ i ].pers.teamSelection != PTE_NONE ) { level.numPlayingClients++; if( level.clients[ i ].sess.sessionTeam != TEAM_SPECTATOR ) level.numNonSpectatorClients++; if( level.clients[ i ].pers.teamSelection == PTE_ALIENS ) { level.numAlienClients++; if( level.clients[ i ].sess.sessionTeam != TEAM_SPECTATOR ) level.numLiveAlienClients++; } else if( level.clients[ i ].pers.teamSelection == PTE_HUMANS ) { level.numHumanClients++; if( level.clients[ i ].sess.sessionTeam != TEAM_SPECTATOR ) level.numLiveHumanClients++; } if( level.clients[ i ].pers.bleeder ) level.bleeders++; } } } level.numteamVotingClients[ 0 ] = level.numHumanClients; level.numteamVotingClients[ 1 ] = level.numAlienClients; P[ i ] = '\0'; trap_Cvar_Set( "P", P ); if( g_friendlyFire.value>0 ) ff |= ( FFF_HUMANS | FFF_ALIENS ); if( g_friendlyFireHumans.value>0 ) ff |= FFF_HUMANS; if( g_friendlyFireAliens.value>0 ) ff |= FFF_ALIENS; if( g_friendlyBuildableFire.value>0 ) ff |= FFF_BUILDABLES; trap_Cvar_Set( "ff", va( "%i", ff ) ); qsort( level.sortedClients, level.numConnectedClients, sizeof( level.sortedClients[ 0 ] ), SortRanks ); // see if it is time to end the level CheckExitRules( ); // if we are at the intermission, send the new info to everyone if( level.intermissiontime && !level.mapRotationVoteTime ) SendScoreboardMessageToAllClients( ); } /* ======================================================================== MAP CHANGING ======================================================================== */ /* ======================== SendScoreboardMessageToAllClients Do this at BeginIntermission time and whenever ranks are recalculated due to enters/exits/forced team changes ======================== */ void SendScoreboardMessageToAllClients( void ) { int i; for( i = 0; i < level.maxclients; i++ ) { if( level.clients[ i ].pers.connected == CON_CONNECTED ) ScoreboardMessage( g_entities + i ); } } /* ======================== MoveClientToIntermission When the intermission starts, this will be called for all players. If a new client connects, this will be called after the spawn function. ======================== */ void MoveClientToIntermission( gentity_t *ent ) { // take out of follow mode if needed if( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) G_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.misc, 0, sizeof( ent->client->ps.misc ) ); ent->client->ps.eFlags = 0; ent->s.eFlags = 0; ent->s.eType = ET_GENERAL; ent->s.modelindex = 0; ent->s.loopSound = 0; ent->s.event = 0; ent->r.contents = 0; } /* ================== FindIntermissionPoint This is also used for spectator spawns ================== */ void FindIntermissionPoint( void ) { gentity_t *ent, *target; vec3_t dir; // find the intermission spot ent = G_Find( NULL, FOFS( classname ), "info_player_intermission" ); if( !ent ) { // the map creator forgot to put in an intermission point... G_SelectSpawnPoint( vec3_origin, level.intermission_origin, level.intermission_angle ); } 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 ); } } } } /* ================== BeginIntermission ================== */ void BeginIntermission( void ) { int i; gentity_t *client; if( level.intermissiontime ) return; // already active level.numTeamWarnings = 99; level.intermissiontime = level.time; G_ClearVotes( ); FindIntermissionPoint( ); // 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 ) respawn(client); MoveClientToIntermission( client ); } // send the current scoring to all clients SendScoreboardMessageToAllClients( ); if( g_nextMap.string[ 0 ] ) { trap_SendServerCommand( -1, va( "print \"next map has been set to %s^7%s\n\"", g_nextMap.string, ( G_CheckMapRotationVote() ) ? ", voting will be skipped" : "" ) ); } } void BeginMapRotationVote( void ) { gentity_t *ent; int length; int i; if( level.mapRotationVoteTime ) return; length = g_mapRotationVote.integer; if( length > 60 ) length = 60; level.mapRotationVoteTime = level.time + ( length * 1000 ); for( i = 0; i < level.maxclients; i++ ) { ent = g_entities + i; if( !ent->inuse ) continue; ent->client->ps.pm_type = PM_SPECTATOR; ent->client->sess.sessionTeam = TEAM_SPECTATOR; ent->client->sess.spectatorState = SPECTATOR_LOCKED; } } /* ============= ExitLevel When the intermission has been exited, the server is either moved to a new map based on the map rotation or the current map restarted ============= */ void ExitLevel( void ) { int i; gclient_t *cl; buildHistory_t *tmp, *mark; char currentmap[ MAX_CVAR_VALUE_STRING ]; trap_Cvar_VariableStringBuffer( "mapname", currentmap, sizeof( currentmap )); if( level.mapRotationVoteTime ) { if( level.time < level.mapRotationVoteTime && !G_IntermissionMapVoteWinner( ) ) return; } else if( g_mapRotationVote.integer > 0 && G_CheckMapRotationVote() && !g_nextMap.string[ 0 ] ) { BeginMapRotationVote( ); return; } while( ( tmp = level.buildHistory ) ) { level.buildHistory = level.buildHistory->next; while( ( mark = tmp ) ) { tmp = tmp->marked; G_Free( mark ); } } if( !Q_stricmp( currentmap, g_nextMap.string ) ) trap_SendConsoleCommand( EXEC_APPEND, "map_restart\n" ); else if ( G_MapExists( g_nextMap.string ) ) trap_SendConsoleCommand( EXEC_APPEND, va("!map %s\n", g_nextMap.string ) ); else if( G_MapRotationActive( ) ) G_AdvanceMapRotation( ); else trap_SendConsoleCommand( EXEC_APPEND, "map_restart\n" ); trap_Cvar_Set( "g_nextMap", "" ); level.restarted = qtrue; level.changemap = NULL; level.intermissiontime = 0; // reset all the scores so we don't enter the intermission again for( i = 0; i < g_maxclients.integer; i++ ) { cl = level.clients + i; if( cl->pers.connected != CON_CONNECTED ) continue; cl->ps.persistant[ PERS_SCORE ] = 0; } // we need to do this here before chaning to CON_CONNECTING G_WriteSessionData( ); // change all client states to connecting, so the early players into the // next level will know the others aren't done reconnecting for( i = 0; i < g_maxclients.integer; i++ ) { if( level.clients[ i ].pers.connected == CON_CONNECTED ) level.clients[ i ].pers.connected = CON_CONNECTING; } } /* ================= G_AdminsPrintf Print to all active admins, and the logfile with a time stamp if it is open, and to the console ================= */ void QDECL G_AdminsPrintf( const char *fmt, ... ) { va_list argptr; char string[ 1024 ]; gentity_t *tempent; int j; va_start( argptr, fmt ); vsprintf( string, fmt,argptr ); va_end( argptr ); for( j = 0; j < level.maxclients; j++ ) { tempent = &g_entities[ j ]; if (tempent->client->pers.control > 0) { gentity_t *e = &g_entities[tempent->client->pers.control - 1]; if (G_admin_permission(e, ADMF_ADMINCHAT) && !e->client->pers.ignoreAdminWarnings) continue; } if( G_admin_permission( tempent, ADMF_ADMINCHAT) && !tempent->client->pers.ignoreAdminWarnings ) { trap_SendServerCommand(tempent-g_entities,va( "print \"^7[^5ADMIN^7] %s\"", string) ); } } G_LogPrintf("%s",string); } /* ================= G_LogPrintf Print to the logfile with a time stamp if it is open ================= */ void QDECL G_LogPrintf( const char *fmt, ... ) { va_list argptr; char string[ 1024 ], decoloured[ 1024 ]; int min, tens, sec; sec = ( level.time - level.startTime ) / 1000; min = sec / 60; sec -= min * 60; tens = sec / 10; sec -= tens * 10; Com_sprintf( string, sizeof( string ), "%3i:%i%i ", min, tens, sec ); va_start( argptr, fmt ); vsprintf( string +7 , fmt,argptr ); va_end( argptr ); if( g_dedicated.integer ) G_Printf( "%s", string + 7 ); if( !level.logFile ) return; if( g_decolourLogfiles.integer ) { G_DecolorString( string, decoloured ); trap_FS_Write( decoloured, strlen( decoloured ), level.logFile ); } else { trap_FS_Write( string, strlen( string ), level.logFile ); } } /* ================= G_LogPrintfColoured Bypasses g_decolourLogfiles for events that need colors in the logs ================= */ void QDECL G_LogPrintfColoured( const char *fmt, ... ) { va_list argptr; char string[ 1024 ]; int min, tens, sec; sec = (level.time - level.startTime) / 1000; min = sec / 60; sec -= min * 60; tens = sec / 10; sec -= tens * 10; Com_sprintf( string, sizeof( string ), "%3i:%i%i ", min, tens, sec ); va_start( argptr, fmt ); 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 ); } /* ================= G_LogOnlyPrintf Print to the logfile only (not console) with a time stamp if it is open ================= */ void QDECL G_LogOnlyPrintf( const char *fmt, ... ) { va_list argptr; char string[ 1024 ], decoloured[ 1024 ]; int min, tens, sec; sec = (level.time - level.startTime) / 1000; min = sec / 60; sec -= min * 60; tens = sec / 10; sec -= tens * 10; Com_sprintf( string, sizeof( string ), "%3i:%i%i ", min, tens, sec ); va_start( argptr, fmt ); vsprintf( string +7 , fmt,argptr ); va_end( argptr ); if( !level.logFile ) return; if( g_decolourLogfiles.integer ) { G_DecolorString( string, decoloured ); trap_FS_Write( decoloured, strlen( decoloured ), level.logFile ); } else { trap_FS_Write( string, strlen( string ), level.logFile ); } } /* ================= G_SendGameStat ================= */ void G_SendGameStat( pTeam_t team ) { char map[ MAX_STRING_CHARS ]; char teamChar; char data[ BIG_INFO_STRING ]; char entry[ MAX_STRING_CHARS ]; int i, dataLength, entryLength; gclient_t *cl; trap_Cvar_VariableStringBuffer( "mapname", map, sizeof( map ) ); switch( team ) { case PTE_ALIENS: teamChar = 'A'; break; case PTE_HUMANS: teamChar = 'H'; break; case PTE_NONE: teamChar = 'L'; break; default: return; } Com_sprintf( data, BIG_INFO_STRING, "%s %s T:%c A:%f H:%f M:%s D:%d SD:%d AS:%d AS2T:%d AS3T:%d HS:%d HS2T:%d HS3T:%d CL:%d", Q3_VERSION, g_tag.string, teamChar, level.averageNumAlienClients, level.averageNumHumanClients, map, level.time - level.startTime, G_TimeTilSuddenDeath( ), g_alienStage.integer, level.alienStage2Time - level.startTime, level.alienStage3Time - level.startTime, g_humanStage.integer, level.humanStage2Time - level.startTime, level.humanStage3Time - level.startTime, level.numConnectedClients ); dataLength = strlen( data ); for( i = 0; i < level.numConnectedClients; i++ ) { int ping; cl = &level.clients[ level.sortedClients[ i ] ]; // Ignore invisible players if ( cl->sess.invisible == qtrue ) continue; if( cl->pers.connected == CON_CONNECTING ) ping = -1; else ping = cl->ps.ping < 999 ? cl->ps.ping : 999; switch( cl->ps.stats[ STAT_PTEAM ] ) { case PTE_ALIENS: teamChar = 'A'; break; case PTE_HUMANS: teamChar = 'H'; break; case PTE_NONE: teamChar = 'S'; break; default: return; } Com_sprintf( entry, MAX_STRING_CHARS, " \"%s\" %c %d %d %d", cl->pers.netname, teamChar, cl->ps.persistant[ PERS_SCORE ], ping, ( level.time - cl->pers.enterTime ) / 60000 ); entryLength = strlen( entry ); if( dataLength + entryLength >= BIG_INFO_STRING ) break; strcpy( data + dataLength, entry ); dataLength += entryLength; } trap_SendGameStat( data ); } /* ================ LogExit Append information about this game to the log file ================ */ void LogExit( const char *string ) { int i, numSorted; gclient_t *cl; gentity_t *ent; 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; for( i = 0; i < numSorted; i++ ) { int ping; cl = &level.clients[ level.sortedClients[ i ] ]; if( cl->ps.stats[ STAT_PTEAM ] == PTE_NONE ) 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 ); } for( i = 1, ent = g_entities + i ; i < level.num_entities ; i++, ent++ ) { if( !ent->inuse ) continue; if( !Q_stricmp( ent->classname, "trigger_win" ) ) { if( level.lastWin == ent->stageTeam ) ent->use( ent, ent, ent ); } } G_SendGameStat( level.lastWin ); } /* ================= CheckIntermissionExit The level will stay at the intermission for a minimum of 5 seconds If all players wish to continue, the level will then exit. If one or more players have not acknowledged the continue, the game will wait 10 seconds before going on. ================= */ void CheckIntermissionExit( void ) { int ready, notReady, numPlayers; int i; gclient_t *cl; int readyMask; //if no clients are connected, just exit if( !level.numConnectedClients ) { ExitLevel( ); return; } // map vote started if( level.mapRotationVoteTime ) { ExitLevel( ); return; } // see which players are ready ready = 0; notReady = 0; readyMask = 0; numPlayers = 0; for( i = 0; i < g_maxclients.integer; i++ ) { cl = level.clients + i; if( cl->pers.connected != CON_CONNECTED ) continue; if( cl->ps.stats[ STAT_PTEAM ] == PTE_NONE ) continue; if( cl->readyToExit ) { ready++; if( i < 16 ) readyMask |= 1 << i; } else notReady++; numPlayers++; } trap_SetConfigstring( CS_CLIENTS_READY, va( "%d", readyMask ) ); // never exit in less than five seconds if( level.time < level.intermissiontime + 5000 ) return; // never let intermission go on for over 1 minute if( level.time > level.intermissiontime + 60000 ) { ExitLevel( ); return; } // if nobody wants to go, clear timer if( !ready && numPlayers ) { level.readyToExit = qfalse; return; } // if everyone wants to go, go now if( !notReady ) { ExitLevel( ); return; } // if only a percent is needed to ready, check for it if( g_readyPercent.integer && numPlayers && ready * 100 / numPlayers >= g_readyPercent.integer ) { ExitLevel( ); return; } // the first person to ready starts the thirty second timeout if( !level.readyToExit ) { level.readyToExit = qtrue; level.exitTime = level.time; } // if we have waited thirty seconds since at least one player // wanted to exit, go ahead if( level.time < level.exitTime + 30000 ) return; ExitLevel( ); } /* ============= ScoreIsTied ============= */ qboolean ScoreIsTied( void ) { int a, b; if( level.numPlayingClients < 2 ) return qfalse; a = level.clients[ level.sortedClients[ 0 ] ].ps.persistant[ PERS_SCORE ]; b = level.clients[ level.sortedClients[ 1 ] ].ps.persistant[ PERS_SCORE ]; return a == b; } /* ================= CheckExitRules There will be a delay between the time the exit is qualified for and the time everyone is moved to the intermission spot, so you can see the last frag. ================= */ void CheckExitRules( void ) { // if at the intermission, wait for all non-bots to // signal ready, then go to next level if( level.intermissiontime ) { CheckIntermissionExit( ); return; } if( level.intermissionQueued ) { if( level.time - level.intermissionQueued >= INTERMISSION_DELAY_TIME ) { level.intermissionQueued = 0; BeginIntermission( ); } return; } if( g_timelimit.integer ) { if( level.time - level.startTime >= g_timelimit.integer * 60000 ) { level.lastWin = PTE_NONE; trap_SendServerCommand( -1, "print \"Timelimit hit\n\"" ); trap_SetConfigstring( CS_WINNER, "Stalemate" ); LogExit( "Timelimit hit." ); G_admin_maplog_result( "t" ); return; } else if( level.time - level.startTime >= ( g_timelimit.integer - 5 ) * 60000 && level.timelimitWarning < TW_IMMINENT ) { trap_SendServerCommand( -1, "cp \"5 minutes remaining!\"" ); level.timelimitWarning = TW_IMMINENT; } else if( level.time - level.startTime >= ( g_timelimit.integer - 1 ) * 60000 && level.timelimitWarning < TW_PASSED ) { trap_SendServerCommand( -1, "cp \"1 minute remaining!\"" ); level.timelimitWarning = TW_PASSED; } } if( level.uncondHumanWin || ( ( level.time > level.startTime + 1000 ) && ( level.numAlienSpawns == 0 ) && ( level.numLiveAlienClients == 0 ) ) ) { //humans win level.lastWin = PTE_HUMANS; trap_SendServerCommand( -1, "print \"Humans win\n\""); trap_SetConfigstring( CS_WINNER, "Humans Win" ); LogExit( "Humans win." ); G_admin_maplog_result( "h" ); } else if( level.uncondAlienWin || ( ( level.time > level.startTime + 1000 ) && ( level.numHumanSpawns == 0 ) && ( level.numLiveHumanClients == 0 ) ) ) { //aliens win level.lastWin = PTE_ALIENS; trap_SendServerCommand( -1, "print \"Aliens win\n\""); trap_SetConfigstring( CS_WINNER, "Aliens Win" ); LogExit( "Aliens win." ); G_admin_maplog_result( "a" ); } } /* ================= AntistackHandicap ================= */ static qboolean AntistackHandicap(void) { qboolean human_bias; float bias, handicap; if (level.alienKills < g_antistackKillThreshold.integer && level.humanKills < g_antistackKillThreshold.integer) return qfalse; if (level.humanKills > level.alienKills) { human_bias = qtrue; bias = (float)level.humanKills / level.alienKills; } else { human_bias = qfalse; bias = (float)level.alienKills / level.humanKills; } bias *= g_antistackBias.value; if (bias < g_antistackBiasThreshold.value) return qfalse; handicap = g_antistackHandicapMultiplier.value / (bias - 1.0f + 0.2f); if (human_bias) { level.alienHandicap = 1.0f; level.humanHandicap = handicap; } else { level.alienHandicap = handicap; level.humanHandicap = 1.0f; } G_LogPrintf("Antistack: %d %d %f %s %f", level.alienKills, level.humanKills, bias, (human_bias ? "human" : "alien"), handicap); if (g_antistack.integer > 0) trap_SendServerCommand(-1, va("print \"^1Teams are uneven. %s income is decreased by %.0f percent.\"", (human_bias ? "Human" : "Alien"), (1.0f - handicap) * 100.0f)); level.antistackWasHandicapping = qtrue; return qtrue; } /* ================= CheckAntistack ================= */ static void CheckAntistack(void) { if (!g_antistack.integer || level.intermissiontime) return; if (level.time < level.antistackNextCheck) return; if (!AntistackHandicap()) { level.alienHandicap = 1.0f; level.humanHandicap = 1.0f; G_LogPrintf("Antistack: %d %d n/a\n", level.alienKills, level.humanKills); if (level.antistackWasHandicapping && g_antistack.integer > 0) trap_SendServerCommand(-1, "^1Teams are no longer uneven."); level.antistackWasHandicapping = qfalse; } // Negative g_antistack values cause a dry run and are for debugging. if (g_antistack.integer < 0) { level.alienHandicap = 1.0f; level.humanHandicap = 1.0f; } level.antistackNextCheck = level.time + g_antistackInterval.integer * 1000; } /* ======================================================================== FUNCTIONS CALLED EVERY FRAME ======================================================================== */ /* ================== CheckVote ================== */ void CheckVote( void ) { int votePassThreshold=level.votePassThreshold; int voteYesPercent; int minVotes = 0; qboolean pass = qfalse; if( level.voteExecuteTime && level.voteExecuteTime < level.time ) { level.voteExecuteTime = 0; if( !Q_stricmp( level.voteString, "map_restart" ) ) { G_admin_maplog_result( "r" ); } else if( !Q_stricmpn( level.voteString, "map", 3 ) ) { G_admin_maplog_result( "m" ); } else if( !Q_stricmpn( level.voteString, "!restart", 8 ) ) { G_admin_maplog_result( "l" ); } if( !Q_stricmp( level.voteString, "suddendeath" ) ) { level.suddenDeathBeginTime = level.time + ( 1000 * g_suddenDeathVoteDelay.integer ) - level.startTime; level.voteString[0] = '\0'; if( g_suddenDeathVoteDelay.integer ) trap_SendServerCommand( -1, va("cp \"Sudden Death will begin in %d seconds\n\"", g_suddenDeathVoteDelay.integer ) ); } if( level.voteString[0] ) trap_SendConsoleCommand( EXEC_APPEND, va( "%s\n", level.voteString ) ); if( !Q_stricmp( level.voteString, "map_restart" ) || !Q_stricmpn( level.voteString, "map", 3 ) ) { level.restarted = qtrue; } } if( !level.voteTime ) return; if( !Q_stricmpn( level.voteString, "ban", 3 ) ) { minVotes = 3; if( level.numConnectedClients < minVotes ) minVotes = level.numConnectedClients; } if( level.voteYes + level.voteNo > 0 ) voteYesPercent = (int)( 100 * ( level.voteYes ) / ( level.voteYes + level.voteNo ) ); else voteYesPercent = 0; if( ( level.time - level.voteTime >= VOTE_TIME ) || ( level.voteYes + level.voteNo == level.numConnectedClients ) ) { if( level.voteYes + level.voteNo < minVotes ) { // not enough voters trap_SendServerCommand( -1, va( "print \"This vote type requires at least %d voters\n\"", minVotes ) ); pass = qfalse; } else if( voteYesPercent > votePassThreshold ) { // execute the command, then remove the vote level.voteExecuteTime = level.time + 3000; pass = qtrue; } else { // same behavior as a timeout pass = qfalse; } } else { if( level.voteYes > (int)( (double) level.numConnectedClients * ( (double) votePassThreshold/100.0 ) ) ) { // execute the command, then remove the vote level.voteExecuteTime = level.time + 3000; pass = qtrue; } else if( level.voteNo > (int)( (double) level.numConnectedClients * ( (double) ( 100.0-votePassThreshold )/ 100.0 ) ) ) { // same behavior as a timeout pass = qfalse; } else { // still waiting for a majority return; } } trap_SendServerCommand( -1, va( "print \"Vote %s^7 (^2Y:%d^7-^1N:%d^7, %d percent) (%s)\n\"", ( pass ) ? "^2passed" : "^1failed", level.voteYes, level.voteNo, voteYesPercent, level.voteDisplayString ) ); G_LogPrintf( "Vote: Vote %s (%d - %d)\n", ( pass ) ? "passed" : "failed", level.voteYes, level.voteNo ); G_admin_adminlog_log( NULL, "vote", va( "%s^7 (^2Y:%d^7-^1N:%d^7, %d percent)", ( pass ) ? "^2passed" : "^1failed", level.voteYes, level.voteNo, voteYesPercent ), 0, pass ); level.voteTime = 0; trap_SetConfigstring( CS_VOTE_TIME, "" ); trap_SetConfigstring( CS_VOTE_STRING, "" ); } /* ================== CheckTeamVote ================== */ void CheckTeamVote( int team ) { int cs_offset; int votePassThreshold; int voteYesPercent = 0; qboolean pass = qfalse; if ( team == PTE_HUMANS ) cs_offset = 0; else if ( team == PTE_ALIENS ) cs_offset = 1; else return; votePassThreshold = level.teamVotePassThreshold[ cs_offset ]; if( !level.teamVoteTime[ cs_offset ] ) return; if( ( level.teamVoteYes[ cs_offset ] + level.teamVoteNo[ cs_offset ] ) ) { voteYesPercent = (100 * level.teamVoteYes[ cs_offset ]) / (level.teamVoteYes[ cs_offset ] + level.teamVoteNo[ cs_offset ]); } if( level.time - level.teamVoteTime[ cs_offset ] >= VOTE_TIME ) { if( voteYesPercent > votePassThreshold && level.teamVoteYes[ cs_offset ] >= 2 ) { // execute the command, then remove the vote trap_SendConsoleCommand( EXEC_APPEND, va( "%s\n", level.teamVoteString[ cs_offset ] ) ); pass = qtrue; } else { pass = qfalse; } } else { if( level.teamVoteYes[ cs_offset ] > (int)((double)level.numteamVotingClients[ cs_offset ] * (double)votePassThreshold/100.0) ) { // execute the command, then remove the vote trap_SendConsoleCommand( EXEC_APPEND, va( "%s\n", level.teamVoteString[ cs_offset ] ) ); pass = qtrue; } else if( level.teamVoteNo[ cs_offset ] > (int)((double)level.numteamVotingClients[ cs_offset ] * ((double)(100.0-votePassThreshold)/100.0)) ) { // same behavior as a timeout pass = qfalse; } else { // still waiting for a majority return; } } trap_SendServerCommand( -1, va( "print \"Team vote %s^7 (^2Y:%d^7-^1N:%d^7, %d percent)\n\"", ( pass ) ? "^2passed" : "^1failed", level.teamVoteYes[ cs_offset ], level.teamVoteNo[ cs_offset ], voteYesPercent ) ); G_LogPrintf( "Teamvote: Team vote %s (%d - %d)\n", ( pass ) ? "passed" : "failed", level.teamVoteYes[ cs_offset ], level.teamVoteNo[ cs_offset ] ); G_admin_adminlog_log( NULL, "teamvote", va( "%s^7 (^2Y:%d^7-^1N:%d^7, %d percent)", ( pass ) ? "^2passed" : "^1failed", level.teamVoteYes[ cs_offset ], level.teamVoteNo[ cs_offset ], voteYesPercent ), 0, pass ); level.teamVoteTime[ cs_offset ] = 0; trap_SetConfigstring( CS_TEAMVOTE_TIME + cs_offset, "" ); trap_SetConfigstring( CS_TEAMVOTE_STRING + cs_offset, "" ); } /* ================== CheckIdleMap ================== */ void CheckIdleMap( void ) { static int nextCheck = 0; static int idleCount = 0; static qboolean triggered = qfalse; if( !g_idleMapSwitch.integer ) return; if( triggered || nextCheck > level.time ) return; nextCheck = level.time + 60000; if( !level.numPlayingClients ) idleCount++; else idleCount = 0; if( idleCount > g_idleMapSwitch.integer && !G_CurrentMapIsRotation() ) { int newTL; triggered = qtrue; newTL = ( level.time - level.startTime ) / 60000; newTL += 5; if( !g_timelimit.integer || g_timelimit.integer > newTL ) { trap_Cvar_Set( "timelimit", va( "%d", newTL ) ); trap_SendServerCommand( -1, va( "print \"Timelimit reduced due to idle server\n\"" ) ); G_LogPrintf( "Server is idle, timelimit reduced to %d\n", newTL ); } } } /* ================== CheckMsgTimer ================== */ void CheckMsgTimer( void ) { static int LastTime = 0; if( level.time - LastTime < 1000 ) return; LastTime = level.time; if( level.mapRotationVoteTime ) { G_IntermissionMapVoteMessageAll( ); return; } if( g_welcomeMsgTime.integer && g_welcomeMsg.string[ 0 ] ) { char buffer[ MAX_STRING_CHARS ]; int wt; int i; buffer[ 0 ] = '\0'; wt = g_welcomeMsgTime.integer * 1000; for( i = 0; i < level.maxclients; i++ ) { if( level.clients[ i ].pers.connected != CON_CONNECTED ) continue; if( level.time - level.clients[ i ].pers.enterTime < wt ) { if( buffer[ 0 ] == '\0' ) { Q_strncpyz( buffer, g_welcomeMsg.string, sizeof( buffer ) ); G_ParseEscapedString( buffer ); } trap_SendServerCommand( i, va( "cp \"%s\"", buffer ) ); } } } if( !g_msgTime.integer ) return; if( level.time - level.lastMsgTime < abs( g_msgTime.integer ) * 60000 ) return; // negative settings only print once per map if( ( level.lastMsgTime ) && g_msgTime.integer < 0 ) return; level.lastMsgTime = level.time; if( g_msg.string[0] ) { char buffer[ MAX_STRING_CHARS ]; Q_strncpyz( buffer, g_msg.string, sizeof( buffer ) ); G_ParseEscapedString( buffer ); trap_SendServerCommand( -1, va( "cp \"%s\"", buffer ) ); trap_SendServerCommand( -1, va( "print \"%s\n\"", buffer ) ); } } /* ================== CheckCountdown ================== */ void CheckCountdown( void ) { static int lastmsg = 0; int timeleft = g_warmup.integer - ( level.time - level.startTime ) / 1000; if( !g_doWarmup.integer || timeleft < 0 ) return; if( level.time - lastmsg < 1000 ) return; lastmsg = level.time; if( timeleft > 0 ) trap_SendServerCommand( -1, va( "cp \"^1Warmup Time:^7\n^%i----- ^7%i ^%i-----\"", timeleft % 7, timeleft, timeleft % 7 ) ); else if( timeleft == 0 ) trap_SendServerCommand( -1, "cp \"^2----- GO! -----^7\"" ); } /* ================== G_CalculateDynamicBuildPoints ================== */ static void G_CalculateDynamicBuildPoints( void ) { static int LastTime = 0; int count = 0; gentity_t *ent; int bps; int i; if( !g_dynamicBuildPoints.integer ) return; if( level.time - LastTime < 10000 ) return; if( level.time - level.startTime < 30000 || !level.defaultAlienBuildPoints ) { // remember default build points, after some time for exec commands if( level.time - level.startTime > 1000 && level.defaultAlienBuildPoints == 0 ) { level.defaultAlienBuildPoints = g_alienBuildPoints.integer; level.defaultHumanBuildPoints = g_humanBuildPoints.integer; } return; } LastTime = level.time; for( i = 0; i < level.maxclients; i++ ) { ent = &g_entities[ i ]; if( ent && ent->client && ent->client->pers.connected == CON_CONNECTED && (ent->client->pers.teamSelection == PTE_ALIENS || ent->client->pers.teamSelection == PTE_HUMANS) ) { count++; } } bps = level.defaultAlienBuildPoints + count * g_dynamicBuildPoints.integer; if( g_alienBuildPoints.integer < bps ) trap_Cvar_Set( "g_alienBuildPoints", va( "%d", bps ) ); bps = level.defaultHumanBuildPoints + count * g_dynamicBuildPoints.integer; if( g_humanBuildPoints.integer < bps ) trap_Cvar_Set( "g_humanBuildPoints", va( "%d", bps ) ); } /* ================== CheckCvars ================== */ void CheckCvars( void ) { static int lastPasswordModCount = -1; static int lastMarkDeconModCount = -1; static int lastSDTimeModCount = -1; if( g_password.modificationCount != lastPasswordModCount ) { lastPasswordModCount = g_password.modificationCount; if( *g_password.string && Q_stricmp( g_password.string, "none" ) ) trap_Cvar_Set( "g_needpass", "1" ); else trap_Cvar_Set( "g_needpass", "0" ); } // Unmark any structures for deconstruction when // the server setting is changed if( g_markDeconstruct.modificationCount != lastMarkDeconModCount ) { int i; gentity_t *ent; lastMarkDeconModCount = g_markDeconstruct.modificationCount; for( i = 1, ent = g_entities + i ; i < level.num_entities ; i++, ent++ ) { if( !ent->inuse ) continue; if( ent->s.eType != ET_BUILDABLE ) continue; ent->deconstruct = qfalse; } } if( g_suddenDeathTime.modificationCount != lastSDTimeModCount ) { lastSDTimeModCount = g_suddenDeathTime.modificationCount; level.suddenDeathBeginTime = g_suddenDeathTime.integer * 60000; } level.frameMsec = trap_Milliseconds( ); } /* ================== G_CheckVampireDeathBuildables ================== */ static int G_VampireDeathKillBuildable( buildable_t buildable, int count ) { int i; gentity_t *ent; int n = 0; for ( i = 1, ent = g_entities + i; i < level.num_entities; i++, ent++ ) { if( ent->s.eType != ET_BUILDABLE ) continue; if( ent->s.modelindex == buildable && ent->health > 0 ) { G_Damage( ent, NULL, NULL, NULL, NULL, 10000, 0, MOD_SUICIDE ); n++; if( count && n >= count ) return n; } } return n; } static void G_CheckVampireDeathBuildables( void ) { static int LastAmmoTime = 0; static int LastSuckTime = 0; static int LastDestructTime = 0; int i; gentity_t *ent; qboolean done = qtrue; if( !level.vampireDeath ) return; if( level.intermissionQueued || level.intermissiontime ) return; // humans get more ammo every 20 seconds if( level.time - LastAmmoTime >= 20000 ) { LastAmmoTime = level.time; for( i = 0; i < level.maxclients; i++ ) { ent = g_entities + i; if( !ent->inuse || ent->health <= 0 || ent->client->pers.connected != CON_CONNECTED) continue; if( ent->client->pers.teamSelection == PTE_HUMANS ) { int maxClips, maxAmmo; BG_FindAmmoForWeapon( ent->client->ps.weapon, &maxAmmo, &maxClips ); if( maxClips ) { if( ent->client->ps.clips < maxClips ) ent->client->ps.clips++; } else { ent->client->ps.ammo += maxAmmo / 5; if( ent->client->ps.ammo > maxAmmo ) ent->client->ps.ammo = maxAmmo; } } } } // health countdown if( level.time - LastSuckTime >= 3000 ) { int value; int hp_rate; int damage; LastSuckTime = level.time; // increase health removal each minute after 1 hp_rate = 1 + ( level.time - level.vampireDeathBeginTime ) / 60000; if( hp_rate < 1 ) hp_rate = 1; if( hp_rate > 10) hp_rate = 10; for( i = 0; i < level.maxclients; i++ ) { ent = g_entities + i; if( !ent->inuse || ent->health <= 0 || !ent->client || ent->client->pers.connected != CON_CONNECTED || ent->client->sess.sessionTeam == TEAM_SPECTATOR || ( ent->client->pers.teamSelection != PTE_ALIENS && ent->client->pers.teamSelection != PTE_HUMANS ) ) continue; value = BG_FindHealthForClass( ent->client->pers.classSelection ); if( value < 1 ) value = 1; // death from full HP in 60s with damage every 3s, 1000 / 60 * 3 = 50 ent->client->pers.vampireSuckFraction += value * 50 * hp_rate; damage = ent->client->pers.vampireSuckFraction / 1000; ent->client->pers.vampireSuckFraction -= damage * 1000; if ( ent->health > damage ) ent->health -= damage; else G_Damage( ent, NULL, NULL, NULL, NULL, damage, DAMAGE_NO_ARMOR|DAMAGE_NO_PROTECTION|DAMAGE_NO_LOCDAMAGE, MOD_SUICIDE ); } } // base self destruct if( level.vampireDeath == 2 ) return; if( level.time - LastDestructTime < 1000 ) return; LastDestructTime = level.time; if( level.numLiveAlienClients == 0 && level.numLiveHumanClients == 0 ) { level.lastWin = PTE_NONE; trap_SendServerCommand( -1, "print \"Timelimit hit\n\"" ); trap_SetConfigstring( CS_WINNER, "Stalemate" ); LogExit( "Timelimit hit." ); G_admin_maplog_result( "t" ); } if( G_VampireDeathKillBuildable( BA_A_ACIDTUBE, 1 ) || G_VampireDeathKillBuildable( BA_A_HIVE, 1 ) || G_VampireDeathKillBuildable( BA_A_TRAPPER, 1 ) || G_VampireDeathKillBuildable( BA_A_BARRICADE, 1 ) || G_VampireDeathKillBuildable( BA_A_BOOSTER, 1 ) || G_VampireDeathKillBuildable( BA_A_SPAWN, 1 ) || G_VampireDeathKillBuildable( BA_A_OVERMIND, 1 ) ) { done = qfalse; } if( G_VampireDeathKillBuildable( BA_H_MGTURRET, 1 ) || G_VampireDeathKillBuildable( BA_H_TESLAGEN, 1 ) || G_VampireDeathKillBuildable( BA_H_DCC, 1 ) || G_VampireDeathKillBuildable( BA_H_REPEATER, 1 ) || G_VampireDeathKillBuildable( BA_H_MEDISTAT, 1 ) || G_VampireDeathKillBuildable( BA_H_ARMOURY, 1 ) || G_VampireDeathKillBuildable( BA_H_SPAWN, 1 ) || G_VampireDeathKillBuildable( BA_H_REACTOR, 1 ) ) { done = qfalse; } if( done ) { level.vampireDeath = 2; } } /* ============= G_RunThink Runs thinking code for this frame if necessary ============= */ void G_RunThink( gentity_t *ent ) { float thinktime; thinktime = ent->nextthink; if( thinktime <= 0 ) return; if( thinktime > level.time ) return; ent->nextthink = 0; if( !ent->think ) G_Error( "NULL ent->think" ); ent->think( ent ); } /* ============= G_EvaluateAcceleration Calculates the acceleration for an entity ============= */ void G_EvaluateAcceleration( gentity_t *ent, int msec ) { vec3_t deltaVelocity; vec3_t deltaAccel; VectorSubtract( ent->s.pos.trDelta, ent->oldVelocity, deltaVelocity ); VectorScale( deltaVelocity, 1.0f / (float)msec, ent->acceleration ); VectorSubtract( ent->acceleration, ent->oldAccel, deltaAccel ); VectorScale( deltaAccel, 1.0f / (float)msec, ent->jerk ); VectorCopy( ent->s.pos.trDelta, ent->oldVelocity ); VectorCopy( ent->acceleration, ent->oldAccel ); } /* ================ G_RunFrame Advances the non-player objects in the world ================ */ void G_RunFrame( int levelTime ) { int i; gentity_t *ent; int msec; // if we are waiting for the level to restart, do nothing if( level.restarted ) return; if( level.paused ) { if( ( levelTime % 6000 ) == 0) trap_SendServerCommand( -1, "cp \"^3Game is paused.\"" ); level.startTime += levelTime - level.time; trap_SetConfigstring( CS_LEVEL_START_TIME, va( "%i", level.startTime ) ); if( levelTime - level.pauseTime > 3 * 60000 ) { trap_SendConsoleCommand( EXEC_APPEND, "!unpause" ); } } CheckMsgTimer( ); CheckCountdown( ); level.framenum++; level.previousTime = level.time; level.time = levelTime; msec = level.time - level.previousTime; //TA: seed the rng srand( level.framenum ); // get any cvar changes G_UpdateCvars( ); // // 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; //ent->client->ps.events[0] = 0; //ent->client->ps.events[1] = 0; } } if( ent->freeAfterEvent ) { // tempEntities or dropped items completely go away after their event G_FreeEntity( ent ); continue; } else if( ent->unlinkAfterEvent ) { // items that will respawn will hide themselves after their pickup event ent->unlinkAfterEvent = qfalse; trap_UnlinkEntity( ent ); } } // temporary entities don't think if( ent->freeAfterEvent ) continue; //TA: calculate the acceleration of this entity if( ent->evaluateAcceleration ) G_EvaluateAcceleration( ent, msec ); if( !ent->r.linked && ent->neverFree ) continue; if( ent->s.eType == ET_MISSILE ) { G_RunMissile( ent ); continue; } if( ent->s.eType == ET_BUILDABLE ) { G_BuildableThink( ent, msec ); continue; } if( ent->s.eType == ET_CORPSE || ent->physicsObject ) { G_Physics( ent, msec ); continue; } if( ent->s.eType == ET_MOVER ) { G_RunMover( ent ); continue; } if( i < MAX_CLIENTS ) { G_RunClient( ent ); continue; } G_RunThink( ent ); } // perform final fixups on the players ent = &g_entities[ 0 ]; for( i = 0; i < level.maxclients; i++, ent++ ) { if( ent->inuse ) ClientEndFrame( ent ); } G_CheckVampireDeathBuildables(); // save position information for all active clients G_UnlaggedStore( ); //TA: G_CountSpawns( ); G_CalculateBuildPoints( ); G_CalculateStages( ); G_SpawnClients( PTE_ALIENS ); G_SpawnClients( PTE_HUMANS ); G_CalculateAvgPlayers( ); G_UpdateZaps( msec ); G_CalculateDynamicBuildPoints( ); // see if it is time to end the level CheckExitRules( ); CheckIdleMap( ); // update to team status? CheckTeamStatus( ); // anti-stacking CheckAntistack( ); // cancel vote if timed out CheckVote( ); // check team votes CheckTeamVote( PTE_HUMANS ); CheckTeamVote( PTE_ALIENS ); G_admin_schachtmeisterFrame(); // 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" ); } }