Game_local.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../idlib/precompiled.h"
#pragma hdrstop

#include "Game_local.h"

#ifdef GAME_DLL

idSys *                                         sys = NULL;
idCommon *                                      common = NULL;
idCmdSystem *                           cmdSystem = NULL;
idCVarSystem *                          cvarSystem = NULL;
idFileSystem *                          fileSystem = NULL;
idNetworkSystem *                       networkSystem = NULL;
idRenderSystem *                        renderSystem = NULL;
idSoundSystem *                         soundSystem = NULL;
idRenderModelManager *          renderModelManager = NULL;
idUserInterfaceManager *        uiManager = NULL;
idDeclManager *                         declManager = NULL;
idAASFileManager *                      AASFileManager = NULL;
idCollisionModelManager *       collisionModelManager = NULL;
idCVar *                                        idCVar::staticVars = NULL;

idCVar com_forceGenericSIMD( "com_forceGenericSIMD", "0", CVAR_BOOL|CVAR_SYSTEM, "force generic platform independent SIMD" );

#endif

idRenderWorld *                         gameRenderWorld = NULL;         // all drawing is done to this world
idSoundWorld *                          gameSoundWorld = NULL;          // all audio goes to this world

static gameExport_t                     gameExport;

// global animation lib
idAnimManager                           animationLib;

// the rest of the engine will only reference the "game" variable, while all local aspects stay hidden
idGameLocal                                     gameLocal;
idGame *                                        game = &gameLocal;      // statically pointed at an idGameLocal

const char *idGameLocal::sufaceTypeNames[ MAX_SURFACE_TYPES ] = {
        "none", "metal", "stone", "flesh", "wood", "cardboard", "liquid", "glass", "plastic",
        "ricochet", "surftype10", "surftype11", "surftype12", "surftype13", "surftype14", "surftype15"
};

#ifdef _D3XP
// List of all defs used by the player that will stay on the fast timeline
static const char* fastEntityList[] = {
        "player_doommarine",
                "weapon_chainsaw",
                "weapon_fists",
                "weapon_flashlight",
                "weapon_rocketlauncher",
                "projectile_rocket",
                "weapon_machinegun",
                "projectile_bullet_machinegun",
                "weapon_pistol",
                "projectile_bullet_pistol",
                "weapon_handgrenade",
                "projectile_grenade",
                "weapon_bfg",
                "projectile_bfg",
                "weapon_chaingun",
                "projectile_chaingunbullet",
                "weapon_pda",
                "weapon_plasmagun",
                "projectile_plasmablast",
                "weapon_shotgun",
                "projectile_bullet_shotgun",
                "weapon_soulcube",
                "projectile_soulblast",
                "weapon_shotgun_double",
                "projectile_shotgunbullet_double",
                "weapon_grabber",
                "weapon_bloodstone_active1",
                "weapon_bloodstone_active2",
                "weapon_bloodstone_active3",
                "weapon_bloodstone_passive",
                NULL };
#endif
/*
===========
GetGameAPI
============
*/
#if __MWERKS__
#pragma export on
#endif
#if __GNUC__ >= 4
#pragma GCC visibility push(default)
#endif
extern "C" gameExport_t *GetGameAPI( gameImport_t *import ) {
#if __MWERKS__
#pragma export off
#endif

        if ( import->version == GAME_API_VERSION ) {

                // set interface pointers used by the game
                sys                                                     = import->sys;
                common                                          = import->common;
                cmdSystem                                       = import->cmdSystem;
                cvarSystem                                      = import->cvarSystem;
                fileSystem                                      = import->fileSystem;
                networkSystem                           = import->networkSystem;
                renderSystem                            = import->renderSystem;
                soundSystem                                     = import->soundSystem;
                renderModelManager                      = import->renderModelManager;
                uiManager                                       = import->uiManager;
                declManager                                     = import->declManager;
                AASFileManager                          = import->AASFileManager;
                collisionModelManager           = import->collisionModelManager;
        }

        // set interface pointers used by idLib
        idLib::sys                                      = sys;
        idLib::common                           = common;
        idLib::cvarSystem                       = cvarSystem;
        idLib::fileSystem                       = fileSystem;

        // setup export interface
        gameExport.version = GAME_API_VERSION;
        gameExport.game = game;
        gameExport.gameEdit = gameEdit;

        return &gameExport;
}
#if __GNUC__ >= 4
#pragma GCC visibility pop
#endif

/*
===========
TestGameAPI
============
*/
void TestGameAPI( void ) {
        gameImport_t testImport;
        gameExport_t testExport;

        testImport.sys                                          = ::sys;
        testImport.common                                       = ::common;
        testImport.cmdSystem                            = ::cmdSystem;
        testImport.cvarSystem                           = ::cvarSystem;
        testImport.fileSystem                           = ::fileSystem;
        testImport.networkSystem                        = ::networkSystem;
        testImport.renderSystem                         = ::renderSystem;
        testImport.soundSystem                          = ::soundSystem;
        testImport.renderModelManager           = ::renderModelManager;
        testImport.uiManager                            = ::uiManager;
        testImport.declManager                          = ::declManager;
        testImport.AASFileManager                       = ::AASFileManager;
        testImport.collisionModelManager        = ::collisionModelManager;

        testExport = *GetGameAPI( &testImport );
}

/*
===========
idGameLocal::idGameLocal
============
*/
idGameLocal::idGameLocal() {
        Clear();
}

/*
===========
idGameLocal::Clear
============
*/
void idGameLocal::Clear( void ) {
        int i;

        serverInfo.Clear();
        numClients = 0;
        for ( i = 0; i < MAX_CLIENTS; i++ ) {
                userInfo[i].Clear();
                persistentPlayerInfo[i].Clear();
        }
        memset( usercmds, 0, sizeof( usercmds ) );
        memset( entities, 0, sizeof( entities ) );
        memset( spawnIds, -1, sizeof( spawnIds ) );
        firstFreeIndex = 0;
        num_entities = 0;
        spawnedEntities.Clear();
        activeEntities.Clear();
        numEntitiesToDeactivate = 0;
        sortPushers = false;
        sortTeamMasters = false;
        persistentLevelInfo.Clear();
        memset( globalShaderParms, 0, sizeof( globalShaderParms ) );
        random.SetSeed( 0 );
        world = NULL;
        frameCommandThread = NULL;
        testmodel = NULL;
        testFx = NULL;
        clip.Shutdown();
        pvs.Shutdown();
        sessionCommand.Clear();
        locationEntities = NULL;
        smokeParticles = NULL;
        editEntities = NULL;
        entityHash.Clear( 1024, MAX_GENTITIES );
        inCinematic = false;
        cinematicSkipTime = 0;
        cinematicStopTime = 0;
        cinematicMaxSkipTime = 0;
        framenum = 0;
        previousTime = 0;
        time = 0;
        vacuumAreaNum = 0;
        mapFileName.Clear();
        mapFile = NULL;
        spawnCount = INITIAL_SPAWN_COUNT;
        mapSpawnCount = 0;
        camera = NULL;
        aasList.Clear();
        aasNames.Clear();
        lastAIAlertEntity = NULL;
        lastAIAlertTime = 0;
        spawnArgs.Clear();
        gravity.Set( 0, 0, -1 );
        playerPVS.h = -1;
        playerConnectedAreas.h = -1;
        gamestate = GAMESTATE_UNINITIALIZED;
        skipCinematic = false;
        influenceActive = false;

        localClientNum = 0;
        isMultiplayer = false;
        isServer = false;
        isClient = false;
        realClientTime = 0;
        isNewFrame = true;
        clientSmoothing = 0.1f;
        entityDefBits = 0;

        nextGibTime = 0;
        globalMaterial = NULL;
        newInfo.Clear();
        lastGUIEnt = NULL;
        lastGUI = 0;

        memset( clientEntityStates, 0, sizeof( clientEntityStates ) );
        memset( clientPVS, 0, sizeof( clientPVS ) );
        memset( clientSnapshots, 0, sizeof( clientSnapshots ) );

        eventQueue.Init();
        savedEventQueue.Init();

        memset( lagometer, 0, sizeof( lagometer ) );

#ifdef _D3XP
        portalSkyEnt                    = NULL;
        portalSkyActive                 = false;

        ResetSlowTimeVars();
#endif
}

/*
===========
idGameLocal::Init

  initialize the game object, only happens once at startup, not each level load
============
*/
void idGameLocal::Init( void ) {
        const idDict *dict;
        idAAS *aas;

#ifndef GAME_DLL

        TestGameAPI();

#else

        // initialize idLib
        idLib::Init();

        // register static cvars declared in the game
        idCVar::RegisterStaticVars();

        // initialize processor specific SIMD
        idSIMD::InitProcessor( "game", com_forceGenericSIMD.GetBool() );

#endif

        Printf( "--------- Initializing Game ----------\n" );
        Printf( "gamename: %s\n", GAME_VERSION );
        Printf( "gamedate: %s\n", __DATE__ );

        // register game specific decl types
        declManager->RegisterDeclType( "model",                         DECL_MODELDEF,          idDeclAllocator<idDeclModelDef> );
        declManager->RegisterDeclType( "export",                        DECL_MODELEXPORT,       idDeclAllocator<idDecl> );

        // register game specific decl folders
        declManager->RegisterDeclFolder( "def",                         ".def",                         DECL_ENTITYDEF );
        declManager->RegisterDeclFolder( "fx",                          ".fx",                          DECL_FX );
        declManager->RegisterDeclFolder( "particles",           ".prt",                         DECL_PARTICLE );
        declManager->RegisterDeclFolder( "af",                          ".af",                          DECL_AF );
        declManager->RegisterDeclFolder( "newpdas",                     ".pda",                         DECL_PDA );

        cmdSystem->AddCommand( "listModelDefs", idListDecls_f<DECL_MODELDEF>, CMD_FL_SYSTEM|CMD_FL_GAME, "lists model defs" );
        cmdSystem->AddCommand( "printModelDefs", idPrintDecls_f<DECL_MODELDEF>, CMD_FL_SYSTEM|CMD_FL_GAME, "prints a model def", idCmdSystem::ArgCompletion_Decl<DECL_MODELDEF> );

        Clear();

        idEvent::Init();
        idClass::Init();

        InitConsoleCommands();


#ifdef _D3XP
        if(!g_xp_bind_run_once.GetBool()) {
                //The default config file contains remapped controls that support the XP weapons
                //We want to run this once after the base doom config file has run so we can
                //have the correct xp binds
                cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "exec default.cfg\n" );
                cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "seta g_xp_bind_run_once 1\n" );
                cmdSystem->ExecuteCommandBuffer();
        }
#endif

        // load default scripts
        program.Startup( SCRIPT_DEFAULT );
        
#ifdef _D3XP
        //BSM Nerve: Loads a game specific main script file
        idStr gamedir;
        int i;
        for ( i = 0; i < 2; i++ ) {
                if ( i == 0 ) {
                        gamedir = cvarSystem->GetCVarString( "fs_game_base" );
                } else if ( i == 1 ) {
                        gamedir = cvarSystem->GetCVarString( "fs_game" );
                }
                if( gamedir.Length() > 0 ) {            
                        idStr scriptFile = va( "script/%s_main.script", gamedir.c_str() );
                        if ( fileSystem->ReadFile( scriptFile.c_str(), NULL ) > 0 ) {
                                program.CompileFile( scriptFile.c_str() );
                                program.FinishCompilation();
                        }
                }
        }
#endif

        smokeParticles = new idSmokeParticles;

        // set up the aas
        dict = FindEntityDefDict( "aas_types" );
        if ( !dict ) {
                Error( "Unable to find entityDef for 'aas_types'" );
        }

        // allocate space for the aas
        const idKeyValue *kv = dict->MatchPrefix( "type" );
        while( kv != NULL ) {
                aas = idAAS::Alloc();
                aasList.Append( aas );
                aasNames.Append( kv->GetValue() );
                kv = dict->MatchPrefix( "type", kv );
        }

        gamestate = GAMESTATE_NOMAP;

        Printf( "...%d aas types\n", aasList.Num() );
        Printf( "game initialized.\n" );
        Printf( "--------------------------------------\n" );
}

/*
===========
idGameLocal::Shutdown

  shut down the entire game
============
*/
void idGameLocal::Shutdown( void ) {

        if ( !common ) {
                return;
        }

        Printf( "------------ Game Shutdown -----------\n" );

        mpGame.Shutdown();

        MapShutdown();

        aasList.DeleteContents( true );
        aasNames.Clear();

        idAI::FreeObstacleAvoidanceNodes();

        // shutdown the model exporter
        idModelExport::Shutdown();

        idEvent::Shutdown();

        delete[] locationEntities;
        locationEntities = NULL;

        delete smokeParticles;
        smokeParticles = NULL;

        idClass::Shutdown();

        // clear list with forces
        idForce::ClearForceList();

        // free the program data
        program.FreeData();

        // delete the .map file
        delete mapFile;
        mapFile = NULL;

        // free the collision map
        collisionModelManager->FreeMap();

        ShutdownConsoleCommands();

        // free memory allocated by class objects
        Clear();

        // shut down the animation manager
        animationLib.Shutdown();

        Printf( "--------------------------------------\n" );

#ifdef GAME_DLL

        // remove auto-completion function pointers pointing into this DLL
        cvarSystem->RemoveFlaggedAutoCompletion( CVAR_GAME );

        // enable leak test
        Mem_EnableLeakTest( "game" );

        // shutdown idLib
        idLib::ShutDown();

#endif
}

/*
===========
idGameLocal::SaveGame

save the current player state, level name, and level state
the session may have written some data to the file already
============
*/
void idGameLocal::SaveGame( idFile *f ) {
        int i;
        idEntity *ent;
        idEntity *link;

        idSaveGame savegame( f );

        if (g_flushSave.GetBool( ) == true ) { 
                // force flushing with each write... for tracking down
                // save game bugs.
                f->ForceFlush();
        }

        savegame.WriteBuildNumber( BUILD_NUMBER );

        // go through all entities and threads and add them to the object list
        for( i = 0; i < MAX_GENTITIES; i++ ) {
                ent = entities[i];

                if ( ent ) {
                        if ( ent->GetTeamMaster() && ent->GetTeamMaster() != ent ) {
                                continue;
                        }
                        for ( link = ent; link != NULL; link = link->GetNextTeamEntity() ) {
                                savegame.AddObject( link );
                        }
                }
        }

        idList<idThread *> threads;
        threads = idThread::GetThreads();

        for( i = 0; i < threads.Num(); i++ ) {
                savegame.AddObject( threads[i] );
        }

        // write out complete object list
        savegame.WriteObjectList();

        program.Save( &savegame );

        savegame.WriteInt( g_skill.GetInteger() );

        savegame.WriteDict( &serverInfo );

        savegame.WriteInt( numClients );
        for( i = 0; i < numClients; i++ ) {
                savegame.WriteDict( &userInfo[ i ] );
                savegame.WriteUsercmd( usercmds[ i ] );
                savegame.WriteDict( &persistentPlayerInfo[ i ] );
        }

        for( i = 0; i < MAX_GENTITIES; i++ ) {
                savegame.WriteObject( entities[ i ] );
                savegame.WriteInt( spawnIds[ i ] );
        }

        savegame.WriteInt( firstFreeIndex );
        savegame.WriteInt( num_entities );

        // enityHash is restored by idEntity::Restore setting the entity name.

        savegame.WriteObject( world );

        savegame.WriteInt( spawnedEntities.Num() );
        for( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                savegame.WriteObject( ent );
        }

        savegame.WriteInt( activeEntities.Num() );
        for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
                savegame.WriteObject( ent );
        }

        savegame.WriteInt( numEntitiesToDeactivate );
        savegame.WriteBool( sortPushers );
        savegame.WriteBool( sortTeamMasters );
        savegame.WriteDict( &persistentLevelInfo );

        for( i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ ) {
                savegame.WriteFloat( globalShaderParms[ i ] );
        }

        savegame.WriteInt( random.GetSeed() );
        savegame.WriteObject( frameCommandThread );

        // clip
        // push
        // pvs

        testmodel = NULL;
        testFx = NULL;

        savegame.WriteString( sessionCommand );

        // FIXME: save smoke particles

        savegame.WriteInt( cinematicSkipTime );
        savegame.WriteInt( cinematicStopTime );
        savegame.WriteInt( cinematicMaxSkipTime );
        savegame.WriteBool( inCinematic );
        savegame.WriteBool( skipCinematic );

        savegame.WriteBool( isMultiplayer );
        savegame.WriteInt( gameType );

        savegame.WriteInt( framenum );
        savegame.WriteInt( previousTime );
        savegame.WriteInt( time );

#ifdef _D3XP
        savegame.WriteInt( msec );
#endif

        savegame.WriteInt( vacuumAreaNum );

        savegame.WriteInt( entityDefBits );
        savegame.WriteBool( isServer );
        savegame.WriteBool( isClient );

        savegame.WriteInt( localClientNum );

        // snapshotEntities is used for multiplayer only

        savegame.WriteInt( realClientTime );
        savegame.WriteBool( isNewFrame );
        savegame.WriteFloat( clientSmoothing );

#ifdef _D3XP
        portalSkyEnt.Save( &savegame );
        savegame.WriteBool( portalSkyActive );

        fast.Save( &savegame );
        slow.Save( &savegame );

        savegame.WriteInt( slowmoState );
        savegame.WriteFloat( slowmoMsec );
        savegame.WriteBool( quickSlowmoReset );
#endif

        savegame.WriteBool( mapCycleLoaded );
        savegame.WriteInt( spawnCount );

        if ( !locationEntities ) {
                savegame.WriteInt( 0 );
        } else {
                savegame.WriteInt( gameRenderWorld->NumAreas() );
                for( i = 0; i < gameRenderWorld->NumAreas(); i++ ) {
                        savegame.WriteObject( locationEntities[ i ] );
                }
        }

        savegame.WriteObject( camera );

        savegame.WriteMaterial( globalMaterial );

        lastAIAlertEntity.Save( &savegame );
        savegame.WriteInt( lastAIAlertTime );

        savegame.WriteDict( &spawnArgs );

        savegame.WriteInt( playerPVS.i );
        savegame.WriteInt( playerPVS.h );
        savegame.WriteInt( playerConnectedAreas.i );
        savegame.WriteInt( playerConnectedAreas.h );

        savegame.WriteVec3( gravity );

        // gamestate

        savegame.WriteBool( influenceActive );
        savegame.WriteInt( nextGibTime );

        // spawnSpots
        // initialSpots
        // currentInitialSpot
        // newInfo
        // makingBuild
        // shakeSounds

        // write out pending events
        idEvent::Save( &savegame );

        savegame.Close();
}

/*
===========
idGameLocal::GetPersistentPlayerInfo
============
*/
const idDict &idGameLocal::GetPersistentPlayerInfo( int clientNum ) {
        idEntity        *ent;

        persistentPlayerInfo[ clientNum ].Clear();
        ent = entities[ clientNum ];
        if ( ent && ent->IsType( idPlayer::Type ) ) {
                static_cast<idPlayer *>(ent)->SavePersistantInfo();
        }

        return persistentPlayerInfo[ clientNum ];
}

/*
===========
idGameLocal::SetPersistentPlayerInfo
============
*/
void idGameLocal::SetPersistentPlayerInfo( int clientNum, const idDict &playerInfo ) {
        persistentPlayerInfo[ clientNum ] = playerInfo;
}

/*
============
idGameLocal::Printf
============
*/
void idGameLocal::Printf( const char *fmt, ... ) const {
        va_list         argptr;
        char            text[MAX_STRING_CHARS];

        va_start( argptr, fmt );
        idStr::vsnPrintf( text, sizeof( text ), fmt, argptr );
        va_end( argptr );

        common->Printf( "%s", text );
}

/*
============
idGameLocal::DPrintf
============
*/
void idGameLocal::DPrintf( const char *fmt, ... ) const {
        va_list         argptr;
        char            text[MAX_STRING_CHARS];

        if ( !developer.GetBool() ) {
                return;
        }

        va_start( argptr, fmt );
        idStr::vsnPrintf( text, sizeof( text ), fmt, argptr );
        va_end( argptr );

        common->Printf( "%s", text );
}

/*
============
idGameLocal::Warning
============
*/
void idGameLocal::Warning( const char *fmt, ... ) const {
        va_list         argptr;
        char            text[MAX_STRING_CHARS];
        idThread *      thread;

        va_start( argptr, fmt );
        idStr::vsnPrintf( text, sizeof( text ), fmt, argptr );
        va_end( argptr );

        thread = idThread::CurrentThread();
        if ( thread ) {
                thread->Warning( "%s", text );
        } else {
                common->Warning( "%s", text );
        }
}

/*
============
idGameLocal::DWarning
============
*/
void idGameLocal::DWarning( const char *fmt, ... ) const {
        va_list         argptr;
        char            text[MAX_STRING_CHARS];
        idThread *      thread;

        if ( !developer.GetBool() ) {
                return;
        }

        va_start( argptr, fmt );
        idStr::vsnPrintf( text, sizeof( text ), fmt, argptr );
        va_end( argptr );

        thread = idThread::CurrentThread();
        if ( thread ) {
                thread->Warning( "%s", text );
        } else {
                common->DWarning( "%s", text );
        }
}

/*
============
idGameLocal::Error
============
*/
void idGameLocal::Error( const char *fmt, ... ) const {
        va_list         argptr;
        char            text[MAX_STRING_CHARS];
        idThread *      thread;

        va_start( argptr, fmt );
        idStr::vsnPrintf( text, sizeof( text ), fmt, argptr );
        va_end( argptr );

        thread = idThread::CurrentThread();
        if ( thread ) {
                thread->Error( "%s", text );
        } else {
                common->Error( "%s", text );
        }
}

/*
===============
gameError
===============
*/
void gameError( const char *fmt, ... ) {
        va_list         argptr;
        char            text[MAX_STRING_CHARS];

        va_start( argptr, fmt );
        idStr::vsnPrintf( text, sizeof( text ), fmt, argptr );
        va_end( argptr );

        gameLocal.Error( "%s", text );
}

/*
===========
idGameLocal::SetLocalClient
============
*/
void idGameLocal::SetLocalClient( int clientNum ) {
        localClientNum = clientNum;
}

/*
===========
idGameLocal::SetUserInfo
============
*/
const idDict* idGameLocal::SetUserInfo( int clientNum, const idDict &userInfo, bool isClient, bool canModify ) {
        int i;
        bool modifiedInfo = false;

        this->isClient = isClient;

        if ( clientNum >= 0 && clientNum < MAX_CLIENTS ) {
                idGameLocal::userInfo[ clientNum ] = userInfo;

                // server sanity
                if ( canModify ) {

                        // don't let numeric nicknames, it can be exploited to go around kick and ban commands from the server
                        if ( idStr::IsNumeric( this->userInfo[ clientNum ].GetString( "ui_name" ) ) ) {
                                idGameLocal::userInfo[ clientNum ].Set( "ui_name", va( "%s_", idGameLocal::userInfo[ clientNum ].GetString( "ui_name" ) ) );
                                modifiedInfo = true;
                        }
                
                        // don't allow dupe nicknames
                        for ( i = 0; i < numClients; i++ ) {
                                if ( i == clientNum ) {
                                        continue;
                                }
                                if ( entities[ i ] && entities[ i ]->IsType( idPlayer::Type ) ) {
                                        if ( !idStr::Icmp( idGameLocal::userInfo[ clientNum ].GetString( "ui_name" ), idGameLocal::userInfo[ i ].GetString( "ui_name" ) ) ) {
                                                idGameLocal::userInfo[ clientNum ].Set( "ui_name", va( "%s_", idGameLocal::userInfo[ clientNum ].GetString( "ui_name" ) ) );
                                                modifiedInfo = true;
                                                i = -1; // rescan
                                                continue;
                                        }
                                }
                        }
                }

                if ( entities[ clientNum ] && entities[ clientNum ]->IsType( idPlayer::Type ) ) {
                        modifiedInfo |= static_cast<idPlayer *>( entities[ clientNum ] )->UserInfoChanged( canModify );
                }

                if ( !isClient ) {
                        // now mark this client in game
                        mpGame.EnterGame( clientNum );
                }
        }

        if ( modifiedInfo ) {
                assert( canModify );
                newInfo = idGameLocal::userInfo[ clientNum ];
                return &newInfo;
        }
        return NULL;
}

/*
===========
idGameLocal::GetUserInfo
============
*/
const idDict* idGameLocal::GetUserInfo( int clientNum ) {
        if ( entities[ clientNum ] && entities[ clientNum ]->IsType( idPlayer::Type ) ) {
                return &userInfo[ clientNum ];
        }
        return NULL;
}

/*
===========
idGameLocal::SetServerInfo
============
*/
void idGameLocal::SetServerInfo( const idDict &_serverInfo ) {
        idBitMsg        outMsg;
        byte            msgBuf[MAX_GAME_MESSAGE_SIZE];

        serverInfo = _serverInfo;
        UpdateServerInfoFlags();

        if ( !isClient ) {
                // Let our clients know the server info changed
                outMsg.Init( msgBuf, sizeof( msgBuf ) );
                outMsg.WriteByte( GAME_RELIABLE_MESSAGE_SERVERINFO );
                outMsg.WriteDeltaDict( gameLocal.serverInfo, NULL );
                networkSystem->ServerSendReliableMessage( -1, outMsg );
        }
}


/*
===================
idGameLocal::LoadMap

Initializes all map variables common to both save games and spawned games.
===================
*/
void idGameLocal::LoadMap( const char *mapName, int randseed ) {
        int i;
        bool sameMap = (mapFile && idStr::Icmp(mapFileName, mapName) == 0);

        // clear the sound system
        gameSoundWorld->ClearAllSoundEmitters();

#ifdef _D3XP
        // clear envirosuit sound fx
        gameSoundWorld->SetEnviroSuit( false );
        gameSoundWorld->SetSlowmo( false );
#endif

        InitAsyncNetwork();

        if ( !sameMap || ( mapFile && mapFile->NeedsReload() ) ) {
                // load the .map file
                if ( mapFile ) {
                        delete mapFile;
                }
                mapFile = new idMapFile;
                if ( !mapFile->Parse( idStr( mapName ) + ".map" ) ) {
                        delete mapFile;
                        mapFile = NULL;
                        Error( "Couldn't load %s", mapName );
                }
        }
        mapFileName = mapFile->GetName();

        // load the collision map
        collisionModelManager->LoadMap( mapFile );

        numClients = 0;

        // initialize all entities for this game
        memset( entities, 0, sizeof( entities ) );
        memset( usercmds, 0, sizeof( usercmds ) );
        memset( spawnIds, -1, sizeof( spawnIds ) );
        spawnCount = INITIAL_SPAWN_COUNT;
        
        spawnedEntities.Clear();
        activeEntities.Clear();
        numEntitiesToDeactivate = 0;
        sortTeamMasters = false;
        sortPushers = false;
        lastGUIEnt = NULL;
        lastGUI = 0;

        globalMaterial = NULL;

        memset( globalShaderParms, 0, sizeof( globalShaderParms ) );

        // 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
        num_entities    = MAX_CLIENTS;
        firstFreeIndex  = MAX_CLIENTS;

        // reset the random number generator.
        random.SetSeed( isMultiplayer ? randseed : 0 );

        camera                  = NULL;
        world                   = NULL;
        testmodel               = NULL;
        testFx                  = NULL;

        lastAIAlertEntity = NULL;
        lastAIAlertTime = 0;
        
        previousTime    = 0;
        time                    = 0;
        framenum                = 0;
        sessionCommand = "";
        nextGibTime             = 0;

#ifdef _D3XP
        portalSkyEnt                    = NULL;
        portalSkyActive                 = false;

        ResetSlowTimeVars();
#endif

        vacuumAreaNum = -1;             // if an info_vacuum is spawned, it will set this

        if ( !editEntities ) {
                editEntities = new idEditEntities;
        }

        gravity.Set( 0, 0, -g_gravity.GetFloat() );

        spawnArgs.Clear();

        skipCinematic = false;
        inCinematic = false;
        cinematicSkipTime = 0;
        cinematicStopTime = 0;
        cinematicMaxSkipTime = 0;

        clip.Init();
        pvs.Init();
        playerPVS.i = -1;
        playerConnectedAreas.i = -1;

        // load navigation system for all the different monster sizes
        for( i = 0; i < aasNames.Num(); i++ ) {
                aasList[ i ]->Init( idStr( mapFileName ).SetFileExtension( aasNames[ i ] ).c_str(), mapFile->GetGeometryCRC() );
        }

        // clear the smoke particle free list
        smokeParticles->Init();

        // cache miscellanious media references
        FindEntityDef( "preCacheExtras", false );

        if ( !sameMap ) {
                mapFile->RemovePrimitiveData();
        }
}

/*
===================
idGameLocal::LocalMapRestart
===================
*/
void idGameLocal::LocalMapRestart( ) {
        int i, latchSpawnCount;

        Printf( "----------- Game Map Restart ------------\n" );

        gamestate = GAMESTATE_SHUTDOWN;

        for ( i = 0; i < MAX_CLIENTS; i++ ) {
                if ( entities[ i ] && entities[ i ]->IsType( idPlayer::Type ) ) {
                        static_cast< idPlayer * >( entities[ i ] )->PrepareForRestart();
                }
        }

        eventQueue.Shutdown();
        savedEventQueue.Shutdown();

        MapClear( false );



        // clear the smoke particle free list
        smokeParticles->Init();

        // clear the sound system
        if ( gameSoundWorld ) {
                gameSoundWorld->ClearAllSoundEmitters();
#ifdef _D3XP
                // clear envirosuit sound fx
                gameSoundWorld->SetEnviroSuit( false );
                gameSoundWorld->SetSlowmo( false );
#endif
        }

        // the spawnCount is reset to zero temporarily to spawn the map entities with the same spawnId
        // if we don't do that, network clients are confused and don't show any map entities
        latchSpawnCount = spawnCount;
        spawnCount = INITIAL_SPAWN_COUNT;

        gamestate = GAMESTATE_STARTUP;

        program.Restart();

        InitScriptForMap();

        MapPopulate();

        // once the map is populated, set the spawnCount back to where it was so we don't risk any collision
        // (note that if there are no players in the game, we could just leave it at it's current value)
        spawnCount = latchSpawnCount;

        // setup the client entities again
        for ( i = 0; i < MAX_CLIENTS; i++ ) {
                if ( entities[ i ] && entities[ i ]->IsType( idPlayer::Type ) ) {
                        static_cast< idPlayer * >( entities[ i ] )->Restart();
                }
        }

        gamestate = GAMESTATE_ACTIVE;

        Printf( "--------------------------------------\n" );
}

/*
===================
idGameLocal::MapRestart
===================
*/
void idGameLocal::MapRestart( ) {
        idBitMsg        outMsg;
        byte            msgBuf[MAX_GAME_MESSAGE_SIZE];
        idDict          newInfo;
        int                     i;
        const idKeyValue *keyval, *keyval2;

#ifdef _D3XP
        if ( isMultiplayer && isServer ) {
                char buf[ MAX_STRING_CHARS ];
                idStr gametype;
                GetBestGameType( si_map.GetString(), si_gameType.GetString(), buf );
                gametype = buf;
                if ( gametype != si_gameType.GetString() ) {
                        cvarSystem->SetCVarString( "si_gameType", gametype );
                }
        }
#endif


    
        if ( isClient ) {
                LocalMapRestart();
        } else {
                newInfo = *cvarSystem->MoveCVarsToDict( CVAR_SERVERINFO );
                for ( i = 0; i < newInfo.GetNumKeyVals(); i++ ) {
                        keyval = newInfo.GetKeyVal( i );
                        keyval2 = serverInfo.FindKey( keyval->GetKey() );
                        if ( !keyval2 ) {
                                break;
                        }
                        // a select set of si_ changes will cause a full restart of the server
                        if ( keyval->GetValue().Cmp( keyval2->GetValue() ) &&
                                ( !keyval->GetKey().Cmp( "si_pure" ) || !keyval->GetKey().Cmp( "si_map" ) ) ) {
                                break;
                        }
                }
                cmdSystem->BufferCommandText( CMD_EXEC_NOW, "rescanSI" );

                if ( i != newInfo.GetNumKeyVals() ) {
                        cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "nextMap" );
                } else {
                        outMsg.Init( msgBuf, sizeof( msgBuf ) );
                        outMsg.WriteByte( GAME_RELIABLE_MESSAGE_RESTART );
                        outMsg.WriteBits( 1, 1 );
                        outMsg.WriteDeltaDict( serverInfo, NULL );
                        networkSystem->ServerSendReliableMessage( -1, outMsg );

                        LocalMapRestart();
                        mpGame.MapRestart();
                }
        }

#ifdef CTF
        if ( isMultiplayer ) {
                gameLocal.mpGame.ReloadScoreboard();
                //              gameLocal.mpGame.Reset();       // force reconstruct the GUIs when reloading maps, different gametypes have different GUIs
                //              gameLocal.mpGame.UpdateMainGui();
                //              gameLocal.mpGame.StartMenu();
                //              gameLocal.mpGame.DisableMenu();
                //              gameLocal.mpGame.Precache();
        }
#endif
}

/*
===================
idGameLocal::MapRestart_f
===================
*/
void idGameLocal::MapRestart_f( const idCmdArgs &args ) {
        if ( !gameLocal.isMultiplayer || gameLocal.isClient ) {
                common->Printf( "server is not running - use spawnServer\n" );
                cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "spawnServer\n" );
                return;
        }

        gameLocal.MapRestart( );
}

/*
===================
idGameLocal::NextMap
===================
*/
bool idGameLocal::NextMap( void ) {
        const function_t        *func;
        idThread                        *thread;
        idDict                          newInfo;
        const idKeyValue        *keyval, *keyval2;
        int                                     i;

        if ( !g_mapCycle.GetString()[0] ) {
                Printf( common->GetLanguageDict()->GetString( "#str_04294" ) );
                return false;
        }
        if ( fileSystem->ReadFile( g_mapCycle.GetString(), NULL, NULL ) < 0 ) {
                if ( fileSystem->ReadFile( va( "%s.scriptcfg", g_mapCycle.GetString() ), NULL, NULL ) < 0 ) {
                        Printf( "map cycle script '%s': not found\n", g_mapCycle.GetString() );
                        return false;
                } else {
                        g_mapCycle.SetString( va( "%s.scriptcfg", g_mapCycle.GetString() ) );
                }
        }

        Printf( "map cycle script: '%s'\n", g_mapCycle.GetString() );
        func = program.FindFunction( "mapcycle::cycle" );
        if ( !func ) {
                program.CompileFile( g_mapCycle.GetString() );
                func = program.FindFunction( "mapcycle::cycle" );
        }
        if ( !func ) {
                Printf( "Couldn't find mapcycle::cycle\n" );
                return false;
        }
        thread = new idThread( func );
        thread->Start();
        delete thread;

        newInfo = *cvarSystem->MoveCVarsToDict( CVAR_SERVERINFO );
        for ( i = 0; i < newInfo.GetNumKeyVals(); i++ ) {
                keyval = newInfo.GetKeyVal( i );
                keyval2 = serverInfo.FindKey( keyval->GetKey() );
                if ( !keyval2 || keyval->GetValue().Cmp( keyval2->GetValue() ) ) {
                        break;
                }
        }
        return ( i != newInfo.GetNumKeyVals() );
}

/*
===================
idGameLocal::NextMap_f
===================
*/
void idGameLocal::NextMap_f( const idCmdArgs &args ) {
        if ( !gameLocal.isMultiplayer || gameLocal.isClient ) {
                common->Printf( "server is not running\n" );
                return;
        }

        gameLocal.NextMap( );
        // next map was either voted for or triggered by a server command - always restart
        gameLocal.MapRestart( );
}

/*
===================
idGameLocal::MapPopulate
===================
*/
void idGameLocal::MapPopulate( void ) {

        if ( isMultiplayer ) {
                cvarSystem->SetCVarBool( "r_skipSpecular", false );
        }
        // parse the key/value pairs and spawn entities
        SpawnMapEntities();

        // mark location entities in all connected areas
        SpreadLocations();

        // prepare the list of randomized initial spawn spots
        RandomizeInitialSpawns();

        // spawnCount - 1 is the number of entities spawned into the map, their indexes started at MAX_CLIENTS (included)
        // mapSpawnCount is used as the max index of map entities, it's the first index of non-map entities
        mapSpawnCount = MAX_CLIENTS + spawnCount - 1;

        // execute pending events before the very first game frame
        // this makes sure the map script main() function is called
        // before the physics are run so entities can bind correctly
        Printf( "==== Processing events ====\n" );
        idEvent::ServiceEvents();
}

/*
===================
idGameLocal::InitFromNewMap
===================
*/
void idGameLocal::InitFromNewMap( const char *mapName, idRenderWorld *renderWorld, idSoundWorld *soundWorld, bool isServer, bool isClient, int randseed ) {

        this->isServer = isServer;
        this->isClient = isClient;
        this->isMultiplayer = isServer || isClient;

        if ( mapFileName.Length() ) {
                MapShutdown();
        }

        Printf( "----------- Game Map Init ------------\n" );

        gamestate = GAMESTATE_STARTUP;

        gameRenderWorld = renderWorld;
        gameSoundWorld = soundWorld;

        LoadMap( mapName, randseed );

        InitScriptForMap();

        MapPopulate();

        mpGame.Reset();

        mpGame.Precache();

        // free up any unused animations
        animationLib.FlushUnusedAnims();

        gamestate = GAMESTATE_ACTIVE;

        Printf( "--------------------------------------\n" );
}

/*
=================
idGameLocal::InitFromSaveGame
=================
*/
bool idGameLocal::InitFromSaveGame( const char *mapName, idRenderWorld *renderWorld, idSoundWorld *soundWorld, idFile *saveGameFile ) {
        int i;
        int num;
        idEntity *ent;
        idDict si;

        if ( mapFileName.Length() ) {
                MapShutdown();
        }

        Printf( "------- Game Map Init SaveGame -------\n" );

        gamestate = GAMESTATE_STARTUP;

        gameRenderWorld = renderWorld;
        gameSoundWorld = soundWorld;

        idRestoreGame savegame( saveGameFile );

        savegame.ReadBuildNumber();

        // Create the list of all objects in the game
        savegame.CreateObjects();

        // Load the idProgram, also checking to make sure scripting hasn't changed since the savegame
        if ( program.Restore( &savegame ) == false ) {

                // Abort the load process, and let the session know so that it can restart the level
                // with the player persistent data.
                savegame.DeleteObjects();
                program.Restart();

                return false;
        }

        // load the map needed for this savegame
        LoadMap( mapName, 0 );

        savegame.ReadInt( i );
        g_skill.SetInteger( i );

        // precache the player
        FindEntityDef( "player_doommarine", false );

        // precache any media specified in the map
        for ( i = 0; i < mapFile->GetNumEntities(); i++ ) {
                idMapEntity *mapEnt = mapFile->GetEntity( i );

                if ( !InhibitEntitySpawn( mapEnt->epairs ) ) {
                        CacheDictionaryMedia( &mapEnt->epairs );
                        const char *classname = mapEnt->epairs.GetString( "classname" );
                        if ( classname != '\0' ) {
                                FindEntityDef( classname, false );
                        }
                }
        }

        savegame.ReadDict( &si );
        SetServerInfo( si );

        savegame.ReadInt( numClients );
        for( i = 0; i < numClients; i++ ) {
                savegame.ReadDict( &userInfo[ i ] );
                savegame.ReadUsercmd( usercmds[ i ] );
                savegame.ReadDict( &persistentPlayerInfo[ i ] );
        }

        for( i = 0; i < MAX_GENTITIES; i++ ) {
                savegame.ReadObject( reinterpret_cast<idClass *&>( entities[ i ] ) );
                savegame.ReadInt( spawnIds[ i ] );

                // restore the entityNumber
                if ( entities[ i ] != NULL ) {
                        entities[ i ]->entityNumber = i;
                }
        }

        savegame.ReadInt( firstFreeIndex );
        savegame.ReadInt( num_entities );

        // enityHash is restored by idEntity::Restore setting the entity name.

        savegame.ReadObject( reinterpret_cast<idClass *&>( world ) );

        savegame.ReadInt( num );
        for( i = 0; i < num; i++ ) {
                savegame.ReadObject( reinterpret_cast<idClass *&>( ent ) );
                assert( ent );
                if ( ent ) {
                        ent->spawnNode.AddToEnd( spawnedEntities );
                }
        }

        savegame.ReadInt( num );
        for( i = 0; i < num; i++ ) {
                savegame.ReadObject( reinterpret_cast<idClass *&>( ent ) );
                assert( ent );
                if ( ent ) {
                        ent->activeNode.AddToEnd( activeEntities );
                }
        }

        savegame.ReadInt( numEntitiesToDeactivate );
        savegame.ReadBool( sortPushers );
        savegame.ReadBool( sortTeamMasters );
        savegame.ReadDict( &persistentLevelInfo );

        for( i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ ) {
                savegame.ReadFloat( globalShaderParms[ i ] );
        }

        savegame.ReadInt( i );
        random.SetSeed( i );

        savegame.ReadObject( reinterpret_cast<idClass *&>( frameCommandThread ) );

        // clip
        // push
        // pvs

        // testmodel = "<NULL>"
        // testFx = "<NULL>"

        savegame.ReadString( sessionCommand );

        // FIXME: save smoke particles

        savegame.ReadInt( cinematicSkipTime );
        savegame.ReadInt( cinematicStopTime );
        savegame.ReadInt( cinematicMaxSkipTime );
        savegame.ReadBool( inCinematic );
        savegame.ReadBool( skipCinematic );

        savegame.ReadBool( isMultiplayer );
        savegame.ReadInt( (int &)gameType );

        savegame.ReadInt( framenum );
        savegame.ReadInt( previousTime );
        savegame.ReadInt( time );

#ifdef _D3XP
        savegame.ReadInt( msec );
#endif

        savegame.ReadInt( vacuumAreaNum );

        savegame.ReadInt( entityDefBits );
        savegame.ReadBool( isServer );
        savegame.ReadBool( isClient );

        savegame.ReadInt( localClientNum );

        // snapshotEntities is used for multiplayer only

        savegame.ReadInt( realClientTime );
        savegame.ReadBool( isNewFrame );
        savegame.ReadFloat( clientSmoothing );

#ifdef _D3XP
        portalSkyEnt.Restore( &savegame );
        savegame.ReadBool( portalSkyActive );

        fast.Restore( &savegame );
        slow.Restore( &savegame );

        int blah;
        savegame.ReadInt( blah );
        slowmoState = (slowmoState_t)blah;

        savegame.ReadFloat( slowmoMsec );
        savegame.ReadBool( quickSlowmoReset );

        if ( slowmoState == SLOWMO_STATE_OFF ) {
                if ( gameSoundWorld ) {
                        gameSoundWorld->SetSlowmo( false );
                }
        }
        else {
                if ( gameSoundWorld ) {
                        gameSoundWorld->SetSlowmo( true );
                }
        }
        if ( gameSoundWorld ) {
                gameSoundWorld->SetSlowmoSpeed( slowmoMsec / (float)USERCMD_MSEC );
        }
#endif

        savegame.ReadBool( mapCycleLoaded );
        savegame.ReadInt( spawnCount );

        savegame.ReadInt( num );
        if ( num ) {
                if ( num != gameRenderWorld->NumAreas() ) {
                        savegame.Error( "idGameLocal::InitFromSaveGame: number of areas in map differs from save game." );
                }

                locationEntities = new idLocationEntity *[ num ];
                for( i = 0; i < num; i++ ) {
                        savegame.ReadObject( reinterpret_cast<idClass *&>( locationEntities[ i ] ) );
                }
        }

        savegame.ReadObject( reinterpret_cast<idClass *&>( camera ) );

        savegame.ReadMaterial( globalMaterial );

        lastAIAlertEntity.Restore( &savegame );
        savegame.ReadInt( lastAIAlertTime );

        savegame.ReadDict( &spawnArgs );

        savegame.ReadInt( playerPVS.i );
        savegame.ReadInt( (int &)playerPVS.h );
        savegame.ReadInt( playerConnectedAreas.i );
        savegame.ReadInt( (int &)playerConnectedAreas.h );

        savegame.ReadVec3( gravity );

        // gamestate is restored after restoring everything else

        savegame.ReadBool( influenceActive );
        savegame.ReadInt( nextGibTime );

        // spawnSpots
        // initialSpots
        // currentInitialSpot
        // newInfo
        // makingBuild
        // shakeSounds

        // Read out pending events
        idEvent::Restore( &savegame );

        savegame.RestoreObjects();

        mpGame.Reset();

        mpGame.Precache();

        // free up any unused animations
        animationLib.FlushUnusedAnims();

        gamestate = GAMESTATE_ACTIVE;

        Printf( "--------------------------------------\n" );

        return true;
}

/*
===========
idGameLocal::MapClear
===========
*/
void idGameLocal::MapClear( bool clearClients ) {
        int i;

        for( i = ( clearClients ? 0 : MAX_CLIENTS ); i < MAX_GENTITIES; i++ ) {
                delete entities[ i ];
                // ~idEntity is in charge of setting the pointer to NULL
                // it will also clear pending events for this entity
                assert( !entities[ i ] );
                spawnIds[ i ] = -1;
        }

        entityHash.Clear( 1024, MAX_GENTITIES );

        if ( !clearClients ) {
                // add back the hashes of the clients
                for ( i = 0; i < MAX_CLIENTS; i++ ) {
                        if ( !entities[ i ] ) {
                                continue;
                        }
                        entityHash.Add( entityHash.GenerateKey( entities[ i ]->name.c_str(), true ), i );
                }
        }

        delete frameCommandThread;
        frameCommandThread = NULL;

        if ( editEntities ) {
                delete editEntities;
                editEntities = NULL;
        }

        delete[] locationEntities;
        locationEntities = NULL;
}

/*
===========
idGameLocal::MapShutdown
============
*/
void idGameLocal::MapShutdown( void ) {
        Printf( "--------- Game Map Shutdown ----------\n" );
        
        gamestate = GAMESTATE_SHUTDOWN;

        if ( gameRenderWorld ) {
                // clear any debug lines, text, and polygons
                gameRenderWorld->DebugClearLines( 0 );
                gameRenderWorld->DebugClearPolygons( 0 );
        }

        // clear out camera if we're in a cinematic
        if ( inCinematic ) {
                camera = NULL;
                inCinematic = false;
        }

        MapClear( true );

        // reset the script to the state it was before the map was started
        program.Restart();

        if ( smokeParticles ) {
                smokeParticles->Shutdown();
        }

        pvs.Shutdown();

        clip.Shutdown();
        idClipModel::ClearTraceModelCache();

        ShutdownAsyncNetwork();

        mapFileName.Clear();

        gameRenderWorld = NULL;
        gameSoundWorld = NULL;

        gamestate = GAMESTATE_NOMAP;

        Printf( "--------------------------------------\n" );
}

/*
===================
idGameLocal::DumpOggSounds
===================
*/
void idGameLocal::DumpOggSounds( void ) {
        int i, j, k, size, totalSize;
        idFile *file;
        idStrList oggSounds, weaponSounds;
        const idSoundShader *soundShader;
        const soundShaderParms_t *parms;
        idStr soundName;

        for ( i = 0; i < declManager->GetNumDecls( DECL_SOUND ); i++ ) {
                soundShader = static_cast<const idSoundShader *>(declManager->DeclByIndex( DECL_SOUND, i, false ));
                parms = soundShader->GetParms();

                if ( soundShader->EverReferenced() && soundShader->GetState() != DS_DEFAULTED ) {

                        const_cast<idSoundShader *>(soundShader)->EnsureNotPurged();

                        for ( j = 0; j < soundShader->GetNumSounds(); j++ ) {
                                soundName = soundShader->GetSound( j );
                                soundName.BackSlashesToSlashes();

#ifdef _D3XP
                                // D3XP :: don't add sounds that are in Doom 3's pak files
                                if ( fileSystem->FileIsInPAK( soundName ) ) {
                                        continue;
                                } else {
                                        // Also check for a pre-ogg'd version in the pak file
                                        idStr testName = soundName;

                                        testName.SetFileExtension( ".ogg" );
                                        if ( fileSystem->FileIsInPAK( testName ) ) {
                                                continue;
                                        }
                                }
#endif
                                // don't OGG sounds that cause a shake because that would
                                // cause continuous seeking on the OGG file which is expensive
                                if ( parms->shakes != 0.0f ) {
                                        shakeSounds.AddUnique( soundName );
                                        continue;
                                }

                                // if not voice over or combat chatter
                                if (    soundName.Find( "/vo/", false ) == -1 &&
                                                soundName.Find( "/combat_chatter/", false ) == -1 &&
                                                soundName.Find( "/bfgcarnage/", false ) == -1 &&
                                                soundName.Find( "/enpro/", false ) == - 1 &&
                                                soundName.Find( "/soulcube/energize_01.wav", false ) == -1 ) {
                                        // don't OGG weapon sounds
                                        if (    soundName.Find( "weapon", false ) != -1 ||
                                                        soundName.Find( "gun", false ) != -1 ||
                                                        soundName.Find( "bullet", false ) != -1 ||
                                                        soundName.Find( "bfg", false ) != -1 ||
                                                        soundName.Find( "plasma", false ) != -1 ) {
                                                weaponSounds.AddUnique( soundName );
                                                continue;
                                        }
                                }

                                for ( k = 0; k < shakeSounds.Num(); k++ ) {
                                        if ( shakeSounds[k].IcmpPath( soundName ) == 0 ) {
                                                break;
                                        }
                                }
                                if ( k < shakeSounds.Num() ) {
                                        continue;
                                }

                                oggSounds.AddUnique( soundName );
                        }
                }
        }

        file = fileSystem->OpenFileWrite( "makeogg.bat", "fs_savepath" );
        if ( file == NULL ) {
                common->Warning( "Couldn't open makeogg.bat" );
                return;
        }

        // list all the shake sounds
        totalSize = 0;
        for ( i = 0; i < shakeSounds.Num(); i++ ) {
                size = fileSystem->ReadFile( shakeSounds[i], NULL, NULL );
                totalSize += size;
                shakeSounds[i].Replace( "/", "\\" );
                file->Printf( "echo \"%s\" (%d kB)\n", shakeSounds[i].c_str(), size >> 10 );
        }
        file->Printf( "echo %d kB in shake sounds\n\n\n", totalSize >> 10 );

        // list all the weapon sounds
        totalSize = 0;
        for ( i = 0; i < weaponSounds.Num(); i++ ) {
                size = fileSystem->ReadFile( weaponSounds[i], NULL, NULL );
                totalSize += size;
                weaponSounds[i].Replace( "/", "\\" );
                file->Printf( "echo \"%s\" (%d kB)\n", weaponSounds[i].c_str(), size >> 10 );
        }
        file->Printf( "echo %d kB in weapon sounds\n\n\n", totalSize >> 10 );

        // list commands to convert all other sounds to ogg
        totalSize = 0;
        for ( i = 0; i < oggSounds.Num(); i++ ) {
                size = fileSystem->ReadFile( oggSounds[i], NULL, NULL );
                totalSize += size;
                oggSounds[i].Replace( "/", "\\" );
                file->Printf( "z:\\d3xp\\ogg\\oggenc -q 0 \"%s\\d3xp\\%s\"\n", cvarSystem->GetCVarString( "fs_basepath" ), oggSounds[i].c_str() );
                file->Printf( "del \"%s\\d3xp\\%s\"\n", cvarSystem->GetCVarString( "fs_basepath" ), oggSounds[i].c_str() );
        }
        file->Printf( "\n\necho %d kB in OGG sounds\n\n\n", totalSize >> 10 );

        fileSystem->CloseFile( file );

        shakeSounds.Clear();
}

/*
===================
idGameLocal::GetShakeSounds
===================
*/
void idGameLocal::GetShakeSounds( const idDict *dict ) {
        const idSoundShader *soundShader;
        const char *soundShaderName;
        idStr soundName;

        soundShaderName = dict->GetString( "s_shader" );
        if ( soundShaderName != '\0' && dict->GetFloat( "s_shakes" ) != 0.0f ) {
                soundShader = declManager->FindSound( soundShaderName );

                for ( int i = 0; i < soundShader->GetNumSounds(); i++ ) {
                        soundName = soundShader->GetSound( i );
                        soundName.BackSlashesToSlashes();

                        shakeSounds.AddUnique( soundName );
                }
        }
}

/*
===================
idGameLocal::CacheDictionaryMedia

This is called after parsing an EntityDef and for each entity spawnArgs before
merging the entitydef.  It could be done post-merge, but that would
avoid the fast pre-cache check associated with each entityDef
===================
*/
void idGameLocal::CacheDictionaryMedia( const idDict *dict ) {
        const idKeyValue *kv;

        if ( dict == NULL ) {
                if ( cvarSystem->GetCVarBool( "com_makingBuild") ) {
                        DumpOggSounds();
                }
                return;
        }

        if ( cvarSystem->GetCVarBool( "com_makingBuild" ) ) {
                GetShakeSounds( dict );
        }

        kv = dict->MatchPrefix( "model" );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->MediaPrint( "Precaching model %s\n", kv->GetValue().c_str() );
                        // precache model/animations
                        if ( declManager->FindType( DECL_MODELDEF, kv->GetValue(), false ) == NULL ) {
                                // precache the render model
                                renderModelManager->FindModel( kv->GetValue() );
                                // precache .cm files only
                                collisionModelManager->LoadModel( kv->GetValue(), true );
                        }
                }
                kv = dict->MatchPrefix( "model", kv );
        }

        kv = dict->FindKey( "s_shader" );
        if ( kv && kv->GetValue().Length() ) {
                declManager->FindType( DECL_SOUND, kv->GetValue() );
        }

        kv = dict->MatchPrefix( "snd", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->FindType( DECL_SOUND, kv->GetValue() );
                }
                kv = dict->MatchPrefix( "snd", kv );
        }


        kv = dict->MatchPrefix( "gui", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        if ( !idStr::Icmp( kv->GetKey(), "gui_noninteractive" )
                                || !idStr::Icmpn( kv->GetKey(), "gui_parm", 8 ) 
                                || !idStr::Icmp( kv->GetKey(), "gui_inventory" ) ) {
                                // unfortunate flag names, they aren't actually a gui
                        } else {
                                declManager->MediaPrint( "Precaching gui %s\n", kv->GetValue().c_str() );
                                idUserInterface *gui = uiManager->Alloc();
                                if ( gui ) {
                                        gui->InitFromFile( kv->GetValue() );
                                        uiManager->DeAlloc( gui );
                                }
                        }
                }
                kv = dict->MatchPrefix( "gui", kv );
        }

        kv = dict->FindKey( "texture" );
        if ( kv && kv->GetValue().Length() ) {
                declManager->FindType( DECL_MATERIAL, kv->GetValue() );
        }

        kv = dict->MatchPrefix( "mtr", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->FindType( DECL_MATERIAL, kv->GetValue() );
                }
                kv = dict->MatchPrefix( "mtr", kv );
        }

        // handles hud icons
        kv = dict->MatchPrefix( "inv_icon", NULL );
        while ( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->FindType( DECL_MATERIAL, kv->GetValue() );
                }
                kv = dict->MatchPrefix( "inv_icon", kv );
        }

        // handles teleport fx.. this is not ideal but the actual decision on which fx to use
        // is handled by script code based on the teleport number
        kv = dict->MatchPrefix( "teleport", NULL );
        if ( kv && kv->GetValue().Length() ) {
                int teleportType = atoi( kv->GetValue() );
                const char *p = ( teleportType ) ? va( "fx/teleporter%i.fx", teleportType ) : "fx/teleporter.fx";
                declManager->FindType( DECL_FX, p );
        }

        kv = dict->MatchPrefix( "fx", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->MediaPrint( "Precaching fx %s\n", kv->GetValue().c_str() );
                        declManager->FindType( DECL_FX, kv->GetValue() );
                }
                kv = dict->MatchPrefix( "fx", kv );
        }

        kv = dict->MatchPrefix( "smoke", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        idStr prtName = kv->GetValue();
                        int dash = prtName.Find('-');
                        if ( dash > 0 ) {
                                prtName = prtName.Left( dash );
                        }
                        declManager->FindType( DECL_PARTICLE, prtName );
                }
                kv = dict->MatchPrefix( "smoke", kv );
        }

        kv = dict->MatchPrefix( "skin", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->MediaPrint( "Precaching skin %s\n", kv->GetValue().c_str() );
                        declManager->FindType( DECL_SKIN, kv->GetValue() );
                }
                kv = dict->MatchPrefix( "skin", kv );
        }

        kv = dict->MatchPrefix( "def", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        FindEntityDef( kv->GetValue().c_str(), false );
                }
                kv = dict->MatchPrefix( "def", kv );
        }

        kv = dict->MatchPrefix( "pda_name", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->FindType( DECL_PDA, kv->GetValue().c_str(), false );
                }
                kv = dict->MatchPrefix( "pda_name", kv );
        }

        kv = dict->MatchPrefix( "video", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->FindType( DECL_VIDEO, kv->GetValue().c_str(), false );
                }
                kv = dict->MatchPrefix( "video", kv );
        }

        kv = dict->MatchPrefix( "audio", NULL );
        while( kv ) {
                if ( kv->GetValue().Length() ) {
                        declManager->FindType( DECL_AUDIO, kv->GetValue().c_str(), false );
                }
                kv = dict->MatchPrefix( "audio", kv );
        }
}

/*
===========
idGameLocal::InitScriptForMap
============
*/
void idGameLocal::InitScriptForMap( void ) {
        // create a thread to run frame commands on
        frameCommandThread = new idThread();
        frameCommandThread->ManualDelete();
        frameCommandThread->SetThreadName( "frameCommands" );

        // run the main game script function (not the level specific main)
        const function_t *func = program.FindFunction( SCRIPT_DEFAULTFUNC );
        if ( func != NULL ) {
                idThread *thread = new idThread( func );
                if ( thread->Start() ) {
                        // thread has finished executing, so delete it
                        delete thread;
                }
        }
}

/*
===========
idGameLocal::SpawnPlayer
============
*/
void idGameLocal::SpawnPlayer( int clientNum ) {
        idEntity        *ent;
        idDict          args;

        // they can connect
        Printf( "SpawnPlayer: %i\n", clientNum );

        args.SetInt( "spawn_entnum", clientNum );
        args.Set( "name", va( "player%d", clientNum + 1 ) );
#ifdef CTF
        if ( isMultiplayer && gameType != GAME_CTF )
                args.Set( "classname", "player_doommarine_mp" );
        else if ( isMultiplayer && gameType == GAME_CTF )
                args.Set( "classname", "player_doommarine_ctf" );
        else
                args.Set( "classname", "player_doommarine" );
#else
        args.Set( "classname", isMultiplayer ? "player_doommarine_mp" : "player_doommarine" );
#endif
        if ( !SpawnEntityDef( args, &ent ) || !entities[ clientNum ] ) {
                Error( "Failed to spawn player as '%s'", args.GetString( "classname" ) );
        }

        // make sure it's a compatible class
        if ( !ent->IsType( idPlayer::Type ) ) {
                Error( "'%s' spawned the player as a '%s'.  Player spawnclass must be a subclass of idPlayer.", args.GetString( "classname" ), ent->GetClassname() );
        }

        if ( clientNum >= numClients ) {
                numClients = clientNum + 1;
        }

        mpGame.SpawnPlayer( clientNum );
}

/*
================
idGameLocal::GetClientByNum
================
*/
idPlayer *idGameLocal::GetClientByNum( int current ) const {
        if ( current < 0 || current >= numClients ) {
                current = 0;
        }
        if ( entities[current] ) {
                return static_cast<idPlayer *>( entities[ current ] );
        }
        return NULL;
}

/*
================
idGameLocal::GetClientByName
================
*/
idPlayer *idGameLocal::GetClientByName( const char *name ) const {
        int i;
        idEntity *ent;
        for ( i = 0 ; i < numClients ; i++ ) {
                ent = entities[ i ];
                if ( ent && ent->IsType( idPlayer::Type ) ) {
                        if ( idStr::IcmpNoColor( name, userInfo[ i ].GetString( "ui_name" ) ) == 0 ) {
                                return static_cast<idPlayer *>( ent );
                        }
                }
        }
        return NULL;
}

/*
================
idGameLocal::GetClientByCmdArgs
================
*/
idPlayer *idGameLocal::GetClientByCmdArgs( const idCmdArgs &args ) const {
        idPlayer *player;
        idStr client = args.Argv( 1 );
        if ( !client.Length() ) {
                return NULL;
        }
        // we don't allow numeric ui_name so this can't go wrong
        if ( client.IsNumeric() ) {
                player = GetClientByNum( atoi( client.c_str() ) );
        } else {
                player = GetClientByName( client.c_str() );
        }
        if ( !player ) {
                common->Printf( "Player '%s' not found\n", client.c_str() );
        }
        return player;
}

/*
================
idGameLocal::GetNextClientNum
================
*/
int idGameLocal::GetNextClientNum( int _current ) const {
        int i, current;

        current = 0;
        for ( i = 0; i < numClients; i++) {
                current = ( _current + i + 1 ) % numClients;
                if ( entities[ current ] && entities[ current ]->IsType( idPlayer::Type ) ) {
                        return current;
                }
        }

        return current;
}

/*
================
idGameLocal::GetLocalPlayer

Nothing in the game tic should EVER make a decision based on what the
local client number is, it shouldn't even be aware that there is a
draw phase even happening.  This just returns client 0, which will
be correct for single player.
================
*/
idPlayer *idGameLocal::GetLocalPlayer() const {
        if ( localClientNum < 0 ) {
                return NULL;
        }

        if ( !entities[ localClientNum ] || !entities[ localClientNum ]->IsType( idPlayer::Type ) ) {
                // not fully in game yet
                return NULL;
        }
        return static_cast<idPlayer *>( entities[ localClientNum ] );
}

/*
================
idGameLocal::SetupClientPVS
================
*/
pvsHandle_t idGameLocal::GetClientPVS( idPlayer *player, pvsType_t type ) {
        if ( player->GetPrivateCameraView() ) {
                return pvs.SetupCurrentPVS( player->GetPrivateCameraView()->GetPVSAreas(), player->GetPrivateCameraView()->GetNumPVSAreas() );
        } else if ( camera ) {
                return pvs.SetupCurrentPVS( camera->GetPVSAreas(), camera->GetNumPVSAreas() );
        } else {
                return pvs.SetupCurrentPVS( player->GetPVSAreas(), player->GetNumPVSAreas() );
        }
}

/*
================
idGameLocal::SetupPlayerPVS
================
*/
void idGameLocal::SetupPlayerPVS( void ) {
        int                     i;
        idEntity *      ent;
        idPlayer *      player;
        pvsHandle_t     otherPVS, newPVS;

        playerPVS.i = -1;
        for ( i = 0; i < numClients; i++ ) {
                ent = entities[i];
                if ( !ent || !ent->IsType( idPlayer::Type ) ) {
                        continue;
                }

                player = static_cast<idPlayer *>(ent);

                if ( playerPVS.i == -1 ) {
                        playerPVS = GetClientPVS( player, PVS_NORMAL );
                } else {
                        otherPVS = GetClientPVS( player, PVS_NORMAL );
                        newPVS = pvs.MergeCurrentPVS( playerPVS, otherPVS );
                        pvs.FreeCurrentPVS( playerPVS );
                        pvs.FreeCurrentPVS( otherPVS );
                        playerPVS = newPVS;
                }

                if ( playerConnectedAreas.i == -1 ) {
                        playerConnectedAreas = GetClientPVS( player, PVS_CONNECTED_AREAS );
                } else {
                        otherPVS = GetClientPVS( player, PVS_CONNECTED_AREAS );
                        newPVS = pvs.MergeCurrentPVS( playerConnectedAreas, otherPVS );
                        pvs.FreeCurrentPVS( playerConnectedAreas );
                        pvs.FreeCurrentPVS( otherPVS );
                        playerConnectedAreas = newPVS;
                }

#ifdef _D3XP
                // if portalSky is preset, then merge into pvs so we get rotating brushes, etc
                if ( portalSkyEnt.GetEntity() ) {
                        idEntity *skyEnt = portalSkyEnt.GetEntity();

                        otherPVS = pvs.SetupCurrentPVS( skyEnt->GetPVSAreas(), skyEnt->GetNumPVSAreas() );
                        newPVS = pvs.MergeCurrentPVS( playerPVS, otherPVS );
                        pvs.FreeCurrentPVS( playerPVS );
                        pvs.FreeCurrentPVS( otherPVS );
                        playerPVS = newPVS;

                        otherPVS = pvs.SetupCurrentPVS( skyEnt->GetPVSAreas(), skyEnt->GetNumPVSAreas() );
                        newPVS = pvs.MergeCurrentPVS( playerConnectedAreas, otherPVS );
                        pvs.FreeCurrentPVS( playerConnectedAreas );
                        pvs.FreeCurrentPVS( otherPVS );
                        playerConnectedAreas = newPVS;
                }
#endif
        }
}

/*
================
idGameLocal::FreePlayerPVS
================
*/
void idGameLocal::FreePlayerPVS( void ) {
        if ( playerPVS.i != -1 ) {
                pvs.FreeCurrentPVS( playerPVS );
                playerPVS.i = -1;
        }
        if ( playerConnectedAreas.i != -1 ) {
                pvs.FreeCurrentPVS( playerConnectedAreas );
                playerConnectedAreas.i = -1;
        }
}

/*
================
idGameLocal::InPlayerPVS

  should only be called during entity thinking and event handling
================
*/
bool idGameLocal::InPlayerPVS( idEntity *ent ) const {
        if ( playerPVS.i == -1 ) {
                return false;
        }
    return pvs.InCurrentPVS( playerPVS, ent->GetPVSAreas(), ent->GetNumPVSAreas() );
}

/*
================
idGameLocal::InPlayerConnectedArea

  should only be called during entity thinking and event handling
================
*/
bool idGameLocal::InPlayerConnectedArea( idEntity *ent ) const {
        if ( playerConnectedAreas.i == -1 ) {
                return false;
        }
    return pvs.InCurrentPVS( playerConnectedAreas, ent->GetPVSAreas(), ent->GetNumPVSAreas() );
}

/*
================
idGameLocal::UpdateGravity
================
*/
void idGameLocal::UpdateGravity( void ) {
        idEntity *ent;

        if ( g_gravity.IsModified() ) {
                if ( g_gravity.GetFloat() == 0.0f ) {
                        g_gravity.SetFloat( 1.0f );
                }
        gravity.Set( 0, 0, -g_gravity.GetFloat() );

                // update all physics objects
                for( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                        if ( ent->IsType( idAFEntity_Generic::Type ) ) {
                                idPhysics *phys = ent->GetPhysics();
                                if ( phys ) {
                                        phys->SetGravity( gravity );
                                }
                        }
                }
                g_gravity.ClearModified();
        }
}

/*
================
idGameLocal::GetGravity
================
*/
const idVec3 &idGameLocal::GetGravity( void ) const {
        return gravity;
}

/*
================
idGameLocal::SortActiveEntityList

  Sorts the active entity list such that pushing entities come first,
  actors come next and physics team slaves appear after their master.
================
*/
void idGameLocal::SortActiveEntityList( void ) {
        idEntity *ent, *next_ent, *master, *part;

        // if the active entity list needs to be reordered to place physics team masters at the front
        if ( sortTeamMasters ) {
                for ( ent = activeEntities.Next(); ent != NULL; ent = next_ent ) {
                        next_ent = ent->activeNode.Next();
                        master = ent->GetTeamMaster();
                        if ( master && master == ent ) {
                                ent->activeNode.Remove();
                                ent->activeNode.AddToFront( activeEntities );
                        }
                }
        }

        // if the active entity list needs to be reordered to place pushers at the front
        if ( sortPushers ) {

                for ( ent = activeEntities.Next(); ent != NULL; ent = next_ent ) {
                        next_ent = ent->activeNode.Next();
                        master = ent->GetTeamMaster();
                        if ( !master || master == ent ) {
                                // check if there is an actor on the team
                                for ( part = ent; part != NULL; part = part->GetNextTeamEntity() ) {
                                        if ( part->GetPhysics()->IsType( idPhysics_Actor::Type ) ) {
                                                break;
                                        }
                                }
                                // if there is an actor on the team
                                if ( part ) {
                                        ent->activeNode.Remove();
                                        ent->activeNode.AddToFront( activeEntities );
                                }
                        }
                }

                for ( ent = activeEntities.Next(); ent != NULL; ent = next_ent ) {
                        next_ent = ent->activeNode.Next();
                        master = ent->GetTeamMaster();
                        if ( !master || master == ent ) {
                                // check if there is an entity on the team using parametric physics
                                for ( part = ent; part != NULL; part = part->GetNextTeamEntity() ) {
                                        if ( part->GetPhysics()->IsType( idPhysics_Parametric::Type ) ) {
                                                break;
                                        }
                                }
                                // if there is an entity on the team using parametric physics
                                if ( part ) {
                                        ent->activeNode.Remove();
                                        ent->activeNode.AddToFront( activeEntities );
                                }
                        }
                }
        }

        sortTeamMasters = false;
        sortPushers = false;
}

#ifdef _D3XP
/*
================
idGameLocal::RunTimeGroup2
================
*/
void idGameLocal::RunTimeGroup2() {
        idEntity *ent;
        int num = 0;

        fast.Increment();
        fast.Get( time, previousTime, msec, framenum, realClientTime );

        for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
                if ( ent->timeGroup != TIME_GROUP2 ) {
                        continue;
                }

                ent->Think();
                num++;
        }

        slow.Get( time, previousTime, msec, framenum, realClientTime );
}
#endif
 
/*
================
idGameLocal::RunFrame
================
*/
gameReturn_t idGameLocal::RunFrame( const usercmd_t *clientCmds ) {
        idEntity *      ent;
        int                     num;
        float           ms;
        idTimer         timer_think, timer_events, timer_singlethink;
        gameReturn_t ret;
        idPlayer        *player;
        const renderView_t *view;

#ifdef _DEBUG
        if ( isMultiplayer ) {
                assert( !isClient );
        }
#endif

        player = GetLocalPlayer();

#ifdef _D3XP
        ComputeSlowMsec();

        slow.Get( time, previousTime, msec, framenum, realClientTime );
        msec = slowmoMsec;
#endif

        if ( !isMultiplayer && g_stopTime.GetBool() ) {
                // clear any debug lines from a previous frame
                gameRenderWorld->DebugClearLines( time + 1 );

                // set the user commands for this frame
                memcpy( usercmds, clientCmds, numClients * sizeof( usercmds[ 0 ] ) );

                if ( player ) {
                        player->Think();
                }
        } else do {
                // update the game time
                framenum++;
                previousTime = time;
                time += msec;
                realClientTime = time;

#ifdef _D3XP
                slow.Set( time, previousTime, msec, framenum, realClientTime );
#endif

#ifdef GAME_DLL
                // allow changing SIMD usage on the fly
                if ( com_forceGenericSIMD.IsModified() ) {
                        idSIMD::InitProcessor( "game", com_forceGenericSIMD.GetBool() );
                }
#endif

                // make sure the random number counter is used each frame so random events
                // are influenced by the player's actions
                random.RandomInt();

                if ( player ) {
                        // update the renderview so that any gui videos play from the right frame
                        view = player->GetRenderView();
                        if ( view ) {
                                gameRenderWorld->SetRenderView( view );
                        }
                }

                // clear any debug lines from a previous frame
                gameRenderWorld->DebugClearLines( time );

                // clear any debug polygons from a previous frame
                gameRenderWorld->DebugClearPolygons( time );

                // set the user commands for this frame
                memcpy( usercmds, clientCmds, numClients * sizeof( usercmds[ 0 ] ) );

                // free old smoke particles
                smokeParticles->FreeSmokes();

                // process events on the server
                ServerProcessEntityNetworkEventQueue();

                // update our gravity vector if needed.
                UpdateGravity();

                // create a merged pvs for all players
                SetupPlayerPVS();

                // sort the active entity list
                SortActiveEntityList();

                timer_think.Clear();
                timer_think.Start();

                // let entities think
                if ( g_timeentities.GetFloat() ) {
                        num = 0;
                        for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
                                if ( g_cinematic.GetBool() && inCinematic && !ent->cinematic ) {
                                        ent->GetPhysics()->UpdateTime( time );
                                        continue;
                                }
                                timer_singlethink.Clear();
                                timer_singlethink.Start();
                                ent->Think();
                                timer_singlethink.Stop();
                                ms = timer_singlethink.Milliseconds();
                                if ( ms >= g_timeentities.GetFloat() ) {
                                        Printf( "%d: entity '%s': %.1f ms\n", time, ent->name.c_str(), ms );
                                }
                                num++;
                        }
                } else {
                        if ( inCinematic ) {
                                num = 0;
                                for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
                                        if ( g_cinematic.GetBool() && !ent->cinematic ) {
                                                ent->GetPhysics()->UpdateTime( time );
                                                continue;
                                        }
                                        ent->Think();
                                        num++;
                                }
                        } else {
                                num = 0;
                                for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
#ifdef _D3XP
                                        if ( ent->timeGroup != TIME_GROUP1 ) {
                                                continue;
                                        }
#endif
                                        ent->Think();
                                        num++;
                                }
                        }
                }

#ifdef _D3XP
                RunTimeGroup2();
#endif

                // remove any entities that have stopped thinking
                if ( numEntitiesToDeactivate ) {
                        idEntity *next_ent;
                        int c = 0;
                        for( ent = activeEntities.Next(); ent != NULL; ent = next_ent ) {
                                next_ent = ent->activeNode.Next();
                                if ( !ent->thinkFlags ) {
                                        ent->activeNode.Remove();
                                        c++;
                                }
                        }
                        //assert( numEntitiesToDeactivate == c );
                        numEntitiesToDeactivate = 0;
                }

                timer_think.Stop();
                timer_events.Clear();
                timer_events.Start();

                // service any pending events
                idEvent::ServiceEvents();

#ifdef _D3XP
                // service pending fast events
                fast.Get( time, previousTime, msec, framenum, realClientTime );
                idEvent::ServiceFastEvents();
                slow.Get( time, previousTime, msec, framenum, realClientTime );
#endif

                timer_events.Stop();

                // free the player pvs
                FreePlayerPVS();

                // do multiplayer related stuff
                if ( isMultiplayer ) {
                        mpGame.Run();
                }

                // display how long it took to calculate the current game frame
                if ( g_frametime.GetBool() ) {
                        Printf( "game %d: all:%.1f th:%.1f ev:%.1f %d ents \n",
                                time, timer_think.Milliseconds() + timer_events.Milliseconds(),
                                timer_think.Milliseconds(), timer_events.Milliseconds(), num );
                }

                // build the return value
                ret.consistencyHash = 0;
                ret.sessionCommand[0] = 0;

                if ( !isMultiplayer && player ) {
                        ret.health = player->health;
                        ret.heartRate = player->heartRate;
                        ret.stamina = idMath::FtoiFast( player->stamina );
                        // combat is a 0-100 value based on lastHitTime and lastDmgTime
                        // each make up 50% of the time spread over 10 seconds
                        ret.combat = 0;
                        if ( player->lastDmgTime > 0 && time < player->lastDmgTime + 10000 ) {
                                ret.combat += 50.0f * (float) ( time - player->lastDmgTime ) / 10000;
                        }
                        if ( player->lastHitTime > 0 && time < player->lastHitTime + 10000 ) {
                                ret.combat += 50.0f * (float) ( time - player->lastHitTime ) / 10000;
                        }
                }

                // see if a target_sessionCommand has forced a changelevel
                if ( sessionCommand.Length() ) {
                        strncpy( ret.sessionCommand, sessionCommand, sizeof( ret.sessionCommand ) );
                        break;
                }

                // make sure we don't loop forever when skipping a cinematic
                if ( skipCinematic && ( time > cinematicMaxSkipTime ) ) {
                        Warning( "Exceeded maximum cinematic skip length.  Cinematic may be looping infinitely." );
                        skipCinematic = false;
                        break;
                }
        } while( ( inCinematic || ( time < cinematicStopTime ) ) && skipCinematic );

        ret.syncNextGameFrame = skipCinematic;
        if ( skipCinematic ) {
                soundSystem->SetMute( false );
                skipCinematic = false;          
        }

        // show any debug info for this frame
        RunDebugInfo();
        D_DrawDebugLines();

        return ret;
}


/*
======================================================================

  Game view drawing

======================================================================
*/

/*
====================
idGameLocal::CalcFov

Calculates the horizontal and vertical field of view based on a horizontal field of view and custom aspect ratio
====================
*/
void idGameLocal::CalcFov( float base_fov, float &fov_x, float &fov_y ) const {
        float   x;
        float   y;
        float   ratio_x;
        float   ratio_y;
        
        if ( !sys->FPU_StackIsEmpty() ) {
                Printf( sys->FPU_GetState() );
                Error( "idGameLocal::CalcFov: FPU stack not empty" );
        }

        // first, calculate the vertical fov based on a 640x480 view
        x = 640.0f / tan( base_fov / 360.0f * idMath::PI );
        y = atan2( 480.0f, x );
        fov_y = y * 360.0f / idMath::PI;

        // FIXME: somehow, this is happening occasionally
        assert( fov_y > 0 );
        if ( fov_y <= 0 ) {
                Printf( sys->FPU_GetState() );
                Error( "idGameLocal::CalcFov: bad result" );
        }

        switch( r_aspectRatio.GetInteger() ) {
        default :
        case 0 :
                // 4:3
                fov_x = base_fov;
                return;
                break;

        case 1 :
                // 16:9
                ratio_x = 16.0f;
                ratio_y = 9.0f;
                break;

        case 2 :
                // 16:10
                ratio_x = 16.0f;
                ratio_y = 10.0f;
                break;
        }

        y = ratio_y / tan( fov_y / 360.0f * idMath::PI );
        fov_x = atan2( ratio_x, y ) * 360.0f / idMath::PI;

        if ( fov_x < base_fov ) {
                fov_x = base_fov;
                x = ratio_x / tan( fov_x / 360.0f * idMath::PI );
                fov_y = atan2( ratio_y, x ) * 360.0f / idMath::PI;
        }

        // FIXME: somehow, this is happening occasionally
        assert( ( fov_x > 0 ) && ( fov_y > 0 ) );
        if ( ( fov_y <= 0 ) || ( fov_x <= 0 ) ) {
                Printf( sys->FPU_GetState() );
                Error( "idGameLocal::CalcFov: bad result" );
        }
}

/*
================
idGameLocal::Draw

makes rendering and sound system calls
================
*/
bool idGameLocal::Draw( int clientNum ) {
        if ( isMultiplayer ) {
                return mpGame.Draw( clientNum );
        }

        idPlayer *player = static_cast<idPlayer *>(entities[ clientNum ]);

        if ( !player ) {
                return false;
        }

        // render the scene
        player->playerView.RenderPlayerView( player->hud );

        return true;
}

/*
================
idGameLocal::HandleESC
================
*/
escReply_t idGameLocal::HandleESC( idUserInterface **gui ) {
        if ( isMultiplayer ) {
                *gui = StartMenu();
                // we may set the gui back to NULL to hide it
                return ESC_GUI;
        }
        idPlayer *player = GetLocalPlayer();
        if ( player ) {
                if ( player->HandleESC() ) {
                        return ESC_IGNORE;
                } else {
                        return ESC_MAIN;
                }
        }
        return ESC_MAIN;
}

/*
================
idGameLocal::StartMenu
================
*/
idUserInterface* idGameLocal::StartMenu( void ) {
        if ( !isMultiplayer ) {
                return NULL;
        }
        return mpGame.StartMenu();
}

/*
================
idGameLocal::HandleGuiCommands
================
*/
const char* idGameLocal::HandleGuiCommands( const char *menuCommand ) {
        if ( !isMultiplayer ) {
                return NULL;
        }
        return mpGame.HandleGuiCommands( menuCommand );
}

/*
================
idGameLocal::HandleMainMenuCommands
================
*/
void idGameLocal::HandleMainMenuCommands( const char *menuCommand, idUserInterface *gui ) { }

/*
================
idGameLocal::GetLevelMap

  should only be used for in-game level editing
================
*/
idMapFile *idGameLocal::GetLevelMap( void ) {
        if ( mapFile && mapFile->HasPrimitiveData()) {
                return mapFile;
        }
        if ( !mapFileName.Length() ) {
                return NULL;
        }

        if ( mapFile ) {
                delete mapFile;
        }

        mapFile = new idMapFile;
        if ( !mapFile->Parse( mapFileName ) ) {
                delete mapFile;
                mapFile = NULL;
        }

        return mapFile;
}

/*
================
idGameLocal::GetMapName
================
*/
const char *idGameLocal::GetMapName( void ) const {
        return mapFileName.c_str();
}

/*
================
idGameLocal::CallFrameCommand
================
*/
void idGameLocal::CallFrameCommand( idEntity *ent, const function_t *frameCommand ) {
        frameCommandThread->CallFunction( ent, frameCommand, true );
        frameCommandThread->Execute();
}

/*
================
idGameLocal::CallObjectFrameCommand
================
*/
void idGameLocal::CallObjectFrameCommand( idEntity *ent, const char *frameCommand ) {
        const function_t *func;

        func = ent->scriptObject.GetFunction( frameCommand );
        if ( !func ) {
                if ( !ent->IsType( idTestModel::Type ) ) {
                        Error( "Unknown function '%s' called for frame command on entity '%s'", frameCommand, ent->name.c_str() );
                }
        } else {
                frameCommandThread->CallFunction( ent, func, true );
                frameCommandThread->Execute();
        }
}

/*
================
idGameLocal::ShowTargets
================
*/
void idGameLocal::ShowTargets( void ) {
        idMat3          axis = GetLocalPlayer()->viewAngles.ToMat3();
        idVec3          up = axis[ 2 ] * 5.0f;
        const idVec3 &viewPos = GetLocalPlayer()->GetPhysics()->GetOrigin();
        idBounds        viewTextBounds( viewPos );
        idBounds        viewBounds( viewPos );
        idBounds        box( idVec3( -4.0f, -4.0f, -4.0f ), idVec3( 4.0f, 4.0f, 4.0f ) );
        idEntity        *ent;
        idEntity        *target;
        int                     i;
        idBounds        totalBounds;

        viewTextBounds.ExpandSelf( 128.0f );
        viewBounds.ExpandSelf( 512.0f );
        for( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                totalBounds = ent->GetPhysics()->GetAbsBounds();
                for( i = 0; i < ent->targets.Num(); i++ ) {
                        target = ent->targets[ i ].GetEntity();
                        if ( target ) {
                                totalBounds.AddBounds( target->GetPhysics()->GetAbsBounds() );
                        }
                }

                if ( !viewBounds.IntersectsBounds( totalBounds ) ) {
                        continue;
                }

                float dist;
                idVec3 dir = totalBounds.GetCenter() - viewPos;
                dir.NormalizeFast();
                totalBounds.RayIntersection( viewPos, dir, dist );
                float frac = ( 512.0f - dist ) / 512.0f;
                if ( frac < 0.0f ) {
                        continue;
                }

                gameRenderWorld->DebugBounds( ( ent->IsHidden() ? colorLtGrey : colorOrange ) * frac, ent->GetPhysics()->GetAbsBounds() );
                if ( viewTextBounds.IntersectsBounds( ent->GetPhysics()->GetAbsBounds() ) ) {
                        idVec3 center = ent->GetPhysics()->GetAbsBounds().GetCenter();
                        gameRenderWorld->DrawText( ent->name.c_str(), center - up, 0.1f, colorWhite * frac, axis, 1 );
                        gameRenderWorld->DrawText( ent->GetEntityDefName(), center, 0.1f, colorWhite * frac, axis, 1 );
                        gameRenderWorld->DrawText( va( "#%d", ent->entityNumber ), center + up, 0.1f, colorWhite * frac, axis, 1 );
                }

                for( i = 0; i < ent->targets.Num(); i++ ) {
                        target = ent->targets[ i ].GetEntity();
                        if ( target ) {
                                gameRenderWorld->DebugArrow( colorYellow * frac, ent->GetPhysics()->GetAbsBounds().GetCenter(), target->GetPhysics()->GetOrigin(), 10, 0 );
                                gameRenderWorld->DebugBounds( colorGreen * frac, box, target->GetPhysics()->GetOrigin() );
                        }
                }
        }
}

/*
================
idGameLocal::RunDebugInfo
================
*/
void idGameLocal::RunDebugInfo( void ) {
        idEntity *ent;
        idPlayer *player;

        player = GetLocalPlayer();
        if ( !player ) {
                return;
        }

        const idVec3 &origin = player->GetPhysics()->GetOrigin();

        if ( g_showEntityInfo.GetBool() ) {
                idMat3          axis = player->viewAngles.ToMat3();
                idVec3          up = axis[ 2 ] * 5.0f;
                idBounds        viewTextBounds( origin );
                idBounds        viewBounds( origin );

                viewTextBounds.ExpandSelf( 128.0f );
                viewBounds.ExpandSelf( 512.0f );
                for( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                        // don't draw the worldspawn
                        if ( ent == world ) {
                                continue;
                        }

                        // skip if the entity is very far away
                        if ( !viewBounds.IntersectsBounds( ent->GetPhysics()->GetAbsBounds() ) ) {
                                continue;
                        }

                        const idBounds &entBounds = ent->GetPhysics()->GetAbsBounds();
                        int contents = ent->GetPhysics()->GetContents();
                        if ( contents & CONTENTS_BODY ) {
                                gameRenderWorld->DebugBounds( colorCyan, entBounds );
                        } else if ( contents & CONTENTS_TRIGGER ) {
                                gameRenderWorld->DebugBounds( colorOrange, entBounds );
                        } else if ( contents & CONTENTS_SOLID ) {
                                gameRenderWorld->DebugBounds( colorGreen, entBounds );
                        } else {
                                if ( !entBounds.GetVolume() ) {
                                        gameRenderWorld->DebugBounds( colorMdGrey, entBounds.Expand( 8.0f ) );
                                } else {
                                        gameRenderWorld->DebugBounds( colorMdGrey, entBounds );
                                }
                        }
                        if ( viewTextBounds.IntersectsBounds( entBounds ) ) {
                                gameRenderWorld->DrawText( ent->name.c_str(), entBounds.GetCenter(), 0.1f, colorWhite, axis, 1 );
                                gameRenderWorld->DrawText( va( "#%d", ent->entityNumber ), entBounds.GetCenter() + up, 0.1f, colorWhite, axis, 1 );
                        }
                }
        }

        // debug tool to draw bounding boxes around active entities
        if ( g_showActiveEntities.GetBool() ) {
                for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() ) {
                        idBounds        b = ent->GetPhysics()->GetBounds();
                        if ( b.GetVolume() <= 0 ) {
                                b[0][0] = b[0][1] = b[0][2] = -8;
                                b[1][0] = b[1][1] = b[1][2] = 8;
                        }
                        if ( ent->fl.isDormant ) {
                                gameRenderWorld->DebugBounds( colorYellow, b, ent->GetPhysics()->GetOrigin() );
                        } else {
                                gameRenderWorld->DebugBounds( colorGreen, b, ent->GetPhysics()->GetOrigin() );
                        }
                }
        }

        if ( g_showTargets.GetBool() ) {
                ShowTargets();
        }

        if ( g_showTriggers.GetBool() ) {
                idTrigger::DrawDebugInfo();
        }

        if ( ai_showCombatNodes.GetBool() ) {
                idCombatNode::DrawDebugInfo();
        }

        if ( ai_showPaths.GetBool() ) {
                idPathCorner::DrawDebugInfo();
        }

        if ( g_editEntityMode.GetBool() ) {
                editEntities->DisplayEntities();
        }

        if ( g_showCollisionWorld.GetBool() ) {
                collisionModelManager->DrawModel( 0, vec3_origin, mat3_identity, origin, 128.0f );
        }

        if ( g_showCollisionModels.GetBool() ) {
                clip.DrawClipModels( player->GetEyePosition(), g_maxShowDistance.GetFloat(), pm_thirdPerson.GetBool() ? NULL : player );
        }

        if ( g_showCollisionTraces.GetBool() ) {
                clip.PrintStatistics();
        }

        if ( g_showPVS.GetInteger() ) {
                pvs.DrawPVS( origin, ( g_showPVS.GetInteger() == 2 ) ? PVS_ALL_PORTALS_OPEN : PVS_NORMAL );
        }

        if ( aas_test.GetInteger() >= 0 ) {
                idAAS *aas = GetAAS( aas_test.GetInteger() );
                if ( aas ) {
                        aas->Test( origin );
                        if ( ai_testPredictPath.GetBool() ) {
                                idVec3 velocity;
                                predictedPath_t path;

                                velocity.x = cos( DEG2RAD( player->viewAngles.yaw ) ) * 100.0f;
                                velocity.y = sin( DEG2RAD( player->viewAngles.yaw ) ) * 100.0f;
                                velocity.z = 0.0f;
                                idAI::PredictPath( player, aas, origin, velocity, 1000, 100, SE_ENTER_OBSTACLE | SE_BLOCKED | SE_ENTER_LEDGE_AREA, path );
                        }
                }
        }

        if ( ai_showObstacleAvoidance.GetInteger() == 2 ) {
                idAAS *aas = GetAAS( 0 );
                if ( aas ) {
                        idVec3 seekPos;
                        obstaclePath_t path;

                        seekPos = player->GetPhysics()->GetOrigin() + player->viewAxis[0] * 200.0f;
                        idAI::FindPathAroundObstacles( player->GetPhysics(), aas, NULL, player->GetPhysics()->GetOrigin(), seekPos, path );
                }
        }

        // collision map debug output
        collisionModelManager->DebugOutput( player->GetEyePosition() );
}

/*
==================
idGameLocal::NumAAS
==================
*/
int     idGameLocal::NumAAS( void ) const {
        return aasList.Num();
}

/*
==================
idGameLocal::GetAAS
==================
*/
idAAS *idGameLocal::GetAAS( int num ) const {
        if ( ( num >= 0 ) && ( num < aasList.Num() ) ) {
                if ( aasList[ num ] && aasList[ num ]->GetSettings() ) {
                        return aasList[ num ];
                }
        }
        return NULL;
}

/*
==================
idGameLocal::GetAAS
==================
*/
idAAS *idGameLocal::GetAAS( const char *name ) const {
        int i;

        for ( i = 0; i < aasNames.Num(); i++ ) {
                if ( aasNames[ i ] == name ) {
                        if ( !aasList[ i ]->GetSettings() ) {
                                return NULL;
                        } else {
                                return aasList[ i ];
                        }
                }
        }
        return NULL;
}

/*
==================
idGameLocal::SetAASAreaState
==================
*/
void idGameLocal::SetAASAreaState( const idBounds &bounds, const int areaContents, bool closed ) {
        int i;

        for( i = 0; i < aasList.Num(); i++ ) {
                aasList[ i ]->SetAreaState( bounds, areaContents, closed );
        }
}

/*
==================
idGameLocal::AddAASObstacle
==================
*/
aasHandle_t idGameLocal::AddAASObstacle( const idBounds &bounds ) {
        int i;
        aasHandle_t obstacle;
        aasHandle_t check;

        if ( !aasList.Num() ) {
                return -1;
        }

        obstacle = aasList[ 0 ]->AddObstacle( bounds );
        for( i = 1; i < aasList.Num(); i++ ) {
                check = aasList[ i ]->AddObstacle( bounds );
                assert( check == obstacle );
        }

        return obstacle;
}

/*
==================
idGameLocal::RemoveAASObstacle
==================
*/
void idGameLocal::RemoveAASObstacle( const aasHandle_t handle ) {
        int i;

        for( i = 0; i < aasList.Num(); i++ ) {
                aasList[ i ]->RemoveObstacle( handle );
        }
}

/*
==================
idGameLocal::RemoveAllAASObstacles
==================
*/
void idGameLocal::RemoveAllAASObstacles( void ) {
        int i;

        for( i = 0; i < aasList.Num(); i++ ) {
                aasList[ i ]->RemoveAllObstacles();
        }
}

/*
==================
idGameLocal::CheatsOk
==================
*/
bool idGameLocal::CheatsOk( bool requirePlayer ) {
        idPlayer *player;

        if ( isMultiplayer && !cvarSystem->GetCVarBool( "net_allowCheats" ) ) {
                Printf( "Not allowed in multiplayer.\n" );
                return false;
        }

        if ( developer.GetBool() ) {
                return true;
        }

        player = GetLocalPlayer();
        if ( !requirePlayer || ( player && ( player->health > 0 ) ) ) {
                return true;
        }

        Printf( "You must be alive to use this command.\n" );

        return false;
}

/*
===================
idGameLocal::RegisterEntity
===================
*/
void idGameLocal::RegisterEntity( idEntity *ent ) {
        int spawn_entnum;

        if ( spawnCount >= ( 1 << ( 32 - GENTITYNUM_BITS ) ) ) {
                Error( "idGameLocal::RegisterEntity: spawn count overflow" );
        }

        if ( !spawnArgs.GetInt( "spawn_entnum", "0", spawn_entnum ) ) {
                while( entities[firstFreeIndex] && firstFreeIndex < ENTITYNUM_MAX_NORMAL ) {
                        firstFreeIndex++;
                }
                if ( firstFreeIndex >= ENTITYNUM_MAX_NORMAL ) {
                        Error( "no free entities" );
                }
                spawn_entnum = firstFreeIndex++;
        }

        entities[ spawn_entnum ] = ent;
        spawnIds[ spawn_entnum ] = spawnCount++;
        ent->entityNumber = spawn_entnum;
        ent->spawnNode.AddToEnd( spawnedEntities );
        ent->spawnArgs.TransferKeyValues( spawnArgs );

        if ( spawn_entnum >= num_entities ) {
                num_entities++;
        }
}

/*
===================
idGameLocal::UnregisterEntity
===================
*/
void idGameLocal::UnregisterEntity( idEntity *ent ) {
        assert( ent );

        if ( editEntities ) {
                editEntities->RemoveSelectedEntity( ent );
        }

        if ( ( ent->entityNumber != ENTITYNUM_NONE ) && ( entities[ ent->entityNumber ] == ent ) ) {
                ent->spawnNode.Remove();
                entities[ ent->entityNumber ] = NULL;
                spawnIds[ ent->entityNumber ] = -1;
                if ( ent->entityNumber >= MAX_CLIENTS && ent->entityNumber < firstFreeIndex ) {
                        firstFreeIndex = ent->entityNumber;
                }
                ent->entityNumber = ENTITYNUM_NONE;
        }
}

/*
================
idGameLocal::SpawnEntityType
================
*/
idEntity *idGameLocal::SpawnEntityType( const idTypeInfo &classdef, const idDict *args, bool bIsClientReadSnapshot ) {
        idClass *obj;

#if _DEBUG
        if ( isClient ) {
                assert( bIsClientReadSnapshot );
        }
#endif

        if ( !classdef.IsType( idEntity::Type ) ) {
                Error( "Attempted to spawn non-entity class '%s'", classdef.classname );
        }

        try {
                if ( args ) {
                        spawnArgs = *args;
                } else {
                        spawnArgs.Clear();
                }
                obj = classdef.CreateInstance();
                obj->CallSpawn();
        }
        
        catch( idAllocError & ) {
                obj = NULL;
        }
        spawnArgs.Clear();

        return static_cast<idEntity *>(obj);
}

/*
===================
idGameLocal::SpawnEntityDef

Finds the spawn function for the entity and calls it,
returning false if not found
===================
*/
bool idGameLocal::SpawnEntityDef( const idDict &args, idEntity **ent, bool setDefaults ) {
        const char      *classname;
        const char      *spawn;
        idTypeInfo      *cls;
        idClass         *obj;
        idStr           error;
        const char  *name;

        if ( ent ) {
                *ent = NULL;
        }

        spawnArgs = args;

        if ( spawnArgs.GetString( "name", "", &name ) ) {
                sprintf( error, " on '%s'", name);
        }

        spawnArgs.GetString( "classname", NULL, &classname );

        const idDeclEntityDef *def = FindEntityDef( classname, false );

        if ( !def ) {
                Warning( "Unknown classname '%s'%s.", classname, error.c_str() );
                return false;
        }

        spawnArgs.SetDefaults( &def->dict );

#ifdef _D3XP
        if ( !spawnArgs.FindKey( "slowmo" ) ) {
                bool slowmo = true;

                for ( int i = 0; fastEntityList[i]; i++ ) {
                        if ( !idStr::Cmp( classname, fastEntityList[i] ) ) {
                                slowmo = false;
                                break;
                        }
                }

                if ( !slowmo ) {
                        spawnArgs.SetBool( "slowmo", slowmo );
                }
        }
#endif

        // check if we should spawn a class object
        spawnArgs.GetString( "spawnclass", NULL, &spawn );
        if ( spawn ) {

                cls = idClass::GetClass( spawn );
                if ( !cls ) {
                        Warning( "Could not spawn '%s'.  Class '%s' not found %s.", classname, spawn, error.c_str() );
                        return false;
                }

                obj = cls->CreateInstance();
                if ( !obj ) {
                        Warning( "Could not spawn '%s'. Instance could not be created %s.", classname, error.c_str() );
                        return false;
                }

                obj->CallSpawn();

                if ( ent && obj->IsType( idEntity::Type ) ) {
                        *ent = static_cast<idEntity *>(obj);
                }

                return true;
        }

        // check if we should call a script function to spawn
        spawnArgs.GetString( "spawnfunc", NULL, &spawn );
        if ( spawn ) {
                const function_t *func = program.FindFunction( spawn );
                if ( !func ) {
                        Warning( "Could not spawn '%s'.  Script function '%s' not found%s.", classname, spawn, error.c_str() );
                        return false;
                }
                idThread *thread = new idThread( func );
                thread->DelayedStart( 0 );
                return true;
        }

        Warning( "%s doesn't include a spawnfunc or spawnclass%s.", classname, error.c_str() );
        return false;
}

/*
================
idGameLocal::FindEntityDef
================
*/
const idDeclEntityDef *idGameLocal::FindEntityDef( const char *name, bool makeDefault ) const {
        const idDecl *decl = NULL;
        if ( isMultiplayer ) {
                decl = declManager->FindType( DECL_ENTITYDEF, va( "%s_mp", name ), false );
        }
        if ( !decl ) {
                decl = declManager->FindType( DECL_ENTITYDEF, name, makeDefault );
        }
        return static_cast<const idDeclEntityDef *>( decl );
}

/*
================
idGameLocal::FindEntityDefDict
================
*/
const idDict *idGameLocal::FindEntityDefDict( const char *name, bool makeDefault ) const {
        const idDeclEntityDef *decl = FindEntityDef( name, makeDefault );
        return decl ? &decl->dict : NULL;
}

/*
================
idGameLocal::InhibitEntitySpawn
================
*/
bool idGameLocal::InhibitEntitySpawn( idDict &spawnArgs ) {
        
        bool result = false;

        if ( isMultiplayer ) {
                spawnArgs.GetBool( "not_multiplayer", "0", result );
        } else if ( g_skill.GetInteger() == 0 ) {
                spawnArgs.GetBool( "not_easy", "0", result );
        } else if ( g_skill.GetInteger() == 1 ) {
                spawnArgs.GetBool( "not_medium", "0", result );
        } else {
                spawnArgs.GetBool( "not_hard", "0", result );
#ifdef _D3XP
                if ( !result && g_skill.GetInteger() == 3 ) {
                        spawnArgs.GetBool( "not_nightmare", "0", result );
                }
#endif
        }


        const char *name;
#ifndef ID_DEMO_BUILD
        if ( g_skill.GetInteger() == 3 ) { 
                name = spawnArgs.GetString( "classname" );
                // _D3XP :: remove moveable medkit packs also
                if ( idStr::Icmp( name, "item_medkit" ) == 0 || idStr::Icmp( name, "item_medkit_small" ) == 0 ||
                         idStr::Icmp( name, "moveable_item_medkit" ) == 0 || idStr::Icmp( name, "moveable_item_medkit_small" ) == 0 ) {

                        result = true;
                }
        }
#endif

        if ( gameLocal.isMultiplayer ) {
                name = spawnArgs.GetString( "classname" );
                if ( idStr::Icmp( name, "weapon_bfg" ) == 0 || idStr::Icmp( name, "weapon_soulcube" ) == 0 ) {
                        result = true;
                }
        }

        return result;
}

/*
================
idGameLocal::SetSkill
================
*/
void idGameLocal::SetSkill( int value ) {
        int skill_level;

        if ( value < 0 ) {
                skill_level = 0;
        } else if ( value > 3 ) {
                skill_level = 3;
        } else {
                skill_level = value;
        }

        g_skill.SetInteger( skill_level );
}

/*
==============
idGameLocal::GameState

Used to allow entities to know if they're being spawned during the initial spawn.
==============
*/
gameState_t     idGameLocal::GameState( void ) const {
        return gamestate;
}

/*
==============
idGameLocal::SpawnMapEntities

Parses textual entity definitions out of an entstring and spawns gentities.
==============
*/
void idGameLocal::SpawnMapEntities( void ) {
        int                     i;
        int                     num;
        int                     inhibit;
        idMapEntity     *mapEnt;
        int                     numEntities;
        idDict          args;

        Printf( "Spawning entities\n" );

        if ( mapFile == NULL ) {
                Printf("No mapfile present\n");
                return;
        }

        SetSkill( g_skill.GetInteger() );

        numEntities = mapFile->GetNumEntities();
        if ( numEntities == 0 ) {
                Error( "...no entities" );
        }

        // the worldspawn is a special that performs any global setup
        // needed by a level
        mapEnt = mapFile->GetEntity( 0 );
        args = mapEnt->epairs;
        args.SetInt( "spawn_entnum", ENTITYNUM_WORLD );
        if ( !SpawnEntityDef( args ) || !entities[ ENTITYNUM_WORLD ] || !entities[ ENTITYNUM_WORLD ]->IsType( idWorldspawn::Type ) ) {
                Error( "Problem spawning world entity" );
        }

        num = 1;
        inhibit = 0;

        for ( i = 1 ; i < numEntities ; i++ ) {
                mapEnt = mapFile->GetEntity( i );
                args = mapEnt->epairs;

                if ( !InhibitEntitySpawn( args ) ) {
                        // precache any media specified in the map entity
                        CacheDictionaryMedia( &args );

                        SpawnEntityDef( args );
                        num++;
                } else {
                        inhibit++;
                }
        }

        Printf( "...%i entities spawned, %i inhibited\n\n", num, inhibit );
}

/*
================
idGameLocal::AddEntityToHash
================
*/
void idGameLocal::AddEntityToHash( const char *name, idEntity *ent ) {
        if ( FindEntity( name ) ) {
                Error( "Multiple entities named '%s'", name );
        }
        entityHash.Add( entityHash.GenerateKey( name, true ), ent->entityNumber );
}

/*
================
idGameLocal::RemoveEntityFromHash
================
*/
bool idGameLocal::RemoveEntityFromHash( const char *name, idEntity *ent ) {
        int hash, i;

        hash = entityHash.GenerateKey( name, true );
        for ( i = entityHash.First( hash ); i != -1; i = entityHash.Next( i ) ) {
                if ( entities[i] && entities[i] == ent && entities[i]->name.Icmp( name ) == 0 ) {
                        entityHash.Remove( hash, i );
                        return true;
                }
        }
        return false;
}

/*
================
idGameLocal::GetTargets
================
*/
int idGameLocal::GetTargets( const idDict &args, idList< idEntityPtr<idEntity> > &list, const char *ref ) const {
        int i, num, refLength;
        const idKeyValue *arg;
        idEntity *ent;

        list.Clear();

        refLength = strlen( ref );
        num = args.GetNumKeyVals();
        for( i = 0; i < num; i++ ) {

                arg = args.GetKeyVal( i );
                if ( arg->GetKey().Icmpn( ref, refLength ) == 0 ) {

                        ent = FindEntity( arg->GetValue() );
                        if ( ent ) {
                                idEntityPtr<idEntity> &entityPtr = list.Alloc();
                entityPtr = ent;
                        }
                }
        }

        return list.Num();
}

/*
=============
idGameLocal::GetTraceEntity

returns the master entity of a trace.  for example, if the trace entity is the player's head, it will return the player.
=============
*/
idEntity *idGameLocal::GetTraceEntity( const trace_t &trace ) const {
        idEntity *master;

        if ( !entities[ trace.c.entityNum ] ) {
                return NULL;
        }
        master = entities[ trace.c.entityNum ]->GetBindMaster();
        if ( master ) {
                return master;
        }
        return entities[ trace.c.entityNum ];
}

/*
=============
idGameLocal::ArgCompletion_EntityName

Argument completion for entity names
=============
*/
void idGameLocal::ArgCompletion_EntityName( const idCmdArgs &args, void(*callback)( const char *s ) ) {
        int i;

        for( i = 0; i < gameLocal.num_entities; i++ ) {
                if ( gameLocal.entities[ i ] ) {
                        callback( va( "%s %s", args.Argv( 0 ), gameLocal.entities[ i ]->name.c_str() ) );
                }
        }
}

/*
=============
idGameLocal::FindEntity

Returns the entity whose name matches the specified string.
=============
*/
idEntity *idGameLocal::FindEntity( const char *name ) const {
        int hash, i;

        hash = entityHash.GenerateKey( name, true );
        for ( i = entityHash.First( hash ); i != -1; i = entityHash.Next( i ) ) {
                if ( entities[i] && entities[i]->name.Icmp( name ) == 0 ) {
                        return entities[i];
                }
        }

        return NULL;
}

/*
=============
idGameLocal::FindEntityUsingDef

Searches all active entities for the next one using the specified entityDef.

Searches beginning at the entity after from, or the beginning if NULL
NULL will be returned if the end of the list is reached.
=============
*/
idEntity *idGameLocal::FindEntityUsingDef( idEntity *from, const char *match ) const {
        idEntity        *ent;

        if ( !from ) {
                ent = spawnedEntities.Next();
        } else {
                ent = from->spawnNode.Next();
        }

        for ( ; ent != NULL; ent = ent->spawnNode.Next() ) {
                assert( ent );
                if ( idStr::Icmp( ent->GetEntityDefName(), match ) == 0 ) {
                        return ent;
                }
        }

        return NULL;
}

/*
=============
idGameLocal::FindTraceEntity

Searches all active entities for the closest ( to start ) match that intersects
the line start,end
=============
*/
idEntity *idGameLocal::FindTraceEntity( idVec3 start, idVec3 end, const idTypeInfo &c, const idEntity *skip ) const {
        idEntity *ent;
        idEntity *bestEnt;
        float scale;
        float bestScale;
        idBounds b;

        bestEnt = NULL;
        bestScale = 1.0f;
        for( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                if ( ent->IsType( c ) && ent != skip ) {
                        b = ent->GetPhysics()->GetAbsBounds().Expand( 16 );
                        if ( b.RayIntersection( start, end-start, scale ) ) {
                                if ( scale >= 0.0f && scale < bestScale ) {
                                        bestEnt = ent;
                                        bestScale = scale;
                                }
                        }
                }
        }

        return bestEnt;
}

/*
================
idGameLocal::EntitiesWithinRadius
================
*/
int idGameLocal::EntitiesWithinRadius( const idVec3 org, float radius, idEntity **entityList, int maxCount ) const {
        idEntity *ent;
        idBounds bo( org );
        int entCount = 0;

        bo.ExpandSelf( radius );
        for( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                if ( ent->GetPhysics()->GetAbsBounds().IntersectsBounds( bo ) ) {
                        entityList[entCount++] = ent;
                }
        }

        return entCount;
}

/*
=================
idGameLocal::KillBox

Kills all entities that would touch the proposed new positioning of ent. The ent itself will not being killed.
Checks if player entities are in the teleporter, and marks them to die at teleport exit instead of immediately.
If catch_teleport, this only marks teleport players for death on exit
=================
*/
void idGameLocal::KillBox( idEntity *ent, bool catch_teleport ) {
        int                     i;
        int                     num;
        idEntity *      hit;
        idClipModel *cm;
        idClipModel *clipModels[ MAX_GENTITIES ];
        idPhysics       *phys;

        phys = ent->GetPhysics();
        if ( !phys->GetNumClipModels() ) {
                return;
        }

        num = clip.ClipModelsTouchingBounds( phys->GetAbsBounds(), phys->GetClipMask(), clipModels, MAX_GENTITIES );
        for ( i = 0; i < num; i++ ) {
                cm = clipModels[ i ];

                // don't check render entities
                if ( cm->IsRenderModel() ) {
                        continue;
                }

                hit = cm->GetEntity();
                if ( ( hit == ent ) || !hit->fl.takedamage ) {
                        continue;
                }

                if ( !phys->ClipContents( cm ) ) {
                        continue;
                }

                // nail it
                if ( hit->IsType( idPlayer::Type ) && static_cast< idPlayer * >( hit )->IsInTeleport() ) {
                        static_cast< idPlayer * >( hit )->TeleportDeath( ent->entityNumber );
                } else if ( !catch_teleport ) {
                        hit->Damage( ent, ent, vec3_origin, "damage_telefrag", 1.0f, INVALID_JOINT );
                }

                if ( !gameLocal.isMultiplayer ) {
                        // let the mapper know about it
                        Warning( "'%s' telefragged '%s'", ent->name.c_str(), hit->name.c_str() );
                }
        }
}

/*
================
idGameLocal::RequirementMet
================
*/
bool idGameLocal::RequirementMet( idEntity *activator, const idStr &requires, int removeItem ) {
        if ( requires.Length() ) {
                if ( activator->IsType( idPlayer::Type ) ) {
                        idPlayer *player = static_cast<idPlayer *>(activator);
                        idDict *item = player->FindInventoryItem( requires );
                        if ( item ) {
                                if ( removeItem ) {
                                        player->RemoveInventoryItem( item );
                                }
                                return true;
                        } else {
                                return false;
                        }
                }
        }

        return true;
}

/*
============
idGameLocal::AlertAI
============
*/
void idGameLocal::AlertAI( idEntity *ent ) {
        if ( ent && ent->IsType( idActor::Type ) ) {
                // alert them for the next frame
                lastAIAlertTime = time + msec;
                lastAIAlertEntity = static_cast<idActor *>( ent );
        }
}

/*
============
idGameLocal::GetAlertEntity
============
*/
idActor *idGameLocal::GetAlertEntity( void ) {
#ifdef _D3XP
        int timeGroup = 0;
        if ( lastAIAlertTime && lastAIAlertEntity.GetEntity() ) {
                timeGroup = lastAIAlertEntity.GetEntity()->timeGroup;
        }
        SetTimeState ts( timeGroup );
#endif

        if ( lastAIAlertTime >= time ) {
                return lastAIAlertEntity.GetEntity();
        }

        return NULL;
}

/*
============
idGameLocal::RadiusDamage
============
*/
void idGameLocal::RadiusDamage( const idVec3 &origin, idEntity *inflictor, idEntity *attacker, idEntity *ignoreDamage, idEntity *ignorePush, const char *damageDefName, float dmgPower ) {
        float           dist, damageScale, attackerDamageScale, attackerPushScale;
        idEntity *      ent;
        idEntity *      entityList[ MAX_GENTITIES ];
        int                     numListedEntities;
        idBounds        bounds;
        idVec3          v, damagePoint, dir;
        int                     i, e, damage, radius, push;

        const idDict *damageDef = FindEntityDefDict( damageDefName, false );
        if ( !damageDef ) {
                Warning( "Unknown damageDef '%s'", damageDefName );
                return;
        }

        damageDef->GetInt( "damage", "20", damage );
        damageDef->GetInt( "radius", "50", radius );
        damageDef->GetInt( "push", va( "%d", damage * 100 ), push );
        damageDef->GetFloat( "attackerDamageScale", "0.5", attackerDamageScale );
        damageDef->GetFloat( "attackerPushScale", "0", attackerPushScale );

        if ( radius < 1 ) {
                radius = 1;
        }

        bounds = idBounds( origin ).Expand( radius );

        // get all entities touching the bounds
        numListedEntities = clip.EntitiesTouchingBounds( bounds, -1, entityList, MAX_GENTITIES );

        if ( inflictor && inflictor->IsType( idAFAttachment::Type ) ) {
                inflictor = static_cast<idAFAttachment*>(inflictor)->GetBody();
        }
        if ( attacker && attacker->IsType( idAFAttachment::Type ) ) {
                attacker = static_cast<idAFAttachment*>(attacker)->GetBody();
        }
        if ( ignoreDamage && ignoreDamage->IsType( idAFAttachment::Type ) ) {
                ignoreDamage = static_cast<idAFAttachment*>(ignoreDamage)->GetBody();
        }

        // apply damage to the entities
        for ( e = 0; e < numListedEntities; e++ ) {
                ent = entityList[ e ];
                assert( ent );

                if ( !ent->fl.takedamage ) {
                        continue;
                }

                if ( ent == inflictor || ( ent->IsType( idAFAttachment::Type ) && static_cast<idAFAttachment*>(ent)->GetBody() == inflictor ) ) {
                        continue;
                }

                if ( ent == ignoreDamage || ( ent->IsType( idAFAttachment::Type ) && static_cast<idAFAttachment*>(ent)->GetBody() == ignoreDamage ) ) {
                        continue;
                }

                // don't damage a dead player
                if ( isMultiplayer && ent->entityNumber < MAX_CLIENTS && ent->IsType( idPlayer::Type ) && static_cast< idPlayer * >( ent )->health < 0 ) {
                        continue;
                }

                // find the distance from the edge of the bounding box
                for ( i = 0; i < 3; i++ ) {
                        if ( origin[ i ] < ent->GetPhysics()->GetAbsBounds()[0][ i ] ) {
                                v[ i ] = ent->GetPhysics()->GetAbsBounds()[0][ i ] - origin[ i ];
                        } else if ( origin[ i ] > ent->GetPhysics()->GetAbsBounds()[1][ i ] ) {
                                v[ i ] = origin[ i ] - ent->GetPhysics()->GetAbsBounds()[1][ i ];
                        } else {
                                v[ i ] = 0;
                        }
                }

                dist = v.Length();
                if ( dist >= radius ) {
                        continue;
                }

                if ( ent->CanDamage( origin, damagePoint ) ) {
                        // push the center of mass higher than the origin so players
                        // get knocked into the air more
                        dir = ent->GetPhysics()->GetOrigin() - origin;
                        dir[ 2 ] += 24;

                        // get the damage scale
                        damageScale = dmgPower * ( 1.0f - dist / radius );
                        if ( ent == attacker || ( ent->IsType( idAFAttachment::Type ) && static_cast<idAFAttachment*>(ent)->GetBody() == attacker ) ) {
                                damageScale *= attackerDamageScale;
                        }

                        ent->Damage( inflictor, attacker, dir, damageDefName, damageScale, INVALID_JOINT );
                } 
        }

        // push physics objects
        if ( push ) {
                RadiusPush( origin, radius, push * dmgPower, attacker, ignorePush, attackerPushScale, false );
        }
}

/*
==============
idGameLocal::RadiusPush
==============
*/
void idGameLocal::RadiusPush( const idVec3 &origin, const float radius, const float push, const idEntity *inflictor, const idEntity *ignore, float inflictorScale, const bool quake ) {
        int i, numListedClipModels;
        idClipModel *clipModel;
        idClipModel *clipModelList[ MAX_GENTITIES ];
        idVec3 dir;
        idBounds bounds;
        modelTrace_t result;
        idEntity *ent;
        float scale;

        dir.Set( 0.0f, 0.0f, 1.0f );

        bounds = idBounds( origin ).Expand( radius );

        // get all clip models touching the bounds
        numListedClipModels = clip.ClipModelsTouchingBounds( bounds, -1, clipModelList, MAX_GENTITIES );

        if ( inflictor && inflictor->IsType( idAFAttachment::Type ) ) {
                inflictor = static_cast<const idAFAttachment*>(inflictor)->GetBody();
        }
        if ( ignore && ignore->IsType( idAFAttachment::Type ) ) {
                ignore = static_cast<const idAFAttachment*>(ignore)->GetBody();
        }

        // apply impact to all the clip models through their associated physics objects
        for ( i = 0; i < numListedClipModels; i++ ) {

                clipModel = clipModelList[i];

                // never push render models
                if ( clipModel->IsRenderModel() ) {
                        continue;
                }

                ent = clipModel->GetEntity();

                // never push projectiles
                if ( ent->IsType( idProjectile::Type ) ) {
                        continue;
                }

                // players use "knockback" in idPlayer::Damage
                if ( ent->IsType( idPlayer::Type ) && !quake ) {
                        continue;
                }

                // don't push the ignore entity
                if ( ent == ignore || ( ent->IsType( idAFAttachment::Type ) && static_cast<idAFAttachment*>(ent)->GetBody() == ignore ) ) {
                        continue;
                }

                if ( gameRenderWorld->FastWorldTrace( result, origin, clipModel->GetOrigin() ) ) {
                        continue;
                }

                // scale the push for the inflictor
                if ( ent == inflictor || ( ent->IsType( idAFAttachment::Type ) && static_cast<idAFAttachment*>(ent)->GetBody() == inflictor ) ) {
                        scale = inflictorScale;
                } else {
                        scale = 1.0f;
                }

                if ( quake ) {
                        clipModel->GetEntity()->ApplyImpulse( world, clipModel->GetId(), clipModel->GetOrigin(), scale * push * dir );
                } else {
                        RadiusPushClipModel( origin, scale * push, clipModel );
                }
        }
}

/*
==============
idGameLocal::RadiusPushClipModel
==============
*/
void idGameLocal::RadiusPushClipModel( const idVec3 &origin, const float push, const idClipModel *clipModel ) {
        int i, j;
        float dot, dist, area;
        const idTraceModel *trm;
        const traceModelPoly_t *poly;
        idFixedWinding w;
        idVec3 v, localOrigin, center, impulse;

        trm = clipModel->GetTraceModel();
        if ( !trm || 1 ) {
                impulse = clipModel->GetAbsBounds().GetCenter() - origin;
                impulse.Normalize();
                impulse.z += 1.0f;
                clipModel->GetEntity()->ApplyImpulse( world, clipModel->GetId(), clipModel->GetOrigin(), push * impulse );
                return;
        }

        localOrigin = ( origin - clipModel->GetOrigin() ) * clipModel->GetAxis().Transpose();
        for ( i = 0; i < trm->numPolys; i++ ) {
                poly = &trm->polys[i];

                center.Zero();
                for ( j = 0; j < poly->numEdges; j++ ) {
                        v = trm->verts[ trm->edges[ abs(poly->edges[j]) ].v[ INTSIGNBITSET( poly->edges[j] ) ] ];
                        center += v;
                        v -= localOrigin;
                        v.NormalizeFast();      // project point on a unit sphere
                        w.AddPoint( v );
                }
                center /= poly->numEdges;
                v = center - localOrigin;
                dist = v.NormalizeFast();
                dot = v * poly->normal;
                if ( dot > 0.0f ) {
                        continue;
                }
                area = w.GetArea();
                // impulse in polygon normal direction
                impulse = poly->normal * clipModel->GetAxis();
                // always push up for nicer effect
                impulse.z -= 1.0f;
                // scale impulse based on visible surface area and polygon angle
                impulse *= push * ( dot * area * ( 1.0f / ( 4.0f * idMath::PI ) ) );
                // scale away distance for nicer effect
                impulse *= ( dist * 2.0f );
                // impulse is applied to the center of the polygon
                center = clipModel->GetOrigin() + center * clipModel->GetAxis();

                clipModel->GetEntity()->ApplyImpulse( world, clipModel->GetId(), center, impulse );
        }
}

/*
===============
idGameLocal::ProjectDecal
===============
*/
void idGameLocal::ProjectDecal( const idVec3 &origin, const idVec3 &dir, float depth, bool parallel, float size, const char *material, float angle ) {
        float s, c;
        idMat3 axis, axistemp;
        idFixedWinding winding;
        idVec3 windingOrigin, projectionOrigin;

        static idVec3 decalWinding[4] = {
                idVec3(  1.0f,  1.0f, 0.0f ),
                idVec3( -1.0f,  1.0f, 0.0f ),
                idVec3( -1.0f, -1.0f, 0.0f ),
                idVec3(  1.0f, -1.0f, 0.0f )
        };

        if ( !g_decals.GetBool() ) {
                return;
        }

        // randomly rotate the decal winding
        idMath::SinCos16( ( angle ) ? angle : random.RandomFloat() * idMath::TWO_PI, s, c );

        // winding orientation
        axis[2] = dir;
        axis[2].Normalize();
        axis[2].NormalVectors( axistemp[0], axistemp[1] );
        axis[0] = axistemp[ 0 ] * c + axistemp[ 1 ] * -s;
        axis[1] = axistemp[ 0 ] * -s + axistemp[ 1 ] * -c;

        windingOrigin = origin + depth * axis[2];
        if ( parallel ) {
                projectionOrigin = origin - depth * axis[2];
        } else {
                projectionOrigin = origin;
        }

        size *= 0.5f;

        winding.Clear();
        winding += idVec5( windingOrigin + ( axis * decalWinding[0] ) * size, idVec2( 1, 1 ) );
        winding += idVec5( windingOrigin + ( axis * decalWinding[1] ) * size, idVec2( 0, 1 ) );
        winding += idVec5( windingOrigin + ( axis * decalWinding[2] ) * size, idVec2( 0, 0 ) );
        winding += idVec5( windingOrigin + ( axis * decalWinding[3] ) * size, idVec2( 1, 0 ) );
        gameRenderWorld->ProjectDecalOntoWorld( winding, projectionOrigin, parallel, depth * 0.5f, declManager->FindMaterial( material ), gameLocal.slow.time /* _D3XP */ );
}

/*
==============
idGameLocal::BloodSplat
==============
*/
void idGameLocal::BloodSplat( const idVec3 &origin, const idVec3 &dir, float size, const char *material ) {
        float halfSize = size * 0.5f;
        idVec3 verts[] = {      idVec3( 0.0f, +halfSize, +halfSize ),
                                                idVec3( 0.0f, +halfSize, -halfSize ),
                                                idVec3( 0.0f, -halfSize, -halfSize ),
                                                idVec3( 0.0f, -halfSize, +halfSize ) };
        idTraceModel trm;
        idClipModel mdl;
        trace_t results;

        // FIXME: get from damage def
        if ( !g_bloodEffects.GetBool() ) {
                return;
        }

        size = halfSize + random.RandomFloat() * halfSize;
        trm.SetupPolygon( verts, 4 );
        mdl.LoadModel( trm );
        clip.Translation( results, origin, origin + dir * 64.0f, &mdl, mat3_identity, CONTENTS_SOLID, NULL );
        ProjectDecal( results.endpos, dir, 2.0f * size, true, size, material );
}

/*
=============
idGameLocal::SetCamera
=============
*/
void idGameLocal::SetCamera( idCamera *cam ) {
        int i;
        idEntity *ent;
        idAI *ai;

        // this should fix going into a cinematic when dead.. rare but happens
        idPlayer *client = GetLocalPlayer();
        if ( client->health <= 0 || client->AI_DEAD ) {
                return;
        }

        camera = cam;
        if ( camera ) {
                inCinematic = true;

                if ( skipCinematic && camera->spawnArgs.GetBool( "disconnect" ) ) {
                        camera->spawnArgs.SetBool( "disconnect", false );
                        cvarSystem->SetCVarFloat( "r_znear", 3.0f );
                        cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "disconnect\n" );
                        skipCinematic = false;
                        return;
                }

                if ( time > cinematicStopTime ) {
                        cinematicSkipTime = time + CINEMATIC_SKIP_DELAY;
                }

                // set r_znear so that transitioning into/out of the player's head doesn't clip through the view
                cvarSystem->SetCVarFloat( "r_znear", 1.0f );
                
                // hide all the player models
                for( i = 0; i < numClients; i++ ) {
                        if ( entities[ i ] ) {
                                client = static_cast< idPlayer* >( entities[ i ] );
                                client->EnterCinematic();
                        }
                }

                if ( !cam->spawnArgs.GetBool( "ignore_enemies" ) ) {
                        // kill any active monsters that are enemies of the player
                        for ( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                                if ( ent->cinematic || ent->fl.isDormant ) {
                                        // only kill entities that aren't needed for cinematics and aren't dormant
                                        continue;
                                }
                                
                                if ( ent->IsType( idAI::Type ) ) {
                                        ai = static_cast<idAI *>( ent );
                                        if ( !ai->GetEnemy() || !ai->IsActive() ) {
                                                // no enemy, or inactive, so probably safe to ignore
                                                continue;
                                        }
                                } else if ( ent->IsType( idProjectile::Type ) ) {
                                        // remove all projectiles
                                } else if ( ent->spawnArgs.GetBool( "cinematic_remove" ) ) {
                                        // remove anything marked to be removed during cinematics
                                } else {
                                        // ignore everything else
                                        continue;
                                }

                                // remove it
                                DPrintf( "removing '%s' for cinematic\n", ent->GetName() );
                                ent->PostEventMS( &EV_Remove, 0 );
                        }
                }

        } else {
                inCinematic = false;
                cinematicStopTime = time + msec;

                // restore r_znear
                cvarSystem->SetCVarFloat( "r_znear", 3.0f );

                // show all the player models
                for( i = 0; i < numClients; i++ ) {
                        if ( entities[ i ] ) {
                                idPlayer *client = static_cast< idPlayer* >( entities[ i ] );
                                client->ExitCinematic();
                        }
                }
        }
}

/*
=============
idGameLocal::GetCamera
=============
*/
idCamera *idGameLocal::GetCamera( void ) const {
        return camera;
}

/*
=============
idGameLocal::SkipCinematic
=============
*/
bool idGameLocal::SkipCinematic( void ) {
        if ( camera ) {
                if ( camera->spawnArgs.GetBool( "disconnect" ) ) {
                        camera->spawnArgs.SetBool( "disconnect", false );
                        cvarSystem->SetCVarFloat( "r_znear", 3.0f );
                        cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "disconnect\n" );
                        skipCinematic = false;
                        return false;
                }

                if ( camera->spawnArgs.GetBool( "instantSkip" ) ) {
                        camera->Stop();
                        return false;
                }
        }

        soundSystem->SetMute( true );
        if ( !skipCinematic ) {
                skipCinematic = true;
                cinematicMaxSkipTime = gameLocal.time + SEC2MS( g_cinematicMaxSkipTime.GetFloat() );
        }

        return true;
}


/*
======================
idGameLocal::SpreadLocations

Now that everything has been spawned, associate areas with location entities
======================
*/
void idGameLocal::SpreadLocations() {
        idEntity *ent;

        // allocate the area table
        int     numAreas = gameRenderWorld->NumAreas();
        locationEntities = new idLocationEntity *[ numAreas ];
        memset( locationEntities, 0, numAreas * sizeof( *locationEntities ) );

        // for each location entity, make pointers from every area it touches
        for( ent = spawnedEntities.Next(); ent != NULL; ent = ent->spawnNode.Next() ) {
                if ( !ent->IsType( idLocationEntity::Type ) ) {
                        continue;
                }
                idVec3  point = ent->spawnArgs.GetVector( "origin" );
                int areaNum = gameRenderWorld->PointInArea( point );
                if ( areaNum < 0 ) {
                        Printf( "SpreadLocations: location '%s' is not in a valid area\n", ent->spawnArgs.GetString( "name" ) );
                        continue;
                }
                if ( areaNum >= numAreas ) {
                        Error( "idGameLocal::SpreadLocations: areaNum >= gameRenderWorld->NumAreas()" );
                }
                if ( locationEntities[areaNum] ) {
                        Warning( "location entity '%s' overlaps '%s'", ent->spawnArgs.GetString( "name" ),
                                locationEntities[areaNum]->spawnArgs.GetString( "name" ) );
                        continue;
                }
                locationEntities[areaNum] = static_cast<idLocationEntity *>(ent);

                // spread to all other connected areas
                for ( int i = 0 ; i < numAreas ; i++ ) {
                        if ( i == areaNum ) {
                                continue;
                        }
                        if ( gameRenderWorld->AreasAreConnected( areaNum, i, PS_BLOCK_LOCATION ) ) {
                                locationEntities[i] = static_cast<idLocationEntity *>(ent);
                        }
                }
        }
}

/*
===================
idGameLocal::LocationForPoint

The player checks the location each frame to update the HUD text display
May return NULL
===================
*/
idLocationEntity *idGameLocal::LocationForPoint( const idVec3 &point ) {
        if ( !locationEntities ) {
                // before SpreadLocations() has been called
                return NULL;
        }

        int areaNum = gameRenderWorld->PointInArea( point );
        if ( areaNum < 0 ) {
                return NULL;
        }
        if ( areaNum >= gameRenderWorld->NumAreas() ) {
                Error( "idGameLocal::LocationForPoint: areaNum >= gameRenderWorld->NumAreas()" );
        }

        return locationEntities[ areaNum ];
}

/*
============
idGameLocal::SetPortalState
============
*/
void idGameLocal::SetPortalState( qhandle_t portal, int blockingBits ) {
        idBitMsg outMsg;
        byte msgBuf[ MAX_GAME_MESSAGE_SIZE ];

        if ( !gameLocal.isClient ) {
                outMsg.Init( msgBuf, sizeof( msgBuf ) );
                outMsg.WriteByte( GAME_RELIABLE_MESSAGE_PORTAL );
                outMsg.WriteLong( portal );
                outMsg.WriteBits( blockingBits, NUM_RENDER_PORTAL_BITS );
                networkSystem->ServerSendReliableMessage( -1, outMsg );
        }
        gameRenderWorld->SetPortalState( portal, blockingBits );
}

/*
============
idGameLocal::sortSpawnPoints
============
*/
int idGameLocal::sortSpawnPoints( const void *ptr1, const void *ptr2 ) {
        const spawnSpot_t *spot1 = static_cast<const spawnSpot_t *>( ptr1 );
        const spawnSpot_t *spot2 = static_cast<const spawnSpot_t *>( ptr2 );
        float diff;

        diff = spot1->dist - spot2->dist;
        if ( diff < 0.0f ) {
                return 1;
        } else if ( diff > 0.0f ) {
                return -1;
        } else {
                return 0;
        }
}

/*
===========
idGameLocal::RandomizeInitialSpawns
randomize the order of the initial spawns
prepare for a sequence of initial player spawns
============
*/
void idGameLocal::RandomizeInitialSpawns( void ) {
        spawnSpot_t     spot;
        int i, j;
#ifdef CTF
        int k;
#endif
    
        idEntity *ent;

        if ( !isMultiplayer || isClient ) {
                return;
        }
        spawnSpots.Clear();
        initialSpots.Clear();
#ifdef CTF
        teamSpawnSpots[0].Clear();
        teamSpawnSpots[1].Clear();
        teamInitialSpots[0].Clear();
        teamInitialSpots[1].Clear();
#endif
    
        spot.dist = 0;
        spot.ent = FindEntityUsingDef( NULL, "info_player_deathmatch" );
        while( spot.ent ) {
#ifdef CTF
                spot.ent->spawnArgs.GetInt( "team", "-1", spot.team );

                if ( mpGame.IsGametypeFlagBased() ) /* CTF */
                {
                        if ( spot.team == 0 || spot.team == 1 )
                                teamSpawnSpots[spot.team].Append( spot );
                        else
                                common->Warning( "info_player_deathmatch : invalid or no team attached to spawn point\n");
                }
#endif        
                spawnSpots.Append( spot );
                if ( spot.ent->spawnArgs.GetBool( "initial" ) ) {
#ifdef CTF
                        if ( mpGame.IsGametypeFlagBased() ) /* CTF */
                        {
                                assert( spot.team == 0 || spot.team == 1 );
                                teamInitialSpots[ spot.team ].Append( spot.ent );
                        }
#endif
            
                        initialSpots.Append( spot.ent );
                }
                spot.ent = FindEntityUsingDef( spot.ent, "info_player_deathmatch" );
        }

#ifdef CTF
        if ( mpGame.IsGametypeFlagBased() ) /* CTF */
        {
                if ( !teamSpawnSpots[0].Num() )
                        common->Warning( "red team : no info_player_deathmatch in map" );
                if ( !teamSpawnSpots[1].Num() )
                        common->Warning( "blue team : no info_player_deathmatch in map" );

                if ( !teamSpawnSpots[0].Num() || !teamSpawnSpots[1].Num() )
                        return;
        }
#endif
    
        if ( !spawnSpots.Num() ) {
                common->Warning( "no info_player_deathmatch in map" );
                return;
        }

#ifdef CTF
        if ( mpGame.IsGametypeFlagBased() ) /* CTF */
        {
                common->Printf( "red team : %d spawns (%d initials)\n", teamSpawnSpots[ 0 ].Num(), teamInitialSpots[ 0 ].Num() );
                // if there are no initial spots in the map, consider they can all be used as initial
                if ( !teamInitialSpots[ 0 ].Num() ) {
                        common->Warning( "red team : no info_player_deathmatch entities marked initial in map" );
                        for ( i = 0; i < teamSpawnSpots[ 0 ].Num(); i++ ) {
                                teamInitialSpots[ 0 ].Append( teamSpawnSpots[ 0 ][ i ].ent );
                        }
                }

                common->Printf( "blue team : %d spawns (%d initials)\n", teamSpawnSpots[ 1 ].Num(), teamInitialSpots[ 1 ].Num() );
                // if there are no initial spots in the map, consider they can all be used as initial
                if ( !teamInitialSpots[ 1 ].Num() ) {
                        common->Warning( "blue team : no info_player_deathmatch entities marked initial in map" );
                        for ( i = 0; i < teamSpawnSpots[ 1 ].Num(); i++ ) {
                                teamInitialSpots[ 1 ].Append( teamSpawnSpots[ 1 ][ i ].ent );
                        }
                }
        }
#endif

    
        common->Printf( "%d spawns (%d initials)\n", spawnSpots.Num(), initialSpots.Num() );
        // if there are no initial spots in the map, consider they can all be used as initial
        if ( !initialSpots.Num() ) {
                common->Warning( "no info_player_deathmatch entities marked initial in map" );
                for ( i = 0; i < spawnSpots.Num(); i++ ) {
                        initialSpots.Append( spawnSpots[ i ].ent );
                }
        }

#ifdef CTF
        for ( k = 0; k < 2; k++ )
        for ( i = 0; i < teamInitialSpots[ k ].Num(); i++ ) {
                j = random.RandomInt( teamInitialSpots[ k ].Num() );
                ent = teamInitialSpots[ k ][ i ];
                teamInitialSpots[ k ][ i ] = teamInitialSpots[ k ][ j ];
                teamInitialSpots[ k ][ j ] = ent;
        }
#endif
    
        for ( i = 0; i < initialSpots.Num(); i++ ) {
                j = random.RandomInt( initialSpots.Num() );
                ent = initialSpots[ i ];
                initialSpots[ i ] = initialSpots[ j ];
                initialSpots[ j ] = ent;
        }
        // reset the counter
        currentInitialSpot = 0;

#ifdef CTF
        teamCurrentInitialSpot[0] = 0;
        teamCurrentInitialSpot[1] = 0;
#endif
}

/*
===========
idGameLocal::SelectInitialSpawnPoint
spectators are spawned randomly anywhere
in-game clients are spawned based on distance to active players (randomized on the first half)
upon map restart, initial spawns are used (randomized ordered list of spawns flagged "initial")
  if there are more players than initial spots, overflow to regular spawning
============
*/
idEntity *idGameLocal::SelectInitialSpawnPoint( idPlayer *player ) {
        int                             i, j, which;
        spawnSpot_t             spot;
        idVec3                  pos;
        float                   dist;
        bool                    alone;

#ifdef CTF
        if ( !isMultiplayer || !spawnSpots.Num() || ( mpGame.IsGametypeFlagBased() && ( !teamSpawnSpots[0].Num() || !teamSpawnSpots[1].Num() ) ) ) { /* CTF */
#else
        if ( !isMultiplayer || !spawnSpots.Num() ) {
#endif
                spot.ent = FindEntityUsingDef( NULL, "info_player_start" );
                if ( !spot.ent ) {
                        Error( "No info_player_start on map.\n" );
                }
                return spot.ent;
        }

#ifdef CTF
        bool useInitialSpots = false;
        if ( mpGame.IsGametypeFlagBased() ) { /* CTF */
                assert( player->team == 0 || player->team == 1 );
                useInitialSpots = player->useInitialSpawns && teamCurrentInitialSpot[ player->team ] < teamInitialSpots[ player->team ].Num();
        } else {
                useInitialSpots = player->useInitialSpawns && currentInitialSpot < initialSpots.Num();
        }
#endif
    
        if ( player->spectating ) {
                // plain random spot, don't bother
                return spawnSpots[ random.RandomInt( spawnSpots.Num() ) ].ent;
#ifdef CTF
        } else if ( useInitialSpots ) {
                if ( mpGame.IsGametypeFlagBased() ) { /* CTF */
                        assert( player->team == 0 || player->team == 1 );
                        player->useInitialSpawns = false;                                                       // only use the initial spawn once
                        return teamInitialSpots[ player->team ][ teamCurrentInitialSpot[ player->team ]++ ];
                }
                return initialSpots[ currentInitialSpot++ ];
#else
        } else if ( player->useInitialSpawns && currentInitialSpot < initialSpots.Num() ) {
                return initialSpots[ currentInitialSpot++ ];
#endif
        } else {
                // check if we are alone in map
                alone = true;
                for ( j = 0; j < MAX_CLIENTS; j++ ) {
                        if ( entities[ j ] && entities[ j ] != player ) {
                                alone = false;
                                break;
                        }
                }
                if ( alone ) {
#ifdef CTF
                        if ( mpGame.IsGametypeFlagBased() ) /* CTF */
                        {
                                assert( player->team == 0 || player->team == 1 );
                                return teamSpawnSpots[ player->team ][ random.RandomInt( teamSpawnSpots[ player->team ].Num() ) ].ent;
                        }
#endif
                        // don't do distance-based
                        return spawnSpots[ random.RandomInt( spawnSpots.Num() ) ].ent;
                }

#ifdef CTF
                if ( mpGame.IsGametypeFlagBased() ) /* CTF */
                {
                        // TODO : make as reusable method, same code as below
                        int team = player->team;
                        assert( team == 0 || team == 1 );

                        // find the distance to the closest active player for each spawn spot
                        for( i = 0; i < teamSpawnSpots[ team ].Num(); i++ ) {
                                pos = teamSpawnSpots[ team ][ i ].ent->GetPhysics()->GetOrigin();

                                // skip initial spawn points for CTF
                                if ( teamSpawnSpots[ team ][ i ].ent->spawnArgs.GetBool("initial") ) {
                                        teamSpawnSpots[ team ][ i ].dist = 0x0;
                                        continue;
                                }

                                teamSpawnSpots[ team ][ i ].dist = 0x7fffffff;

                                for( j = 0; j < MAX_CLIENTS; j++ ) {
                                        if ( !entities[ j ] || !entities[ j ]->IsType( idPlayer::Type )
                                                || entities[ j ] == player
                                                || static_cast< idPlayer * >( entities[ j ] )->spectating ) {
                                                continue;
                                        }
                                        
                                        dist = ( pos - entities[ j ]->GetPhysics()->GetOrigin() ).LengthSqr();
                                        if ( dist < teamSpawnSpots[ team ][ i ].dist ) {
                                                teamSpawnSpots[ team ][ i ].dist = dist;
                                        }
                                }
                        }

                        // sort the list
                        qsort( ( void * )teamSpawnSpots[ team ].Ptr(), teamSpawnSpots[ team ].Num(), sizeof( spawnSpot_t ), ( int (*)(const void *, const void *) )sortSpawnPoints );

                        // choose a random one in the top half
                        which = random.RandomInt( teamSpawnSpots[ team ].Num() / 2 );
                        spot = teamSpawnSpots[ team ][ which ];
//                      assert( teamSpawnSpots[ team ][ which ].dist != 0 );

                        return spot.ent;
                }
#endif
        
                // find the distance to the closest active player for each spawn spot
                for( i = 0; i < spawnSpots.Num(); i++ ) {
                        pos = spawnSpots[ i ].ent->GetPhysics()->GetOrigin();
                        spawnSpots[ i ].dist = 0x7fffffff;
                        for( j = 0; j < MAX_CLIENTS; j++ ) {
                                if ( !entities[ j ] || !entities[ j ]->IsType( idPlayer::Type )
                                        || entities[ j ] == player
                                        || static_cast< idPlayer * >( entities[ j ] )->spectating ) {
                                        continue;
                                }
                                
                                dist = ( pos - entities[ j ]->GetPhysics()->GetOrigin() ).LengthSqr();
                                if ( dist < spawnSpots[ i ].dist ) {
                                        spawnSpots[ i ].dist = dist;
                                }
                        }
                }

                // sort the list
                qsort( ( void * )spawnSpots.Ptr(), spawnSpots.Num(), sizeof( spawnSpot_t ), ( int (*)(const void *, const void *) )sortSpawnPoints );

                // choose a random one in the top half
                which = random.RandomInt( spawnSpots.Num() / 2 );
                spot = spawnSpots[ which ];
        }
        return spot.ent;
}

/*
================
idGameLocal::UpdateServerInfoFlags
================
*/
void idGameLocal::UpdateServerInfoFlags() {
        gameType = GAME_SP;
        if ( ( idStr::Icmp( serverInfo.GetString( "si_gameType" ), "deathmatch" ) == 0 ) ) {
                gameType = GAME_DM;
        } else if ( ( idStr::Icmp( serverInfo.GetString( "si_gameType" ), "Tourney" ) == 0 ) ) {
                gameType = GAME_TOURNEY;
        } else if ( ( idStr::Icmp( serverInfo.GetString( "si_gameType" ), "Team DM" ) == 0 ) ) {
                gameType = GAME_TDM;
        } else if ( ( idStr::Icmp( serverInfo.GetString( "si_gameType" ), "Last Man" ) == 0 ) ) {
                gameType = GAME_LASTMAN;
        }
#ifdef CTF
        else if ( ( idStr::Icmp( serverInfo.GetString( "si_gameType" ), "CTF" ) == 0 ) ) {
                gameType = GAME_CTF;
        }
#endif
    
        if ( gameType == GAME_LASTMAN ) {
                if ( !serverInfo.GetInt( "si_warmup" ) ) {
                        common->Warning( "Last Man Standing - forcing warmup on" );
                        serverInfo.SetInt( "si_warmup", 1 );
                }
                if ( serverInfo.GetInt( "si_fraglimit" ) <= 0 ) {
                        common->Warning( "Last Man Standing - setting fraglimit 1" );
                        serverInfo.SetInt( "si_fraglimit", 1 );
                }
        }
}


/*
================
idGameLocal::SetGlobalMaterial
================
*/
void idGameLocal::SetGlobalMaterial( const idMaterial *mat ) {
        globalMaterial = mat;
}

/*
================
idGameLocal::GetGlobalMaterial
================
*/
const idMaterial *idGameLocal::GetGlobalMaterial() {
        return globalMaterial;
}

/*
================
idGameLocal::GetSpawnId
================
*/
int idGameLocal::GetSpawnId( const idEntity* ent ) const {
        return ( gameLocal.spawnIds[ ent->entityNumber ] << GENTITYNUM_BITS ) | ent->entityNumber;
}

/*
================
idGameLocal::ThrottleUserInfo
================
*/
void idGameLocal::ThrottleUserInfo( void ) {
        mpGame.ThrottleUserInfo();
}

#ifdef _D3XP
/*
=================
idPlayer::SetPortalSkyEnt
=================
*/
void idGameLocal::SetPortalSkyEnt( idEntity *ent ) {
        portalSkyEnt = ent;
}

/*
=================
idPlayer::IsPortalSkyAcive
=================
*/
bool idGameLocal::IsPortalSkyAcive() {
        return portalSkyActive;
}

/*
===========
idGameLocal::SelectTimeGroup
============
*/
void idGameLocal::SelectTimeGroup( int timeGroup ) {
        int i = 0;

        if ( timeGroup ) {
                fast.Get( time, previousTime, msec, framenum, realClientTime );
        } else {
                slow.Get( time, previousTime, msec, framenum, realClientTime );
        }
}

/*
===========
idGameLocal::GetTimeGroupTime
============
*/
int idGameLocal::GetTimeGroupTime( int timeGroup ) {
        if ( timeGroup ) {
                return fast.time;
        } else {
                return slow.time;
        }
}

/*
===============
idGameLocal::GetBestGameType
===============
*/
void idGameLocal::GetBestGameType( const char* map, const char* gametype, char buf[ MAX_STRING_CHARS ] ) {
        idStr aux = mpGame.GetBestGametype( map, gametype );
        strncpy( buf, aux.c_str(), MAX_STRING_CHARS );
        buf[ MAX_STRING_CHARS - 1 ] = '\0';
}

/*
===========
idGameLocal::ComputeSlowMsec
============
*/
void idGameLocal::ComputeSlowMsec() {
        idPlayer *player;
        bool powerupOn;
        float delta;

        // check if we need to do a quick reset
        if ( quickSlowmoReset ) {
                quickSlowmoReset = false;

                // stop the sounds
                if ( gameSoundWorld ) {
                        gameSoundWorld->SetSlowmo( false );
                        gameSoundWorld->SetSlowmoSpeed( 1 );
                }

                // stop the state
                slowmoState = SLOWMO_STATE_OFF;
                slowmoMsec = USERCMD_MSEC;
        }

        // check the player state
        player = GetLocalPlayer();
        powerupOn = false;

        if ( player && player->PowerUpActive( HELLTIME ) ) {
                powerupOn = true;
        }
        else if ( g_enableSlowmo.GetBool() ) {
                powerupOn = true;
        }

        // determine proper slowmo state
        if ( powerupOn && slowmoState == SLOWMO_STATE_OFF ) {
                slowmoState = SLOWMO_STATE_RAMPUP;

                slowmoMsec = msec;
                if ( gameSoundWorld ) {
                        gameSoundWorld->SetSlowmo( true );
                        gameSoundWorld->SetSlowmoSpeed( slowmoMsec / (float)USERCMD_MSEC );
                }
        }
        else if ( !powerupOn && slowmoState == SLOWMO_STATE_ON ) {
                slowmoState = SLOWMO_STATE_RAMPDOWN;

                // play the stop sound
                if ( player ) {
                        player->PlayHelltimeStopSound();
                }
        }

        // do any necessary ramping
        if ( slowmoState == SLOWMO_STATE_RAMPUP ) {
                delta = 4 - slowmoMsec;

                if ( fabs( delta ) < g_slowmoStepRate.GetFloat() ) {
                        slowmoMsec = 4;
                        slowmoState = SLOWMO_STATE_ON;
                }
                else {
                        slowmoMsec += delta * g_slowmoStepRate.GetFloat();
                }

                if ( gameSoundWorld ) {
                        gameSoundWorld->SetSlowmoSpeed( slowmoMsec / (float)USERCMD_MSEC );
                }
        }
        else if ( slowmoState == SLOWMO_STATE_RAMPDOWN ) {
                delta = 16 - slowmoMsec;

                if ( fabs( delta ) < g_slowmoStepRate.GetFloat() ) {
                        slowmoMsec = 16;
                        slowmoState = SLOWMO_STATE_OFF;
                        if ( gameSoundWorld ) {
                                gameSoundWorld->SetSlowmo( false );
                        }
                }
                else {
                        slowmoMsec += delta * g_slowmoStepRate.GetFloat();
                }

                if ( gameSoundWorld ) {
                        gameSoundWorld->SetSlowmoSpeed( slowmoMsec / (float)USERCMD_MSEC );
                }
        }
}

/*
===========
idGameLocal::ResetSlowTimeVars
============
*/
void idGameLocal::ResetSlowTimeVars() {
        msec                            = USERCMD_MSEC;
        slowmoMsec                      = USERCMD_MSEC;
        slowmoState                     = SLOWMO_STATE_OFF;

        fast.framenum           = 0;
        fast.previousTime       = 0;
        fast.time                       = 0;
        fast.msec                       = USERCMD_MSEC;

        slow.framenum           = 0;
        slow.previousTime       = 0;
        slow.time                       = 0;
        slow.msec                       = USERCMD_MSEC;
}

/*
===========
idGameLocal::QuickSlowmoReset
============
*/
void idGameLocal::QuickSlowmoReset() {
        quickSlowmoReset = true;
}

/*
===============
idGameLocal::NeedRestart
===============
*/
bool idGameLocal::NeedRestart() {
        
        idDict          newInfo;
        const idKeyValue *keyval, *keyval2;

        newInfo = *cvarSystem->MoveCVarsToDict( CVAR_SERVERINFO );
        
        for ( int i = 0; i < newInfo.GetNumKeyVals(); i++ ) {
                keyval = newInfo.GetKeyVal( i );
                keyval2 = serverInfo.FindKey( keyval->GetKey() );
                if ( !keyval2 ) {
                        return true;
                }
                // a select set of si_ changes will cause a full restart of the server
                if ( keyval->GetValue().Cmp( keyval2->GetValue() ) && ( !keyval->GetKey().Cmp( "si_pure" ) || !keyval->GetKey().Cmp( "si_map" ) ) ) {
                        return true;
                }
        }
        return false;
}

#endif

/*
================
idGameLocal::GetClientStats
================
*/
void idGameLocal::GetClientStats( int clientNum, char *data, const int len ) {
        mpGame.PlayerStats( clientNum, data, len );
}


/*
================
idGameLocal::SwitchTeam
================
*/
void idGameLocal::SwitchTeam( int clientNum, int team ) {

        idPlayer *   player;
        player = static_cast< idPlayer * >( entities[ clientNum ] );
        int oldTeam = player->team ;

        // Put in spectator mode
        if ( team == -1 ) {
                static_cast< idPlayer * >( entities[ clientNum ] )->Spectate( true );
        }
        // Switch to a team
        else {
                mpGame.SwitchToTeam ( clientNum, oldTeam, team );
        }
        player->forceRespawn = true ;
}

/*
===============
idGameLocal::GetMapLoadingGUI
===============
*/
void idGameLocal::GetMapLoadingGUI( char gui[ MAX_STRING_CHARS ] ) { }