// Copyright (C) 2007 Id Software, Inc.
//

#ifndef __GAME_LOCAL_H__
#define	__GAME_LOCAL_H__

void gameError( const char *fmt, ... );

#include "physics/Clip.h"
#include "physics/ClipModel.h"
#include "physics/TraceModelCache.h"
#include "physics/Push.h"
#include "Game.h"
#include "Game_network.h"
#include "Pvs.h"
#include "roles/RoleManager.h" // Gordon: FIXME: get rid of this
#include "Entity.h"
#include "PlayerProperties.h"
#include "LimboProperties.h"
#include "UpdateManager.h"
#include "rules/GUIDState.h"
#include "decls/HeightMap.h"
#include "physics/PhysicsEvent.h"
#include "proficiency/ProficiencyManager.h"
#include "PlayerView.h"
#include "AORManager.h"
#include "proficiency/StatsTracker.h"

#ifndef _XENON
#include "sdnet/SDNetManager.h"
#endif //_XENON

// Gordon: FIXME: Remove these
#include "anim/Anim.h"

#include "decls/GameDeclInfo.h"

#include "decls/DeclAmmoType.h"
#include "decls/DeclCampaign.h"
#include "decls/DeclDamage.h"
#include "decls/DeclDamageFilter.h"
#include "decls/DeclDeployableObject.h"
#include "decls/DeclDeployableZone.h"
#include "decls/DeclInvItem.h"
#include "decls/DeclInvItemType.h"
#include "decls/DeclInvSlot.h"
#include "decls/DeclItemPackage.h"
#include "decls/DeclMapInfo.h"
#include "decls/DeclProficiencyItem.h"
#include "decls/DeclProficiencyType.h"
#include "decls/DeclQuickChat.h"
#include "decls/DeclRank.h"
#include "decls/DeclStringMap.h"
#include "decls/DeclTargetInfo.h"
#include "decls/DeclToolTip.h"
#include "decls/declVehicleScript.h"
#include "decls/DeclPlayerClass.h"
#include "decls/DeclGUI.h"
#include "decls/DeclGUITheme.h"
#include "decls/DeclPlayerTask.h"
#include "decls/DeclRequirement.h"
#include "decls/DeclVehiclePath.h"
#include "decls/DeclKeyBinding.h"
#include "decls/DeclRadialMenu.h"
#include "decls/DeclAOR.h"
#include "decls/DeclRating.h"
#include "decls/DeclHeightMap.h"
#include "decls/DeclDeployMask.h"

#include "../decllib/declAF.h"
#include "../decllib/declAtmosphere.h"
#include "../decllib/declEntityDef.h"
#include "../decllib/declSkin.h"
#include "../decllib/declTable.h"
#include "../decllib/declStuffType.h"
#include "../decllib/declDecal.h"
#include "../decllib/declLocStr.h"

#include "gamesys/Pvs.h"

// Gordon: For oob access prevention
template< typename T, const int MAX >
class sdSafeArray {
public:
	ID_INLINE T& operator[] ( int index ) {
		assert( index >= 0 && index < MAX );
		return data[ index ];
	}

	ID_INLINE const T& operator[] ( int index ) const {
		assert( index >= 0 && index < MAX );
		return data[ index ];
	}

	ID_INLINE void Memset( int value ) {
		memset( data, value, sizeof( data ) );
	}

private:
	T		data[ MAX ];
};

class sdLoggedTrace : public idClass {
public:
	CLASS_PROTOTYPE( sdLoggedTrace );

							sdLoggedTrace( void );
							~sdLoggedTrace( void );

	void					Init( int index, const trace_t& _trace );
	idScriptObject*			GetScriptObject( void ) { return object; }
	const trace_t*			GetTrace( void ) const { return &trace; }
	int						GetIndex( void ) const { return index; }

	void					Event_GetTraceFraction( void );
	void					Event_GetTraceEndPos( void );
	void					Event_GetTracePoint( void );
	void					Event_GetTraceNormal( void );
	void					Event_GetTraceEntity( void );
	void					Event_GetTraceSurfaceFlags( void );
	void					Event_GetTraceSurfaceType( void );
	void					Event_GetTraceSurfaceColor( void );
	void					Event_GetTraceJoint( void );
	void					Event_GetTraceBody( void );

private:
	idScriptObject*			object;
	trace_t					trace;
	int						index;
};

class sdUIScopeParser {
public:
				sdUIScopeParser( const char* text );

	bool		IsLastEntry( void ) const { return entryIndex == entries.Num(); }
	const char* GetNextEntry( void ) { if ( entryIndex < entries.Num() ) { return entries[ entryIndex++ ]; } return NULL; }
	void		Revert( void ) { entryIndex--; assert( entryIndex >= 0 ); }

private:
	char							entryText[ 256 ];
	idStaticList< const char*, 32 > entries;
	int								entryIndex;
};

struct userInfo_t {
	void					ToDict( idDict& info ) const;
	void					FromDict( const idDict& info );

	idStr					name;
	idStr					baseName;
	idStr					rawName;
	idStr					cleanName;
	idWStr					wideName;
	bool					showGun;
	bool					ignoreExplosiveWeapons;
	bool					autoSwitchEmptyWeapons;
	bool					postArmFindBestWeapon;
	bool					advancedFlightControls;
	bool					rememberCameraMode;
	bool					drivingCameraFreelook;
	bool					isBot;
	bool					voipReceiveGlobal;
	bool					voipReceiveTeam;
	bool					voipReceiveFireTeam;
	bool					showComplaints;
	bool					swapFlightYawAndRoll;
};

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

	Local implementation of the public game interface.

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

const int LAGO_IMG_WIDTH	= 64;
const int LAGO_IMG_HEIGHT	= 64;
const int LAGO_WIDTH		= 64;
const int LAGO_HEIGHT		= 44;
#define LAGO_MATERIAL		"textures/sfx/lagometer"
#define LAGO_IMAGE			"textures/sfx/lagometer.tga"

const int MAX_BATTLESENSE_RANKS = 5;

// if set to 1 the server sends the client PVS with snapshots and the client compares against what it sees
#ifndef ASYNC_WRITE_PVS
	#define ASYNC_WRITE_PVS 0
#endif

// the "gameversion" client command will print this plus compile date
#define	GAME_VERSION		"baseETQW-1"

const int NUM_RENDER_PORTAL_BITS	= idMath::BitsForInteger( PS_BLOCK_ALL );

const unsigned short DOF_VIEWWEAPON_VIEW_ID	= 0xFFFD;

// classes used by idGameLocal
class idPlayerStart;
class idEntity;
class idActor;
class idPlayer;
class idCamera;
class idWorldspawn;
class idTestModel;
class idTypeInfo;
class idEditEntities;
class idRenderWorld;
class idSoundWorld;
class sdGameRules;
class sdDeclMapInfo;
class sdDeclDamage;
class sdTeamInfo;
class idGameLocal;
class sdVehiclePathGrid;
class sdDeployMask;
class sdDeployRequest;
class sdDeployZone;
class sdProgram;
class sdKeyCommand;
class sdBindContext;
class sdPlayerStatEntry;

extern idRenderWorld*				gameRenderWorld;
extern idSoundWorld*				gameSoundWorld;

#ifdef _XENON
class LiveManager;					//Forward Declarations to prevent rebuild all
class LiveService;					//downside is anyone who used it must include the header.
extern LiveService*					liveService;
extern LiveManager*					liveManager;
#endif

extern idCVar						com_timescale;
extern idCVar						com_timeServer;

extern idCVar						g_debugPlayerList;
extern idCVar						g_skipLocalizedPrecipitation;


//============================================================================

class sdPlayZone {
public:
	enum playZoneFlags_t {
		PZF_COMMANDMAP		= BITT< 0 >::VALUE,
		PZF_PLAYZONE		= BITT< 1 >::VALUE,
		PZF_DEPLOYMENT		= BITT< 2 >::VALUE,
		PZF_PATH			= BITT< 3 >::VALUE,
		PZF_HEIGHTMAP		= BITT< 4 >::VALUE,
		PZF_VEHICLEROUTE	= BITT< 5 >::VALUE,
		PZF_WORLD			= BITT< 6 >::VALUE,
		PZF_CHOOSABLE		= BITT< 7 >::VALUE,
	};

							sdPlayZone( const idDict& info, const idBounds& bounds );
							~sdPlayZone( void );

	const idVec2&			GetSize( void ) const { return _size; }
	const sdBounds2D&		GetBounds( void ) const { return _bounds; }
	int						GetFlags( void ) const { return _flags; }
	const sdDeployMaskInstance*	GetMask( qhandle_t handle ) const;
	int						GetPriority( void ) const { return _priority; }
	const char*				GetTarget( void ) const { return _target; }
	sdVehiclePathGrid*		GetPath( const char* name ) const;
	const sdHeightMapInstance&	GetHeightMap( void ) const { return _heightMap; }

	void					SaveMasks( void );

	const idMaterial*		GetCommandMapMaterial( void ) const { return _commandmapMaterial; }

	const sdDeclLocStr*		GetTitle( void ) const { return _title; }

private:
	sdBounds2D				_bounds;
	idVec2					_size;
	idList< sdDeployMaskInstance >	_masks;
	int						_flags;
	int						_priority;
	idStr					_target;
	const idMaterial*		_commandmapMaterial;
	sdHeightMapInstance		_heightMap;
	const sdDeclLocStr*		_title;

	typedef sdPair< idStr, sdVehiclePathGrid* > playzonePath_t;
	idList< playzonePath_t >	_paths;
};

/*
============
serverInfo_t
============
*/
struct serverInfo_t {
	int						timeLimit;
	bool					adminStart;
	bool					votingDisabled;
	bool					noProficiency;
	int						minPlayers;
	float					readyPercent;
	bool					gameReviewReadyWait;
};


/*
============
gameDecalInfo_t
============
*/
struct gameDecalInfo_t {
	qhandle_t				renderEntityHandle;
	renderEntity_t			renderEntity;
};

enum radiusPushFlags_t {
	RP_GROUNDONLY = BITT< 0 >::VALUE,
};

/*
============
sdSpawnPoint
============
*/
class sdSpawnPoint {
public:
									sdSpawnPoint( void ) { _lastUsedTime = 0; _relativePosition = true; _parachute = false; _inUse = false; }

	void							Clear( void );

	idEntity*						GetOwner( void ) const;
	const sdRequirementContainer&	GetRequirements( void ) const { return _requirements; }
	const idVec3&					GetOffset( void ) const { return _offset; }
	const idAngles&					GetAngles( void ) const { return _angles; }
	bool							GetRelativePositioning( void ) const { return _relativePosition; }
	int								GetLastUsedTime( void ) const { return _lastUsedTime; }
	void							SetLastUsedTime( int lastTime ) const { _lastUsedTime = lastTime; }

	sdRequirementContainer&			GetRequirements( void ) { return _requirements; }
	void							SetOwner( idEntity* owner );
	void							SetPosition( const idVec3& offset, const idAngles& angles ) { _offset = offset; _angles = angles; }
	void							SetRelativePositioning( bool value ) { _relativePosition = value; }

	bool							GetParachute( void ) const { return _parachute; }
	void							SetParachute( bool parachute ) { _parachute = parachute; }

	void							SetInUse( bool inUse ) { _inUse = inUse; }
	bool							InUse( void ) const { return _inUse; }

private:
	idEntityPtr< idEntity >			_owner;

	idVec3							_offset;
	idAngles						_angles;

	sdRequirementContainer			_requirements;

	bool							_relativePosition;
	bool							_parachute;

	mutable int						_lastUsedTime;

	bool							_inUse;
};


/*
============
surfaceProperties_t
============
*/
struct surfaceProperties_t {
	surfaceProperties_t() :	friction( 1.0f ) {}
	float friction;
};

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

	sdEntityCollection

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

class sdEntityCollection {
public:
										sdEntityCollection( void ) { }
										~sdEntityCollection( void ) { }

	void								SetName( const char* _name ) { name = _name; }

	void								Add( idEntity* entity ) { mask.Set( entity->entityNumber ); list.Alloc() = entity; }
	void								Remove( idEntity* entity );
	int									Num( void ) const { return list.Num(); }
	idEntity*							operator[]( int index ) const { return list[ index ]; }
	const char*							GetName( void ) const { return name; }
	bool								Contains( idEntity* entity ) const { return Contains( entity->entityNumber ); }
	bool								Contains( int entityNumber ) const { return mask[ entityNumber ] != 0; }
	void								Clear( void ) { mask.Clear(); list.SetNum( 0, false ); }

private:
	idStr								name;
	sdBitField< MAX_GENTITIES >			mask;
	idList< idEntityPtr< idEntity > >	list;
};


/*
============
sdEntityNetEvent
============
*/
class sdEntityNetEvent {
public:
	typedef idLinkList< sdEntityNetEvent > nodeType_t;

	static const size_t		MAX_EVENT_PARAM_SIZE = 128;

							sdEntityNetEvent( void );

	void					Create( const idEntity* _entity, int _event, bool _saveEvent, const idBitMsg* _msg );
	void					Create( const sdEntityNetEvent& other );

	void					Read( const idBitMsg& msg );
	void					Write( idBitMsg& msg ) const;
	void					OutputParms( idBitMsg& msg ) const;

	void					Write( idFile* file ) const;
	void					Read( idFile* file );

	int						GetEntityNumber( void ) const { return ( spawnId & ( ( 1 << GENTITYNUM_BITS ) - 1 ) ); }
	int						GetId( void ) const { return spawnId >> GENTITYNUM_BITS; }
	int						GetSpawnId( void ) const { return spawnId; }
	int						GetEvent( void ) const { return event; }
	int						GetTime( void ) const { return time; }
	int						GetParamsSize( void ) const { return paramsSize; }
	const byte*				GetParams( void ) const { return paramsBuf; }

	bool					ShouldSaveEvent( void ) const { return saveEvent; }

	int						GetTotalSize( void ) const;

	nodeType_t&				GetNode( void ) { return node; }
	const nodeType_t&		GetNode( void ) const { return node; }

private:
	int						spawnId;
	int						event;
	int						time;
	bool					saveEvent;
	int						paramsSize;
	byte					paramsBuf[ MAX_EVENT_PARAM_SIZE ];

	nodeType_t				node;
};

/*
============
sdUnreliableEntityNetEvent
============
*/
class sdUnreliableEntityNetEvent : public sdEntityNetEvent {
public:
	typedef idLinkList< sdUnreliableEntityNetEvent > unreliableNodeType_t;

									sdUnreliableEntityNetEvent( void );

	void							ClearSent( void );
	void							SetSent( int clientTo );
	bool							GetSent( int clientTo ) const;
#ifdef SD_SUPPORT_REPEATER
	void							SetRepeaterSent( int clientTo );
	bool							GetRepeaterSent( int clientTo ) const;
#endif // SD_SUPPORT_REPEATER
	bool							HasExpired( void ) const;

	unreliableNodeType_t&			GetUnreliableNode( void ) { return unreliableNode; }
	const unreliableNodeType_t&		GetUnreliableNode( void ) const { return unreliableNode; }

private:
	sdBitField< MAX_CLIENTS+1 >		sentClients;
#ifdef SD_SUPPORT_REPEATER
	sdBitField_Dynamic				sentRepeaterClients;
	int								numRepeaterClients;
#endif // SD_SUPPORT_REPEATER

	unreliableNodeType_t			unreliableNode;
};

/*
============
sdEnvDefinition
============
*/
struct sdEnvDefinition {
	idVec3 origin;
	idStr name;
	int size;
};

class sdEntityDebugInfo {
public:
	enum operation_t {
		OP_CREATE,
		OP_DESTROY,
		OP_NONE,
	};
public:
							sdEntityDebugInfo( void );

	void					OnCreate( idEntity* self );
	void					OnDestroy( idEntity* self );

	void					PrintStatus( int index );

	int						lastOperationTime;
	operation_t				lastOperation;
	idTypeInfo*				type;
	idStr					name;
};

struct savedPlayerStat_t {
	const sdDeclRank*		rank;
	const sdTeamInfo*		team;
	idStr					name;
	float					value;
	float					data[ MAX_CLIENTS ];
};

//===============================================================



//============================================================================
class sdUserInterfaceLocal;
class sdUIWindow;

const int NUM_DEPLOY_REQUESTS = MAX_CLIENTS;
const int GUI_GLOBALS_HANDLE = -999;

struct persistentRank_t {
	int						rank;
	bool					calculated;
};

struct lifeStat_t {
	idStr					stat;
	const sdDeclLocStr*		text;			// used for lists
	const sdDeclLocStr*		textLong;		// used for in-game announcements
	bool					isTimeBased;
};

struct quickChatMuteEntry_t {
	idStr					name;
};

class idGameLocal : public idGame {
public:
	idDict					serverInfo;				// all the tunable parameters, like numclients, etc
	serverInfo_t			serverInfoData;
	int						numClients;				// pulled from serverInfo and verified

	// [
	usercmd_t				usercmds[ MAX_CLIENTS ];	// client input commands
	sdDeployRequest*		deployRequests[ NUM_DEPLOY_REQUESTS ];
	bool					clientConnected[ MAX_CLIENTS ];
	persistentRank_t		clientRanks[ MAX_CLIENTS ];
	sdNetStatKeyValList		clientStatsList[ MAX_CLIENTS ];
	idHashIndex				clientStatsHash[ MAX_CLIENTS ];
	int						clientLastBanIndexReceived[ MAX_CLIENTS ];
	bool					clientStatsRequestsPending;

#if !defined( SD_DEMO_BUILD )
	sdNetTask*				clientStatsRequestTask;
	int						clientStatsRequestIndex;
#endif /* !SD_DEMO_BUILD */
	int						clientCompaintCount[ MAX_CLIENTS ];
	idList< sdNetClientId >	clientUniqueComplaints[ MAX_CLIENTS ];
	sdBitField< MAX_CLIENTS >clientMuteMask[ MAX_CLIENTS ]; // Mask of people who have muted this player

	idList< quickChatMuteEntry_t > clientQuickChatMuteList;		// List of players the local client has muted for quickchat
	// ]

	// [
	sdSafeArray< idEntity*, MAX_GENTITIES > entities;// index to entities
	int						spawnIds[ MAX_GENTITIES ];// for use in idEntityPtr
	sdEntityDebugInfo		entityDebugInfo[ MAX_GENTITIES ]; // for debugging ( mainly network ) issues
	// ]

	int						firstFreeIndex;			// first free index in the entities array
	int						numEntities;			// current number <= MAX_GENTITIES
	idHashIndex				entityHash;				// hash table to quickly find entities by name
	idWorldspawn*			world;					// world entity
	idLinkList< idEntity >	spawnedEntities;		// all spawned entities
	idLinkList< idEntity >	networkedEntities;		// all entities that want to send/receive network traffic
	idLinkList< idEntity >	nonNetworkedEntities;	// all entities that dont send/receive network traffic
	idLinkList< idEntity >	activeEntities;			// all thinking entities (idEntity::thinkFlags != 0)
	idLinkList< idEntity >	activeNetworkEntities;	// all thinking entities (idEntity::thinkFlags != 0)
	idLinkList< idEntity >	postThinkEntities;		// 
	idList< idEntityPtr< idEntity > > changedEntities;
	bool					sortPushers;			// true if active lists needs to be reordered to place pushers at the front
	bool					sortTeamMasters;		// true if active lists needs to be reordered to place physics team masters before their slaves
	bool					insideExecuteMapChange;

	idTraceModelCache		traceModelCache;

	sdLock						clientEntLock;
	class rvClientEntity*		clientEntities[ MAX_CENTITIES ];	// index to client entities
	int							clientSpawnIds[ MAX_CENTITIES ];	// for use in idClientEntityPtr
	idLinkList<rvClientEntity>	clientSpawnedEntities;			// all client side entities
	int							num_clientEntities;				// current number of client entities
	int							firstFreeClientIndex;			// first free index in the client entities array

	int							mapLoadCount;

	sdPlayerStatEntry*			totalShotsFiredStat;
	sdPlayerStatEntry*			totalShotsHitStat;

	sdPhysicsEvent::nodeType_t	physicsEvents;

	idPlayerView				playerView;			// handles damage kicks and effects

	idRandom				random;					// random number generator used throughout the game

	sdProgram*				program;				// currently loaded script and data space
	sdProgramThread*	frameCommandThread;

	idClip					clip;					// collision detection
	idPush					push;					// geometric pushing
	idPVS					pvs;					// potential visible set
	
	sdAORManagerLocal		aorManager;

	sdPersistentRankInfo					rankInfo;
	sdPersistentRankInfo::sdRankInstance	rankScratchInfo;

	idTestModel *			testmodel;				// for development testing of models

	sdGameRules*			rules;
	const sdDeclMapInfo*	mapInfo;
	const idDict*			mapMetaData;
	const idDict			defaultMetaData;
	const sdDeclStringMap*	mapSkinPool;
	qhandle_t				playzoneMask;

	const sdDeclProficiencyItem* battleSenseBonus[ MAX_BATTLESENSE_RANKS ];

	idEditEntities *		editEntities;			// in game editing

	typedef struct targetTimer_s {
		idStr				name;
		int					endTimes[ MAX_CLIENTS ];
		int					serverHandle;
	} targetTimer_t;

	idList< targetTimer_t>	targetTimers;
	idList< int >			targetTimerLookup;
	int						numServerTimers;

	idList< savedPlayerStat_t > endGameStats;
	idList< lifeStat_t >		lifeStats;

	int						framenum;
	int						startTime;
	int						previousTime;			// time in msec of last frame
	int						time;					// in msec
	int						timeOffset;				// 
	int						msec;					// time since last update in milliseconds
	int						localViewChangedTime;	// time that the local player view changed
	int						playerSpawnTime;		// time at which players are allowed to spawn again

	int						nextTeamBalanceCheckTime;

	bool					isServer;				// set if the game is run for a dedicated or listen server
	bool					isClient;				// set if the game is run for a client
	bool					isRepeater;
	bool					serverIsRepeater;
	bool					snapShotClientIsRepeater;
	mutable int				repeaterClientFollowIndex;

	bool					isPaused;
	bool					pauseViewInited;
	idVec3					pauseViewOrg;
	idAngles				pauseViewAngles;
	idAngles				pauseViewAnglesBase;
	int						pauseStartGuiTime;

													// discriminates between the RunFrame path and the ClientPrediction path
													// NOTE: on a listen server, isClient is false
	int						localClientNum;			// number of the local client. MP: -1 on a dedicated
	idLinkList<idEntity>	snapshotEntities;		// entities from the last snapshot
	idLinkList<idEntity>	snapshotVisbileEntities;// entities from the last snapshot that are actually visible
	int						realClientTime;			// real client time
	bool					isNewFrame;				// true if this is a new game frame, not a rerun due to prediction
	bool					predictionUpdateRequired;

	float					flightCeilingLower;
	float					flightCeilingUpper;


	idHashIndex						entityCollectionsHash;
	idList< sdEntityCollection* >	entityCollections;

	sdGUIDFile						guidFile;

	sdPlayerProperties		localPlayerProperties;
	sdGlobalProperties		globalProperties;
	sdLimboProperties		limboProperties;
	sdUpdateManager			updateManager;

	idFile*					proficiencyLog;
	idFile*					networkLog;
	idFile*					objectiveLog;

	float					globalShaderParms[ MAX_GLOBAL_SHADER_PARMS ];

	sdBindContext*			defaultBindContext;

	// fps unlock
	idCVar					*com_unlockFPS;			// shortcut to the core cvar
	idLinkList<idEntity>	interpolateEntities;	// entities marked for interpolation

	struct idUnlock {
		bool					canUnlockFrames;		// tracks when extra view and angles updates are allowed
		bool					unlockedDraw;			// differenciate between doing draws for unlocked frames and regular draws
		idVec3					originlog[2];			// log last two origins
		idAngles				minAngles;
		idAngles				maxAngles;
		idAngles				refAngles;
		int						lastFullDrawFrame;
		bool					doWeapon;
		idVec3					viewOrigin;
		idVec3					weaponOrigin;
		idMat3					weaponAxis;
		idVec3					weaponGUIOrigin;
		idMat3					weaponGUIAxis;
	} unlock;

	// ---------------------- Public idGame Interface -------------------

							idGameLocal();

	const idList< guiScope_t >& GetUIScopes() const { return uiScopes; }

	sdEntityCollection*		GetEntityCollection( const char* name, bool allowCreate = false );
	qhandle_t				GetPlayZoneMask( void ) const { return playzoneMask; }

	void					LoadScript( void );

	void					OnPreMapStart( void );
	void					OnNewMapLoad( const char* mapName );
	void					OnMapStart( void );

	static void				CleanName( idStr& name );

	bool					IsMultiPlayer( void );
	bool					IsMetaDataValidForPlay( const metaDataContext_t& context, bool checkBrowserStatus );

	virtual void			Init( void );
	virtual void			Shutdown( void );
	virtual void			UserInfoChanged( int clientNum );
	virtual bool			ValidateUserInfo( int clientNum, idDict& _userInfo );
	virtual void			SetServerInfo( const idDict &serverInfo );
	void					ParseServerInfo( void );

	void					LoadLifeStatsData( void );

	void					PushChangedEntity( idEntity* ent );

	sdDeployZone*			TerritoryForPoint( const idVec3& point, sdTeamInfo* team = NULL, bool requireTeam = false, bool requireActive = false ) const;

	void					MakeRules( void );
	idTypeInfo*				GetRulesType( bool errorOnFail );

	void					ChangeLocalSpectateClient( int spectateeNum );
	int						GetRepeaterFollowClientIndex( void ) const;

#ifdef SD_SUPPORT_REPEATER
	virtual void			RepeaterClientDisconnect( int clientNum );
	virtual void			RepeaterWriteInitialReliableMessages( int clientNum );
	virtual void			RepeaterWriteSnapshot( int clientNum, int sequence, idBitMsg &msg, idBitMsg &ucmdmsg, const repeaterUserOrigin_t& userOrigin, bool clientIsRepeater );
	virtual allowReply_t	RepeaterAllowClient( int numViewers, int maxViewers, const clientNetworkAddress_t& address, const sdNetClientId& netClientId, const char *guid, const char *password, allowFailureReason_t& reason, bool isRepeater );
	virtual void			RepeaterClientBegin( int clientNum );
	virtual void			SetRepeaterState( bool isRepeater );
	virtual bool			RepeaterApplySnapshot( int clientNum, int sequence );
	virtual void			RepeaterProcessReliableMessage( int clientNum, const idBitMsg &msg );
	void					BuildRepeaterInfo( idDict &repeaterInfo );
	void					UpdateRepeaterInfo( void );
	int						GetNumRepeaterClients( void ) const;
	bool					IsRepeaterClientConnected( int clientNum ) const;
	void					ShutdownRepeatersNetworkStates( void );
	void					ShutdownRepeatersNetworkState( int clientNum );
#endif // SD_SUPPORT_REPEATER

	virtual void			InitFromNewMap( const char *mapName, idRenderWorld *renderWorld, idSoundWorld *soundWorld, bool isServer, bool isClient, int randSeed, int startTime, bool isUserChange );
	virtual void			MapShutdown( void );
	void					CacheDictionaryMedia_r( const idTypeInfo* cls, const idDict& dict );
	virtual void			CacheDictionaryMedia( const idDict& dict );
	void					DumpOggSounds();
	void					GetShakeSounds( const idDict& dict );
	virtual void			FinishBuild( void );
	virtual void			SpawnPlayer( int clientNum, bool isBot );
	virtual void			RunFrame( const usercmd_t* clientCmds, int elapsedTime );
	virtual bool			Draw();
	virtual bool			Draw2D();

	bool					IsPaused( void );
	void					SetPaused( bool value );
	void					OnPausedChanged( void );
	void					SendPauseInfo( const sdReliableMessageClientInfoBase& info );
	int						ToGuiTime( int time ) { return time + timeOffset; }
	void					GetPausedView( idVec3& origin, idMat3& axis );
	void					UpdatePauseNoClip( usercmd_t& cmd );

	void					SetActionCommand( const char* action );

	sdBindContext*			GetDefaultBindContext( void ) { return defaultBindContext; }

	idPlayer*				GetActiveViewer( void ) const;

	virtual void			OnServerShutdown( void );
	virtual allowReply_t	ServerAllowClient( int numClients, int numBots, const clientNetworkAddress_t& address, const sdNetClientId& netClientId, const char *guid, const char *password, allowFailureReason_t& reason );

	void					HandleGuiScriptMessage( idPlayer* player, idEntity* entity, const char* message );
	void					HandleNetworkMessage( idPlayer* player, idEntity* entity, const char* message );
	void					HandleNetworkEvent( idEntity* entity, const char* message );

	virtual void			PacifierUpdate();

	sdNetworkStateObject&	GetGameStateObject( extNetworkStateMode_t mode );
	void					WriteGameState( extNetworkStateMode_t mode, snapshot_t* snapshot, clientNetworkInfo_t& info, idBitMsg& msg );
	void					ReadGameState( extNetworkStateMode_t mode, snapshot_t* snapshot, const idBitMsg& msg );
	void					ResetGameState( extNetworkStateMode_t mode );

	void					ParseClamp( angleClamp_t& clamp, const char* prefix, const idDict& dict );
	
	void					FreeGameState( sdGameState* state );
	void					FreeNetworkState( sdEntityState* state );
	void					CreateNetworkState( int entityNum );
	void					CreateNetworkState( clientNetworkInfo_t& networkInfo, int entityNum );
	void					FreeNetworkState( clientNetworkInfo_t& networkInfo, int entityNum );
	void					FreeNetworkState( int entityNum );
	void					ClientSpawn( int entityNum, int spawnId, int typeNum, int entityDefNumber, int mapSpawnId );
	void					OnEntityCreateMessage( const idBitMsg& msg );

	snapshot_t*				AllocateSnapshot( int sequence, clientNetworkInfo_t& nwInfo );
	void					WriteSnapshotGameStates( snapshot_t* snapshot, clientNetworkInfo_t& nwInfo, idBitMsg& msg );
	void					WriteSnapshotEntityStates( snapshot_t* snapshot, clientNetworkInfo_t& nwInfo, int clientNum, idBitMsg& msg, bool useAOR );
	void					WriteSnapshotUserCmds( snapshot_t* snapshot, idBitMsg& msg, int ignoreClientNum, bool useAOR );
	void					WriteInitialReliableMessages( const sdReliableMessageClientInfoBase& target );
	void					HandleNewEntityEvent( const idBitMsg &msg );

	virtual void			ServerClientConnect( int clientNum );
	virtual void			ServerClientBegin( int clientNum, bool isBot );
	virtual void			SetClientNum( int clientNum, bool server );
	virtual void			ServerClientDisconnect( int clientNum );
	virtual void			ServerWriteInitialReliableMessages( int clientNum );
	virtual void			ServerWriteSnapshot( int clientNum, int sequence, idBitMsg &msg, idBitMsg &ucmdmsg );
	virtual bool			ServerApplySnapshot( int clientNum, int sequence );
	virtual void			ServerProcessReliableMessage( int clientNum, const idBitMsg &msg );
	void					EnsureAlloced( int entityNum, idEntity* ent, const char* oldState, const char* currentState );
	void					ClientWriteGameState( idFile* file );
	void					ClientReadGameState( idFile* file );
	bool					SetupClientAoR( void );
	virtual bool			ClientReadSnapshot( int sequence, const int gameFrame, const int gameTime, const int numDuplicatedUsercmds, const int aheadOfServer, const idBitMsg &msg, const idBitMsg &ucmdmsg );
	virtual bool			ClientApplySnapshot( int sequence );
	virtual void			ClientProcessReliableMessage( const idBitMsg &msg );
	virtual void			ClientPrediction( const usercmd_t* clientCmds, const usercmd_t* demoCmd );
	virtual void			OnSnapshotHitch( int snapshotTime );
	virtual void			OnClientDisconnected( void );
	virtual void			ClientUpdateView( const usercmd_t &cmd, int timeLeft );
	virtual void			WriteClientNetworkInfo( idFile* file );
	virtual void			ReadClientNetworkInfo( idFile* file );
	virtual void			WriteUserInfo( idBitMsg& msg, const idDict& info );
	virtual void			ReadUserInfo( const idBitMsg& msg, idDict& info );

	virtual void			CreateStatusResponseDict( const idDict& serverInfo, idDict& statusResponseDict );
	virtual int				GetProbeTime() const;
	virtual byte			GetProbeState() const;
	virtual void			WriteExtendedProbeData( idBitMsg& msg );

	void					LogComplaint( idPlayer* player, idPlayer* attacker );
	bool					DoSkyCheck( const idVec3& location ) const;
	
	virtual bool			HandleGuiEvent( const sdSysEvent* event );
	virtual bool			TranslateGuiBind( const idKey& key, sdKeyCommand** cmd );

	virtual void			ShowMainMenu();
	virtual void			HideMainMenu();
	virtual bool			IsMainMenuActive();
	virtual void			DrawMainMenu();
	virtual void			DrawLoadScreen();
	virtual void			DrawPureWaitScreen();
	virtual void			DrawSystemUI();
	virtual void			GuiFrameEvents( bool outOfSequence );

	virtual void			AddChatLine( const wchar_t* text );

	virtual userMapChangeResult_e OnUserStartMap( const char* text, idStr& reason, idStr& mapName );
	virtual void			ArgCompletion_StartGame( const idCmdArgs& args, argCompletionCallback_t callback );

	virtual void			RunFrame();

	virtual bool			DownloadRequest( const char *IP, const char *guid, const char *paks, char urls[ MAX_STRING_CHARS ] );
	virtual bool			HTTPRequest( const char *IP, const char *file, bool isGamePak );

#ifdef ID_DEBUG_MEMORY
	virtual void			MemDump( const char* fileName ) { Mem_Dump( fileName ); }
	virtual void			MemDumpCompressed( const char *fileName, memoryGroupType_t memGroup, memorySortType_t memSort, int sortCallStack, int numFrames, bool xlFriendly ) { Mem_DumpCompressed( fileName, memGroup, memSort, sortCallStack, numFrames, xlFriendly ); }
	virtual void			MemDumpPerClass( const char* fileName ) { Mem_DumpPerClass( fileName ); }
#endif

	virtual void				OnInputInit( void );
	virtual void				OnInputShutdown( void );

	virtual void				OnLanguageInit( void );
	virtual void				OnLanguageShutdown( void );

	virtual sdKeyCommand*		Translate( const idKey& key );
	virtual usercmdbuttonType_t	SetupBinding( const char* binding, int& action );
	virtual void				HandleLocalImpulse( int action, bool down );

	virtual int					GetBotFPS( void ) const;
	virtual botDebugInfo_t		GetBotDebugInfo( int clientNum );
	virtual bool				GetRandomBotName( int clientNum, idStr& botName );

	const char*					GetCookieString( const char* value );
	int							GetCookieInt( const char* value );

	void						SetCookieString( const char* key, const char* value );
	void						SetCookieInt( const char* key, int value );

	sdProficiencyTable&			GetProficiencyTable( int entityNumber ) { return proficiencyTables[ entityNumber ]; }
	const sdProficiencyTable&	GetProficiencyTable( int entityNumber ) const { return proficiencyTables[ entityNumber ]; }

	int						ClassCount( const sdDeclPlayerClass* pc, idPlayer* skip, sdTeamInfo* team );

	void					SetTargetTimer( qhandle_t timerHandle, idPlayer* player, int t );
	qhandle_t				AllocTargetTimer( const char* targetName );
	qhandle_t				GetTargetTimerForServerHandle( qhandle_t timerHandle );
	const char*				GetTargetTimerName( qhandle_t timerHandle ) { return targetTimers[ timerHandle ].name; }
	int						GetTargetTimerValue( qhandle_t timerHandle, idPlayer* player );
	void					ClearTargetTimers();

	void					StartRecordingDemo( void );
	void					GetDemoName( idStr& output );

	sdDeployRequest*		GetDeploymentRequest( idPlayer* player );
	bool					RequestDeployment( idPlayer* player, const sdDeclDeployableObject* object, const idVec3& position, float rotation, int delayMS );
	void					UpdateDeploymentRequests( void );
	void					ClearDeployRequests( void );
	void					ClearDeployRequest( int deployIndex );
	deployResult_t			CheckDeploymentRequestBlock( const idBounds& bounds );

	bool					IsDeveloper( void ) const { return cvarSystem->GetCVarBool( "developer" ); }

	virtual sdUserInterfaceManager* GetUIManager();
	
	virtual void			MessageBox( msgBoxType_t type, const wchar_t* message, const sdDeclLocStr* title );
	virtual void			CloseMessageBox();

	virtual void				SetUpdateAvailability( updateAvailability_t type );
	virtual void				SetUpdateState( updateState_t state );
	virtual void				SetUpdateFromServer( bool fromServer );
	virtual guiUpdateResponse_t	GetUpdateResponse();
	virtual void				SetUpdateProgress( float percent );
	virtual void				SetUpdateMessage( const wchar_t* text );

	virtual void			AddSystemNotification( const wchar_t* text );

	virtual void			UpdateLevelLoadScreen( const wchar_t* status );

	// RAVEN BEGIN
	// bdube: added effect calls
	const rvDeclEffect *			FindEffect( const char* name, bool makeDefault = true );
	virtual rvClientEffect*			PlayEffect			( const int effectHandle, const idVec3& color, const idVec3& origin, const idMat3& axis, bool loop = false, const idVec3& endOrigin = vec3_origin, float distanceOffset = 0.0f );
	rvClientEffect*					PlayEffect			( const idDict& args, const idVec3& color, const char* effectName, const char* materialType, const idVec3& origin, const idMat3& axis, bool loop = false, const idVec3& endOrigin = vec3_origin );
	int								GetEffectHandle		( const idDict& args, const char* effectName, const char* materialType );
	int								GetDecal			( const idDict& args, const char* decalName, const char* materialType );

	// jscott: for effects system
	virtual void					StartViewEffect( int type, float time, float scale );
	virtual void					GetPlayerView( idVec3& origin, idMat3& axis, float& fovx );
	virtual void					TracePoint( trace_t& trace, const idVec3 &source, const idVec3 &dest, int clipMask );
	virtual void					Translation( trace_t &trace, const idVec3 &source, const idVec3 &dest, const idTraceModel &trm, int clipMask );
	virtual rvClientMoveable*		SpawnClientMoveable( const char* name, int lifetime, const idVec3& origin, const idMat3& axis, const idVec3& velocity, const idVec3& angular_velocity, int effectSet = 0 );

	// RAVEN END

	void							AddCheapDecal( const idDict& decalDict, idEntity *attachTo, idVec3 &origin, idVec3 &normal, int jointIdx, int id, const char* decalName, const char* materialName );

	virtual bool					ClientsOnSameTeam( int clientNum1, int clientNum2, voiceMode_t voiceMode );
	virtual bool					AllowClientAudio( int clientNum1, voiceMode_t voiceMode );

	// Setup game rules
	void							SetRules( idTypeInfo* type );
	bool							HasMapInfo( void ) const { return mapInfo != NULL; }
	const sdDeclMapInfo&			GetMapInfo( void ) const { assert( mapInfo ); return *mapInfo; }
	const idDict&					GetMapMetaData( void ) const { assert( mapMetaData ); return *mapMetaData; }

	int								GetNumMapEntities( void ) const { return mapFile == NULL ? 0 : mapFile->GetNumEntities(); }

	virtual bool					KeyMove( char forward, char right, char up, usercmd_t& cmd );
	virtual void					ControllerMove( bool doGameCallback, const int numControllers, const int* controllerNumbers,
													const float** controllerAxis, idVec3& viewAngles, usercmd_t& cmd );
	virtual void					MouseMove( const idVec3& angleBase, idVec3& angleDelta );

	virtual bool					GetSensitivity( float& scaleX, float& scaleY );

	virtual void					UsercommandCallback( usercmd_t& cmd );

	virtual void					ShowLevelLoadScreen( const char* mapName );
	virtual void					HideLevelLoadScreen( void );

	bool							NextMap( void );
	virtual void					BeginLevelLoad();
	virtual	void					EndLevelLoad();

	void							StartAutorecording();
	void							StopAutorecording();
	void							GetScoreboardShotName( idStr& output );
	void							OnEndGameScoreboardActive();

	virtual void					DrawLCD( sdLogitechLCDSystem* lcd );

	void							MutePlayerLocal( idPlayer* player, int clientIndex );
	void							UnMutePlayerLocal( idPlayer* player, int clientIndex );
	void							MutePlayerQuickChatLocal( int clientIndex );
	void							UnMutePlayerQuickChatLocal( int clientIndex );
	bool							IsClientQuickChatMuted( idPlayer* player );

	void							OnUserNameChanged( idPlayer* player, idStr oldName, idStr newName );

	guiHandle_t						LoadUserInterface( const char* name, bool requireUnique, bool permanent, const char* theme = "default", sdHudModule* module = NULL );
	void							FreeUserInterface( guiHandle_t handle );
	sdUserInterfaceLocal*			GetUserInterface( guiHandle_t handle );
	sdUIWindow*						GetUserInterfaceWindow( const guiHandle_t handle, const char* windowName );
	sdProperties::sdProperty*		GetUserInterfaceProperty( const guiHandle_t handle, const char* propertyName, sdProperties::ePropertyType expectedType );
	sdProperties::sdProperty*		GetUserInterfaceProperty_r( const guiHandle_t handle, const char* propertyName, sdProperties::ePropertyType expectedType );
	sdUserInterfaceScope*			GetGlobalUserInterfaceScope( sdUserInterfaceScope& scope, const char* name );

	sdUserInterfaceScope*			GetUserInterfaceScope( sdUserInterfaceScope& scope, idLexer* src );
	sdUserInterfaceScope*			GetUserInterfaceScope( sdUserInterfaceScope& scope, sdUIScopeParser& src );

	void							SetGUIInt( int handle, const char* name, int value );
	void							SetGUIFloat( int handle, const char* name, float value );
	void							SetGUIVec2( int handle, const char* name, const idVec2& value );
	void							SetGUIVec3( int handle, const char* name, const idVec3& value );
	void							SetGUIVec4( int handle, const char* name, const idVec4& value );
	void							SetGUIString( int handle, const char* name, const char* value );
	void							SetGUIWString( int handle, const char* name, const wchar_t* value );
	void							SetGUITheme( guiHandle_t handle, const char* theme );
	void							GUIPostNamedEvent( int handle, const char* window, const char* name );
	float							GetGUIFloat( int handle, const char* name );

	void							ResetEntityStates( void );
	void							SetupGameStateBase( clientNetworkInfo_t& networkInfo );
	void							SetupEntityStateBase( clientNetworkInfo_t& networkInfo );

	qhandle_t						GetDeploymentMask( const char* name );

	// playzone manipulation
	void							CreatePlayZone( const idDict& info, const idBounds& bounds );
	void							SavePlayZoneMasks( void );
	void							ClearPlayZones( void );
	void							DebugDeploymentMask( qhandle_t handle );
	void							SetPlayZoneAreaName( int index, const char* name );
	void							LinkPlayZoneAreas( void );

	const sdDeclTargetInfo*			GetMDFExportTargets( void ) { return declTargetInfoType[ "target_mdfExport" ]; }

	// playzone querying
	int								GetWorldPlayZoneIndex( const idVec3& point ) const;
	const sdPlayZone*				GetPlayZone( const idVec3& point, int flags ) const;
	const sdPlayZone*				GetChoosablePlayZone( int id ) const;
	int								GetIndexForChoosablePlayZone( const sdPlayZone* zone ) const;
	int								GetNumChoosablePlayZones() const;
	const sdPlayZone*				ClosestPlayZone( const idVec3& point, float& dist, int flags ) const;

	sdSpawnPoint&					RegisterSpawnPoint( idEntity* owner, const idVec3& offset, const idAngles& angles );
	void							UnRegisterSpawnPoint( sdSpawnPoint* point );

	void							RegisterTargetEntity( idLinkList< idEntity >& node );
	void							RegisterIconEntity( idLinkList< idEntity >& node );

	sdEntityState*					AllocEntityState( networkStateMode_t mode, idEntity* ent ) const;
	sdGameState*					AllocGameState( const sdNetworkStateObject& object ) const;

	int								AllocEndGameStat( void );
	void							SetEndGameStatValue( int index, idPlayer* player, float value );
	void							SetEndGameStatWinner( int statIndex, idPlayer* player );
	void							SendEndGameStats( const sdReliableMessageClientInfoBase& target );
	void							ClearEndGameStats( void );
	void							OnEndGameStatsReceived( void );

public:
	// ---------------------- Public idGameLocal Interface -------------------

	void							Printf( const char *fmt, ... ) const;
	void							DPrintf( const char *fmt, ... ) const;
	void							Warning( const char *fmt, ... ) const;
	void							DWarning( const char *fmt, ... ) const;
	void							Error( const char *fmt, ... ) const;

	void							LoadMap( const char *mapName, int randSeed, int startTime );

	void							OnLocalMapRestart( void );
	void							LocalMapRestart( void );
	void							MapRestart( void );
	static void						MapRestart_f( const idCmdArgs &args );
	static void						NextMap_f( const idCmdArgs &args );
	static void						StartDemos_f( const idCmdArgs &args );

	idPlayer*						GetClient( int i ) const { assert( i >= 0 && i < MAX_CLIENTS ); return reinterpret_cast< idPlayer * >( entities[ i ] ); }

	idMapFile *						GetLevelMap( void );
	const char *					GetMapName( void ) const;

	bool							CheatsOk( bool requirePlayer = true );
	gameState_t						GameState( void ) const;

	template< typename T > 
	T* SpawnEntityTypeT( bool callPostMapSpawn, const idDict *args = NULL ) {
		return static_cast< T* >( SpawnEntityType( T::Type, callPostMapSpawn, args ) );
	}
	idEntity *						SpawnEntityType( const idTypeInfo &classdef, bool callPostMapSpawn, const idDict *args = NULL );
	bool							SpawnEntityDef( const idDict &args, bool callPostMapSpawn, idEntity **ent = NULL, int entityNum = -1, int mapSpawnId = -1 );
	bool							SpawnClientEntityDef( const idDict &args, rvClientEntity **ent = NULL, int mapSpawnId = -1 );

	int								GetSpawnId( const idEntity* ent ) const { return ent ? ( ( spawnIds[ ent->entityNumber ] << GENTITYNUM_BITS ) | ent->entityNumber ) : 0; }
	int								SpawnNumForSpawnId( int spawnId ) const { return spawnId >> GENTITYNUM_BITS; }
	int								EntityNumForSpawnId( int spawnId ) const { return spawnId & ( ( 1 << GENTITYNUM_BITS ) - 1 ); }
	idEntity*						EntityForSpawnId( int spawnId ) const { int entityNum = EntityNumForSpawnId( spawnId ); return ( ( spawnId >> GENTITYNUM_BITS ) == spawnIds[ entityNum ] ) ? entities[ entityNum ] : NULL; }

	void							CallSpawnFuncs( idEntity* entity, const idDict *args );
	idEntity*						CreateEntityType( const idTypeInfo &classdef );

	const idDict*					FindEntityDefDict( const char *name, bool makeDefault = false ) const;

	// RAVEN BEGIN
	void							RegisterClientEntity( rvClientEntity *cent );
	void							UnregisterClientEntity( rvClientEntity *cent );
	// RAVEN END

	float							RangeSquare( const idEntity* ent1, const idEntity* ent2 ) const	{ return ( ent1->GetPhysics()->GetOrigin() - ent2->GetPhysics()->GetOrigin() ).LengthSqr(); }

	void							ToggleGodMode( idPlayer* player ) const;
	void							ToggleNoclipMode( idPlayer* player ) const;
	void							NetworkSpawn( const char* classname, idPlayer* player );

	void							RegisterEntity( idEntity *ent );
	void							UnregisterEntity( idEntity *ent );

	void							ForceNetworkUpdate( idEntity *ent );

	void							SetCamera( idCamera *cam );
	idCamera *						GetCamera( void ) const;
	void							CalcFov( float base_fov, float &fov_x, float &fov_y, const int width = SCREEN_WIDTH, const int height = SCREEN_HEIGHT, const float correctYAspect = 0.f ) const;

	void							AddEntityToHash( const char *name, idEntity *ent );
	bool							RemoveEntityFromHash( const char *name, idEntity *ent );
	int								GetTargets( const idDict &args, idList< idEntityPtr<idEntity> > &list, const char *ref ) const;

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

	static void						ArgCompletion_EntityName( const idCmdArgs &args, void(*callback)( const char *s ) );
	idEntity*						FindTraceEntity( idVec3 start, idVec3 end, const idTypeInfo &c, const idEntity *skip ) const;
	idEntity*						FindEntity( const char *name ) const;
	idEntity*						FindEntityByType( idEntity *from, const idDeclEntityDef* type ) const;
	idEntity*						FindClassType( idEntity *from, const idTypeInfo& type, idEntity *ignore = NULL ) const;
	idEntity*						FindClassTypeReverse( idEntity *from, const idTypeInfo& type, idEntity *ignore = NULL ) const;
	idEntity*						FindClassTypeInRadius( const idVec3& org, float radius, idEntity *from, const idTypeInfo& type, idEntity *ignore = NULL ) const;


	template< typename T > T* FindClassTypeT( idEntity *from ) const;

	template< typename T > T* EntityFromRenderEntity( renderEntity_t* entity ) const {
			idEntity* other = EntityForSpawnId( entity->spawnID );
			if ( other == NULL || !other->IsType( T::Type ) ) {
				return NULL;
			}

			return static_cast< T* >( other );
	}

	int								EntitiesWithinRadius( const idVec3 org, float radius, idEntity **entityList, int maxCount ) const;
	int								EntitiesOfClass( const char *name, idList< idEntityPtr<idEntity> > &list ) const;

	void							KillBox( idEntity *ent );
	void							RadiusDamage( const idVec3 &origin, idEntity *inflictor, idEntity *attacker, idEntity *ignoreDamage, idEntity *ignorePush, const sdDeclDamage* damage, float dmgPower = 1.f, float radiusScale = 1.f );
	void							RadiusPush( const idVec3 &origin, float radius, const sdDeclDamage* damageDecl, float pushScale, const idEntity *inflictor, const idEntity *ignore, int flags, bool saveEvent );
	void							RadiusPushClipModel( const idVec3 &origin, const float push, const idClipModel *clipModel );
	void							RadiusPushEntities( const idVec3& origin, float force, float radius );

	void							ProjectDecal( const idVec3 &origin, const idVec3 &dir, float depth, bool parallel, float size, const char *material, float angle = 0 );
	void							CreateProjectedDecal( const idVec3 &origin, const idVec3 &dir, float depth, bool parallel, float width, float height, float angle, const idVec4& color, idRenderModel* model );
	void							ProjectDecal( const idVec3 &origin, const idVec3 &dir, float depth, bool parallel, float size, const idMaterial *material, float angle = 0 );

	void							CallFrameCommand( const sdProgram::sdFunction* frameCommand );
	void							CallFrameCommand( idScriptObject* object, const sdProgram::sdFunction* frameCommand );
	void							CallObjectFrameCommand( idScriptObject* object, const char *frameCommand, bool allowError );

	const idVec3&					GetGravity( void ) const;
	const idVec3&					GetWindVector( const idVec3 & origin ) const;

	// added the following to assist licensees with merge issues
	int								GetFrameNum() const { return framenum; }
	int								GetTime() const { return time; }
	int								GetMSec() const { return msec; }

	idPlayer*						GetClientByName( const char *name ) const;

	void							OnLocalViewPlayerChanged( void );
	void							OnLocalViewPlayerTeamChanged( void );

	void							ResetTeamAssets( void );

	void							CheckTeamBalance( void );
	sdTeamInfo*						FindUnbalancedTeam( sdTeamInfo** lowest );

	idPlayer*						GetLocalViewPlayer( void ) const;
	idPlayer*						GetLocalPlayer( void ) const {
		if ( localClientNum == ASYNC_DEMO_CLIENT_INDEX ) {
			return NULL;
		}
#ifdef SD_SUPPORT_REPEATER
		if ( localClientNum == REPEATER_CLIENT_INDEX ) {
			return NULL;
		}
#endif // SD_SUPPORT_REPEATER
		return GetClient( localClientNum );
	}

	idPlayer*						GetSnapshotPlayer( void ) const { return snapShotPlayer; }
	void							SetSnapShotPlayer( idPlayer* player );
	idPlayer*						GetSnapshotClient( void ) const { return snapShotClient; }
	void							SetSnapShotClient( idPlayer* client );
	void							UpdatePlayerShadows( void );
	const snapshot_t*				GetActiveSnapshot( void ) { return activeSnapshot; }
	bool							IsLocalViewPlayer( const idEntity* player ) const;
	bool							IsLocalPlayer( const idEntity* player ) const { return player->entityNumber == localClientNum; }

	bool							DoClientSideStuff() const;

	void							LogDamage( const char* message );
	void							LogProficiency( const char* message );
	void							LogNetwork( const char* message );
	void							LogObjective( const char* message );
	void							LogDebugText( const idEntity* entFrom, const char* fmt, ... );

	int								GetNumEntityDefBits( void ) const { return numEntityDefBits; }
	int								GetNumDamageDeclBits( void ) const { return numDamageDeclBits; }
	int								GetNumInvItemBits( void ) const { return numInvItemBits; }
	int								GetNumSkinDeclBits( void ) const { return numSkinDeclBits; }
	int								GetNumDeployObjectBits( void ) const { return numDeployObjectBits; }
	int								GetNumPlayerClassBits( void ) const { return numPlayerClassBits; }
	int								GetNumClientIndexBits( void ) const { return numClientIndexBits; }

	bool							SelectInitialSpawnPointForRepeaterClient( idVec3& outputOrg, idAngles& outputAngles );
	const sdSpawnPoint*				SelectInitialSpawnPoint( idPlayer *player, idVec3& outputOrg, idAngles& outputAngles );
	static int						SortSpawnsByAge( const void* a, const void* b );

	void							SetPortalState( qhandle_t portal, int blockingBits );
	void							SaveEntityNetworkEvent( const sdEntityNetEvent& oldEvent );
	void							FreeEntityNetworkEvents( const idEntity *ent, int event );
	void							SendUnreliableEntityNetworkEvent( const idEntity *ent, int event, const idBitMsg *msg );
	void							SendUnreliableEntityNetworkEvent( const sdUnreliableEntityNetEvent& oldEvent );
	void							WriteUnreliableEntityNetEvents( int clientNum, bool repeaterClient, idBitMsg &msg );

	void							SetGlobalMaterial( const idMaterial *mat );
	const idMaterial *				GetGlobalMaterial();

	void							ServerSendQuickChatMessage( idPlayer* player, const sdDeclQuickChat* quickChat, idPlayer* recipient = NULL, idEntity* target = NULL );

#ifdef SD_SUPPORT_REPEATER
	clientNetworkInfo_t&			GetRepeaterNetworkInfo( int clientNum ) {
		assert( repeaterNetworkInfo[ clientNum ] != NULL );
		return *repeaterNetworkInfo[ clientNum ];
	}

	const clientNetworkInfo_t&		GetRepeaterNetworkInfo( int clientNum ) const {
		assert( repeaterNetworkInfo[ clientNum ] != NULL );
		return *repeaterNetworkInfo[ clientNum ];
	}
#endif // SD_SUPPORT_REPEATER

	clientNetworkInfo_t&			GetNetworkInfo( int clientNum ) {
		if ( clientNum == ASYNC_DEMO_CLIENT_INDEX ) {
			return demoClientNetworkInfo;
		}
#ifdef SD_SUPPORT_REPEATER
		if ( clientNum == REPEATER_CLIENT_INDEX ) {
			return repeaterClientNetworkInfo;
		}
#endif // SD_SUPPORT_REPEATER
		return clientNetworkInfo[ clientNum ];
	}
	const clientNetworkInfo_t&		GetNetworkInfo( int clientNum ) const  {
		if ( clientNum == ASYNC_DEMO_CLIENT_INDEX ) {
			return demoClientNetworkInfo;
		}
#ifdef SD_SUPPORT_REPEATER
		if ( clientNum == REPEATER_CLIENT_INDEX ) {
			return repeaterClientNetworkInfo;
		}
#endif // SD_SUPPORT_REPEATER
		return clientNetworkInfo[ clientNum ];
	}

	enum {
		EVENT_MAXEVENTS
	};

	int								GetLastMarker( int clientNum, int entityNum ) const { return GetNetworkInfo( clientNum ).lastMarker[ entityNum ]; }

	sdLoggedTrace*					RegisterLoggedTrace( const trace_t& trace );
	void							FreeLoggedTrace( sdLoggedTrace* trace );

	int								RegisterLoggedDecal( const idMaterial* material = NULL );
	gameDecalInfo_t*				GetLoggedDecal( int handle );
	void							FreeLoggedDecal( int index );
	void							ResetLoggedDecal( int index );

	void							NetworkEventWarning( const sdEntityNetEvent& event, const char *fmt, ... );
	void							UnreliableNetworkEventWarning( const sdUnreliableEntityNetEvent& event, const char *fmt, ... );
	void							ShutdownClientNetworkState( int clientNum );

	static surfaceProperties_t&		GetSurfaceTypeForIndex( int index );

	void							AddEnvDefinition( sdEnvDefinition &envDef ) { envDefs.Append( envDef ); }
	const idList<sdEnvDefinition>&	GetEnvDefinitions( void ) { return envDefs; }

	// GUIs
	const guiHandle_t&				GetMainMenuGui() const { return uiMainMenuHandle; }	

	void							ApplyRulesData( const sdEntityStateNetworkData& newState );
	void							ReadRulesData( const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, const idBitMsg& msg ) const;
	void							WriteRulesData( const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, idBitMsg& msg ) const;
	bool							CheckRulesData( const sdEntityStateNetworkData& baseState ) const;
	sdEntityStateNetworkData*		CreateRulesData( void ) const;

#ifndef _XENON
	void							UpdateGameSession( void );

	sdNetManager&					GetSDNet() { return sdnet; }
#endif

	idLinkList< idEntity >*			GetTargetEntities( void ) { return targetEntities.NextNode(); }
	idLinkList< idEntity >*			GetIconEntities( void ) { return iconEntities.NextNode(); }

	//int								GetBytesNeededForMapLoad( void ) const { return bytesNeededForMapLoad; }

	const idCmdArgs&				GetActionArgs( void ) { return actionArgs; }

	void							PurgeAndLoadTeamAssets( const sdDeclStringMap* newPartialLoadTeamAssets );

	const idList< idEntity* >&		GetOcclusionQueryList() const { return occlusionQueryList; }
	qhandle_t						AddEntityOcclusionQuery( idEntity *ent );
	void							FreeEntityOcclusionQuery( idEntity *ent );

	const idWStrList&				GetSystemNotifications() { return systemNotifications; }

	const char*						GetTimeText( void ) {
		sysTime_t time;
		sys->RealTime( &time );
		return va( "%d-%02d-%02d %02d:%02d:%02d", 1900 + time.tm_year, 1 + time.tm_mon, time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec );
	}

	sdGameRules*					GetRulesInstance( const char* type ) const;

	bool							IsDoingMapRestart( void ) const { return doingMapRestart; }

	int								GetMaxPrivateClients( void );

	void							EnablePlayerHeadModels( void );
	void							DisablePlayerHeadModels( void );

	void							StartSendingBanList( idPlayer* player );
	void							SendBanList( idPlayer* player );

private:
//	int								GetBytesNeededForMapLoad( const char* map );
//	void							SetBytesNeededForMapLoad( const char* map, int numBytes );

	void							UpdateLagometer( int aheadOfServer, int numDuplicatedUsercmds );

	void							ReserveClientSlot( const sdNetClientId& netClientId );
	void							CheckForExpiredReservedSlots( void );

	void							UpdateCampaignStats( bool allowMedia );

	static void						SurfaceTypePostParse( idDecl* decl );

	void							LoadMainMenuPartialMedia( bool blocking );
	void							PurgeMainMenuPartialMedia();

	void							ControlBotPopulation( void );
	void							TouchMedia();

private:
	int														nextBotPopulationCheck;

	static idList< surfaceProperties_t >					surfaceTypes;

	idWStrList												systemNotifications;

	const static int										INITIAL_SPAWN_COUNT = 1;

	int														commandmapOverlayIndex;

	idLinkList< idEntity >									targetEntities;
	idLinkList< idEntity >									iconEntities;

	int														numEntityDefBits;		// bits required to store an entity def number
	int														numDamageDeclBits;		//
	int														numInvItemBits;			// bits required to store an inventory item number
	int														numSkinDeclBits;		// bits required to store a skin index
	int														numDeployObjectBits;	//
	int														numPlayerClassBits;		//
	int														numClientIndexBits;		// bits required for a clientnumber

	bool													reloadingSameMap;		// only guaranteed to be correct during map load
	idStr													mapFileName;			// name of the map, empty string if no map loaded
	idMapFile *												mapFile;				// will be NULL during the game unless in-game editing is used
	bool													doingMapRestart;
	bool													useSimpleEffect;

	idMapFile *												botMapFile;				// the bot's map file info.

	int														spawnCount;

	idStrList												deploymentMasks;
	idList< sdPlayZone* >									playZones;
	idList< sdPlayZone* >									worldPlayZones;
	idList< sdPlayZone* >									choosablePlayZones;

	idEntityPtr< idCamera >									camera;
	const idMaterial *										globalMaterial;			// for overriding everything

	idDict													spawnArgs;				// spawn args used during entity spawning  FIXME: shouldn't be necessary anymore

	idVec3													gravity;				// global gravity vector
	gameState_t												gamestate;				// keeps track of whether we're spawning, shutting down, or normal gameplay

	clientNetworkInfo_t										clientNetworkInfo[ MAX_CLIENTS ];
	clientNetworkInfo_t										demoClientNetworkInfo;

#ifdef SD_SUPPORT_REPEATER
	clientNetworkInfo_t										repeaterClientNetworkInfo;
	idList< clientNetworkInfo_t* >							repeaterNetworkInfo;
#endif // SD_SUPPORT_REPEATER

	sdProficiencyTable										proficiencyTables[ MAX_CLIENTS ];

	idBlockAlloc< snapshot_t, 64 >							snapshotAllocator;

	sdEntityNetEvent::nodeType_t							entityNetEventQueue;
	sdEntityNetEvent::nodeType_t							savedEntityNetEventQueue;
	sdUnreliableEntityNetEvent::unreliableNodeType_t		unreliableEntityNetEventQueue;
	idBlockAlloc< sdEntityNetEvent, 32 >					entityNetEventAllocator;
	idBlockAlloc< sdUnreliableEntityNetEvent, 32 >			unreliableEntityNetEventAllocator;

	idCmdArgs												actionArgs;

	sdNetworkStateObject_Generic< idGameLocal, &idGameLocal::ApplyRulesData, &idGameLocal::ReadRulesData, &idGameLocal::WriteRulesData, &idGameLocal::CheckRulesData, &idGameLocal::CreateRulesData > rulesStateObject;

	idStaticList< sdSpawnPoint, 256 >						spawnSpots;
	idList< idList< sdPlayZone* >* >						playZoneAreas;
	idStrList												playZoneAreaNames;
	idPlayer*												snapShotPlayer;
	idPlayer*												snapShotClient;
	snapshot_t*												activeSnapshot;

	idFile*													damageLogFile;
	idFile*													debugLogFile;

	idDict													newInfo;

	int														bytesNeededForMapLoad;

	idStaticList< sdLoggedTrace*, MAX_LOGGED_TRACES >		loggedTraces;
	idStaticList< gameDecalInfo_t*, MAX_LOGGED_DECALS >		loggedDecals;

	// Defines name + origin of ambient cubemaps, can be rendered out with the makeEnvMaps command
	idList<sdEnvDefinition>									envDefs;

	guiHandle_t												uiMainMenuHandle;
	guiHandle_t												uiSystemUIHandle;
	guiHandle_t												uiLevelLoadHandle;
	guiHandle_t												pureWaitHandle;

	const idMaterial*										lagoMaterial;
	byte													lagometer[ LAGO_IMG_HEIGHT ][ LAGO_IMG_WIDTH ][ 4 ];

#ifndef _XENON
	sdNetManager											sdnet;
#endif

	idStrList												shakeSounds;

	const sdDeclStringMap*									currentPartialLoadTeamAssets;

	static idList< qhandle_t >								taskListHandles;

	idList< guiScope_t >									uiScopes;

	// clients allowed access to the reserved slots, setup when a client gets invited to a session
	struct reservedSlot_t {
		sdNetClientId	netClientId;
		int				time;
	};
	idStaticList< reservedSlot_t, MAX_CLIENTS >				reservedClientSlots;

	idList< idEntity* >										occlusionQueryList;

	enum fireTeamListType_t {
		FIRETEAMLIST_MYFIRETEAM = 0,
		FIRETEAMLIST_MAIN,
		FIRETEAMLIST_JOIN,
		FIRETEAMLIST_INVITE,
		FIRETEAMLIST_KICK,
		FIRETEAMLIST_PROMOTE,
		FIRETEAMLIST_MANAGE
	};

	static const int		FIRETEAMLIST_PAGE_NUM_PLAYERS = 8;

	// keep an instance of each type of game rules around
	// we use these in various places where we need to use virtual functions on
	// an instance that doesn't match the current local rules 
	// (eg, the server browser needs to query information from rules running on servers)

	typedef sdHashMapGeneric< idStr, sdGameRules*, sdHashCompareStrCmp > rulesMap_t;
	rulesMap_t rulesCache;

	bool					isAutorecording;
	bool					hasTakenScoreShot;

public:
	void					Clear( void );
							// returns true if the entity shouldn't be spawned at all in this game type or difficulty level
	bool					InhibitEntitySpawn( idDict &spawnArgs );
							// spawn entities from the map file
	void					SpawnMapEntities( void );
							// commons used by init, shutdown, and restart
	void					MapClear( bool clearClients );

	void					UpdateGravity( void );
	void					SortActiveEntityList( void );
	void					ShowTargets( void );
	void					RunDebugInfo( void );

	void					InitScriptForMap( void );

	void					InitConsoleCommands( void );
	void					ShutdownConsoleCommands( void );

	void					UpdateServerRankStats( void );

#if !defined( SD_DEMO_BUILD )
	void					FreeClientStatsRequestTask( void );
	void					FinishClientStatsRequest( void );
	bool					StartClientStatsRequest( int clientIndex );
#endif /* !SD_DEMO_BUILD */

	void					CreateClientStatsHash( int clientIndex );
	void					GetGlobalStatsValueMax( int clientIndex, const char* name, sdPlayerStatEntry::statValue_t& value );
	void					SetupFixedClientRank( int clientIndex );

	const sdDeclRank*		FindRankForLevel( int rankLevel );

	void					UpdateLoggedDecals( void );

	void					InitAsyncNetwork( void );
	void					ShutdownAsyncNetwork( void );
	void					InitLocalClient( int clientNum, bool server );
	void					FreeSnapshotsOlderThanSequence( clientNetworkInfo_t& nwInfo, int sequence );
	bool					ApplySnapshot( clientNetworkInfo_t& nwInfo, int sequence );

	void					ClientProcessEntityNetworkEventQueue( void );
	void					ClientShowSnapshot( int clientNum ) const;
	void					ClientShowAOR( int clientNum ) const;

	bool					ClientReceiveEvent( const idVec3& origin, int event, int time, const idBitMsg &msg );

							// call after any change to serverInfo. Will update various quick-access flags
	void					UpdateServerInfoFlags( void );

	void					UpdateHudStats( idPlayer* player );

	static void				CreateDemoList( sdUIList* list );
	static void				CreateModList( sdUIList* list );
	static void				CreateCrosshairList( sdUIList* list );
	static void				CreateKeyBindingList( sdUIList* list );
	static void				CreateActiveTaskList( sdUIList* list );
	static qhandle_t		GetTaskListHandle( int index );
	static void				CreateVehiclePlayerList( sdUIList* list );
	static void				CreateFireTeamListEntry( sdUIList* list, int index, idPlayer* player );
	static void				CreateFireTeamList( sdUIList* list );
	static void				CreateInventoryList( sdUIList* list );
	static void				CreateScoreboardList( sdUIList* list );
	static void				CreatePlayerAdminList( sdUIList* list );
	static void				CreateUserGroupList( sdUIList* list );
	static void				CreateServerConfigList( sdUIList* list );
	static void				CreateVideoModeList( sdUIList* list );
	static void				CreateCampaignList( sdUIList* list );
	static void				CreateMapList( sdUIList* list );
	static void				CreateWeaponSwitchList( sdUIList* list );
	static void				CreateColorList( sdUIList* list );
	static void				CreateSpawnLocationList( sdUIList* list );
	static void				CreateMSAAList( sdUIList* list );
	static void				CreateSoundPlaybackList( sdUIList* list );
	static void				CreateSoundCaptureList( sdUIList* list );

	static void				CreateFireTeamList_MyFireTeam( sdUIList* list );
	static void				CreateFireTeamList_Main( sdUIList* list );
	static void				CreateFireTeamList_Join( sdUIList* list );
	static void				CreateFireTeamList_Invite( sdUIList* list );
	static void				CreateFireTeamList_Kick( sdUIList* list );
	static void				CreateFireTeamList_Promote( sdUIList* list );
	static void				CreateFireTeamList_Manage( sdUIList* list );

	static void				CreateLifeStatsList( sdUIList* list );
	static void				CreatePredictedUpgradesList( sdUIList* list );
	static void				CreateUpgradesReviewList( sdUIList* list );

	static void				GeneratePlayerListForTask( idStr& playerList, const sdPlayerTask* task );
	static int				InsertTask( sdUIList* list, const sdPlayerTask* task, bool highlightActive );

	static void				TestGUI_f( const idCmdArgs& args );
	static void				ListClientEntities_f( const idCmdArgs& args );

	void					SetupMapMetaData( const char* mapName );

public:
	idDeclTypeTemplate< idDeclModelDef,			&declModelDefInfo >			declModelDefType;
	idDeclTypeTemplate< idDecl,					&declExportDefInfo >		declExportDefType;
	idDeclTypeTemplate< sdDeclVehicleScript,	&declVehicleScriptDefInfo >	declVehicleScriptDefType;
	idDeclTypeTemplate< sdDeclAmmoType,			&declAmmoTypeInfo >			declAmmoTypeType;
	idDeclTypeTemplate< sdDeclInvSlot,			&declInvSlotInfo >			declInvSlotType;
	idDeclTypeTemplate< sdDeclInvItemType,		&declInvItemTypeInfo >		declInvItemTypeType;
	idDeclTypeTemplate< sdDeclInvItem,			&declInvItemInfo >			declInvItemType;
	idDeclTypeTemplate< sdDeclItemPackage,		&declItemPackageInfo >		declItemPackageType;
	idDeclTypeTemplate< sdDeclStringMap,		&declStringMapInfo >		declStringMapType;
	idDeclTypeTemplate< sdDeclDamage,			&declDamageInfo >			declDamageType;
	idDeclTypeTemplate< sdDeclDamageFilter,		&declDamageFilterInfo >		declDamageFilterType;
	idDeclTypeTemplate< sdDeclCampaign,			&declCampaignInfo >			declCampaignType;
	idDeclTypeTemplate< sdDeclQuickChat,		&declQuickChatInfo >		declQuickChatType;
	idDeclTypeTemplate< sdDeclMapInfo,			&declMapInfoInfo >			declMapInfoType;
	idDeclTypeTemplate< sdDeclToolTip,			&declToolTipInfo >			declToolTipType;
	idDeclTypeTemplate< sdDeclTargetInfo,		&declTargetInfoInfo >		declTargetInfoType;
	idDeclTypeTemplate< sdDeclProficiencyType,	&declProficiencyTypeInfo >	declProficiencyTypeType;
	idDeclTypeTemplate< sdDeclProficiencyItem,	&declProficiencyItemInfo >	declProficiencyItemType;
	idDeclTypeTemplate< sdDeclRank,				&declRankInfo >				declRankType;
	idDeclTypeTemplate< sdDeclDeployableObject,	&declDeployableObjectInfo >	declDeployableObjectType;
	idDeclTypeTemplate< sdDeclDeployableZone,	&declDeployableZoneInfo >	declDeployableZoneType;
	idDeclTypeTemplate< sdDeclPlayerClass,		&declPlayerClassInfo >		declPlayerClassType;
	idDeclTypeTemplate< sdDeclKeyBinding,		&declKeyBindingInfo >		declKeyBindingType;

	idDeclTypeTemplate< sdDeclGUI,				&declGUIInfo >				declGUIType;
	idDeclTypeTemplate< sdDeclGUITheme,			&declGUIThemeInfo >			declGUIThemeType;

	idDeclTypeTemplate< sdDeclStringMap,		&declTeamInfoInfo >			declTeamInfoType;
	idDeclTypeTemplate< sdDeclPlayerTask,		&declPlayerTaskInfo >		declPlayerTaskType;
	idDeclTypeTemplate< sdDeclRequirement,		&declRequirementInfo >		declRequirementType;

	idDeclTypeTemplate< sdDeclVehiclePath,		&declVehiclePathInfo >		declVehiclePathType;
	idDeclTypeTemplate< sdDeclRadialMenu,		&declRadialMenuInfo >		declRadialMenuType;
	idDeclTypeTemplate< sdDeclAOR,				&declAreaOfRelevanceInfo >	declAORType;
	idDeclTypeTemplate< sdDeclRating,			&declRatingInfo >			declRatingType;

	idDeclTypeTemplate< sdDeclHeightMap,		&declHeightMapInfo >		declHeightMapType;
	idDeclTypeTemplate< sdDeclDeployMask,		&declDeployMaskInfo >		declDeployMaskType;

	sdDeclWrapperTemplate< idDeclTable >		declTableType;
	sdDeclWrapperTemplate< idMaterial >			declMaterialType;
	sdDeclWrapperTemplate< idDeclSkin >			declSkinType;
	sdDeclWrapperTemplate< idSoundShader >		declSoundShaderType;
	sdDeclWrapperTemplate< idDeclEntityDef >	declEntityDefType;
	sdDeclWrapperTemplate< idDeclAF >			declAFType;
	sdDeclWrapperTemplate< class rvDeclEffect >	declEffectsType;
	sdDeclWrapperTemplate< sdDeclAtmosphere >	declAtmosphereType;
	sdDeclWrapperTemplate< sdDeclStuffType >	declStuffTypeType;
	sdDeclWrapperTemplate< sdDeclDecal >		declDecalType;
	sdDeclWrapperTemplate< sdDeclSurfaceType >	declSurfaceTypeType;

	sdAddonMetaDataList*						mapMetaDataList;
	sdAddonMetaDataList*						campaignMetaDataList;

	static idCVar								g_cacheDictionaryMedia;
};

/*
===============
idGameLocal::ProjectDecal
===============
*/
ID_INLINE void idGameLocal::ProjectDecal( const idVec3 &origin, const idVec3 &dir, float depth, bool parallel, float size, const char *material, float angle ) {
	ProjectDecal( origin, dir, depth, parallel, size, declHolder.declMaterialType.LocalFind( material ), angle );
}

// RAVEN BEGIN
// bdube: inlines
ID_INLINE rvClientEffect* idGameLocal::PlayEffect ( const idDict& args, const idVec3& color, const char* effectName, const char* materialType, const idVec3& origin, const idMat3& axis, bool loop, const idVec3& endOrigin ) {
	return PlayEffect ( GetEffectHandle ( args, effectName, materialType ), color, origin, axis, loop, endOrigin );
}
// RAVEN END
//============================================================================

extern idGameLocal			gameLocal;
extern idAnimManager		animationLib;

//============================================================================

class idGameError : public idException {
public:
	idGameError( const char *text ) : idException( text ) {}
};

//============================================================================

//
// these defines work for all startsounds from all entity types
// make sure to change script/defs.script and def/sound.def if you add any channels, or change their order
//
typedef enum {
	SND_ANY = SCHANNEL_ANY,
	SND_VOICE = SCHANNEL_ONE,
	SND_BODY,
	SND_DOOR,
	SND_ITEM,
	SND_MUSIC,

	SND_ENGINE = SND_ANY + 10,
	SND_ENGINE_LAST = ( SND_ENGINE + /* MAX ENGINE SOUNDS */ 8 ) - 1,

	SND_WALKER_LEGS = SND_ANY + 20,
	SND_WALKER_LEGS_LAST = ( SND_WALKER_LEGS + /* MAX WALKER LEG SOUNDS */ 8 ) - 1,

	// quickchat starts at a crazy number just so that if MAX_CLIENTS 
	// is increased then it won't collide with other channels
	SND_QUICKCHAT = SND_ANY + 1000,
	SND_QUICKCHAT_LAST = ( SND_QUICKCHAT + MAX_CLIENTS ) - 1,

	//
	// Player sounds
	SND_PLAYER = SND_ANY + 50,
	SND_PLAYER_JUMP,
	SND_PLAYER_LAND,
	SND_PLAYER_HURT,
	SND_PLAYER_DEATH,
	SND_PLAYER_CHAT,
	SND_PLAYER_VO,
	SND_PLAYER_VO_MCP_UPDATE,
	SND_PLAYER_TARGETLOCK,
	SND_PLAYER_TOOLTIP,
	SND_PLAYER_FALL,
	SND_PLAYER_MOVE,
	SND_PLAYER_ALARM,

	//
	// Weapon sounds
	SND_WEAPON = SND_ANY + 100,
	SND_WEAPON_BRASS,
	SND_WEAPON_FIRE,
	SND_WEAPON_FIRE2,
	SND_WEAPON_FIRE3,
	SND_WEAPON_FIRE_FAR,
	SND_WEAPON_FIRE_LOCAL,
	SND_WEAPON_RELOAD,
	SND_WEAPON_COCK,
	SND_WEAPON_RAISE,
	SND_WEAPON_LOWER,
	SND_WEAPON_SIG,
	SND_WEAPON_MECH,
	SND_WEAPON_MOVE,
	SND_WEAPON_FOLEY,
	SND_WEAPON_BOUNCE,
	SND_WEAPON_ARM,
	SND_WEAPON_DISARM,
	SND_WEAPON_REMOVE,
	SND_WEAPON_DEPLOY,
	SND_WEAPON_IDLE,
	SND_WEAPON_MODE,
	SND_WEAPON_DRYFIRE,
	SND_WEAPON_DEPLOY_ROTATION,
	SND_WEAPON_DEPLOY_MISC,

	//
	// Vehicle sounds
	SND_VEHICLE = SND_ANY + 200,
	SND_VEHICLE_IDLE,
	SND_VEHICLE_START,
	SND_VEHICLE_STOP,
	SND_VEHICLE_BRAKE,
	SND_VEHICLE_ENTER,
	SND_VEHICLE_EXIT,
	SND_VEHICLE_POWERUP,
	SND_VEHICLE_POWERDOWN,
	SND_VEHICLE_DEATH,
	SND_VEHICLE_DISABLE,
	SND_VEHICLE_OVERDRIVE,
	SND_VEHICLE_SKID,
	SND_VEHICLE_MISC,
	SND_VEHICLE_RADIO,
	SND_VEHICLE_ALARM,
	SND_VEHICLE_OFFROAD,
	SND_VEHICLE_DRIVE,
	SND_VEHICLE_DRIVE2,
	SND_VEHICLE_DRIVE3,
	SND_VEHICLE_DRIVE4,
	SND_VEHICLE_DRIVE5,
	SND_VEHICLE_WALK,
	SND_VEHICLE_WALK2,
	SND_VEHICLE_WALK3,
	SND_VEHICLE_WALK4,
	SND_VEHICLE_WALK5,
	SND_VEHICLE_WALK6,
	SND_VEHICLE_HORN,
	SND_VEHICLE_REV,
	SND_VEHICLE_JUMP,
	SND_VEHICLE_ZOOM,

	//
	// Vehicle interior sounds
	SND_VEHICLE_INTERIOR = SND_ANY + 250,
	SND_VEHICLE_INTERIOR_IDLE,
	SND_VEHICLE_INTERIOR_START,
	SND_VEHICLE_INTERIOR_STOP,
	SND_VEHICLE_INTERIOR_POWERUP,
	SND_VEHICLE_INTERIOR_POWERDOWN,
	SND_VEHICLE_INTERIOR_OFFROAD,
	SND_VEHICLE_INTERIOR_DRIVE,
	SND_VEHICLE_INTERIOR_DRIVE2,
	SND_VEHICLE_INTERIOR_DRIVE3,
	SND_VEHICLE_INTERIOR_DRIVE4,
	SND_VEHICLE_INTERIOR_DRIVE5,
	SND_VEHICLE_INTERIOR_OVERDRIVE,
	SND_VEHICLE_INTERIOR_LOWHEALTH,

	//
	// Deployable sounds
	SND_DEPLOYABLE = SND_ANY + 300,
	SND_DEPLOYABLE_BRASS,
	SND_DEPLOYABLE_FIRE,
	SND_DEPLOYABLE_FIRE2,
	SND_DEPLOYABLE_FIRE3,
	SND_DEPLOYABLE_FIRE_FAR,
	SND_DEPLOYABLE_RELOAD,
	SND_DEPLOYABLE_SIG,
	SND_DEPLOYABLE_MECH,
	SND_DEPLOYABLE_IDLE,
	SND_DEPLOYABLE_DEATH,
	SND_DEPLOYABLE_DEPLOY,
	SND_DEPLOYABLE_DEPLOY2,
	SND_DEPLOYABLE_DEPLOY3,
	SND_DEPLOYABLE_DEPLOY4,
	SND_DEPLOYABLE_DEPLOY5,
	SND_DEPLOYABLE_YAW,
	SND_DEPLOYABLE_PITCH,

	//
	// Structure sounds
	SND_STRUCTURE = SND_ANY + 400,
	SND_STRUCTURE_IDLE,
	SND_STRUCTURE_POWERUP,
	SND_STRUCTURE_POWERDOWN,
	SND_STRUCTURE_ALARM,
	SND_STRUCTURE_DEPLOY,
	SND_STRUCTURE_DEPLOY2,
	SND_STRUCTURE_DEPLOY3,
	SND_STRUCTURE_DEPLOY4,
	SND_STRUCTURE_DEPLOY5,
	SND_STRUCTURE_SPAWNLOCATION,
	SND_STRUCTURE_CAPTUREPOINT,

	//
	// Motor sounds for vehicles and other script entities
	SND_MOTOR = SND_ANY + 450,
	SND_MOTOR_LAST = ( SND_MOTOR + 50 ) - 1,

	//
	// Mover sounds
	SND_MOVER = SND_ANY + 500,
	SND_MOVER_IDLE,
	SND_MOVER_POWERUP,
	SND_MOVER_POWERDOWN,
	SND_MOVER_ALARM,
	SND_MOVER_START,
	SND_MOVER_MOVE,
	SND_MOVER_STOP,

	SND_LAST
} gameSoundChannel_t;

//============================================================================

// TTimo: those can't be inlined in the class declaration, as gameLocal is not defined yet
ID_INLINE idEntity*	sdSpawnPoint::GetOwner( void ) const { return _owner.GetEntity(); }
ID_INLINE void		sdSpawnPoint::SetOwner( idEntity* owner ) { _owner = owner; }

#include "EntityPtr.h"
#include "client/ClientEntityInlines.h"

#include "Player.h"
#include "ScriptEntity.h"

#endif	/* !__GAME_LOCAL_H__ */