#ifndef __GAME_H__
#define __GAME_H__

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

	Public game interface with methods to run the game.

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

// RAVEN BEGIN
// bgeisler: moved into scripts directory
// default scripts
#define SCRIPT_DEFAULTDEFS			"scripts/defs.script"
#define SCRIPT_DEFAULT				"scripts/main.script"
// RAVEN END
#define SCRIPT_DEFAULTFUNC			"doom_main"

struct gameReturn_t {
	char		sessionCommand[MAX_STRING_CHARS];	// "map", "disconnect", "victory", etc
	int			consistencyHash;					// used to check for network game divergence
	int			health;
	int			heartRate;
	int			stamina;
	int			combat;
	bool		syncNextGameFrame;					// used when cinematics are skipped to prevent session from simulating several game frames to
													// keep the game time in sync with real time
};

enum allowReply_t {
	ALLOW_YES = 0,
	ALLOW_BADPASS,	// core will prompt for password and connect again
	ALLOW_NOTYET,	// core will wait with transmitted message
	ALLOW_NO		// core will abort with transmitted message
};

enum escReply_t {
	ESC_IGNORE = 0,	// do nothing
	ESC_MAIN,		// start main menu GUI
	ESC_GUI			// set an explicit GUI
};

enum demoState_t {
	DEMO_NONE,
	DEMO_RECORDING,
	DEMO_PLAYING
};

enum demoReliableGameMessage_t {
	DEMO_RECORD_CLIENTNUM,
	DEMO_RECORD_EXCLUDE,
	DEMO_RECORD_COUNT
};

//
// these defines work for all startsounds from all entity types
// make sure to change script/doom_defs.script if you add any channels, or change their order
//
typedef enum {
	SND_CHANNEL_ANY = SCHANNEL_ANY,
	SND_CHANNEL_VOICE = SCHANNEL_ONE,
	SND_CHANNEL_VOICE2,
	SND_CHANNEL_BODY,
	SND_CHANNEL_BODY2,
	SND_CHANNEL_BODY3,
	SND_CHANNEL_WEAPON,
	SND_CHANNEL_ITEM,
	SND_CHANNEL_HEART,
	SND_CHANNEL_DEMONIC,
	SND_CHANNEL_RADIO,

	// internal use only.  not exposed to script or framecommands.
	SND_CHANNEL_AMBIENT,
	SND_CHANNEL_DAMAGE

// RAVEN BEGIN
// bdube: added custom to tell us where the end of the predefined list is
	,
	SND_CHANNEL_POWERUP,
	SND_CHANNEL_POWERUP_IDLE,
	SND_CHANNEL_MP_ANNOUNCER,
	SND_CHANNEL_CUSTOM
// RAVEN END
} gameSoundChannel_t;

// RAVEN BEGIN
// bdube: forward reference
class rvClientEffect;
// RAVEN END

struct ClientStats_t {
	bool	isLastPredictFrame;
	bool	isLagged;
	bool	isNewFrame;
};

typedef struct userOrigin_s {
	idVec3	origin;
	int		followClient;
} userOrigin_t;

class idGame {
public:
	virtual						~idGame() {}

	// Initialize the game for the first time.
// RAVEN BEGIN
// jsinger: attempt to eliminate cross-DLL allocation issues
#ifdef RV_UNIFIED_ALLOCATOR
	virtual void				Init( void *(*allocator)( size_t size ), void (*deallocator)( void *ptr ), size_t (*msize)( void *ptr ) ) = 0;
#else
	virtual void				Init( void ) = 0;
#endif

	// Shut down the entire game.
	virtual void				Shutdown( void ) = 0;

	// Set the local client number. Distinguishes listen ( == 0 ) / dedicated ( == -1 )
	virtual void				SetLocalClient( int clientNum ) = 0;

	// Sets the user info for a client.
	// The game can modify the user info in the returned dictionary pointer, server will forward back.
	virtual const idDict *		SetUserInfo( int clientNum, const idDict &userInfo, bool isClient ) = 0;

	// Retrieve the game's userInfo dict for a client.
	virtual const idDict *		GetUserInfo( int clientNum ) = 0;

	// Sets the user info for a viewer.
	// The game can modify the user info in the returned dictionary pointer.
	virtual const idDict *		RepeaterSetUserInfo( int clientNum, const idDict &userInfo ) = 0;

	// Checks to see if a client is active
	virtual bool				IsClientActive( int clientNum ) = 0;

	// The game gets a chance to alter userinfo before they are emitted to server.
	virtual void				ThrottleUserInfo( void ) = 0;

	// Sets the serverinfo at map loads and when it changes.
	virtual void				SetServerInfo( const idDict &serverInfo ) = 0;

	// The session calls this before moving the single player game to a new level.
	virtual const idDict &		GetPersistentPlayerInfo( int clientNum ) = 0;

	// The session calls this right before a new level is loaded.
	virtual void				SetPersistentPlayerInfo( int clientNum, const idDict &playerInfo ) = 0;

	// Loads a map and spawns all the entities.
	virtual void				InitFromNewMap( const char *mapName, idRenderWorld *renderWorld, bool isServer, bool isClient, int randseed ) = 0;

	// Loads a map from a savegame file.
	virtual bool				InitFromSaveGame( const char *mapName, idRenderWorld *renderWorld, idFile *saveGameFile ) = 0;

	// Saves the current game state, the session may have written some data to the file already.
// RAVEN BEGIN
// mekberg: added saveTypes
	virtual void				SaveGame( idFile *saveGameFile, saveType_t saveType = ST_REGULAR ) = 0;
// RAVEN END

	// Shut down the current map.
	virtual void				MapShutdown( void ) = 0;

	// Caches media referenced from in key/value pairs in the given dictionary.
	virtual void				CacheDictionaryMedia( const idDict *dict ) = 0;

	// Spawns the player entity to be used by the client.
	virtual void				SpawnPlayer( int clientNum ) = 0;

// RAVEN BEGIN
	// Runs a game frame, may return a session command for level changing, etc
	// lastCatchupFrame is always true except if we are running several game frames in a row and this one is not the last one
	// subsystems which can tolerate skipping frames will not run during those catchup frames
	// several game frames in a row happen when game + renderer time goes above the tick time ( 16ms )
	virtual gameReturn_t		RunFrame( const usercmd_t *clientCmds, int activeEditors, bool lastCatchupFrame, int serverGameFrame ) = 0;

	virtual void				MenuFrame( void ) = 0;
// RAVEN END

	// Runs a repeater frame
	virtual void				RepeaterFrame( const userOrigin_t *clientOrigins, bool lastCatchupFrame, int serverGameFrame ) = 0;

	// Makes rendering and sound system calls to display for a given clientNum.
	virtual bool				Draw( int clientNum ) = 0;

	// Let the game do it's own UI when ESCAPE is used
	virtual escReply_t			HandleESC( idUserInterface **gui ) = 0;

	// get the games menu if appropriate ( multiplayer )
	virtual idUserInterface *	StartMenu() = 0;

	// When the game is running it's own UI fullscreen, GUI commands are passed through here
	// return NULL once the fullscreen UI mode should stop, or "main" to go to main menu
	virtual const char *		HandleGuiCommands( const char *menuCommand ) = 0;

	// main menu commands not caught in the engine are passed here
	virtual void				HandleMainMenuCommands( const char *menuCommand, idUserInterface *gui ) = 0;

	// Early check to deny connect.
	virtual allowReply_t		ServerAllowClient( int clientId, int numClients, const char *IP, const char *guid, const char *password, const char *privatePassword, char reason[MAX_STRING_CHARS] ) = 0;

	// Connects a client.
	virtual void				ServerClientConnect( int clientNum, const char *guid ) = 0;

	// Spawns the player entity to be used by the client.
	virtual void				ServerClientBegin( int clientNum ) = 0;

	// Disconnects a client and removes the player entity from the game.
	virtual void				ServerClientDisconnect( int clientNum ) = 0;

	// Writes initial reliable messages a client needs to recieve when first joining the game.
	virtual void				ServerWriteInitialReliableMessages( int clientNum ) = 0;

	// Early check to deny connect.
	virtual allowReply_t		RepeaterAllowClient( int clientId, int numClients, const char *IP, const char *guid, bool repeater, const char *password, const char *privatePassword, char reason[MAX_STRING_CHARS] ) = 0;

	// Connects a client.
	virtual void				RepeaterClientConnect( int clientNum ) = 0;

	// Spawns the player entity to be used by the client.
	virtual void				RepeaterClientBegin( int clientNum ) = 0;

	// Disconnects a client and removes the player entity from the game.
	virtual void				RepeaterClientDisconnect( int clientNum ) = 0;

	// Writes initial reliable messages a client needs to recieve when first joining the game.
	virtual void				RepeaterWriteInitialReliableMessages( int clientNum ) = 0;

	// Writes a snapshot of the server game state for the given client.
	virtual void				ServerWriteSnapshot( int clientNum, int sequence, idBitMsg &msg, dword *clientInPVS, int numPVSClients, int lastSnapshotFrame ) = 0;

	// Patches the network entity states at the server with a snapshot for the given client.
	virtual bool				ServerApplySnapshot( int clientNum, int sequence ) = 0;

	// Processes a reliable message from a client.
	virtual void				ServerProcessReliableMessage( int clientNum, const idBitMsg &msg ) = 0;

	// Patches the network entity states at the server with a snapshot for the given client.
	virtual bool				RepeaterApplySnapshot( int clientNum, int sequence ) = 0;

	// Processes a reliable message from a client.
	virtual void				RepeaterProcessReliableMessage( int clientNum, const idBitMsg &msg ) = 0;

	// Reads a snapshot and updates the client game state.
	virtual void				ClientReadSnapshot( int clientNum, int snapshotSequence, const int gameFrame, const int gameTime, const int dupeUsercmds, const int aheadOfServer, const idBitMsg &msg ) = 0;

	// Patches the network entity states at the client with a snapshot.
	virtual bool				ClientApplySnapshot( int clientNum, int sequence ) = 0;

	// Processes a reliable message from the server.
	virtual void				ClientProcessReliableMessage( int clientNum, const idBitMsg &msg ) = 0;

	// Runs prediction on entities at the client.
	virtual gameReturn_t		ClientPrediction( int clientNum, const usercmd_t *clientCmds, bool lastPredictFrame = true, ClientStats_t *cs = NULL ) = 0;

// RAVEN BEGIN
// ddynerman: client game frame
	virtual void				ClientRun( void ) = 0;
	virtual void				ClientEndFrame( void ) = 0;

// jshepard: rcon password check
	virtual void				ProcessRconReturn( bool success ) = 0;

// RAVEN END

	virtual bool				ValidateServerSettings( const char *map, const char *gameType ) = 0;

	// Returns a summary of stats for a given client
	virtual void				GetClientStats( int clientNum, char *data, const int len ) = 0;

	// Switch a player to a particular team
	virtual void				SwitchTeam( int clientNum, int team ) = 0;

	virtual bool				DownloadRequest( const char *IP, const char *guid, const char *paks, char urls[ MAX_STRING_CHARS ] ) = 0;

	// return true to allow download from the built-in http server
	virtual bool				HTTPRequest( const char *IP, const char *file, bool isGamePak ) = 0;

// RAVEN BEGIN
// jscott: for the effects system
	virtual void				StartViewEffect( int type, float time, float scale ) = 0;
	virtual rvClientEffect*		PlayEffect( const idDecl *effect, const idVec3& origin, const idMat3& axis, bool loop = false, const idVec3& endOrigin = vec3_origin, bool broadcast = false, bool predictBit = false, effectCategory_t category = EC_IGNORE, const idVec4& effectTint = vec4_one ) = 0;
	virtual void				GetPlayerView( idVec3 &origin, idMat3 &axis ) = 0;
	virtual const idVec3		GetCurrentGravity( const idVec3& origin, const idMat3& axis ) const = 0;
	virtual void				Translation( trace_t &trace, idVec3 &source, idVec3 &dest, idTraceModel *trm, int clipMask ) = 0;
	virtual void				SpawnClientMoveable ( const char* name, int lifetime, const idVec3& origin, const idMat3& axis, const idVec3& velocity, const idVec3& angular_velocity ) = 0;
// bdube: debugging stuff	
	virtual void				DebugSetString ( const char* name, const char* value ) = 0;
	virtual void				DebugSetFloat ( const char* name, float value ) = 0;
	virtual void				DebugSetInt ( const char* name, int value ) = 0;
	virtual const char*			DebugGetStatString ( const char* name ) = 0;
	virtual int					DebugGetStatInt ( const char* name ) = 0;
	virtual float				DebugGetStatFloat ( const char* name ) = 0;
	virtual bool				IsDebugHudActive ( void ) const = 0;
// rjohnson: for new note taking mechanism
	virtual bool				GetPlayerInfo( idVec3 &origin, idMat3 &axis, int PlayerNum = -1, idAngles *deltaViewAngles = NULL, int reqClientNum = -1 ) = 0;
	virtual void				SetPlayerInfo( idVec3 &origin, idMat3 &axis, int PlayerNum = -1 ) = 0;
	virtual	bool				PlayerChatDisabled( int clientNum ) = 0;
	virtual void				SetViewComments( const char *text = 0 ) = 0;
// ddynerman: utility functions
	virtual void				GetPlayerName( int clientNum, char* name ) = 0;
	virtual void				GetPlayerClan( int clientNum, char* clan ) = 0;
	virtual void				SetFriend( int clientNum, bool isFriend ) = 0;
	virtual const char*			GetLongGametypeName( const char* gametype ) = 0;
	virtual void				ReceiveRemoteConsoleOutput( const char* output ) = 0;
// rjohnson: entity usage stats
	virtual void				ListEntityStats( const idCmdArgs &args ) = 0;
// shouchard:  for ban lists
	virtual void				RegisterClientGuid( int clientNum, const char *guid ) = 0;
	virtual bool				IsMultiplayer( void ) = 0;
// mekberg: added
	virtual bool				InCinematic( void ) = 0;
// mekberg: so banlist can be populated outside of multiplayer game
	virtual void				PopulateBanList( idUserInterface* hud ) = 0;
	virtual void				RemoveGuidFromBanList( const char *guid ) = 0;
// mekberg: interface
	virtual void				AddGuidToBanList( const char *guid ) = 0;
	virtual const char*			GetGuidByClientNum( int clientNum ) = 0;
// jshepard: updating player post-menu
	virtual void				UpdatePlayerPostMainMenu( void ) = 0;
	virtual void				ResetRconGuiStatus( void ) = 0;
// RAVEN END

// RAVEN BEGIN
// mwhitlock: Dynamic memory consolidation
#if defined(_RV_MEM_SYS_SUPPORT)
	virtual void				FlushBeforelevelLoad( void ) = 0;
#endif
// RAVEN END

	// Set the demo state.
	virtual void				SetDemoState( demoState_t state, bool serverDemo, bool timeDemo ) = 0;

	// Set the repeater state; engine will call this with true for isRepeater if this is a repeater, and true for serverIsRepeater if we are connected to a repeater
	virtual void				SetRepeaterState( bool isRepeater, bool serverIsRepeater ) = 0;

	// Writes current network info to a file (used as initial state for demo recording).
	virtual void				WriteNetworkInfo( idFile* file, int clientNum ) = 0;

	// Reads current network info from a file (used as initial state for demo playback).
	virtual void				ReadNetworkInfo( int gameTime, idFile* file, int clientNum ) = 0;

	// Let gamecode decide if it wants to accept demos from older releases of the engine.
	virtual bool				ValidateDemoProtocol( int minor_ref, int minor ) = 0;

	// Write a snapshot for server demo recording.
	virtual void				ServerWriteServerDemoSnapshot( int sequence, idBitMsg &msg, int lastSnapshotFrame ) = 0;

	// Read a snapshot from a server demo stream.
	virtual void				ClientReadServerDemoSnapshot( int sequence, const int gameFrame, const int gameTime, const idBitMsg &msg ) = 0;

	// Write a snapshot for repeater clients.
	virtual void				RepeaterWriteSnapshot( int clientNum, int sequence, idBitMsg &msg, dword *clientInPVS, int numPVSClients, const userOrigin_t &pvs_origin, int lastSnapshotFrame ) = 0;

	// Done writing snapshots for repeater clients.
	virtual void				RepeaterEndSnapshots( void ) = 0;

	// Read a snapshot from a repeater stream.
	virtual void				ClientReadRepeaterSnapshot( int sequence, const int gameFrame, const int gameTime, const int aheadOfServer, const idBitMsg &msg ) = 0;

	// Get the currently followed client in demo playback
	virtual int					GetDemoFollowClient( void ) = 0;

	// Build a bot's userCmd
	virtual void				GetBotInput( int clientNum, usercmd_t &userCmd ) = 0;

	// Return the name of a gui to override the loading screen
	virtual const char *		GetLoadingGui( const char *mapDeclName ) = 0;

	// Set any additional gui variables needed by the loading screen
	virtual void				SetupLoadingGui( idUserInterface *gui ) = 0;
};

extern idGame *					game;


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

	Public game interface with methods for in-game editing.

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

struct refSound_t {
// RAVEN BEGIN
	int							referenceSoundHandle;	// this is the interface to the sound system, created
														// with idSoundWorld::AllocSoundEmitter() when needed
// RAVEN END
	idVec3						origin;
// RAVEN BEGIN
// jscott: for Miles doppler
	idVec3						velocity;
// RAVEN END
	int							listenerId;		// SSF_PRIVATE_SOUND only plays if == listenerId from PlaceListener
												// no spatialization will be performed if == listenerID
	const idSoundShader *		shader;			// this really shouldn't be here, it is a holdover from single channel behavior
	float						diversity;		// 0.0 to 1.0 value used to select which
												// samples in a multi-sample list from the shader are used
	bool						waitfortrigger;	// don't start it at spawn time
	soundShaderParms_t			parms;			// override volume, flags, etc
};

enum {
	TEST_PARTICLE_MODEL = 0,
	TEST_PARTICLE_IMPACT,
	TEST_PARTICLE_MUZZLE,
	TEST_PARTICLE_FLIGHT,
	TEST_PARTICLE_SELECTED
};

class idEntity;
class idMD5Anim;
// RAVEN BEGIN
// bdube: more forward declarations
class idProgram;
class idInterpreter;
class idThread;

typedef void (*debugInfoProc_t) ( const char* classname, const char* name, const char* value, void *userdata );
// RAVEN END

// FIXME: this interface needs to be reworked but it properly separates code for the time being
class idGameEdit {
public:
	virtual						~idGameEdit( void ) {}

	// These are the canonical idDict to parameter parsing routines used by both the game and tools.
	virtual bool				ParseSpawnArgsToRenderLight( const idDict *args, renderLight_t *renderLight );
	virtual void				ParseSpawnArgsToRenderEntity( const idDict *args, renderEntity_t *renderEntity );
	virtual void				ParseSpawnArgsToRefSound( const idDict *args, refSound_t *refSound );

	// Animation system calls for non-game based skeletal rendering.
	virtual idRenderModel *		ANIM_GetModelFromEntityDef( const char *classname );
	virtual const idVec3 		&ANIM_GetModelOffsetFromEntityDef( const char *classname );
	virtual idRenderModel *		ANIM_GetModelFromEntityDef( const idDict *args );
	virtual idRenderModel *		ANIM_GetModelFromName( const char *modelName );
	virtual const idMD5Anim *	ANIM_GetAnimFromEntityDef( const char *classname, const char *animname );
// RAVEN BEGIN
// bdube: added
// scork: added 'const' qualifiers so other stuff would compile
	virtual const idMD5Anim *	ANIM_GetAnimFromEntity( const idEntity* ent, int animNum );
	virtual float				ANIM_GetAnimPlaybackRateFromEntity ( idEntity* ent, int animNum );
	virtual const char*			ANIM_GetAnimNameFromEntity ( const idEntity* ent, int animNum );
// RAVEN END
	virtual int					ANIM_GetNumAnimsFromEntityDef( const idDict *args );
	virtual const char *		ANIM_GetAnimNameFromEntityDef( const idDict *args, int animNum );
	virtual const idMD5Anim *	ANIM_GetAnim( const char *fileName );
	virtual int					ANIM_GetLength( const idMD5Anim *anim );
	virtual int					ANIM_GetNumFrames( const idMD5Anim *anim );
// RAVEN BEGIN
// bdube: added
	virtual const char *		ANIM_GetFilename( const idMD5Anim* anim );
	virtual int					ANIM_ConvertFrameToTime ( const idMD5Anim* anim, int frame );
	virtual int					ANIM_ConvertTimeToFrame ( const idMD5Anim* anim, int time );
// RAVEN END
	virtual void				ANIM_CreateAnimFrame( const idRenderModel *model, const idMD5Anim *anim, int numJoints, idJointMat *frame, int time, const idVec3 &offset, bool remove_origin_offset );
	virtual idRenderModel *		ANIM_CreateMeshForAnim( idRenderModel *model, const char *classname, const char *animname, int frame, bool remove_origin_offset );

// RAVEN BEGIN
// mekberg: access to animationlib functions for radiant
	virtual void				FlushUnusedAnims( void );
// RAVEN END

	// Articulated Figure calls for AF editor and Radiant.
	virtual bool				AF_SpawnEntity( const char *fileName );
	virtual void				AF_UpdateEntities( const char *fileName );
	virtual void				AF_UndoChanges( void );
	virtual idRenderModel *		AF_CreateMesh( const idDict &args, idVec3 &meshOrigin, idMat3 &meshAxis, bool &poseIsSet );


	// Entity selection.
	virtual void				ClearEntitySelection( void );
	virtual int					GetSelectedEntities( idEntity *list[], int max );
	virtual void				AddSelectedEntity( idEntity *ent );

	// Selection methods
	virtual void				TriggerSelected();

	// Entity defs and spawning.
	virtual const idDict *		FindEntityDefDict( const char *name, bool makeDefault = true ) const;
	virtual void				SpawnEntityDef( const idDict &args, idEntity **ent );
	virtual idEntity *			FindEntity( const char *name ) const;
	virtual const char *		GetUniqueEntityName( const char *classname ) const;

	// Entity methods.
	virtual void				EntityGetOrigin( idEntity *ent, idVec3 &org ) const;
	virtual void				EntityGetAxis( idEntity *ent, idMat3 &axis ) const;
	virtual void				EntitySetOrigin( idEntity *ent, const idVec3 &org );
	virtual void				EntitySetAxis( idEntity *ent, const idMat3 &axis );
	virtual void				EntityTranslate( idEntity *ent, const idVec3 &org );
// RAVEN BEGIN
// scork: const-qualified 'ent' so other things would compile
	virtual const idDict *		EntityGetSpawnArgs( const idEntity *ent ) const;
// RAVEN END
	virtual void				EntityUpdateChangeableSpawnArgs( idEntity *ent, const idDict *dict );
	virtual void				EntityChangeSpawnArgs( idEntity *ent, const idDict *newArgs );
	virtual void				EntityUpdateVisuals( idEntity *ent );
	virtual void				EntitySetModel( idEntity *ent, const char *val );
	virtual void				EntityStopSound( idEntity *ent );
	virtual void				EntityDelete( idEntity *ent );
	virtual void				EntitySetColor( idEntity *ent, const idVec3 color );
// RAVEN BEGIN
// bdube: added
	virtual const char*			EntityGetName ( idEntity* ent ) const;
	virtual int					EntityToSafeId( idEntity* ent ) const;
	virtual idEntity *			EntityFromSafeId( int safeID) const;
	virtual void				EntitySetSkin ( idEntity *ent, const char* temp ) const;
	virtual void				EntityClearSkin ( idEntity *ent ) const;
	virtual void				EntityShow ( idEntity* ent ) const;
	virtual void				EntityHide ( idEntity* ent ) const;
	virtual void				EntityGetBounds ( idEntity* ent, idBounds &bounds ) const;
	virtual int					EntityPlayAnim ( idEntity* ent, int animNum, int time, int blendtime );
	virtual void				EntitySetFrame ( idEntity* ent, int animNum, int frame, int time, int blendtime );
	virtual void				EntityStopAllEffects ( idEntity* ent );
	virtual void				EntityGetDelta ( idEntity* ent, int fromTime, int toTime, idVec3& delta ); 
	virtual void				EntityRemoveOriginOffset ( idEntity* ent, bool remove );
	virtual const char*			EntityGetClassname ( idEntity* ent ) const;
	virtual bool				EntityIsDerivedFrom ( idEntity* ent, const char* classname ) const;
	virtual renderEntity_t*		EntityGetRenderEntity ( idEntity* ent );
// scork: accessor functions for various utils
	virtual	idEntity *			EntityGetNextTeamEntity( idEntity *pEnt ) const;
	virtual void				GetPlayerInfo( idVec3 &v3Origin, idMat3 &mat3Axis, int PlayerNum = -1, idAngles *deltaViewAngles = NULL ) const;
	virtual void				SetPlayerInfo( idVec3 &v3Origin, idMat3 &mat3Axis, int PlayerNum = -1 ) const;
	virtual void				EntitySetName( idEntity* pEnt, const char *psName );
// RAVEN END

	// Player methods.
	virtual bool				PlayerIsValid() const;
	virtual void				PlayerGetOrigin( idVec3 &org ) const;
	virtual void				PlayerGetAxis( idMat3 &axis ) const;
	virtual void				PlayerGetViewAngles( idAngles &angles ) const;
	virtual void				PlayerGetEyePosition( idVec3 &org ) const;
// RAVEN BEGIN
// bdube: new game edit stuff
	virtual bool				PlayerTraceFromEye ( trace_t &results, float length, int contentMask );

	// Effect methods
	virtual void				EffectRefreshTemplate ( const idDecl *effect ) const;

	// Light entity methods
	virtual void				LightSetParms ( idEntity* ent, int maxLevel, int currentLevel, float radius );

	// Common editing functions
	virtual int					GetGameTime ( int *previous = NULL ) const;
	virtual void				SetGameTime	( int time ) const;
	virtual bool				TracePoint ( trace_t &results, const idVec3 &start, const idVec3 &end, int contentMask ) const;
	virtual void				CacheDictionaryMedia ( const idDict* dict ) const;
	virtual void				SetCamera ( idEntity* camera ) const;
// RAVEN BEGIN
// bdube: added
	virtual int					GetGameEntityRegisterTime ( void ) const;
	virtual idEntity*			GetFirstSpawnedEntity ( void ) const;
	virtual idEntity*			GetNextSpawnedEntity ( idEntity* from ) const; 
// jscott: added
	virtual	void				DrawPlaybackDebugInfo( void );
	virtual	void				RecordPlayback( const usercmd_t &cmd, idEntity *source );
	virtual	bool				PlayPlayback( void );
	virtual	void				ShutdownPlaybacks( void );
// RAVEN END	
	
	// Script methods
	virtual int					ScriptGetStatementLineNumber ( idProgram* program, int instructionPointer ) const;
	virtual const char*			ScriptGetStatementFileName ( idProgram* program, int instructionPointer ) const;
	virtual int					ScriptGetStatementOperator ( idProgram* program, int instructionPointer ) const;
	virtual void*				ScriptGetCurrentFunction ( idInterpreter* interpreter ) const;
	virtual const char*			ScriptGetCurrentFunctionName ( idInterpreter* interpreter ) const;
	virtual int					ScriptGetCallstackDepth ( idInterpreter* interpreter ) const;
	virtual void*				ScriptGetCallstackFunction ( idInterpreter* interpreter, int depth ) const;
	virtual const char*			ScriptGetCallstackFunctionName ( idInterpreter* interpreter, int depth ) const;
	virtual int					ScriptGetCallstackStatement ( idInterpreter* interpreter, int depth ) const;
	virtual bool				ScriptIsReturnOperator ( int op ) const;
	virtual const char*			ScriptGetRegisterValue ( idInterpreter* interpreter, const char* varname, int callstackDepth ) const;
	virtual idThread*			ScriptGetThread ( idInterpreter* interpreter ) const;
	
	// Thread methods
	virtual int					ThreadGetCount ( void );
	virtual idThread*			ThreadGetThread ( int index );
	virtual const char*			ThreadGetName ( idThread* thread );
	virtual int					ThreadGetNumber ( idThread* thread );
	virtual const char*			ThreadGetState ( idThread* thread );
	
	// Class externals for entity viewer
	virtual void				GetClassDebugInfo ( const idEntity* entity, debugInfoProc_t proc, void* userdata );

	// In game map editing support.
	virtual const idDict *		MapGetEntityDict( const char *name ) const;
	virtual void				MapSave( const char *path = NULL ) const;
// RAVEN BEGIN
// rjohnson: added entity export
	virtual bool				MapHasExportEntities( void ) const;
// scork: simple func for the sound editor
	virtual const char*			MapLoaded( void ) const;
// cdr: AASTactical
	virtual idAASFile*			GetAASFile( int i );
// jscott: added entries for memory tracking
	virtual void				PrintMemInfo( MemInfo *mi );
	virtual size_t				ScriptSummary( const idCmdArgs &args ) const;
	virtual size_t				ClassSummary( const idCmdArgs &args ) const;
	virtual size_t				EntitySummary( const idCmdArgs &args ) const;
// RAVEN END
	virtual void				MapSetEntityKeyVal( const char *name, const char *key, const char *val ) const ;
	virtual void				MapCopyDictToEntity( const char *name, const idDict *dict ) const;
	virtual int					MapGetUniqueMatchingKeyVals( const char *key, const char *list[], const int max ) const;
	virtual void				MapAddEntity( const idDict *dict ) const;
	virtual int					MapGetEntitiesMatchingClassWithString( const char *classname, const char *match, const char *list[], const int max ) const;
	virtual void				MapRemoveEntity( const char *name ) const;
	virtual void				MapEntityTranslate( const char *name, const idVec3 &v ) const;
};

extern idGameEdit *				gameEdit;

// RAVEN BEGIN
// bdube: game logging
/*
===============================================================================

	Game Log.

===============================================================================
*/
class rvGameLog {
public:
	virtual				~rvGameLog( void ) {}

	virtual void		Init		( void ) = 0;
	virtual void		Shutdown	( void ) = 0;

	virtual void		BeginFrame	( int time ) = 0;
	virtual void		EndFrame	( void ) = 0;

	virtual	void		Set			( const char* keyword, int value ) = 0;
	virtual void		Set			( const char* keyword, float value ) = 0;
	virtual void		Set			( const char* keyword, const char* value ) = 0;
	virtual void		Set			( const char* keyword, bool value ) = 0;
	
	virtual void		Add			( const char* keyword, int value ) = 0;
	virtual void		Add			( const char* keyword, float value ) = 0;
};

extern rvGameLog *				gameLog;

#define GAMELOG_SET(x,y)		{if(g_gamelog.GetBool())gameLog->Set ( x, y );}
#define GAMELOG_ADD(x,y)		{if(g_gamelog.GetBool())gameLog->Add ( x, y );}

#define GAMELOG_SET_IF(x,y,z)	{if(g_gamelog.GetBool()&&(z))gameLog->Set ( x, y );}
#define GAMELOG_ADD_IF(x,y,z)	{if(g_gamelog.GetBool()&&(z))gameLog->Add ( x, y );}

// RAVEN END

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

	Game API.

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

// 4: network demos
// 5: fix idNetworkSystem ( memory / DLL boundary related )
// 6: more network demo APIs
// 7: cleanups
// 8: added some demo functions to the FS class
// 9: bump up for 1.1 patch
// 9: Q4 Gold
// 10: Patch 2 changes
// 14: 1.3
// 26: 1.4 beta
// 30: 1.4
// 37: 1.4.2
const int GAME_API_VERSION		= 37;

struct gameImport_t {

	int							version;				// API version
	idSys *						sys;					// non-portable system services
	idCommon *					common;					// common
	idCmdSystem *				cmdSystem;				// console command system
	idCVarSystem *				cvarSystem;				// console variable system
	idFileSystem *				fileSystem;				// file system
	idNetworkSystem *			networkSystem;			// network system
	idRenderSystem *			renderSystem;			// render system
	idSoundSystem *				soundSystem;			// sound system
	idRenderModelManager *		renderModelManager;		// render model manager
	idUserInterfaceManager *	uiManager;				// user interface manager
	idDeclManager *				declManager;			// declaration manager
	idAASFileManager *			AASFileManager;			// AAS file manager
	idCollisionModelManager *	collisionModelManager;	// collision model manager

// RAVEN BEGIN
// jscott:
	rvBSEManager *				bse;					// Raven effects system
// RAVEN END

// RAVEN BEGIN
// dluetscher: added the following members to exchange memory system data
#ifdef _RV_MEM_SYS_SUPPORT
	rvHeapArena *				heapArena;								// main heap arena that all other heaps use
	rvHeap *					systemHeapArray[MAX_SYSTEM_HEAPS];		// array of pointers to rvHeaps that are common to idLib, Game, and executable 
#endif
// RAVEN END
};

struct gameExport_t {

	int							version;				// API version
	idGame *					game;					// interface to run the game
	idGameEdit *				gameEdit;				// interface for in-game editing
// RAVEN BEGIN
// bdube: added
	rvGameLog *					gameLog;				// interface for game logging
// RAVEN END	
};

extern "C" {
typedef gameExport_t * (*GetGameAPI_t)( gameImport_t *import );
}

#endif /* !__GAME_H__ */