entity.h

this keik game source

#define	FL_FATPROJECTILE		0x00000040	// projectile should use fat trace
#define	FL_TEAMSLAVE			0x00000080	// not the first on the team
#define	FL_NO_KNOCKBACK		0x00000100
#define	FL_PRETHINK				0x00000200
#define	FL_POSTTHINK			0x00000400
#define  FL_BLOOD             0x00000800
#define  FL_SPARKS            0x00001000
#define  FL_TESSELATE         0x00002000
#define  FL_BLASTMARK         0x00004000
#define  FL_DIE_TESSELATE     0x00008000
#define  FL_DARKEN            0x00010000
#define  FL_DIE_GIBS          0x00020000
#define  FL_SHIELDS           0x00040000  // sentient has reactive shields
#define  FL_DIE_EXPLODE       0x00080000  // when it dies, it will explode
#define  FL_ADRENALINE        0x00100000  // sentient is under adrenaline effects
#define  FL_CLOAK             0x00200000  // sentient is cloaked
#define  FL_ROTATEDBOUNDS     0x00400000  // model uses rotated mins and maxs
#define  FL_MUTANT            0x00800000  // sentient is in mutant mode
#define  FL_OXYGEN            0x01000000  // sentient has oxygen powerup
#define  FL_SILENCER          0x02000000  // sentient has silencer
#define  FL_SP_MUTANT         0x04000000  // mutant mode single player
#define  FL_MUTATED           0x08000000  // keep track of mutation
#define  FL_FORCEFIELD        0x10000000  // sentient has force field ( invulnerable )
#define  FL_DONTSAVE          0x20000000  // don't add to the savegame
#define  FL_STEALTH           0x40000000  // character is in "stealth" mode
#define  FL_NOION             0x80000000  // don't allow Ion tesselation

// damage flags
#define DAMAGE_RADIUS			0x00000001	// damage was indirect
#define DAMAGE_NO_ARMOR			0x00000002	// armour does not protect from this damage
#define DAMAGE_ENERGY			0x00000004	// damage is from an energy based weapon
#define DAMAGE_NO_KNOCKBACK	0x00000008	// do not affect velocity, just view angles
#define DAMAGE_BULLET			0x00000010  // damage is from a bullet (used for ricochets)
#define DAMAGE_NO_PROTECTION	0x00000020  // armor, shields, invulnerability, and godmode have no effect
#define DAMAGE_NO_SKILL       0x00000040  // damage is not affected by skill level

// means of death flags

typedef enum {
   MOD_FISTS,
   MOD_MAGNUM,
   MOD_SHOTGUN,
   MOD_ASSRIFLE,
   MOD_CHAINGUN,
   MOD_GRENADE,
   MOD_ROCKET,
   MOD_ROCKETSPLASH,
   MOD_PULSE,
   MOD_PULSELASER,
   MOD_SPEARGUN,
   MOD_SNIPER,
   MOD_VEHICLE,
   MOD_CRUSH,
   MOD_SHOTROCKET,
   MOD_FALLING,
   MOD_DROWN,
   MOD_SUICIDE,
   MOD_EXPLODEWALL,
   MOD_ELECTRIC,
   MOD_TELEFRAG,
   MOD_GENBULLET,
   MOD_LASER,
   MOD_BETTYSPIKE,
   MOD_HELIGUN,
   MOD_DEBRIS,
   MOD_THROWNOBJECT,
   MOD_LAVA,
   MOD_SLIME,
   MOD_ADRENALINE,
   MOD_ION,
   MOD_ION_DESTRUCT,
   MOD_QUANTUM,
   MOD_BEAM, 
   MOD_IMPACT,
   MOD_FRIENDLY_FIRE,
   MOD_SPIDERSPLASH,
   MOD_MUTANTHANDS,
   MOD_MUTANT_DRAIN
   } mod_type_t;

//
// Sound travel distances
//

#define SOUND_BREAKING_RADIUS 500
#define SOUND_WEAPON_RADIUS   800
#define SOUND_MOVEMENT_RADIUS 256
#define SOUND_PAIN_RADIUS     320
#define SOUND_DEATH_RADIUS    800
#define SOUND_DOOR_RADIUS     240
#define SOUND_MUTANT_RADIUS   256
#define SOUND_VOICE_RADIUS    800
#define SOUND_MACHINE_RADIUS  512
#define SOUND_RADIO_RADIUS    8192

extern Event EV_ClientConnect;
extern Event EV_ClientDisconnect;
extern Event EV_ClientKill;
extern Event EV_ClientMove;
extern Event EV_ClientEndFrame;

// Generic entity events
extern Event EV_Classname;
extern Event EV_Activate;
extern Event EV_Use;
//extern Event EV_Footstep;
extern Event EV_FadeOut;
extern Event EV_Fade;
extern Event EV_Killed;
extern Event EV_GotKill;
extern Event EV_Pain;
extern Event EV_Damage;
extern Event EV_Gib;
extern Event EV_Mutate;

// Physics events
extern Event EV_MoveDone;
extern Event EV_Touch;
extern Event EV_Blocked;
extern Event EV_Attach;
extern Event EV_AttachModel;
extern Event EV_Detach;
extern Event EV_UseBoundingBox;

// Animation events
extern Event EV_NewAnim;
extern Event EV_LastFrame;
extern Event EV_TakeDamage;
extern Event EV_NoDamage;
extern Event EV_SetSkin;

// script stuff
extern Event EV_Hide;
extern Event EV_Show;
extern Event EV_BecomeSolid;
extern Event EV_BecomeNonSolid;
extern Event EV_PlaySound;
extern Event EV_StopSound;
extern Event EV_GravityAxis;
extern Event EV_Bind;
extern Event EV_Unbind;
extern Event EV_JoinTeam;
extern Event EV_QuitTeam;
extern Event EV_SetHealth;
extern Event EV_SetSize;
extern Event EV_SetAlpha;
extern Event EV_SetOrigin;
extern Event EV_SetTargetName;
extern Event EV_SetTarget;
extern Event EV_SetKillTarget;
extern Event EV_SetAngles;
extern Event EV_RegisterAlias;
extern Event EV_RandomSound;
extern Event EV_EntitySound;
extern Event EV_RandomEntitySound;
extern Event EV_RandomGlobalEntitySound;
extern Event EV_StopEntitySound;
extern Event EV_Anim;
extern Event EV_StartAnimating;
extern Event EV_GroupModelEvent;
extern Event EV_DialogEvent;
extern Event EV_RandomPHSSound;
extern Event EV_PHSSound;
extern Event EV_ProcessInitCommands;
// dir is 1
// power is 2
// minsize is 3
// maxsize is 4
// percentage is 5
// thickness 6
// entity is 7
// origin 8
extern Event EV_Tesselate;
extern Event EV_Shatter_MinSize;
extern Event EV_Shatter_MaxSize;
extern Event EV_Shatter_Thickness;
extern Event EV_Shatter_Percentage;

// AI sound events
extern Event EV_WeaponSound;
extern Event EV_MovementSound;
extern Event EV_PainSound;
extern Event EV_DeathSound;
extern Event EV_BreakingSound;
extern Event EV_DoorSound;
extern Event EV_MutantSound;
extern Event EV_VoiceSound;
extern Event EV_MachineSound;
extern Event EV_RadioSound;

extern Event EV_HeardWeapon;
extern Event EV_HeardMovement;
extern Event EV_HeardPain;
extern Event EV_HeardDeath;
extern Event EV_HeardBreaking;
extern Event EV_HeardDoor;
extern Event EV_HeardMutant;
extern Event EV_HeardVoice;
extern Event EV_HeardMachine;
extern Event EV_HeardRadio;
extern Event EV_Hurt;
extern Event EV_IfSkill;

// Define ScriptMaster
class ScriptMaster;

//
// Spawn args
//
// "spawnflags"
// "alpha" default 1.0
// "model"
// "origin"
// "targetname"
// "target"
//
#define MAX_MODEL_CHILDREN 8

class Entity;
#ifdef EXPORT_TEMPLATE
template class EXPORT_FROM_DLL SafePtr<Entity>;
#endif
typedef SafePtr<Entity> EntityPtr;

class EXPORT_FROM_DLL Entity : public Listener
	{
	public:
		CLASS_PROTOTYPE( Entity );

		// spawning variables
		int					entnum;
		edict_t				*edict;
		gclient_t			*client;
		const char			*classname;
		int					spawnflags;

		// rendering variables
		float					translucence;
		int					viewheight;		// height above origin where eyesight is determined
		int					light_level;	// keeps track of light level at origin

		// Animation variables
		str					model;
      int               next_anim;     // index of next_anim, if an anim change is pending,
                                       // this value is non-negative
      int               next_frame;    // index of next_frame, if a frame change is pending,
                                       // this value is non-negative
      int               last_frame_in_anim;// last frame in the current animation
      Vector            frame_delta;   // current movement from this frame
      Vector            total_delta;   // total unprocessed movement 
      Vector            next_anim_delta; // total delta of next animation
      float             next_anim_time;  // total time of next animation
      qboolean          animating;     // whether the model is currently animating
		Event					*animDoneEvent;
      float             last_animation_time; // the last server frame this model was animated
      int               num_frames_in_gun_anim; // num frames in the gun animation, if there is one

		// physics variables
		Vector				mins;
		Vector				maxs;
		Vector				absmin;
		Vector				absmax;
		Vector				size;
		Vector				centroid;
		Vector				origin;
		Vector				velocity;
		Vector				avelocity;
		Vector				angles;
		Vector				worldorigin;
		Vector				worldangles;
		Vector				vieworigin;
		Vector				viewangles;
		int					contents;
		int					movetype;
		int					mass;
		float					gravity;			// per entity gravity multiplier (1.0 is normal)
		int					gravaxis;		// per entity gravity axis

		edict_t				*groundentity;
		csurface_t			*groundsurface;
		cplane_t				groundplane;
		int					groundcontents;

		int					groundentity_linkcount;

		// Binding variables
		Entity 				*bindmaster;
		str					moveteam;
		Entity				*teamchain;
		Entity 				*teammaster;
		float					orientation[3][3];

      // Model Binding variables
      int               numchildren;
      int               children[MAX_MODEL_CHILDREN];

		// targeting variables
		str					target;
		str					targetname;
		str			      killtarget;

		// Character state
		float					health;
		float             max_health;
		int					deadflag;
		int					flags;

		// underwater variables
		int					watertype;
		int					waterlevel;

		// Pain and damage variables
		damage_t				takedamage;
		EntityPtr			enemy;
		float					pain_finished;
		float					damage_debounce_time;

      // tesselation variables
      int               tess_min_size;
      int               tess_max_size;
      int               tess_thickness;
      float             tess_percentage;

								Entity::Entity();
		virtual				Entity::~Entity();

      void              SetEntNum( int num );
      void              GetEntName( Event *ev );

      qboolean				DistanceTo( Vector pos );
      qboolean				DistanceTo( Entity *ent );
		qboolean				WithinDistance( Vector pos, float dist );
		qboolean				WithinDistance( Entity *ent, float dist );

		const char			*Target( void );
		void					SetTarget( const char *target );
		qboolean				Targeted( void );
		const char			*TargetName( void );
		void					SetTargetName( const char *target );
      void              SetKillTarget( const char *killtarget );
      const char        *KillTarget( void );

      int               modelIndex( const char * mdl );
		virtual void		setModel( const char *model );
		virtual void		setModel( str &mdl );
		void					SetModelEvent( Event *ev );
		void					hideModel( void );
		void					EventHideModel( Event *ev );
		void					showModel( void );
		void					EventShowModel( Event *ev );
		qboolean				hidden( void );
      void              ProcessInitCommandsEvent( Event *ev );
      void              ProcessInitCommands( int index );

		void					setAlpha( float alpha );
		float					alpha( void );

		void					setMoveType( int type );
		int					getMoveType( void );

		void					setSolidType( solid_t type );
		int					getSolidType( void );

		Vector				getParentVector( Vector vec );
		Vector				getLocalVector( Vector vec );

		virtual void		setSize( Vector min, Vector max );
		void					setOrigin( Vector org );
		qboolean				GetBone( const char *name, Vector *pos, Vector *forward, Vector *right, Vector *up );
		void					setAngles( Vector ang );

		void					link( void );
		void					unlink( void );

		void					setContents( int type );
		int					getContents( void );
      void              setScale( float scale );

		qboolean				droptofloor( float maxfall );
		qboolean				isClient( void );

      virtual void		SetDeltaAngles( void );

		virtual void		DamageEvent( Event *event );
      virtual void      Damage( Entity *inflictor, 
                                Entity *attacker, 
                                int damage, 
                                Vector position,
                                Vector direction,
                                Vector normal,
                                int knockback,
                                int flags,
                                int meansofdeath,
                                int groupnum,
                                int trinum,
                                float damage_multiplier );

		virtual qboolean	CanDamage( Entity *target );

		qboolean				IsTouching( Entity *e1 );
      void              NextAnim( int animnum );
      void              NextFrame( int framenum );
      void              AnimateFrame( void );
      void              StopAnimating( void );
      void              StartAnimating( void );
		void					RandomAnimate( const char *animname, Event *endevent );
		void					RandomAnimate( const char *animname, Event &endevent );
      qboolean          HasAnim( const char *animname );

		void					joinTeam( Entity *teammember );
		void					quitTeam( void );
		void					EventQuitTeam( Event *ev );
      qboolean          isBoundTo( Entity *master );
		void					bind( Entity *master );
		void					unbind( void );
		void					EventUnbind( Event *ev );

		void					FadeOut( Event *ev );
		void					Fade( Event *ev );

		virtual void		CheckGround( void );
		virtual qboolean	HitSky( trace_t *trace );
		virtual qboolean	HitSky( void );

		void					BecomeSolid( Event *ev );
		void					BecomeNonSolid( Event *ev );
		void					PlaySound( Event *ev );
		void					StopSound( Event *ev );
		void					SetGravityAxis( int axis );
		void					GravityAxisEvent( Event *ev );
		void					BindEvent( Event *ev );
		void					JoinTeam( Event *ev );
		void					SetHealth( Event *ev );
		void					SetSize( Event *ev );
		void					SetScale( Event *ev );
		void					SetAlpha( Event *ev );
		void					SetOrigin( Event *ev );
		void					SetTargetName( Event *ev );
		void					SetTarget( Event *ev );
		void		         SetKillTarget( Event *ev );
		void					SetAngles( Event *ev );

		void					CourseAnglesEvent( Event *ev );
		void					SmoothAnglesEvent( Event *ev );

      str               GetRandomAlias( str name );
      void              SetWaterType( void );
      
      // model binding functions
      qboolean          attach( int parent_entity_num, int group_num, int tri_num, Vector orient );
      void              detach( void );

      void              RegisterAlias( Event *ev );
      void              RegisterAliasAndCache( Event *ev );

		qboolean				GlobalAliasExists( const char *name );
		qboolean				AliasExists( const char *name );

		virtual void		positioned_sound( Vector origin, str soundname, float volume = 1.0f, 
									int channel = CHAN_BODY, int attenuation = ATTN_NORM, float pitch = 1.0f, 
									float timeofs = 0, float fadetime = 0, int flags = SOUND_SYNCH );
		
		virtual void		sound( str soundname, float volume = 1.0f, int channel = CHAN_BODY, 
									int attenuation = ATTN_NORM, float pitch = 1.0f, float timeofs = 0, 
									float fadetime = 0, int flags = SOUND_SYNCH );
		
		virtual void		stopsound( int	channel );
		
		virtual void		RandomPositionedSound( Vector origin, str soundname, float volume = 1.0f, 
									int channel = CHAN_BODY, int attenuation = ATTN_NORM, float pitch = 1.0f, 
									float timeofs = 0, float fadetime = 0, int flags = SOUND_SYNCH );

		void					RandomSound( str soundname, float volume = 1.0f, int channel = CHAN_BODY, 
									int attenuation = ATTN_NORM, float pitch = 1.0f, float timeofs = 0, 
									float fadetime = 0, int flags = SOUND_SYNCH );
		
		void					RandomGlobalSound( str soundname, float volume = 1.0f, int channel = CHAN_BODY, 
									int attenuation = ATTN_NORM, float pitch = 1.0f, float timeofs = 0, 
									float fadetime = 0, int flags = SOUND_SYNCH );

      void              RandomGlobalEntitySound( str soundname, int attenuation = ATTN_IDLE );
      void              RandomGlobalEntitySoundEvent( Event *ev );

		void              RandomSound( Event *ev );
      void              EntitySound( Event *ev );
      void              StopEntitySound( Event *ev );
      void              RandomEntitySound( Event *ev );
      void              AnimEvent( Event *ev );
      void              StartAnimatingEvent( Event *ev );
		void					StopAnimatingEvent( Event *ev );
		void					EndAnimEvent( Event *ev );
		void					NextAnimEvent( Event *ev );
		void					NextFrameEvent( Event *ev );
		void					PrevFrameEvent( Event *ev );
		void					SetFrameEvent( Event *ev );
      void              SetLight(Event *ev);
      void              LightOn(Event *ev);
      void              LightOff(Event *ev);
      void              LightRed(Event *ev);
      void              LightGreen(Event *ev);
      void              LightBlue(Event *ev);
      void              LightRadius(Event *ev);
      void              Tesselate(Event *ev);
      void              SetShatterMinSize(Event *ev);
      void              SetShatterMaxSize(Event *ev);
      void              SetShatterThickness(Event *ev);
      void              SetShatterPercentage(Event *ev);
      void              Flags( Event *ev );
      void              Effects( Event *ev );
      void              RenderEffects( Event *ev );

		void					BroadcastSound( Event *soundevent, int channel, Event &event, float radius );
		void					WeaponSound( Event *ev );
		void					MovementSound( Event *ev );
		void					PainSound( Event *ev );
		void 					DeathSound( Event *ev );
		void					BreakingSound( Event *ev );
		void					DoorSound( Event *ev );
		void					MutantSound( Event *ev );
		void					VoiceSound( Event *ev );
		void					MachineSound( Event *ev );
		void					RadioSound( Event *ev );
      void              SpawnParticles( Event *ev );
      void              Kill( Event *ev );
      void              GroupModelEvent( Event *ev );

		virtual void		Prethink( void );
		virtual void		Postthink( void );
      void              DamageSkin( trace_t * trace, float damage );
      virtual void      DialogEvent( Event *ev );
		void					PHSSound( Event *ev );
		void              RandomPHSSound( Event *ev );
		void					AttachEvent( Event *ev );
		void					AttachModelEvent( Event *ev );
		void					DetachEvent( Event *ev );
      void              TakeDamageEvent( Event *ev );
      void              NoDamageEvent( Event *ev );
      void              SetSkinEvent( Event *ev	);
      void              Lightoffset( Event *ev );
      void              Gravity( Event *ev );
      void              Minlight( Event *ev );
      void              GiveOxygen( float time );
      void              UseBoundingBoxEvent( Event *ev );
      void              HurtEvent( Event *ev );
      void              IfSkillEvent( Event *ev );
      void              SetMassEvent( Event *ev );
      void              Censor( Event *ev );
      void              Ghost( Event *ev );

      virtual void      Archive( Archiver &arc );
      virtual void      Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL qboolean Entity::DistanceTo
	(