entity.cpp

this keik game source

// Generic entity events
Event EV_GetEntName( "getentname" );
Event EV_Classname( "classname" );
Event EV_Activate( "doActivate" );
Event EV_Use( "doUse" );
//Event EV_Footstep( "footstep" );
Event EV_FadeOut( "fadeout" );
Event EV_Fade( "fade" );
Event EV_Killed( "killed" );
Event EV_GotKill( "gotkill" );
Event EV_Pain( "pain" );
Event EV_Damage( "damage" );
Event EV_Kill( "kill", EV_CONSOLE );
Event EV_Gib( "gib" );
Event EV_Hurt( "hurt" );

Event EV_CourseAngles( "courseangles" );
Event EV_SmoothAngles( "smoothangles" );
Event EV_TakeDamage( "takedamage" );
Event EV_NoDamage( "nodamage" );

// Physics events
Event EV_MoveDone( "movedone" );
Event EV_Touch( "doTouch" );
Event EV_Blocked( "doBlocked" );
Event EV_UseBoundingBox( "usebbox" );

// Animation events
Event EV_NewAnim( "animChanged" );
Event EV_LastFrame( "lastFrame" );
Event EV_NextAnim( "nextanim" );
Event EV_NextFrame( "nextframe" );
Event EV_PrevFrame( "prevframe" );
Event EV_SetFrame( "setframe" );
Event EV_StopAnim( "stopanim" );
Event EV_EndAnim( "endanim" );
Event EV_ProcessInitCommands( "processinit" );
Event EV_Attach( "attach" );
Event EV_AttachModel( "attachmodel" );
Event EV_Detach( "detach" );

// script stuff
Event EV_Model( "model" );
Event EV_Hide( "hide" );
Event EV_Show( "show" );
Event EV_BecomeSolid( "solid" );
Event EV_BecomeNonSolid( "notsolid" );
Event EV_Ghost( "ghost" );
Event EV_PlaySound( "playsound" );
Event EV_PHSSound( "phssound" );
Event EV_StopSound( "stopsound" );
Event EV_GravityAxis( "gravityaxis", EV_CHEAT );
Event EV_Bind( "bind" );
Event EV_Unbind( "unbind" );
Event EV_JoinTeam( "joinTeam" );
Event EV_QuitTeam( "quitTeam" );
Event EV_SetHealth( "health", EV_CHEAT );
Event EV_SetScale( "scale" );
Event EV_SetSize( "setsize" );
Event EV_SetAlpha( "alpha" );
Event EV_SetOrigin( "origin" );
Event EV_SetTargetName( "targetname" );
Event EV_SetTarget( "target" );
Event EV_SetKillTarget( "killtarget" );
Event EV_SetAngles( "angles" );
Event EV_RegisterAlias( "alias" );
Event EV_RegisterAliasAndCache( "aliascache" );
Event EV_RandomSound( "randomsound" );
Event EV_RandomPHSSound( "randomphssound" );
Event EV_Tesselate( "shatter" );
Event EV_SetMass( "mass" );

//HACK HACK
Event EV_EntitySound( "ambientsound" );
Event EV_RandomGlobalEntitySound( "randomglobalambientsound" );
Event EV_RandomEntitySound( "randomambientsound" );
Event EV_StopEntitySound( "stopambientsound" );
Event EV_Anim( "anim" );
Event EV_StartAnimating( "animate" );
Event EV_GroupModelEvent( "group" );
Event EV_DialogEvent( "dialog" );
Event EV_SetSkin( "skin" );

// AI sound events
Event EV_WeaponSound( "weaponsound" );
Event EV_MovementSound( "movementsound" );
Event EV_PainSound( "painsound" );
Event EV_DeathSound( "deathsound" );
Event EV_BreakingSound( "breakingsound" );
Event EV_DoorSound( "doorsound" );
Event EV_MutantSound( "mutantsound" );
Event EV_VoiceSound( "voicesound" );
Event EV_MachineSound( "machinesound" );
Event EV_RadioSound( "radiosound" );

Event EV_HeardWeapon( "heardweapon" );
Event EV_HeardMovement( "heardmovement" );
Event EV_HeardPain( "heardpain" );
Event EV_HeardDeath( "hearddeath" );
Event EV_HeardBreaking( "heardbreaking" );
Event EV_HeardDoor( "hearddoor" );
Event EV_HeardMutant( "heardmutant" );
Event EV_HeardVoice( "heardvoice" );
Event EV_HeardMachine( "heardmachine" );
Event EV_HeardRadio( "heardradio" );

// Conditionals
Event EV_IfSkill( "ifskill" );

// Lighting
Event EV_SetLight( "light" );
Event EV_LightOn( "lightOn" );
Event EV_LightOff( "lightOff" );
Event EV_LightRed( "lightRed" );
Event EV_LightGreen( "lightGreen" );
Event EV_LightBlue( "lightBlue" );
Event EV_LightRadius( "lightRadius" );

Event EV_Lightoffset( "lightoffset" );
Event EV_Minlight( "minlight" );
Event EV_Gravity( "gravity" );

// Entity flag specific
Event EV_EntityFlags( "flags" );
Event EV_EntityRenderEffects( "rendereffects" );
Event EV_EntityEffects( "effects" );

// Special Effects
Event EV_SpawnParticles( "sparks" );

// Tesselation setup events
Event EV_Shatter_MinSize( "shatter_minsize" );
Event EV_Shatter_MaxSize( "shatter_maxsize" );
Event EV_Shatter_Thickness( "shatter_thickness" );
Event EV_Shatter_Percentage( "shatter_percentage" );

Event EV_Mutate( "mutate", EV_CHEAT );
Event EV_Censor( "censor" );

ResponseDef Entity::Responses[] =
	{
		{ &EV_Damage,				( Response )Entity::DamageEvent },
      { &EV_Kill, 				( Response )Entity::Kill },
	   { &EV_FadeOut,				( Response )Entity::FadeOut },
	   { &EV_Fade,				   ( Response )Entity::Fade },
	   { &EV_Hide,					( Response )Entity::EventHideModel },
	   { &EV_Show,					( Response )Entity::EventShowModel },
	   { &EV_BecomeSolid,		( Response )Entity::BecomeSolid },
	   { &EV_BecomeNonSolid,	( Response )Entity::BecomeNonSolid },
	   { &EV_Ghost,	         ( Response )Entity::Ghost },
	   { &EV_PlaySound,			( Response )Entity::PlaySound },
	   { &EV_StopSound,			( Response )Entity::StopSound },
		{ &EV_GravityAxis,		( Response )Entity::GravityAxisEvent },
	   { &EV_Bind,					( Response )Entity::BindEvent },
	   { &EV_Unbind,				( Response )Entity::EventUnbind },
	   { &EV_JoinTeam,			( Response )Entity::JoinTeam },
	   { &EV_QuitTeam,			( Response )Entity::EventQuitTeam },
	   { &EV_SetHealth,			( Response )Entity::SetHealth },
	   { &EV_SetSize,				( Response )Entity::SetSize },
		{ &EV_SetScale,			( Response )Entity::SetScale },
	   { &EV_SetAlpha,			( Response )Entity::SetAlpha },
	   { &EV_SetOrigin,			( Response )Entity::SetOrigin },
	   { &EV_SetTargetName,		( Response )Entity::SetTargetName },
	   { &EV_SetTarget,			( Response )Entity::SetTarget },
	   { &EV_SetKillTarget,		( Response )Entity::SetKillTarget },
	   { &EV_SetAngles,			( Response )Entity::SetAngles },
      { &EV_SetMass,          ( Response )Entity::SetMassEvent },

		{ &EV_CourseAngles,		( Response )Entity::CourseAnglesEvent },
		{ &EV_SmoothAngles,		( Response )Entity::SmoothAnglesEvent },

	   { &EV_RegisterAlias,	   ( Response )Entity::RegisterAlias },
	   { &EV_RegisterAliasAndCache, ( Response )Entity::RegisterAliasAndCache },
	   { &EV_RandomSound,	   ( Response )Entity::RandomSound },
	   { &EV_EntitySound,	   ( Response )Entity::EntitySound },
	   { &EV_RandomEntitySound,( Response )Entity::RandomEntitySound },
      { &EV_RandomGlobalEntitySound, ( Response )Entity::RandomGlobalEntitySoundEvent },
	   { &EV_StopEntitySound,	( Response )Entity::StopEntitySound },
      { &EV_Anim,             ( Response )Entity::AnimEvent },
	   { &EV_StartAnimating,	( Response )Entity::StartAnimatingEvent },
		{ &EV_NextAnim,			( Response )Entity::NextAnimEvent },
		{ &EV_NextFrame,			( Response )Entity::NextFrameEvent },
		{ &EV_PrevFrame,			( Response )Entity::PrevFrameEvent },
		{ &EV_SetFrame,			( Response )Entity::SetFrameEvent },
		{ &EV_StopAnim,			( Response )Entity::StopAnimatingEvent },
		{ &EV_EndAnim,				( Response )Entity::EndAnimEvent },
		{ &EV_Model,				( Response )Entity::SetModelEvent },
      { &EV_SetLight,			( Response )Entity::SetLight },
      { &EV_LightOn,				( Response )Entity::LightOn },
      { &EV_LightOff,		   ( Response )Entity::LightOff },
      { &EV_LightRed,		   ( Response )Entity::LightRed },
      { &EV_LightGreen,		   ( Response )Entity::LightGreen },
      { &EV_LightBlue,		   ( Response )Entity::LightBlue },
      { &EV_LightRadius,	   ( Response )Entity::LightRadius },
      { &EV_Tesselate,	      ( Response )Entity::Tesselate },
      { &EV_EntityFlags,	   ( Response )Entity::Flags },
      { &EV_EntityEffects,	   ( Response )Entity::Effects },
      { &EV_EntityRenderEffects,	   ( Response )Entity::RenderEffects },
	   { &EV_RandomPHSSound,	( Response )Entity::RandomPHSSound },
	   { &EV_PHSSound,	      ( Response )Entity::PHSSound },

		{ &EV_WeaponSound,		( Response )Entity::WeaponSound },
		{ &EV_MovementSound,		( Response )Entity::MovementSound },
		{ &EV_PainSound,			( Response )Entity::PainSound },
		{ &EV_DeathSound,			( Response )Entity::DeathSound },
		{ &EV_BreakingSound,		( Response )Entity::BreakingSound },
		{ &EV_DoorSound,			( Response )Entity::DoorSound },
		{ &EV_MutantSound,		( Response )Entity::MutantSound },
		{ &EV_VoiceSound,			( Response )Entity::VoiceSound },
		{ &EV_MachineSound,		( Response )Entity::MachineSound },
		{ &EV_RadioSound,			( Response )Entity::RadioSound },
	   { &EV_SpawnParticles,	( Response )Entity::SpawnParticles },
	   { &EV_GroupModelEvent,	( Response )Entity::GroupModelEvent },
      { &EV_DialogEvent,	   ( Response )Entity::DialogEvent },
      { &EV_ProcessInitCommands,( Response )Entity::ProcessInitCommandsEvent },
      { &EV_Attach,           ( Response )Entity::AttachEvent },
      { &EV_AttachModel,      ( Response )Entity::AttachModelEvent },
      { &EV_Detach,           ( Response )Entity::DetachEvent },
      { &EV_TakeDamage,       ( Response )Entity::TakeDamageEvent },
      { &EV_NoDamage,         ( Response )Entity::NoDamageEvent },
      { &EV_SetSkin,          ( Response )Entity::SetSkinEvent },
      { &EV_Lightoffset,      ( Response )Entity::Lightoffset },
      { &EV_Minlight,         ( Response )Entity::Minlight },
      { &EV_Gravity,          ( Response )Entity::Gravity },

	   { &EV_Shatter_MinSize,	( Response )Entity::SetShatterMinSize },
	   { &EV_Shatter_MaxSize,	( Response )Entity::SetShatterMaxSize },
	   { &EV_Shatter_Thickness,( Response )Entity::SetShatterThickness },
	   { &EV_Shatter_Percentage,( Response )Entity::SetShatterPercentage },

	   { &EV_UseBoundingBox,   ( Response )Entity::UseBoundingBoxEvent },
	   { &EV_Hurt,             ( Response )Entity::HurtEvent },
	   { &EV_IfSkill,          ( Response )Entity::IfSkillEvent },

      { &EV_GetEntName,       ( Response )Entity::GetEntName },
      { &EV_Censor,           ( Response )Entity::Censor },

		{ NULL, NULL }
	};

Entity::Entity()
	{
	const char *m;
	Event *ev;
   int   minlight;

	classname = this->getClassname();

	if ( game.force_entnum )
		{
		game.force_entnum = false;
		edict = &g_edicts[ game.spawn_entnum ];
		LL_Remove( edict, next, prev );
		G_InitEdict( edict );
		LL_Add( &active_edicts, edict, next, prev );
		}
	else
		{
		edict = G_Spawn ();
		}

	client = edict->client;
	edict->entity = this;
	entnum = edict->s.number;

	m = G_GetSpawnArg( "classname" );
	if ( m )
		{
		strncpy( edict->entname, m, sizeof( edict->entname ) - 1 );
		}

	// spawning variables
	spawnflags = G_GetIntArg( "spawnflags" );
   if ( spawnflags & SPAWNFLAG_DETAIL )
		{
      edict->s.renderfx |= RF_DETAIL;
		}

	// rendering variables
	setAlpha( G_GetFloatArg( "alpha", 1.0f ) );
	setScale( G_GetFloatArg( "scale", 1.0f ) );
   
   minlight = G_GetIntArg( "minlight", 0 );
   if ( minlight )
      edict->s.renderfx |= RF_MINLIGHT;
	
   edict->s.lightofs = G_GetFloatArg( "lightoffset", 0 );
   if ( edict->s.lightofs )
      edict->s.renderfx |= RF_LIGHTOFFSET;
      
   viewheight	= 0;
	light_level = 0;

	// Animation variables
   next_anim      = -1;
   next_frame     = -1;
   frame_delta    = "0 0 0";
   next_anim_delta = "0 0 0";
   next_anim_time = 0;
   total_delta    = "0 0 0";
	animDoneEvent	= NULL;
	animating		= false;
	last_frame_in_anim = 0;
   last_animation_time = -1;
	num_frames_in_gun_anim = 0;

	// team variables
	teamchain	= NULL;
	teammaster	= NULL;
	m		   	= G_GetSpawnArg( "team" );
	if ( m )
		{
      moveteam = str( m );
		}

	// physics variables
	contents						= 0;
	mass							= 0;
	gravity						= 1.0;
	groundentity				= NULL;
	groundsurface				= NULL;
	groundentity_linkcount	= 0;
	bindmaster					= NULL;
	velocity						= vec_zero;
	avelocity					= vec_zero;
	
	SetGravityAxis( G_GetIntArg( "gravityaxis", 0 ) );

   // model binding variables
   numchildren             = 0;
   memset( &children, 0, sizeof( children ) );

	setOrigin( G_GetSpawnArg( "origin" ) );
	worldorigin.copyTo( edict->s.old_origin );

	setMoveType( MOVETYPE_NONE );
	setSolidType( SOLID_NOT );

	// targeting variables
	SetTargetName( G_GetSpawnArg( "targetname" ) );
	SetTarget( G_GetSpawnArg( "target" ) );

	// Character state
	health		= 0;
	max_health	= 0;
	deadflag		= DEAD_NO;
	flags			= 0; 

	// underwater variables
	watertype		= 0;
	waterlevel		= 0;

	// Pain and damage variables
	takedamage				= DAMAGE_NO;
	enemy						= NULL;
	pain_finished			= 0;
	damage_debounce_time = 0;

	m = G_GetSpawnArg( "model" );
	if ( m )
		{
		setModel( m );
		}

   //
   // see if we have a mins and maxs set for this model
   //
   if ( gi.IsModel( edict->s.modelindex ) && !mins.length() && !maxs.length())
      {
      vec3_t tempmins, tempmaxs;
      gi.CalculateBounds( edict->s.modelindex, edict->s.scale, tempmins, tempmaxs );
      setSize( tempmins, tempmaxs );
      }

   //
   // get the number of groups for this model
   //
   edict->s.numgroups = gi.NumGroups( edict->s.modelindex );

	m = G_GetSpawnArg( "bind" );
	if ( m )
		{
		str name;

		ev = new Event( EV_Bind );

		// construct an object name
		name = "$";
		name += m;
		ev->AddString( name );

		// Wait until all entities are spawned.
		PostEvent( ev, 0 );
		}

   //
   // initialize tesselation variables
   //
   tess_max_size = size.length() / 4;
   tess_min_size = tess_max_size / 3;

   if ( tess_min_size < 8 )
		{
      tess_min_size = 8;
		}

   if ( tess_max_size <= tess_min_size )
		{
      tess_max_size = tess_min_size * 2;
		}

   tess_thickness = tess_min_size;
   tess_percentage = TESS_DEFAULT_PERCENT;
	}

Entity::~Entity()
	{
   Container<Entity *> bindlist;
   Entity *ent;
   int num;
   int i;

	// unbind any entities that are bound to me
   // can't unbind within this loop, so make an array
   // and unbind them outside of it.
   num = 0;
	for( ent = teamchain; ent; ent = ent->teamchain )
		{
      if ( ent->bindmaster == this )
         {
         bindlist.AddObject( ent );
         }
		}

   num = bindlist.NumObjects();
   for( i = 1; i <= num; i++ )
      {
      bindlist.ObjectAt( i )->unbind();
      }

   bindlist.FreeObjectList();

	unbind();
	quitTeam();
   detach();

   //
   // go through and set our children
   //
   num = numchildren;
   for( i = 0; ( i < MAX_MODEL_CHILDREN ) && num; i++ )
      {
      if ( !children[ i ] )
			{
         continue;
			}
      ent = ( Entity * )G_GetEntity( children[ i ] );
      ent->PostEvent( EV_Remove, 0 );
      num--;
      }

   if ( targetname.length() && world )
      {
		world->RemoveTargetEntity( targetname, this );
      }
	G_FreeEdict( edict );
	}

EXPORT_FROM_DLL void Entity::SetEntNum
   (
   int num
   )

   {
   if ( edict )
      {
      G_FreeEdict( edict );
      }

	edict = &g_edicts[ num ];
	LL_Remove( edict, next, prev );
	G_InitEdict( edict );
	LL_Add( &active_edicts, edict, next, prev );

	client = edict->client;
	edict->entity = this;
	entnum = num;
   }

EXPORT_FROM_DLL void Entity::GetEntName
	(
	Event *ev
   )

   {
   strncpy( edict->entname, getClassname(), sizeof( edict->entname ) - 1 );
	}

EXPORT_FROM_DLL void Entity::SetTarget
	(
	const char *text