codemp/game/g_main.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//

#include "g_local.h"
#include "g_ICARUScb.h"
#include "g_nav.h"
#include "bg_saga.h"

level_locals_t  level;

int             eventClearTime = 0;
static int navCalcPathTime = 0;
extern int fatalErrors;

int killPlayerTimer = 0;

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];

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;

#ifdef _DEBUG
vmCvar_t        g_disableServerG2;
#endif

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;
#ifndef FINAL_BUILD
vmCvar_t        g_debugDamage;
#endif
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;

#include "../namespace_begin.h"
vmCvar_t        pmove_fixed;
vmCvar_t        pmove_msec;
#include "../namespace_end.h"

vmCvar_t        g_listEntity;
//vmCvar_t      g_redteam;
//vmCvar_t      g_blueteam;
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;

#ifdef DEBUG_SABER_BOX
vmCvar_t        g_saberDebugBox;
#endif

//NPC nav debug
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;
// nmckenzie: SABER_DAMAGE_WALLS
vmCvar_t                g_saberWallDamageScale;

vmCvar_t                d_saberStanceDebug;
// ai debug cvars
vmCvar_t                debugNPCAI;                     // used to print out debug info about the bot AI
vmCvar_t                debugNPCFreeze;         // set to disable bot ai and temporarily freeze them in place
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;

// nmckenzie: temporary way to show player healths in duels - some iface gfx in game would be better, of course.
// DUEL_HEALTH
vmCvar_t                g_showDuelHealths;

// bk001129 - made static to avoid aliasing
static cvarTable_t              gameCvarTable[] = {
        // don't override the cheat state set by the system
        { &g_cheats, "sv_cheats", "", 0, 0, qfalse },

        { &g_debugMelee, "g_debugMelee", "0", CVAR_SERVERINFO, 0, qtrue  },
        { &g_stepSlideFix, "g_stepSlideFix", "1", CVAR_SERVERINFO, 0, qtrue  },

        { &g_noSpecMove, "g_noSpecMove", "0", CVAR_SERVERINFO, 0, qtrue },

        // noset vars
        { NULL, "gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_ROM, 0, qfalse  },
        { NULL, "gamedate", __DATE__ , CVAR_ROM, 0, qfalse  },
        { &g_restarted, "g_restarted", "0", CVAR_ROM, 0, qfalse  },
        { NULL, "sv_mapname", "", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse  },

        // latched vars
        { &g_gametype, "g_gametype", "0", CVAR_SERVERINFO | CVAR_LATCH, 0, qfalse  },
        { &g_MaxHolocronCarry, "g_MaxHolocronCarry", "3", CVAR_SERVERINFO | CVAR_LATCH, 0, qfalse  },

        { &g_maxclients, "sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qfalse  },
        { &g_maxGameClients, "g_maxGameClients", "0", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qfalse  },

        { &g_trueJedi, "g_jediVmerc", "0", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qtrue },

        // change anytime vars
        { &g_ff_objectives, "g_ff_objectives", "0", /*CVAR_SERVERINFO |*/ CVAR_CHEAT | CVAR_NORESTART, 0, qtrue },

        { &g_autoMapCycle, "g_autoMapCycle", "0", CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
        { &g_dmflags, "dmflags", "0", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },
        
        { &g_maxForceRank, "g_maxForceRank", "6", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qfalse  },
        { &g_forceBasedTeams, "g_forceBasedTeams", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qfalse  },
        { &g_privateDuel, "g_privateDuel", "1", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },

        { &g_allowNPC, "g_allowNPC", "1", CVAR_SERVERINFO | CVAR_CHEAT, 0, qtrue  },

        { &g_armBreakage, "g_armBreakage", "0", 0, 0, qtrue  },

        { &g_saberLocking, "g_saberLocking", "1", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },
        { &g_saberLockFactor, "g_saberLockFactor", "2", CVAR_ARCHIVE, 0, qtrue  },
        { &g_saberTraceSaberFirst, "g_saberTraceSaberFirst", "0", CVAR_ARCHIVE, 0, qtrue  },

        { &d_saberKickTweak, "d_saberKickTweak", "1", 0, 0, qtrue  },

        { &d_powerDuelPrint, "d_powerDuelPrint", "0", 0, qtrue },

        { &d_saberGhoul2Collision, "d_saberGhoul2Collision", "1", CVAR_CHEAT, 0, qtrue  },
        { &g_saberBladeFaces, "g_saberBladeFaces", "1", 0, 0, qtrue  },

        { &d_saberAlwaysBoxTrace, "d_saberAlwaysBoxTrace", "0", CVAR_CHEAT, 0, qtrue  },
        { &d_saberBoxTraceSize, "d_saberBoxTraceSize", "0", CVAR_CHEAT, 0, qtrue  },

        { &d_siegeSeekerNPC, "d_siegeSeekerNPC", "0", CVAR_CHEAT, 0, qtrue },

#ifdef _DEBUG
        { &g_disableServerG2, "g_disableServerG2", "0", 0, 0, qtrue },
#endif

        { &d_perPlayerGhoul2, "d_perPlayerGhoul2", "0", CVAR_CHEAT, 0, qtrue },

        { &d_projectileGhoul2Collision, "d_projectileGhoul2Collision", "1", CVAR_CHEAT, 0, qtrue  },

        { &g_g2TraceLod, "g_g2TraceLod", "3", 0, 0, qtrue  },

        { &g_optvehtrace, "com_optvehtrace", "0", 0, 0, qtrue  },

        { &g_locationBasedDamage, "g_locationBasedDamage", "1", 0, 0, qtrue },

        { &g_allowHighPingDuelist, "g_allowHighPingDuelist", "1", 0, 0, qtrue },

        { &g_logClientInfo, "g_logClientInfo", "0", CVAR_ARCHIVE, 0, qtrue  },

        { &g_slowmoDuelEnd, "g_slowmoDuelEnd", "0", CVAR_ARCHIVE, 0, qtrue  },

        { &g_saberDamageScale, "g_saberDamageScale", "1", CVAR_ARCHIVE, 0, qtrue  },

        { &g_useWhileThrowing, "g_useWhileThrowing", "1", 0, 0, qtrue  },

        { &g_RMG, "RMG", "0", 0, 0, qtrue  },

        { &g_svfps, "sv_fps", "20", 0, 0, qtrue },

        { &g_forceRegenTime, "g_forceRegenTime", "200", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },

        { &g_spawnInvulnerability, "g_spawnInvulnerability", "3000", CVAR_ARCHIVE, 0, qtrue  },

        { &g_forcePowerDisable, "g_forcePowerDisable", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qtrue  },
        { &g_weaponDisable, "g_weaponDisable", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qtrue  },
        { &g_duelWeaponDisable, "g_duelWeaponDisable", "1", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qtrue  },

        { &g_allowDuelSuicide, "g_allowDuelSuicide", "1", CVAR_ARCHIVE, 0, qtrue },

        { &g_fraglimitVoteCorrection, "g_fraglimitVoteCorrection", "1", CVAR_ARCHIVE, 0, qtrue },

        { &g_fraglimit, "fraglimit", "20", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
        { &g_duel_fraglimit, "duel_fraglimit", "10", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
        { &g_timelimit, "timelimit", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
        { &g_capturelimit, "capturelimit", "8", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },

        { &g_synchronousClients, "g_synchronousClients", "0", CVAR_SYSTEMINFO, 0, qfalse  },

        { &d_saberInterpolate, "d_saberInterpolate", "0", CVAR_CHEAT, 0, qtrue },

        { &g_friendlyFire, "g_friendlyFire", "0", CVAR_ARCHIVE, 0, qtrue  },
        { &g_friendlySaber, "g_friendlySaber", "0", CVAR_ARCHIVE, 0, qtrue  },

        { &g_teamAutoJoin, "g_teamAutoJoin", "0", CVAR_ARCHIVE  },
        { &g_teamForceBalance, "g_teamForceBalance", "0", CVAR_ARCHIVE  },

        { &g_warmup, "g_warmup", "20", CVAR_ARCHIVE, 0, qtrue  },
        { &g_doWarmup, "g_doWarmup", "0", 0, 0, qtrue  },
        { &g_log, "g_log", "games.log", CVAR_ARCHIVE, 0, qfalse  },
        { &g_logSync, "g_logSync", "0", CVAR_ARCHIVE, 0, qfalse  },

        { &g_statLog, "g_statLog", "0", CVAR_ARCHIVE, 0, qfalse },
        { &g_statLogFile, "g_statLogFile", "statlog.log", 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_developer, "developer", "0", 0, 0, qfalse },

        { &g_speed, "g_speed", "250", 0, 0, qtrue  },
        { &g_gravity, "g_gravity", "800", 0, 0, qtrue  },
        { &g_knockback, "g_knockback", "1000", 0, 0, qtrue  },
        { &g_quadfactor, "g_quadfactor", "3", 0, 0, qtrue  },
        { &g_weaponRespawn, "g_weaponrespawn", "5", 0, 0, qtrue  },
        { &g_weaponTeamRespawn, "g_weaponTeamRespawn", "5", 0, 0, qtrue },
        { &g_adaptRespawn, "g_adaptrespawn", "1", 0, 0, qtrue  },               // Make weapons respawn faster with a lot of players.
        { &g_forcerespawn, "g_forcerespawn", "60", 0, 0, qtrue },               // One minute force respawn.  Give a player enough time to reallocate force.
        { &g_siegeRespawn, "g_siegeRespawn", "20", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue }, //siege respawn wave time
        { &g_inactivity, "g_inactivity", "0", 0, 0, qtrue },
        { &g_debugMove, "g_debugMove", "0", 0, 0, qfalse },
#ifndef FINAL_BUILD
        { &g_debugDamage, "g_debugDamage", "0", 0, 0, qfalse },
#endif
        { &g_debugAlloc, "g_debugAlloc", "0", 0, 0, qfalse },
        { &g_debugServerSkel, "g_debugServerSkel", "0", CVAR_CHEAT, 0, qfalse },
        { &g_motd, "g_motd", "", 0, 0, qfalse },
        { &g_blood, "com_blood", "1", 0, 0, qfalse },

        { &g_podiumDist, "g_podiumDist", "80", 0, 0, qfalse },
        { &g_podiumDrop, "g_podiumDrop", "70", 0, 0, qfalse },

        { &g_allowVote, "g_allowVote", "1", CVAR_ARCHIVE, 0, qfalse },
        { &g_listEntity, "g_listEntity", "0", 0, 0, qfalse },

#if 0
        { &g_debugForward, "g_debugForward", "0", 0, 0, qfalse },
        { &g_debugRight, "g_debugRight", "0", 0, 0, qfalse },
        { &g_debugUp, "g_debugUp", "0", 0, 0, qfalse },
#endif

//      { &g_redteam, "g_redteam", "Empire", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO , 0, qtrue, qtrue },
//      { &g_blueteam, "g_blueteam", "Rebellion", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO , 0, qtrue, qtrue  },
        { &g_singlePlayer, "ui_singlePlayerActive", "", 0, 0, qfalse, qfalse  },

        { &g_enableBreath, "g_enableBreath", "0", 0, 0, qtrue, qfalse },
        { &g_smoothClients, "g_smoothClients", "1", 0, 0, qfalse},
        { &pmove_fixed, "pmove_fixed", "0", CVAR_SYSTEMINFO, 0, qfalse},
        { &pmove_msec, "pmove_msec", "8", CVAR_SYSTEMINFO, 0, qfalse},

        { &g_dismember, "g_dismember", "0", CVAR_ARCHIVE, 0, qtrue  },
        { &g_forceDodge, "g_forceDodge", "1", 0, 0, qtrue  },

        { &g_timeouttospec, "g_timeouttospec", "70", CVAR_ARCHIVE, 0, qfalse },

        { &g_saberDmgVelocityScale, "g_saberDmgVelocityScale", "0", CVAR_ARCHIVE, 0, qtrue  },
        { &g_saberDmgDelay_Idle, "g_saberDmgDelay_Idle", "350", CVAR_ARCHIVE, 0, qtrue  },
        { &g_saberDmgDelay_Wound, "g_saberDmgDelay_Wound", "0", CVAR_ARCHIVE, 0, qtrue  },

#ifndef FINAL_BUILD
        { &g_saberDebugPrint, "g_saberDebugPrint", "0", CVAR_CHEAT, 0, qfalse  },
#endif
        { &g_debugSaberLocks, "g_debugSaberLocks", "0", CVAR_CHEAT, 0, qfalse },
        { &g_saberLockRandomNess, "g_saberLockRandomNess", "2", CVAR_CHEAT, 0, qfalse },
// nmckenzie: SABER_DAMAGE_WALLS
        { &g_saberWallDamageScale, "g_saberWallDamageScale", "0.4", CVAR_SERVERINFO, 0, qfalse },

        { &d_saberStanceDebug, "d_saberStanceDebug", "0", 0, 0, qfalse },

        { &g_siegeTeamSwitch, "g_siegeTeamSwitch", "1", CVAR_SERVERINFO|CVAR_ARCHIVE, qfalse },

        { &bg_fighterAltControl, "bg_fighterAltControl", "0", CVAR_SERVERINFO, 0, qtrue },

#ifdef DEBUG_SABER_BOX
        { &g_saberDebugBox, "g_saberDebugBox", "0", CVAR_CHEAT, 0, qfalse },
#endif

        { &d_altRoutes, "d_altRoutes", "0", CVAR_CHEAT, 0, qfalse },
        { &d_patched, "d_patched", "0", CVAR_CHEAT, 0, qfalse },

        { &g_saberRealisticCombat, "g_saberRealisticCombat", "0", CVAR_CHEAT },
        { &g_saberRestrictForce, "g_saberRestrictForce", "0", CVAR_CHEAT },
        { &d_saberSPStyleDamage, "d_saberSPStyleDamage", "1", CVAR_CHEAT },

        { &debugNoRoam, "d_noroam", "0", CVAR_CHEAT },
        { &debugNPCAimingBeam, "d_npcaiming", "0", CVAR_CHEAT },
        { &debugBreak, "d_break", "0", CVAR_CHEAT },
        { &debugNPCAI, "d_npcai", "0", CVAR_CHEAT },
        { &debugNPCFreeze, "d_npcfreeze", "0", CVAR_CHEAT },
        { &d_JediAI, "d_JediAI", "0", CVAR_CHEAT },
        { &d_noGroupAI, "d_noGroupAI", "0", CVAR_CHEAT },
        { &d_asynchronousGroupAI, "d_asynchronousGroupAI", "0", CVAR_CHEAT },
        
        //0 = never (BORING)
        //1 = kyle only
        //2 = kyle and last enemy jedi
        //3 = kyle and any enemy jedi
        //4 = kyle and last enemy in a group
        //5 = kyle and any enemy
        //6 = also when kyle takes pain or enemy jedi dodges player saber swing or does an acrobatic evasion

        { &d_slowmodeath, "d_slowmodeath", "0", CVAR_CHEAT },

        { &d_saberCombat, "d_saberCombat", "0", CVAR_CHEAT },

        { &g_spskill, "g_npcspskill", "0", CVAR_ARCHIVE | CVAR_INTERNAL },

        //for overriding the level defaults
        { &g_siegeTeam1, "g_siegeTeam1", "none", CVAR_ARCHIVE|CVAR_SERVERINFO, 0, qfalse  },
        { &g_siegeTeam2, "g_siegeTeam2", "none", CVAR_ARCHIVE|CVAR_SERVERINFO, 0, qfalse  },

        //mainly for debugging with bots while I'm not around (want the server to
        //cycle through levels naturally)
        { &d_noIntermissionWait, "d_noIntermissionWait", "0", CVAR_CHEAT, 0, qfalse  },

        { &g_austrian, "g_austrian", "0", CVAR_ARCHIVE, 0, qfalse  },
// nmckenzie:
// DUEL_HEALTH
        { &g_showDuelHealths, "g_showDuelHealths", "0", CVAR_SERVERINFO },
        { &g_powerDuelStartHealth, "g_powerDuelStartHealth", "150", CVAR_ARCHIVE, 0, qtrue  },
        { &g_powerDuelEndHealth, "g_powerDuelEndHealth", "90", CVAR_ARCHIVE, 0, qtrue  },
};

// bk001129 - made static to avoid aliasing
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_ROFF_NotetrackCallback   ( gentity_t *cent, const char *notetrack);

extern stringID_table_t setTable[];

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 );

/*
================
vmMain

This is the only way control passes into the module.
This must be the very first function compiled into the .q3vm file
================
*/
#include "../namespace_begin.h"
#ifdef __linux__
extern "C" {
#endif
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  ) {
        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 (int)ClientConnect( arg0, arg1, arg2 );
        case GAME_CLIENT_THINK:
                ClientThink( arg0, NULL );
                return 0;
        case GAME_CLIENT_USERINFO_CHANGED:
                ClientUserinfoChanged( arg0 );
                return 0;
        case GAME_CLIENT_DISCONNECT:
                ClientDisconnect( arg0 );
                return 0;
        case GAME_CLIENT_BEGIN:
                ClientBegin( arg0, qtrue );
                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();
        case BOTAI_START_FRAME:
                return BotAIStartFrame( arg0 );
        case GAME_ROFF_NOTETRACK_CALLBACK:
                G_ROFF_NotetrackCallback( &g_entities[arg0], (const char *)arg1 );
                return 0;
        case GAME_SPAWN_RMG_ENTITY:
                if (G_ParseSpawnVars(qfalse))
                {
                        G_SpawnGEntityFromSpawnVars(qfalse);
                }
                return 0;

        //rww - begin icarus callbacks
        case GAME_ICARUS_PLAYSOUND:
                {
                        T_G_ICARUS_PLAYSOUND *sharedMem = (T_G_ICARUS_PLAYSOUND *)gSharedBuffer;
                        return Q3_PlaySound(sharedMem->taskID, sharedMem->entID, sharedMem->name, sharedMem->channel);
                }
        case GAME_ICARUS_SET:
                {
                        T_G_ICARUS_SET *sharedMem = (T_G_ICARUS_SET *)gSharedBuffer;
                        return Q3_Set(sharedMem->taskID, sharedMem->entID, sharedMem->type_name, sharedMem->data);
                }
        case GAME_ICARUS_LERP2POS:
                {
                        T_G_ICARUS_LERP2POS *sharedMem = (T_G_ICARUS_LERP2POS *)gSharedBuffer;
                        if (sharedMem->nullAngles)
                        {
                                Q3_Lerp2Pos(sharedMem->taskID, sharedMem->entID, sharedMem->origin, NULL, sharedMem->duration);
                        }
                        else
                        {
                                Q3_Lerp2Pos(sharedMem->taskID, sharedMem->entID, sharedMem->origin, sharedMem->angles, sharedMem->duration);
                        }
                }
                return 0;
        case GAME_ICARUS_LERP2ORIGIN:
                {
                        T_G_ICARUS_LERP2ORIGIN *sharedMem = (T_G_ICARUS_LERP2ORIGIN *)gSharedBuffer;
                        Q3_Lerp2Origin(sharedMem->taskID, sharedMem->entID, sharedMem->origin, sharedMem->duration);
                }
                return 0;
        case GAME_ICARUS_LERP2ANGLES:
                {
                        T_G_ICARUS_LERP2ANGLES *sharedMem = (T_G_ICARUS_LERP2ANGLES *)gSharedBuffer;
                        Q3_Lerp2Angles(sharedMem->taskID, sharedMem->entID, sharedMem->angles, sharedMem->duration);
                }
                return 0;
        case GAME_ICARUS_GETTAG:
                {
                        T_G_ICARUS_GETTAG *sharedMem = (T_G_ICARUS_GETTAG *)gSharedBuffer;
                        return Q3_GetTag(sharedMem->entID, sharedMem->name, sharedMem->lookup, sharedMem->info);
                }
        case GAME_ICARUS_LERP2START:
                {
                        T_G_ICARUS_LERP2START *sharedMem = (T_G_ICARUS_LERP2START *)gSharedBuffer;
                        Q3_Lerp2Start(sharedMem->entID, sharedMem->taskID, sharedMem->duration);
                }
                return 0;
        case GAME_ICARUS_LERP2END:
                {
                        T_G_ICARUS_LERP2END *sharedMem = (T_G_ICARUS_LERP2END *)gSharedBuffer;
                        Q3_Lerp2End(sharedMem->entID, sharedMem->taskID, sharedMem->duration);
                }
                return 0;
        case GAME_ICARUS_USE:
                {
                        T_G_ICARUS_USE *sharedMem = (T_G_ICARUS_USE *)gSharedBuffer;
                        Q3_Use(sharedMem->entID, sharedMem->target);
                }
                return 0;
        case GAME_ICARUS_KILL:
                {
                        T_G_ICARUS_KILL *sharedMem = (T_G_ICARUS_KILL *)gSharedBuffer;
                        Q3_Kill(sharedMem->entID, sharedMem->name);
                }
                return 0;
        case GAME_ICARUS_REMOVE:
                {
                        T_G_ICARUS_REMOVE *sharedMem = (T_G_ICARUS_REMOVE *)gSharedBuffer;
                        Q3_Remove(sharedMem->entID, sharedMem->name);
                }
                return 0;
        case GAME_ICARUS_PLAY:
                {
                        T_G_ICARUS_PLAY *sharedMem = (T_G_ICARUS_PLAY *)gSharedBuffer;
                        Q3_Play(sharedMem->taskID, sharedMem->entID, sharedMem->type, sharedMem->name);
                }
                return 0;
        case GAME_ICARUS_GETFLOAT:
                {
                        T_G_ICARUS_GETFLOAT *sharedMem = (T_G_ICARUS_GETFLOAT *)gSharedBuffer;
                        return Q3_GetFloat(sharedMem->entID, sharedMem->type, sharedMem->name, &sharedMem->value);
                }
        case GAME_ICARUS_GETVECTOR:
                {
                        T_G_ICARUS_GETVECTOR *sharedMem = (T_G_ICARUS_GETVECTOR *)gSharedBuffer;
                        return Q3_GetVector(sharedMem->entID, sharedMem->type, sharedMem->name, sharedMem->value);
                }
        case GAME_ICARUS_GETSTRING:
                {
                        T_G_ICARUS_GETSTRING *sharedMem = (T_G_ICARUS_GETSTRING *)gSharedBuffer;
                        int r;
                        char *crap = NULL; //I am sorry for this -rww
                        char **morecrap = &crap; //and this
                        r = Q3_GetString(sharedMem->entID, sharedMem->type, sharedMem->name, morecrap);

                        if (crap)
                        { //success!
                                strcpy(sharedMem->value, crap);
                        }

                        return r;
                }
        case GAME_ICARUS_SOUNDINDEX:
                {
                        T_G_ICARUS_SOUNDINDEX *sharedMem = (T_G_ICARUS_SOUNDINDEX *)gSharedBuffer;
                        G_SoundIndex(sharedMem->filename);
                }
                return 0;
        case GAME_ICARUS_GETSETIDFORSTRING:
                {
                        T_G_ICARUS_GETSETIDFORSTRING *sharedMem = (T_G_ICARUS_GETSETIDFORSTRING *)gSharedBuffer;
                        return GetIDForString(setTable, sharedMem->string);
                }
        //rww - end icarus callbacks

        case GAME_NAV_CLEARPATHTOPOINT:
                return NAV_ClearPathToPoint(&g_entities[arg0], (float *)arg1, (float *)arg2, (float *)arg3, arg4, arg5);
        case GAME_NAV_CLEARLOS:
                return NPC_ClearLOS2(&g_entities[arg0], (const float *)arg1);
        case GAME_NAV_CLEARPATHBETWEENPOINTS:
                return NAVNEW_ClearPathBetweenPoints((float *)arg0, (float *)arg1, (float *)arg2, (float *)arg3, arg4, arg5);
        case GAME_NAV_CHECKNODEFAILEDFORENT:
                return NAV_CheckNodeFailedForEnt(&g_entities[arg0], arg1);
        case GAME_NAV_ENTISUNLOCKEDDOOR:
                return G_EntIsUnlockedDoor(arg0);
        case GAME_NAV_ENTISDOOR:
                return G_EntIsDoor(arg0);
        case GAME_NAV_ENTISBREAKABLE:
                return G_EntIsBreakable(arg0);
        case GAME_NAV_ENTISREMOVABLEUSABLE:
                return G_EntIsRemovableUsable(arg0);
        case GAME_NAV_FINDCOMBATPOINTWAYPOINTS:
                CP_FindCombatPointWaypoints();
                return 0;
        case GAME_GETITEMINDEXBYTAG:
                return BG_GetItemIndexByTag(arg0, arg1);
        }

        return -1;
}
#ifdef __linux__
}
#endif
#include "../namespace_end.h"


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;
                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);
}

void G_RemapTeamShaders( void ) {
#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
}


/*
=================
G_RegisterCvars
=================
*/
void G_RegisterCvars( void ) {
        int                     i;
        cvarTable_t     *cv;
        qboolean remapped = qfalse;

        for ( i = 0, cv = gameCvarTable ; i < gameCvarTableSize ; i++, cv++ ) {
                trap_Cvar_Register( cv->vmCvar, cv->cvarName,
                        cv->defaultString, cv->cvarFlags );
                if ( cv->vmCvar )
                        cv->modificationCount = cv->vmCvar->modificationCount;

                if (cv->teamShader) {
                        remapped = qtrue;
                }
        }

        if (remapped) {
                G_RemapTeamShaders();
        }

        // check some things
        if ( g_gametype.integer < 0 || g_gametype.integer >= GT_MAX_GAME_TYPE ) {
                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;
}

/*
=================
G_UpdateCvars
=================
*/
void G_UpdateCvars( void ) {
        int                     i;
        cvarTable_t     *cv;
        qboolean remapped = qfalse;

        for ( i = 0, cv = gameCvarTable ; i < gameCvarTableSize ; i++, cv++ ) {
                if ( cv->vmCvar ) {
                        trap_Cvar_Update( cv->vmCvar );

                        if ( cv->modificationCount != cv->vmCvar->modificationCount ) {
                                cv->modificationCount = cv->vmCvar->modificationCount;

                                if ( cv->trackChange ) {
                                        trap_SendServerCommand( -1, va("print \"Server: %s changed to %s\n\"", 
                                                cv->cvarName, cv->vmCvar->string ) );
                                }

                                if (cv->teamShader) {
                                        remapped = qtrue;
                                }                               
                        }
                }
        }

        if (remapped) {
                G_RemapTeamShaders();
        }
}

char gSharedBuffer[MAX_G_SHARED_BUFFER_SIZE];

#include "../namespace_begin.h"
void WP_SaberLoadParms( void );
void BG_VehicleLoadParms( void );
#include "../namespace_end.h"

/*
============
G_InitGame

============
*/
extern void RemoveAllWP(void);
extern void BG_ClearVehicleParseParms(void);
void G_InitGame( int levelTime, int randomSeed, int restart ) {
        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 /