entity.h

this keik game source

	Vector pos
	)

	{
	Vector delta;

	delta = worldorigin - pos;
	return delta.length();
	}

inline EXPORT_FROM_DLL qboolean Entity::DistanceTo
	(
	Entity *ent
	)

	{
	Vector delta;

	assert( ent );

	if ( !ent )
		{
		// "Infinite" distance
		return 999999;
		}

	delta = worldorigin - ent->worldorigin;
	return delta.length();
	}

inline EXPORT_FROM_DLL qboolean Entity::WithinDistance
	(
	Vector pos,
	float dist
	)

	{
	Vector delta;

	delta = worldorigin - pos;

	// check squared distance
	return ( ( delta * delta ) < ( dist * dist ) );
	}

inline EXPORT_FROM_DLL qboolean Entity::WithinDistance
	(
	Entity *ent,
	float dist
	)

	{
	Vector delta;

	assert( ent );

	if ( !ent )
		{
		return false;
		}

	delta = worldorigin - ent->worldorigin;

	// check squared distance
	return ( ( delta * delta ) < ( dist * dist ) );
	}

inline EXPORT_FROM_DLL const char *Entity::Target
	(
	void
	)

	{
	return target.c_str();
	}

inline EXPORT_FROM_DLL qboolean Entity::Targeted
	(
	void
	)

	{
	if ( !targetname.length() )
		{
		return false;
		}
	return true;
	}

inline EXPORT_FROM_DLL const char *Entity::TargetName
	(
	void
	)

	{
	return targetname.c_str();
	}

inline EXPORT_FROM_DLL const char * Entity::KillTarget
	(
	void
	)

	{
	return killtarget.c_str();
	}

inline EXPORT_FROM_DLL qboolean Entity::hidden
	(
	void
	)

	{
	if ( edict->s.renderfx & RF_DONTDRAW )
		{
		return true;
		}
	return false;
	}

inline EXPORT_FROM_DLL void Entity::setModel
	(
	str &mdl
	)

	{
	setModel( mdl.c_str() );
	}

inline EXPORT_FROM_DLL void Entity::SetModelEvent
	(
	Event *ev
	)

	{
	setModel( ev->GetString( 1 ) );
	}

inline EXPORT_FROM_DLL void Entity::hideModel
	(
	void
	)

	{
	edict->s.renderfx |= RF_DONTDRAW;
	if ( getSolidType() <= SOLID_TRIGGER )
		{
		edict->svflags |= SVF_NOCLIENT;
		}
	}

inline EXPORT_FROM_DLL void Entity::showModel
	(
	void
	)

	{
	edict->s.renderfx &= ~RF_DONTDRAW;
	edict->svflags &= ~SVF_NOCLIENT;
	}

inline EXPORT_FROM_DLL float Entity::alpha
	(
	void
	)

	{
	return 1.0f - translucence;
	}

inline EXPORT_FROM_DLL void Entity::setMoveType
	(
	int type
	)

	{
	movetype = type;
	}

inline EXPORT_FROM_DLL int Entity::getMoveType
	(
	void
	)

	{
	return movetype;
	}

inline EXPORT_FROM_DLL int Entity::getSolidType
	(
	void
	)

	{
	return edict->solid;
	}

inline EXPORT_FROM_DLL void Entity::unlink
	(
	void
	)

	{
	gi.unlinkentity( edict );
	}

inline EXPORT_FROM_DLL void Entity::setContents
	(
	int type
	)

	{
	contents = type;
	}

inline EXPORT_FROM_DLL int Entity::getContents
	(
	void
	)

	{
	return contents;
	}

inline EXPORT_FROM_DLL qboolean Entity::isClient
	(
	void
	)

	{
	if ( client )
		{
		return true;
		}
	return false;
	}

inline EXPORT_FROM_DLL void Entity::SetDeltaAngles
   (
   void
   )

   {
   int i;

   if ( client )
      {
	   for( i = 0; i < 3; i++ )
         {
		   client->ps.pmove.delta_angles[ i ] = ANGLE2SHORT( client->ps.viewangles[ i ] );
         }
      }
   }

inline EXPORT_FROM_DLL void Entity::RandomAnimate
	(
   const char *animname,
	Event &endevent
   )

   {
	Event *ev;

	ev = new Event( endevent );
	RandomAnimate( animname, ev );
   }

inline EXPORT_FROM_DLL qboolean Entity::HasAnim
	(
   const char *animname
   )
   {
   int num;

	num = gi.Anim_Random( edict->s.modelindex, animname );
   return ( num >= 0 );
   }

inline EXPORT_FROM_DLL qboolean Entity::GlobalAliasExists
	(
	const char *name
	)

	{
	assert( name );

	return ( gi.GlobalAlias_FindRandom( name ) != NULL );
	}

inline EXPORT_FROM_DLL qboolean Entity::AliasExists
	(
	const char *name
	)

	{
	assert( name );

	return ( gi.Alias_FindRandom( edict->s.modelindex, name ) != NULL );
	}

inline EXPORT_FROM_DLL void Entity::stopsound
	(
	int channel
	)

	{
   RandomGlobalSound( "null_sound", 0.1, channel, 0 );
	}

inline EXPORT_FROM_DLL str Entity::GetRandomAlias
	(
   str name
	)

	{
	str realname;
   const char *s;

   s = gi.Alias_FindRandom( edict->s.modelindex, name.c_str() );   
   if ( s )
      {
      realname = s;
      }

   return realname;
	}

inline EXPORT_FROM_DLL qboolean Entity::HitSky
	(
	trace_t *trace
	)
	
	{
	assert( trace );
	if ( trace->surface && ( trace->surface->flags & SURF_SKY ) )
		{
		return true;
		}
	return false;
	}

inline EXPORT_FROM_DLL qboolean Entity::HitSky
	(
	void
	)
	
	{
	return HitSky( &level.impact_trace );
	}

inline EXPORT_FROM_DLL void Entity::Archive
	(
	Archiver &arc
	)

   {
   Listener::Archive( arc );

   G_ArchiveEdict( arc, edict );

   arc.WriteInteger( spawnflags );

   arc.WriteFloat( translucence );
   arc.WriteInteger( viewheight );
   arc.WriteInteger( light_level );

   arc.WriteString( model );
   arc.WriteInteger( next_anim );
   arc.WriteInteger( next_frame );
   arc.WriteInteger( last_frame_in_anim );
   arc.WriteVector( frame_delta );
   arc.WriteVector( total_delta );
   arc.WriteVector( next_anim_delta );
   arc.WriteFloat( next_anim_time );
   arc.WriteBoolean( animating );
   arc.WriteEvent( *animDoneEvent );
   arc.WriteFloat( last_animation_time );
   arc.WriteInteger( num_frames_in_gun_anim );

   arc.WriteVector( mins );
   arc.WriteVector( maxs );
   arc.WriteVector( absmin );
   arc.WriteVector( absmax );
   arc.WriteVector( size );
   arc.WriteVector( centroid );
   arc.WriteVector( origin );
   arc.WriteVector( velocity );
   arc.WriteVector( avelocity );
   arc.WriteVector( angles );
   arc.WriteVector( worldorigin );
   arc.WriteVector( worldangles );
   arc.WriteRaw( orientation, sizeof( orientation ) );
   arc.WriteVector( vieworigin );
   arc.WriteVector( viewangles );
   arc.WriteInteger( contents );
   arc.WriteInteger( movetype );
   arc.WriteInteger( mass );
   arc.WriteFloat( gravity );
   arc.WriteInteger( gravaxis );

   if ( groundentity )
      {
		arc.WriteInteger( groundentity - g_edicts );
      }
   else
      {
      arc.WriteInteger( -1 );
      }

   arc.WriteRaw( &groundplane, sizeof( groundplane ) );
   arc.WriteInteger( groundcontents );

   arc.WriteInteger( groundentity_linkcount );

   arc.WriteObjectPointer( bindmaster );
   arc.WriteString( moveteam );
   arc.WriteObjectPointer( teamchain );
   arc.WriteObjectPointer( teammaster );

   arc.WriteInteger( numchildren );
   arc.WriteRaw( children, sizeof( children ) );

   arc.WriteString( target );
   arc.WriteString( targetname );
   // add to target list to rebuild targetlists
   arc.WriteString( killtarget );

   arc.WriteFloat( health );
   arc.WriteFloat( max_health );
   arc.WriteInteger( deadflag );
   arc.WriteInteger( flags );

   arc.WriteInteger( watertype );
   arc.WriteInteger( waterlevel );

   arc.WriteInteger( ( int )takedamage );
   arc.WriteSafePointer( enemy );
   arc.WriteFloat( pain_finished );
   arc.WriteFloat( damage_debounce_time );

   arc.WriteInteger( tess_min_size );
   arc.WriteInteger( tess_max_size );
   arc.WriteInteger( tess_thickness );
   arc.WriteFloat( tess_percentage );
   }

inline EXPORT_FROM_DLL void Entity::Unarchive
	(
	Archiver &arc
	)

   {
   int temp;

   Listener::Unarchive( arc );

   G_UnarchiveEdict( arc, edict );

   arc.ReadInteger( &spawnflags );

   arc.ReadFloat( &translucence );
   arc.ReadInteger( &viewheight );
   arc.ReadInteger( &light_level );

   arc.ReadString( &model );
   setModel( model );

   arc.ReadInteger( &next_anim );
   arc.ReadInteger( &next_frame );
   arc.ReadInteger( &last_frame_in_anim );
   arc.ReadVector( &frame_delta );
   arc.ReadVector( &total_delta );
   arc.ReadVector( &next_anim_delta );
   arc.ReadFloat( &next_anim_time );
   arc.ReadBoolean( &animating );
   animDoneEvent = new Event( arc.ReadEvent() );
   arc.ReadFloat( &last_animation_time );
   arc.ReadInteger( &num_frames_in_gun_anim );

   arc.ReadVector( &mins );
   arc.ReadVector( &maxs );
   arc.ReadVector( &absmin );
   arc.ReadVector( &absmax );
   arc.ReadVector( &size );
   arc.ReadVector( &centroid );
   arc.ReadVector( &origin );
   arc.ReadVector( &velocity );
   arc.ReadVector( &avelocity );
   arc.ReadVector( &angles );
   arc.ReadVector( &worldorigin );
   arc.ReadVector( &worldangles );
   arc.ReadRaw( orientation, sizeof( orientation ) );
   arc.ReadVector( &vieworigin );
   arc.ReadVector( &viewangles );
   arc.ReadInteger( &contents );
   arc.ReadInteger( &movetype );
   arc.ReadInteger( &mass );
   arc.ReadFloat( &gravity );
   arc.ReadInteger( &gravaxis );

   temp = arc.ReadInteger();
   if ( temp == -1 )
      groundentity = NULL;
   else
      groundentity = &g_edicts[ temp ];

   groundsurface = NULL;

   arc.ReadRaw( &groundplane, sizeof( groundplane ) );
   arc.ReadInteger( &groundcontents );

   arc.ReadInteger( &groundentity_linkcount );

   arc.ReadObjectPointer( ( Class ** )&bindmaster );
   arc.ReadString( &moveteam );
   arc.ReadObjectPointer( ( Class ** )&teamchain );
   arc.ReadObjectPointer( ( Class ** )&teammaster );

   arc.ReadInteger( &numchildren );
   arc.ReadRaw( children, sizeof( children ) );

   arc.ReadString( &target );
   arc.ReadString( &targetname );
   arc.ReadString( &killtarget );

	// reset target stuff
	SetTargetName( targetname.c_str() );
	SetTarget( target.c_str() );

   arc.ReadFloat( &health );
   arc.ReadFloat( &max_health );
   arc.ReadInteger( &deadflag );
   arc.ReadInteger( &flags );

   arc.ReadInteger( &watertype );
   arc.ReadInteger( &waterlevel );

   temp = arc.ReadInteger();
   takedamage = ( damage_t )temp;
   arc.ReadSafePointer( &enemy );
   arc.ReadFloat( &pain_finished );
   arc.ReadFloat( &damage_debounce_time );

   arc.ReadInteger( &tess_min_size );
   arc.ReadInteger( &tess_max_size );
   arc.ReadInteger( &tess_thickness );
   arc.ReadFloat( &tess_percentage );
   }

#include "worldspawn.h"

#endif