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

#ifndef __GAME_ENTITY_H__
#define __GAME_ENTITY_H__

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

	Game entity base class.

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

#include "Game.h"
#include "Pvs.h"
#include "physics/Physics_Static.h"
#include "script/Script_Interface.h"
#include "../sound/SoundShader.h"
#include "../sound/SoundEmitter.h"
#include "guis/UserInterfaceTypes.h"

typedef enum radarMasks_e {
	RM_RADAR		= BITT< 0 >::VALUE,
} radarMasks_t;

extern const idEventDefInternal EV_PostSpawn;
extern const idEventDefInternal EV_FindTargets;
extern const idEventDef EV_Use;
extern const idEventDef EV_Activate;
extern const idEventDef EV_Bind;
extern const idEventDef EV_BindToJoint;
extern const idEventDef EV_Unbind;
extern const idEventDef EV_Hide;
extern const idEventDef EV_Show;
extern const idEventDef EV_GetShaderParm;
extern const idEventDef EV_SetShaderParm;
extern const idEventDef EV_GetAngles;
extern const idEventDef EV_SetAngles;
extern const idEventDef EV_SetWorldAxis;
extern const idEventDef EV_SetLinearVelocity;
extern const idEventDef EV_SetAngularVelocity;
extern const idEventDef EV_SetSkin;
extern const idEventDef EV_StartSoundShader;
extern const idEventDef EV_StopSound;
extern const idEventDef EV_StopAllEffects;
extern const idEventDef EV_PlayEffect;
extern const idEventDef EV_StopEffect;
extern const idEventDef EV_StopEffectHandle;
extern const idEventDef EV_KillEffect;
extern const idEventDef EV_PlayOriginEffect;
extern const idEventDef EV_GetMins;
extern const idEventDef EV_GetMaxs;
extern const idEventDef EV_SetOrigin;
extern const idEventDef EV_SetAngles;
extern const idEventDef EV_SetGravity;
extern const idEventDef EV_SetTeam;

extern const idEventDef EV_SetModel;
extern const idEventDef EV_GetLinearVelocity;

extern const idEventDef EV_GetKeyWithDefault;
extern const idEventDef EV_GetIntKeyWithDefault;
extern const idEventDef EV_GetFloatKeyWithDefault;
extern const idEventDef EV_GetVectorKeyWithDefault;

extern const idEventDef EV_GetWorldOrigin;
extern const idEventDef EV_GetWorldAxis;
extern const idEventDef EV_GetOwner;
extern const idEventDef EV_IsOwner;
extern const idEventDef EV_GetDamagePower;

extern const idEventDef EV_PlayMaterialEffect;

extern const idEventDef EV_GetKey;
extern const idEventDef EV_GetIntKey;
extern const idEventDef EV_GetFloatKey;
extern const idEventDef EV_GetVectorKey;
extern const idEventDef EV_GetEntityKey;

extern const idEventDef EV_GetGUI;

extern const idEventDef AI_SetHealth;

extern const idEventDef EV_AddCheapDecal;

typedef enum teamAllegiance_e {
	TA_FRIEND,
	TA_NEUTRAL,
	TA_ENEMY,
} teamAllegiance_t;

const int TA_FLAG_FRIEND	= BITT< 0 >::VALUE;
const int TA_FLAG_NEUTRAL	= BITT< 1 >::VALUE;
const int TA_FLAG_ENEMY		= BITT< 2 >::VALUE;

class idProjectile;
class sdBindContext;
class sdDeclTargetInfo;
class sdDeclAOR;

// Think flags
typedef enum thinkFlags_s {
	TH_ALL					= -1,
	TH_THINK				= 1,		// run think function each frame
	TH_PHYSICS				= 2,		// run physics each frame
	TH_ANIMATE				= 4,		// update animation each frame
	TH_UPDATEVISUALS		= 8,		// update renderEntity
	TH_UPDATEPARTICLES		= 16,
	TH_RUNSCRIPT			= 32,
} thinkFlags_t;

enum cheapDecalUsage_t {
	CDU_INHIBIT,// genau genau die CDU ist gans toll! oder?
	CDU_LOCAL,	// Decails are attached and move around with the render entity
	CDU_WORLD	// Decails go in a big world list (But don't get deleted or moved then the spawner moves)
};

struct renderView_s;
struct renderEntity_t;
struct trace_t;
struct impactInfo_s;
class sdTeamInfo;
class sdScriptHelper;
class sdRequirementContainer;
class rvClientEntity;
class idPlayer;
class idAnimator;
class idPhysics;
class sdDeclDamage;
class sdCrosshairInfo;
class sdCommandMapInfo;
class sdRequirementCheckInterface;
class sdRadarInterface;
class sdGuiInterface;
class sdNetworkInterface;
class sdTaskInterface;
class sdDeclDeployableObject;
class sdUsableInterface;
class sdInteractiveInterface;
class sdEntityDisplayIconInterface;
class sdPlayerTask;
class sdTeleporter;

typedef sdTeamInfo* ( idEntity::*teamFunc_t )( void ) const;

const int PVS_VISIBLE			= BITT< 0 >::VALUE;
const int PVS_BROADCAST			= BITT< 1 >::VALUE;
const int PVS_DEFERRED_VISIBLE	= BITT< 2 >::VALUE;
const int PVS_NUMBITS			= 3;

class sdBindNetworkData {
public:
							sdBindNetworkData( void );

	void					MakeDefault( void );

	void					Write( const idEntity* ent, const sdBindNetworkData& base, idBitMsg& msg );
	void					Read( const idEntity* ent, const sdBindNetworkData& base, const idBitMsg& msg );
	bool					Check( const idEntity* ent ) const;
	void					Apply( idEntity* ent ) const;

	static const int		bindPosBits;

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

	jointHandle_t			joint;
	int						bodyId;
	int						bindMasterId;
	bool					oriented;
};

class sdColorNetworkData {
public:
							sdColorNetworkData( void );

	void					MakeDefault( void );

	void					Write( const idEntity* ent, const sdColorNetworkData& base, idBitMsg& msg );
	void					Read( const idEntity* ent, const sdColorNetworkData& base, const idBitMsg& msg );
	void					Apply( idEntity* ent ) const;
	bool					Check( const idEntity* ent ) const;

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

	static int				GetColor( const idEntity* ent );

	int						color;
};

class idEntity : public idClass {
public:
	static const int		MAX_PROXIMITY_ENTITIES = 128;
	static const int		NUM_ENTITY_CAHCES = 8;

	typedef idStaticList< idEntityPtr< idEntity >, MAX_PROXIMITY_ENTITIES > entityCache_t;

	int						entityNumber;			// index into the entity list
	int						entityDefNumber;		// index into the entity def list
	int						mapSpawnId;				//

	idLinkList<idEntity>	spawnNode;				// for being linked into spawnedEntities list
	idLinkList<idEntity>	activeNode;				// for being linked into activeEntities list
	idLinkList<idEntity>	activeNetworkNode;		// for being linked into activeEntities list
	idLinkList<idEntity>	networkNode;			// for being linked into networkedEntities list

	sdEntityState*			freeStates[ NSM_NUM_MODES ];				//

	idLinkList< idClass >	instanceNode;			//

	idStr					name;					// name of entity
	idDict					spawnArgs;				// key/value pairs used to spawn and initialize entity
	idScriptObject*			scriptObject;			// contains all script defined data for this entity

	int						thinkFlags;				// TH_? flags

	// temp storage during write snapshot
	int						snapshotPVSFlags;		//

	const sdDeclAOR*		aorLayout;
	int						aorFlags;
	float					aorDistanceSqr;			// last distance squared used for AOR calculations
	int						aorPacketSpread;

//	renderView_s*			renderView;				// for camera views from this entity

	idList< idEntityPtr< idEntity > >	targets;	// when this entity is activated these entities entity are activated

	// RAVEN BEGIN
	// bdube: client entities
	idLinkList< rvClientEntity >	clientEntities;

	// RAVEN END

	struct entityFlags_s {
		bool				notarget			:1;	// if true never attack or target this entity
		bool				noknockback			:1;	// if true no knockback from hits
		bool				takedamage			:1;	// if true this entity can be damaged
		bool				hidden				:1;	// if true this entity is not visible
		bool				bindOrientated		:1;	// if true both the master orientation is used for binding

		bool				forceDisableClip	:1; // EnableClip will not re-enable clip if this flag is set

		bool				preventDeployment	:1; // don't allow objects to be deployed on top of this one

		bool				selected			:1; // FIXME: deprecated...

		bool				canCollideWithTeam	:1;

		bool				noCrosshairTrace	:1; // disable crosshair traces against this entity

		bool				spotted				:1;

		bool				unlockInterpolate	:1;	// origin interpolated when running unlock fps mode

		bool				noGuiInteraction	:1;

		bool				dontLink			:1; // never link the clip

		bool				noDamageFeedback	:1; // allow damage feedback if this entity is the inflictor

		bool				allowPredictionErrorDecay	:1;	// allow PED to run this frame

		bool				forceDoorCollision	:1;

		bool				forceDecalUsageLocal :1;
	} fl;

	idLinkList<idEntity>			interpolateNode;			// entities marked for interpolation in fps unlock mode
	idVec3							interpolateHistory[2];		// holds origin for interpolation work
	int								interpolateLastFramenum;	// holds last frame number this entity was picked up for interpolation

	idRandom						missileRandom;	// random number generator for things like bullet spread etc

public:

	ABSTRACT_PROTOTYPE( idEntity );

							idEntity();
	virtual					~idEntity();

	void					Spawn( void );

	virtual bool			StartSynced( void ) const { return spawnArgs.GetBool( "networkSync" ); }

	virtual const char*		GetDefaultSurfaceType( void ) const { return ""; }

	void					WriteCreateEvent( idBitMsg* msg, const sdReliableMessageClientInfoBase& target );
	void					WriteDestroyEvent( void );

	static void				ClearEntityCaches( void );

	static idEntity*		FromCreationData( idFile* file );
	void					WriteCreationData( idFile* file ) const;

	void					LoadDemoBaseData( idFile* file );
	virtual void			ReadDemoBaseData( idFile* file ) { ; }
	virtual void			WriteDemoBaseData( idFile* file ) const { ; }

	virtual bool			NoThink( void ) const { return false; }

	void					FixupRemoteCamera( void );

	void					CallNonBlockingScriptEvent( const sdProgram::sdFunction* function, sdScriptHelper& helper ) const;
	bool					CallBooleanNonBlockingScriptEvent( const sdProgram::sdFunction* function, sdScriptHelper& helper ) const;
	float					CallFloatNonBlockingScriptEvent( const sdProgram::sdFunction* function, sdScriptHelper& helper ) const;

	const char *			GetEntityDefName( void ) const;
	void					SetName( const char *name );
	virtual const char *	GetName( void ) const;
	virtual void			UpdateChangeableSpawnArgs( const idDict *source );

	virtual bool			DoRadiusPush( void ) const { return !fl.noknockback; }
	virtual float			GetRadiusPushScale( void ) const { return 1.0f; }
	virtual void			ApplyRadiusPush( const idVec3& pushOrigin, const idVec3& entityOrigin, const sdDeclDamage* damageDecl, float pushScale, float radius );

	virtual idScriptObject*	GetScriptObject( void ) const { return this ? scriptObject : NULL; }

	// command map
	void					SetSpotted( idEntity* other );
	bool					SendCommandMapInfo( idPlayer* player );
	bool					IsInRadar( idPlayer* player );

	void					SetNetworkSynced( bool value );
	bool					IsNetSynced( void ) const;

	virtual void						ApplyNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& newState ) { ; }
	virtual void						ReadNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, const idBitMsg& msg ) const { ; }
	virtual void						WriteNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& baseState, sdEntityStateNetworkData& newState, idBitMsg& msg ) const { ; }
	virtual bool						CheckNetworkStateChanges( networkStateMode_t mode, const sdEntityStateNetworkData& baseState ) const { return false; }
	virtual sdEntityStateNetworkData*	CreateNetworkStructure( networkStateMode_t mode ) const { return NULL; }
	// this is called when resetting the state back to the base state before applying a new state and repredicting
	virtual void						ResetNetworkState( networkStateMode_t mode, const sdEntityStateNetworkData& newState ) { ; }

	virtual void			WriteInitialReliableMessages( const sdReliableMessageClientInfoBase& target ) const {};
	virtual void			OnSnapshotHitch() { ; }

	bool					IsInterpolated( void ) const;

							// clients generate views based on all the player specific options,
							// cameras have custom code, and everything else just uses the axis orientation
	virtual renderView_t *	GetRenderView();

	virtual idLinkList< idClass >* GetInstanceNode( void ) { return &instanceNode; }

	virtual bool			HasAbility( qhandle_t handle ) const { return false; }
	virtual bool			SupportsAbilities( void ) const { return false; }

	// thinking
	virtual void			Think( void );
	virtual void					PostThink( void ) { assert( false ); }
	virtual idLinkList<idEntity>*	GetPostThinkNode( void ) { return NULL; }
	bool					IsActive( void ) const;
	void					BecomeActive( int flags, bool force = false );
	void					BecomeInactive( int flags, bool force = false );

	virtual void			DisableClip( bool activateContacting = true );
	virtual void			EnableClip( void );
	virtual void			GetLocalAngles( idAngles& localAng );

	virtual void			SetMaxHealth( int count ) { }
	virtual void			SetHealth( int count ) { }
	virtual void			SetHealthDamaged( int count, teamAllegiance_t allegiance ) { SetHealth( count ); } // Gordon: Specifically from ::Damage, some things may wish to filter this in some way
	virtual int				GetHealth( void ) const { return 0; }
	virtual int				GetMaxHealth( void ) const { return 0; }
	virtual int				GetMinDisplayHealth( void ) const { return 0; }

	virtual void			ReachedPosition( void ) { }
	virtual void			PostMapSpawn( void );

	virtual const idVec3&	GetWayPointOrigin( void ) const { return GetPhysics()->GetOrigin(); }
	virtual const idBounds&	GetWayPointBounds( void ) const { return GetPhysics()->GetBounds(); }
	virtual const idMat3&	GetWayPointAxis( void ) const { return GetPhysics()->GetAxis(); }

	// visuals
	virtual void			OnModelDefCreated( void ) { }
	virtual void			Present( void );
	virtual renderEntity_t* GetRenderEntity( void ) { return &renderEntity; }
	virtual const renderEntity_t* GetRenderEntity( void ) const { return &renderEntity; }
	virtual int				GetModelDefHandle( int id = 0 );
	virtual void			SetModel( const char *modelname );
	void					SetSkin( const idDeclSkin *skin );
	const idDeclSkin *		GetSkin( void ) const;
	void					SetShaderParm( int parmnum, float value );
	virtual void			SetColor( float red, float green, float blue );
	virtual void			SetColor( const idVec3 &color );
	virtual void			GetColor( idVec3 &out ) const;
	virtual void			SetColor( const idVec4 &color );
	virtual void			GetColor( idVec4 &out ) const;
	virtual void			FreeModelDef( void );
	virtual void			FreeLightDef( void );
	virtual void			Hide( void );
	virtual void			Show( void );
	bool					IsHidden( void ) const;
	void					ForceDisableClip( void );
	void					ForceEnableClip( void );
	void					UpdateVisuals( void );
	void					UpdateModel( void );
	virtual void			UpdateModelTransform( void );
	virtual void			OnUpdateVisuals( void );
	virtual int				EvaluateContacts( contactInfo_t* list, contactInfoExt_t* extList, int max ) { return 0; }
	virtual int				AddCustomConstraints( constraintInfo_t* list, int max ) { return 0; }

	virtual bool			IsOwner( idEntity* other ) const { return false; }

	// animation
	virtual bool			AllowAnimationInhibit( void ) { return true; }
	virtual bool			UpdateAnimationControllers( void );
	virtual bool			UpdateRenderEntity( renderEntity_t* renderEntity, const renderView_s* renderView, int& lastModifiedGameTime );
	static bool				ModelCallback( renderEntity_t* renderEntity, const renderView_s* renderView, int& lastModifiedGameTime );

	virtual void			GetWaterCurrent( idVec3& waterCurrent ) const { waterCurrent = vec3_zero; }
	virtual void			CheckWater( const idVec3& waterBodyOrg, const idMat3& waterBodyAxis, idCollisionModel* waterBodyModel ) { ; }
	virtual void			CheckWaterEffectsOnly( void ) { ; }

	int						FindSurfaceId( const char* surfaceName );

	virtual void			OnGuiActivated( void ) { ; }
	virtual void			OnGuiDeactivated( void ) { ; }

	virtual sdBindContext*	GetBindContext( void ) { return NULL; }

	// sound
	bool					StartSound( const char *soundName, const soundChannel_t channelStart, const soundChannel_t channelEnd, int soundShaderFlags, int *length );
	bool					StartSound( const char *soundName, const soundChannel_t channel, int soundShaderFlags, int *length );
	bool					StartSoundShader( const idSoundShader *shader, const soundChannel_t channel, int soundShaderFlags, int *length );
	bool					StartSoundShader( const idSoundShader *shader, const soundChannel_t channelStart, const soundChannel_t channelEnd, int soundShaderFlags, int *length );
	void					StopSound( const soundChannel_t channel );	// pass SND_ANY to stop all sounds
	void					SetChannelVolume( const soundChannel_t channel, float volume );
	void					SetChannelPitchShift( const soundChannel_t channel, float pitchshift );
	void					SetChannelFlags( const soundChannel_t channel, int flags );
	void					ClearChannelFlags( const soundChannel_t channel, int flags );
	void					SetChannelOffset( const soundChannel_t channel, int ms );
	void					SetSoundVolume( float volume );
	void					UpdateSound( void );
	int						GetListenerId( void ) const;
	idSoundEmitter *		GetSoundEmitter( void ) const;
	void					FreeSoundEmitter( bool immediate );
	void					FadeSound( const soundChannel_t channel, float to, float over );

	virtual void			OnEventRemove( void );

// RAVEN BEGIN
// bdube: added effect functions
	// effects
	rvClientEffect*			PlayEffect		( const char* effectName, const idVec3& color, const char* materialType, jointHandle_t joint, bool loop = false, const idVec3& endOrigin = vec3_origin );
	rvClientEffect*			PlayEffect		( const char* effectName, const idVec3& color, const char* materialType, const idVec3& origin, const idMat3& axis, bool loop = false, const idVec3& endOrigin = vec3_origin, bool viewsuppress = true );
	rvClientEffect*			PlayEffectMaxVisDist		( const char* effectName, const idVec3& color, const char* materialType, jointHandle_t joint, bool loop = false, bool isStatic = false, float maxVisDist = 0.f, const idVec3& endOrigin = vec3_origin );
	rvClientEffect*			PlayEffectMaxVisDist		( const char* effectName, const idVec3& color, const char* materialType, const idVec3& origin, const idMat3& axis, bool loop = false, bool isStatic = false, float maxVisDist = 0.f, const idVec3& endOrigin = vec3_origin );
	rvClientEffect*			PlayEffect		( const int effectHandle, const idVec3& color, jointHandle_t joint, bool loop = false, const idVec3& endOrigin = vec3_origin );
	rvClientEffect*			PlayEffect		( const int effectHandle, const idVec3& color, const idVec3& origin, const idMat3& axis, bool loop = false, const idVec3& endOrigin = vec3_origin, bool viewsuppress = true );
	rvClientEffect*			PlayEffectMaxVisDist		( const int effectHandle, const idVec3& color, jointHandle_t joint, bool loop = false, bool isStatic = false, float maxVisDist= 0.f, const idVec3& endOrigin = vec3_origin );
	rvClientEffect*			PlayEffectMaxVisDist		( const int effectHandle, const idVec3& color, const idVec3& origin, const idMat3& axis, bool loop = false, bool isStatic = false, float maxVisDist = 0.f, const idVec3& endOrigin = vec3_origin );
	void					StopEffect		( const char* effectName, bool destroyParticles = false );
	void					StopEffect		( int effectHandle, bool destroyParticles = false );
	void					StopEffectHandle( unsigned int handle, bool destroyParticles = false );
	void					UnBindEffectHandle( unsigned int handle );
	void					SetEffectAttenuation( unsigned int handle, float attenuation );
	void					SetEffectColor	( unsigned int handle, const idVec4& color );
	void					SetEffectOrigin	( unsigned int handle, const idVec3& origin );
	void					SetEffectAxis	( unsigned int handle, const idMat3& axis);

	void					StopAllEffects	( bool destroyParticles = false );
	void					UpdateEffects	( void );

	float					DistanceTo		( idEntity* ent );
	float					DistanceTo		( const idVec3& pos );
	float					DistanceTo2d	( idEntity* ent );
	float					DistanceTo2d	( const idVec3& pos );

// RAVEN END

	// entity binding
	virtual void			PreBind( void );
	virtual void			PostBind( void );
	virtual void			PreUnbind( void );
	virtual void			PostUnbind( void );
	void					JoinTeam( idEntity *teammember );
	void					Bind( idEntity *master, bool orientated );
	void					BindToJoint( idEntity *master, const char *jointname, bool orientated );
	void					BindToJoint( idEntity *master, jointHandle_t jointnum, bool orientated );
	void					BindToBody( idEntity *master, int bodyId, bool orientated );
	void					Unbind( void );
	bool					IsBound( void ) const;
	bool					IsBoundTo( idEntity *master ) const;

	// called when the bind master's visibility changes
	virtual void			OnBindMasterVisChanged();
	void					NotifyVisChanged();

	idEntity*				GetBindMaster( void ) const { return bindMaster; }
	jointHandle_t			GetBindJoint( void ) const { return bindJoint; }
	int						GetBindBody( void ) const { return bindBody; }
	idEntity*				GetTeamMaster( void ) const { return teamMaster; }
	idEntity*				GetNextTeamEntity( void ) const { return teamChain; }

	void					ConvertLocalToWorldTransform( idVec3 &offset, idMat3 &axis );
	void					ConvertLocalToWorldTransform( idVec3& offset );
	void					ConvertLocalToWorldTransform( idMat3& axis );
	idVec3					GetLocalVector( const idVec3 &vec ) const;
	idVec3					GetLocalCoordinates( const idVec3 &vec ) const;
	idVec3					GetWorldVector( const idVec3 &vec ) const;
	idVec3					GetWorldCoordinates( const idVec3 &vec ) const;
	bool					GetMasterPosition( idVec3 &masterOrigin, idMat3 &masterAxis ) const;
	idEntity*				GetMaster( void ) const { return bindMaster; }
	void					GetWorldVelocities( idVec3 &linearVelocity, idVec3 &angularVelocity ) const;
	
	// physics
							// set a new physics object to be used by this entity
	void					SetPhysics( idPhysics *phys );
							// get the physics object used by this entity
	idPhysics *				GetPhysics( void ) const { return physics; }
							// restore physics pointer for save games
	void					RestorePhysics( idPhysics *phys );
							// run the physics for this entity
	bool					RunPhysics( void );
							// set the origin of the physics object (relative to bindMaster if not NULL)
	virtual void			SetOrigin( const idVec3 &org );
							// set the axis of the physics object (relative to bindMaster if not NULL)
	virtual void			SetAxis( const idMat3 &axis );
	virtual const idMat3	&GetAxis( void );
							// sets the origin and axis of the physics object (relative to bindMaster if not NULL)
	virtual void			SetPosition( const idVec3 &org, const idMat3 &axis );
							// use angles to set the axis of the physics object (relative to bindMaster if not NULL)
	void					SetAngles( const idAngles &ang );
							// get the floor position underneath the physics object
	bool					GetFloorPos( float max_dist, idVec3 &floorpos ) const;
							// retrieves the transformation going from the physics origin/axis to the visual origin/axis
	virtual bool			GetPhysicsToVisualTransform( idVec3 &origin, idMat3 &axis );
							// retrieves the transformation going from the physics origin/axis to the sound origin/axis
	virtual bool			GetPhysicsToSoundTransform( idVec3 &origin, idMat3 &axis );
							// called from the physics object when colliding, should return true if the physics simulation should stop
	virtual bool			Collide( const trace_t& collision, const idVec3 &velocity, int bodyId );
							// called from the physics object when colliding, this outright kills whatever is being hit
	virtual void			CollideFatal( idEntity* other );
							// called from the physics object when being collided with
	virtual void			Hit( const trace_t &collision, const idVec3 &velocity, idEntity *other );
							// retrieves impact information, 'ent' is the entity retrieving the info
	virtual void			GetImpactInfo( idEntity *ent, int id, const idVec3 &point, impactInfo_s* info );
							// apply an impulse to the physics object, 'ent' is the entity applying the impulse
	virtual void			ApplyImpulse( idEntity *ent, int id, const idVec3 &point, const idVec3 &impulse );
							// add a force to the physics object, 'ent' is the entity adding the force
	virtual void			AddForce( idEntity *ent, int id, const idVec3 &point, const idVec3 &force );
							// activate the physics object, 'ent' is the entity activating this entity
	virtual void			ActivatePhysics( void );
							// returns true if the physics object is at rest
	virtual bool			IsAtRest( void ) const;
							// returns the time the physics object came to rest
	virtual int				GetRestStartTime( void ) const;
							// add a contact entity
	virtual void			AddContactEntity( idEntity *ent );
							// remove a touching entity
	virtual void			RemoveContactEntity( idEntity *ent );

	virtual	bool			IsCollisionPushable( void ) { return true; }

	// damage
							// returns true if this entity can be damaged from the given origin
	virtual bool			CanDamage( const idVec3 &origin, idVec3 &damagePoint, int mask, idEntity* passEntity, trace_t* tr = NULL ) const;

							// applies damage to this entity
	virtual	void			Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const sdDeclDamage* damage, const float damageScale, const trace_t* collision, bool forceKill = false );

	bool					CheckTeamDamage( idEntity *inflictor, const sdDeclDamage* damageDecl );

	virtual	void			UpdateKillStats( idPlayer* player, const sdDeclDamage* damageDecl, bool headshot ) { ; }

	virtual	void			OnBulletImpact( idEntity* attacker, const trace_t& trace ) { ; }

	virtual	void			SetLastAttacker( idEntity* attacker, const sdDeclDamage* damage ) { ; }

							// callback function for when another entity received damage from this entity.  damage can be adjusted and returned to the caller.
	virtual void			DamageFeedback( idEntity *victim, idEntity *inflictor, int oldHealth, int newHealth, const sdDeclDamage* damageDecl, bool headshot ) { ; }
							// notifies this entity that it is in pain
	virtual bool			Pain( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location, const sdDeclDamage* damageDecl );
							// notifies this entity that is has been killed
	virtual void			Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location, const sdDeclDamage* damageDecl );

	virtual bool			CanCollide( const idEntity* other, int traceId ) const;
							// this is the proxy entity for the other - should it collide?
	virtual bool			ShouldProxyCollide( const idEntity* other ) const;

	static void				CheckForDuplicateRenderEntityHandles( void );

	// scripting
	virtual bool			ShouldConstructScriptObjectAtSpawn( void ) const;
	virtual sdProgramThread* ConstructScriptObject( void );
	virtual void			DeconstructScriptObject( void );

	virtual void			OnTeamBlocked( idEntity* blockedPart, idEntity* blockingEntity ) { ; }
	virtual void			OnPartBlocked( idEntity* blockingEntity ) { ; }

	virtual void			OnMoveStarted( void ) { ; }
	virtual void			OnMoveFinished( void ) { ; }

	virtual bool			WantsTouch( void ) const { return false; }
	virtual void			OnTouch( idEntity *other, const trace_t& trace ) { ; }

	virtual void			OnTeleportStarted( sdTeleporter* teleporter ) { ; }
	virtual void			OnTeleportFinished( void ) { ; }
	virtual bool			AllowTeleport( void ) const { return false; }

	virtual const idBounds*	GetSelectionBounds( void ) const { return NULL; }

	virtual bool			RunPausedPhysics( void ) const { return false; }

	// targets
	void					FindTargets( void );
	void					RemoveNullTargets( void );

	// misc
	virtual void			Teleport( const idVec3 &origin, const idAngles &angles, idEntity *destination );
	bool					TouchTriggers( void );
	idCurve_Spline<idVec3> *GetSpline( void ) const;
	virtual void			ShowEditingDialog( void );

	bool					GetWorldAxis( jointHandle_t joint, idMat3& axis );
	bool					GetWorldOrigin( jointHandle_t joint, idVec3& org );
	bool					GetWorldOriginAxisNoUpdate( jointHandle_t joint, idVec3& org, idMat3& axis );
	bool					GetWorldOriginAxis( jointHandle_t joint, idVec3& org, idMat3& axis );

	enum {
		EVENT_MAXEVENTS
	};

	virtual void			UpdatePredictionErrorDecay( void ) { ; }
	virtual void			OnNewOriginRead( const idVec3& newOrigin ) { ; }
	virtual void			OnNewAxesRead( const idMat3& newAxes ) { ; }
	virtual void			ResetPredictionErrorDecay( const idVec3* origin = NULL, const idMat3* axes = NULL ) { ; }

	virtual void			OnPhysicsRested( void ) { BecomeInactive( TH_PHYSICS ); }

	void					ForceNetworkUpdate( void );

	virtual bool			ClientReceiveEvent( int event, int time, const idBitMsg &msg );
	virtual bool			ClientReceiveUnreliableEvent( int event, int time, const idBitMsg &msg );

	virtual bool			UpdateCrosshairInfo( idPlayer* player, sdCrosshairInfo& info );

	void					BroadcastEvent( int eventId, const idBitMsg *msg, bool saveEvent, const sdReliableMessageClientInfoBase& target ) const;
	void					BroadcastUnreliableEvent( int eventId, const idBitMsg *msg ) const;

	virtual void			SetGameTeam( sdTeamInfo* _team ) { ; }
	virtual sdTeamInfo*		GetGameTeam( void ) const { return NULL; }
	teamAllegiance_t		GetEntityAllegiance( const idEntity* other ) const;
	const idVec4&			GetColorForAllegiance( idEntity* other ) const;
	static const idVec4&	GetColorForAllegiance( teamAllegiance_t allegiance );
	static const idVec4&	GetFireteamColor( void );
	static const idVec4&	GetFireteamLeaderColor( void );
	static const idVec4&	GetBuddyColor( void );
	virtual void			GetTaskName( idWStr& out );

	virtual sdRequirementCheckInterface*	GetRequirementInterface( void ) { return NULL; }
	virtual sdGuiInterface*					GetGuiInterface( void ) { return NULL; }
	virtual sdNetworkInterface*				GetNetworkInterface( void ) { return NULL; }
	virtual sdTaskInterface*				GetTaskInterface( void ) { return NULL; }
	virtual sdRequirementContainer*			GetSpawnRequirements( void ) { return NULL; }
	virtual sdUsableInterface*				GetUsableInterface( void ) { return NULL; }
	virtual sdInteractiveInterface*			GetInteractiveInterface( void ) { return NULL; }
	virtual sdEntityDisplayIconInterface*	GetDisplayIconInterface( void ) { return NULL; }

	idPhysics_Static&		GetDefaultPhysics( void ) { return defaultPhysicsObj; }

	virtual bool			NeedsRepair() { return false; }

	virtual idEntity*		GetDisguiseEntity( void ) { return this; }

	virtual cheapDecalUsage_t GetDecalUsage( void );

	virtual	bool			OverridePreventDeployment( idPlayer* ) { return false; }

	virtual	int				PlayHitBeep( idPlayer* player, bool headshot ) const;
	virtual float			GetDamageXPScale( void ) const { return 1.f; }

	// input -> usercmd translation
	virtual bool			OnKeyMove( char forward, char right, char up, usercmd_t& cmd ) { return false; }
	virtual void			OnControllerMove( bool doGameCallback, const int numControllers, const int* controllerNumbers,
											const float** controllerAxis, idVec3& viewAngles, usercmd_t& cmd );
	virtual void			OnMouseMove( idPlayer* player, const idAngles& baseAngles, idAngles& angleDelta ) {}
	

	virtual int							GetOcclusionQueryHandle( void ) const { return occlusionQueryHandle; }
	virtual const occlusionTest_t&		GetOcclusionQueryInfo( void ) const { return occlusionQueryInfo; }
	virtual const occlusionTest_t&		UpdateOcclusionInfo( int viewId );
	virtual bool						IsVisibleOcclusionTest();

	virtual bool			IsPhysicsInhibited( void ) const { return ( aorFlags & AOR_INHIBIT_PHYSICS ) != 0; }
	int						GetAORPhysicsLOD( void ) const;

	const idVec3&			GetLastPushedOrigin( void ) const { return lastPushedOrigin; }
	const idMat3&			GetLastPushedAxis( void ) const { return lastPushedAxis; }
			
	virtual bool			DisableClipOnRemove( void ) const { return false; }

protected:
	renderEntity_t			renderEntity;						// used to present a model to the renderer
	int						modelDefHandle;						// handle to static renderer model
	refSound_t				refSound;							// used to present sound to the audio engine

	float					occlusionQueryBBScale;				// Gordon: FIXME: This probably shouldn't be here
	int						occlusionQueryHandle;
	occlusionTest_t			occlusionQueryInfo;

	// last origin & axis pushed to the renderer
	idVec3					lastPushedOrigin;
	idMat3					lastPushedAxis;

private:
	idPhysics_Static		defaultPhysicsObj;					// default physics object
	idPhysics *				physics;							// physics used for this entity
	const sdDeclTargetInfo*	contentBoundsFilter;

	// Gordon: FIXME: Alloc only as needed
	idEntity*				bindMaster;							// entity bound to if unequal NULL
	jointHandle_t			bindJoint;							// joint bound to if unequal INVALID_JOINT
	int						bindBody;							// body bound to if unequal -1
	idEntity*				teamMaster;							// master of the physics team
	idEntity*				teamChain;							// next entity in physics team

	typedef struct beamInfo_s {
		renderEntity_t			beamEnt;
		qhandle_t				beamHandle;
	} beamInfo_t;

	idList< beamInfo_t* >	beams;
	const sdDeclLocStr*		taskName;

protected:
	static entityCache_t					scriptEntityCache;
	static sdPair< bool, entityCache_t >	savedEntityCache[ NUM_ENTITY_CAHCES ];
	static sdCrosshairInfo*					crosshairInfo;

public:
	// physics
							// initialize the default physics
	void					InitDefaultPhysics( const idVec3 &origin, const idMat3 &axis );
	
	idClipModel*			InitDefaultClipModel();
	const char*				GetClipModelName( void ) const;

	bool					CheckEntityContentBoundsFilter( idEntity* other ) const;

	// deletes any entities bound to this object
	void					RemoveBinds( idBounds* bounds = NULL, bool onlyUnbindScripted = false );

protected:

	// physics

	// entity binding
	virtual bool			InitBind( idEntity *master );		// initialize an entity binding
	virtual void			FinishBind( void );					// finish an entity binding
	void					QuitTeam( void );					// leave the current team
	void					FreeBeam( int index );				// kill a specific handle's beam render entity
	void					FreeAllBeams( void );				// kill all beam render entities

// RAVEN BEGIN
// bdube: client entities
	void					RemoveClientEntities ( void );		// deletes any client entities bound to this object
// RAVEN END

	static void				AddClassToBoundsCache( idClass* cls );

	bool					LaunchBullet( idEntity* owner, idEntity* ignoreEntity, const idDict& projectileDict, const idVec3& origin, const idMat3& axis, const idVec3& tracerMuzzleOrigin, const idMat3& tracerMuzzleAxis, float damagePower, int forceTracer, rvClientEffect** tracerOut = NULL, bool useAntiLag = true );
	bool					DoLaunchBullet( idEntity* owner, idEntity* ignoreEntity, const idDict& projectileDict, const idVec3& startPos, const idVec3& endPos, const idVec3& tracerMuzzleOrigin, const idMat3& tracerMuzzleAxis, float damagePower, int forceTracer, rvClientEffect** tracerOut, int mask, const sdDeclDamage* bulletDamage, bool doEffects, bool doImpact, bool useAntiLag );

	idVec3					bulletTracerStart;
	idVec3					bulletTracerEnd;

	guiHandle_t				GetEntityGuiHandle( const int guiNum );

	// events
	void					Event_GetName( void );
	void					Event_FindTargets( void );
	void					Event_Bind( idEntity *master );
	void					Event_BindPosition( idEntity *master );
	void					Event_BindToJoint( idEntity *master, const char *jointname, bool orientated );
	void					Event_Unbind( void );
	void					Event_RemoveBinds( void );
	void					Event_SetModel( const char *modelname );
	void					Event_SetSkin( const char *skinname );
	void					Event_SetCoverage( float v );
	void					Event_GetShaderParm( int parmnum );
	void					Event_SetShaderParm( int parmnum, float value );
	void					Event_SetShaderParms( float parm0, float parm1, float parm2, float parm3 );
	void					Event_SetColor( float red, float green, float blue );
	void					Event_GetColor( void );
	void					Event_IsHidden( void );
	void					Event_Hide( void );
	void					Event_Show( void );
	void					Event_StartSound( const char *soundName, int channel );
	void					Event_StopSound( int channel );
	void					Event_FadeSound( int channel, float to, float over );
	void					Event_SetChannelPitchShift( const soundChannel_t channel, float shift );
	void					Event_SetChannelFlags( const soundChannel_t channel, int flags );
	void					Event_ClearChannelFlags( const soundChannel_t channel, int flags );
	void					Event_GetWorldAxis( int index );
	void					Event_SetWorldAxis( const idVec3& fwd, const idVec3& right, const idVec3& up );
	void					Event_GetWorldOrigin( void );
	void					Event_GetGravityNormal( void );
	void					Event_SetWorldOrigin( const idVec3 &org );
	void					Event_GetOrigin( void );
	void					Event_SetOrigin( const idVec3 &org );
	void					Event_GetAngles( void );
	void					Event_SetAngles( const idAngles &ang );
	void					Event_SetGravity( const idVec3& gravity );
	void					Event_AlignToAxis( const idVec3& vec, int axis );
	void					Event_SetLinearVelocity( const idVec3 &velocity );
	void					Event_GetLinearVelocity( void );
	void					Event_SetAngularVelocity( const idVec3 &velocity );
	void					Event_GetAngularVelocity( void );
	void					Event_GetMass( void );
	void					Event_GetCenterOfMass( void );
	void					Event_SetFriction( float linear, float angular, float contact );
	void					Event_SetSize( const idVec3 &mins, const idVec3 &maxs );
	void					Event_GetSize( void );
	void					Event_GetMins( void );
	void					Event_GetMaxs( void );
	void					Event_GetAbsMins( void );
	void					Event_GetAbsMaxs( void );
	void					Event_GetRenderMins( void );
	void					Event_GetRenderMaxs( void );
	void					Event_SetRenderBounds( const idVec3& mins, const idVec3& maxs );
	void					Event_Touches( idEntity *ent, bool ignoreNonTrace );
	void					Event_TouchesBounds( idEntity *ent );
	void					Event_GetNextKey( const char *prefix, const char *lastMatch );
	void					Event_SetKey( const char *key, const char *value );
	void					Event_GetKey( const char *key );
	void					Event_GetIntKey( const char *key );
	void					Event_GetFloatKey( const char *key );
	void					Event_GetVectorKey( const char *key );
	void					Event_GetEntityKey( const char *key );
	void					Event_DistanceTo( idEntity *ent );
	void					Event_DistanceToPoint( const idVec3 &point );
	void					Event_DetachRotationBind( int handle );

	void					Event_DisablePhysics( void );
	void					Event_EnablePhysics( void );
	void					Event_EntitiesInBounds( const idVec3& mins, const idVec3& maxs, int contentMask, bool absoluteCoords );
	void					Event_EntitiesInLocalBounds( const idVec3& mins, const idVec3& maxs, int contentMask );
	void					Event_EntitiesInTranslation( const idVec3& start, const idVec3& end, int contentMask, idEntity* passEntity );
	void					Event_EntitiesInRadius( const idVec3& centre, float radius, int contentMask, bool absoluteCoords );
	void					Event_EntitiesOfClass( int typeHandle, bool additive );
	void					Event_EntitiesOfType( int typeHandle );
	void					Event_EntitiesOfCollection( const char* name );
	void					Event_FilterEntitiesByRadius( const idVec3& origin, float radius, bool inclusive );
	void					Event_FilterEntitiesByClass( const char* typeName, bool inclusive );
	void					Event_FilterEntitiesByAllegiance( int mask, bool inclusive );
	void					Event_FilterEntitiesByDisguiseAllegiance( int mask, bool inclusive );
	void					Event_FilterEntitiesByFilter( int filterIndex, bool inclusive );
	void					Event_FilterEntitiesByTouching( bool inclusive );
	void					Event_GetBoundsCacheCount( void );
	void					Event_GetBoundsCacheEntity( int index );
	void					Event_GetEntityAllegiance( idEntity* entity );
	void					Event_HasAbility( const char* abilityName );
	void					Event_SyncScriptField( const char* fieldName );
	void					Event_SyncScriptFieldBroadcast( const char* fieldName );
	void					Event_SyncScriptFieldCallback( const char* fieldName, const char* functionName );
	void					Event_GetMaster( void );
	void					Event_TakesDamage( void );
	void					Event_SetTakesDamage( bool value );
	void					Event_SetNetworkSynced( bool value );
	void					Event_ApplyDamage( idEntity* inflictor, idEntity* attacker, const idVec3& dir, int damageIndex, float damageScale, idScriptObject* collisionHandle );
	void					Event_Physics_ClearContacts( void );
	void					Event_Physics_SetContents( int contents );
	void					Event_Physics_SetClipmask( int clipmask );
	void					Event_Physics_PutToRest( void );
	void					Event_Physics_HasGroundContacts( void );
	void					Event_DisableGravity( bool disable );
	void					Event_Physics_SetComeToRest( bool value );
	void					Event_Physics_ApplyImpulse( const idVec3& origin, const idVec3& impulse );
	void					Event_Physics_AddForce( const idVec3& force );
	void					Event_Physics_AddForceAt( const idVec3& force, const idVec3& position );
	void					Event_Physics_AddTorque( const idVec3& torque );
	void					Event_HasForceDisableClip( void );
	void					Event_ForceDisableClip( void );
	void					Event_ForceEnableClip( void );
	void					Event_PreventDeployment( bool prevent );
	void					Event_TurnTowards( const idVec3& dir, float maxAngularSpeed );
	void					Event_GetTeam( void );
	void					Event_SetTeam( idScriptObject* object );
	void					Event_LaunchMissile( idEntity* owner, idEntity* owner2, idEntity* enemy, int projectileDefIndex, int clientProjectileDefIndex, float spread, const idVec3& origin, const idVec3& velocity );
	void					Event_LaunchBullet( idEntity* owner, idEntity* ignoreEntity, int projectileDefIndex, float spread, const idVec3& origin, const idVec3& velocity, int forceTracer, bool useAntiLag );
	void					Event_GetBulletTracerStart( void );
	void					Event_GetBulletTracerEnd( void );
	void					Event_GetGUI( const char* name );
	void					Event_IsAtRest( void );
	void					Event_IsBound( void );
	void					Event_DisableImpact( void );
	void					Event_EnableImpact( void );
	void					Event_EnableKnockback( void );
	void					Event_DisableKnockback( void );
	void					Event_Physics_Activate( void );

	void					Event_SetNumCrosshairLines( int count );
	void					Event_AddCrosshairLine();
	void					Event_GetCrosshairDistance();
	void					Event_SetCrosshairLineText( int index, const wchar_t* text );
	void					Event_SetCrosshairLineTextIndex( int index, const int textIndex );
	void					Event_SetCrosshairLineMaterial( int index, const char* material );
	void					Event_SetCrosshairLineColor( int index, const idVec3& color, float alpha );
	void					Event_SetCrosshairLineSize( int index, float x, float y );
	void					Event_SetCrosshairLineFraction( int index, float frac );
	void					Event_SetCrosshairLineType( int index, int type );

	void					Event_SendNetworkEvent( int clientIndex, bool isRepeaterClient, const char* message );
	void					Event_SendNetworkCommand( const char* message );
	void					Event_PointInRadar( const idVec3& point, radarMasks_t type, bool ignoreJammers );

	void					Event_GetMaxHealth( void );
	void					Event_SetMaxHealth( int value );
	void					Event_GetHealth( void );
	void					Event_SetHealth( int value );

	void					Event_AllocBeam( const char* shader );
	void					Event_UpdateBeam( int handle, const idVec3& start, const idVec3& end, const idVec3& color, float alpha, float width );
	void					Event_FreeBeam( int index );
	void					Event_FreeAllBeams();
	
	void					Event_GetNextTeamEntity( void );

	void					Event_GetKeyWithDefault( const char *key, const char* defaultvalue );
	void					Event_GetIntKeyWithDefault( const char *key, int defaultvalue );
	void					Event_GetFloatKeyWithDefault( const char *key, float defaultvalue );
	void					Event_GetVectorKeyWithDefault( const char *key, idVec3 &defaultvalue );

	void					Event_SetCanCollideWithTeam( bool canCollide );

	void					Event_PlayMaterialEffect( const char *effectName, const idVec3& color, const char* jointName, const char* materialType, bool loop );
	void					Event_PlayMaterialEffectMaxVisDist( const char *effectName, const idVec3& color, const char* jointName, const char* materialType, bool loop, float maxVisDist, bool isStatic );
	void					Event_PlayEffect( const char* effectName, const char* boneName, bool loop );
	void					Event_PlayEffectMaxVisDist( const char* effectName, const char* boneName, bool loop, float maxVisDist, bool isStatic );
	void					Event_PlayJointEffect( const char* effectName, jointHandle_t joint, bool loop );
	void					Event_PlayJointEffectViewSuppress( const char* effectName, jointHandle_t joint, bool loop, bool suppress );
	void					Event_PlayOriginEffect( const char* effectName, const char* materialType, const idVec3& origin, const idVec3& forward, bool loop );
	void					Event_PlayOriginEffectMaxVisDist( const char* effectName, const char* materialType, const idVec3& origin, const idVec3& forward, bool loop, float maxVisDist, bool isStatic );
	void					Event_PlayBeamEffect( const char* effectName, const char* materialType, const idVec3& origin, const idVec3& endOrigin, bool loop );
	void					Event_LookupEffect( const char* effectName, const char* materialType );
	void					Event_StopEffect( const char* effectName );
	void					Event_KillEffect( const char *effectName );
	void					Event_StopEffectHandle( int handle );
	void					Event_UnBindEffectHandle( int handle );
	void					Event_SetEffectRenderBounds( int handle, bool renderBounds );
	void					Event_SetEffectAttenuation( int handle, float attenuation );
	void					Event_SetEffectColor( int handle, const idVec3& color, float alpha );
	void					Event_SetEffectOrigin( int handle, const idVec3& origin );
	void					Event_SetEffectAngles( int handle, const idAngles& angles );
	void					Event_GetEffectOrigin( int handle );
	void					Event_GetEffectEndOrigin( int handle );
	void					Event_StopAllEffects( void );
	void					Event_SpawnClientEffect( const char* effectName );
	void					Event_SpawnClientCrawlEffect( const char* effectName, idEntity* ent, float crawlTime );

	void					Event_IsInWater( void );
	void					Event_GetSpawnID( void );
	void					Event_IsSpotted( void );
	void					Event_SetSpotted( idEntity* other );
	void					Event_ForceNetworkUpdate( void );

	void					Event_AddCheapDecal( idEntity *attachTo, idVec3 &origin, idVec3 &normal, const char* decalName, const char* materialName );

	void					Event_GetEntityNumber( void );

	void					Event_DisableCrosshairTrace( bool value );
	void					Event_InCollection( const char* name );

	void					Event_GetEntityContents();
	void					Event_GetMaskedEntityContents( int mask );

	void					Event_SaveCachedEntities( void );
	void					Event_FreeSavedCache( int index );
	void					Event_GetSavedCacheCount( int index );
	void					Event_GetSavedCacheEntity( int index, int entityIndex );

	void					Event_GetDriver( void );
	void					Event_GetNumPositions( void );
	void					Event_GetPositionPlayer( int index );
	void					Event_GetDamageScale( void );

	void					Event_GetJointHandle( const char *jointname );
	void					Event_GetDefaultSurfaceType( void );
	void					Event_ForceRunPhysics( void );

private:
	void					FilterEntitiesByAllegiance( int mask, bool inclusive, bool ignoreDisguise );

};

class sdEntityBroadcastEvent : public idBitMsg {
public:
	sdEntityBroadcastEvent( const idEntity* _owner, int event ) {
		assert( _owner );

		InitWrite( buffer, sizeof( buffer ) );
		eventId = event;
		owner	= _owner;
	}

	void Send( bool saveEvent, const sdReliableMessageClientInfoBase& target ) {
		owner->BroadcastEvent( eventId, this, saveEvent, target );
	}

protected:
	byte				buffer[ MAX_GAME_MESSAGE_SIZE ];
	int					eventId;
	const idEntity*		owner;
};

class sdEntityBroadcastUnreliableEvent : public idBitMsg {
public:
	sdEntityBroadcastUnreliableEvent( const idEntity* _owner, int event ) {
		assert( _owner );

		InitWrite( buffer, sizeof( buffer ) );
		eventId = event;
		owner	= _owner;
	}

	void Send( void ) {
		owner->BroadcastUnreliableEvent( eventId, this );
	}

protected:
	byte				buffer[ MAX_GAME_MESSAGE_SIZE ];
	int					eventId;
	const idEntity*		owner;
};

#endif /* !__GAME_ENTITY_H__ */