actor.h

this keik game source

      {
      arc.WriteSafePointer( targetList.ObjectAt( i ) );
      }

   num = nearbyList.NumObjects();
   arc.WriteInteger( num );
   for ( i = 1; i <= num; i++ )
      {
      arc.WriteSafePointer( nearbyList.ObjectAt( i ) );
      }

   num = enemyList.NumObjects();
   arc.WriteInteger( num );
   for ( i = 1; i <= num; i++ )
      {
      arc.WriteSafePointer( enemyList.ObjectAt( i ) );
      }

   arc.WriteSafePointer( currentEnemy );
   arc.WriteBoolean( seenEnemy );
   // cast as range_t on read
   arc.WriteInteger( ( int )enemyRange );
   arc.WriteSafePointer( lastEnemy );

   arc.WriteFloat( fov );
   arc.WriteFloat( fovdot );
   arc.WriteFloat( vision_distance );

   arc.WriteVector( startpos );

   arc.WriteVector( move );
   arc.WriteVector( movedir );
   arc.WriteFloat( movespeed );
   arc.WriteVector( movevelocity );
   arc.WriteFloat( totallen );
   arc.WriteFloat( turnspeed );
   arc.WriteVector( animdir );

   arc.WriteFloat( chattime );
   arc.WriteFloat( nextsoundtime );

   arc.WriteBoolean( hasalert );

   arc.WriteSafePointer( movegoal );
   arc.WriteSafePointer( soundnode );
   arc.WriteSafePointer( thread );

   arc.WriteSafePointer( actorthread );
   arc.WriteString( actorscript );
   arc.WriteString( actorstart );
   arc.WriteSafePointer( trig );

   arc.WriteBoolean( has_melee );
   arc.WriteFloat( melee_damage );
   arc.WriteFloat( melee_range );
   arc.WriteFloat( aim );
   arc.WriteFloat( pain_threshold );

   arc.WriteBoolean( checkStrafe );

   arc.WriteFloat( next_drown_time );
   arc.WriteFloat( air_finished );
   arc.WriteFloat( attack_range );
   arc.WriteFloat( shots_per_attack );
   arc.WriteBoolean( deathgib );

   arc.WriteString( kill_thread );
   arc.WriteVector( eyeoffset );
   arc.WriteFloat( last_jump_time );
   arc.WriteBoolean( nodeathfade );
   arc.WriteBoolean( nochatter );
   }

inline EXPORT_FROM_DLL void Actor::Unarchive
	(
	Archiver &arc
	)
   {
   Event * ev;
   int i, num, temp;

   Sentient::Unarchive( arc );

   arc.ReadString( &newanim );
   ev = new Event;
   arc.ReadEvent( ev );
   newanimevent = ev;
   arc.ReadInteger( &newanimnum );

   arc.ReadString( &spawngroup );

   arc.ReadInteger( &movement );
   // cast as stepmoveresult_t on read
   temp = arc.ReadInteger();
   lastmove = ( stepmoveresult_t )temp;
   arc.ReadFloat( &forwardspeed );

   // cast as actortype_t on read
   temp = arc.ReadInteger();
   actortype = ( actortype_t )temp;
   arc.ReadInteger( &attackmode );

   arc.ReadVector( &standsize_min );
   arc.ReadVector( &standsize_max );
   arc.ReadVector( &crouchsize_min );
   arc.ReadVector( &crouchsize_max );

   arc.ReadString( &state );
   arc.ReadString( &animname );

   arc.ReadInteger( &num );
   for( i = 1; i <= num; i++ )
      {
      StateInfo * info;

      info = new StateInfo;
      arc.ReadObject( info );
      actionList.AddObject( info );
      }

   arc.ReadInteger( &numonstack );

   for( i = 1; i <= numonstack; i++ )
      {
      ActorState * state;

      state = new ActorState;
      arc.ReadObject( state );
      stateStack.Push( state );
      }

   behavior = NULL;
   if ( arc.ReadBoolean() )
      {
      behavior = ( Behavior * )arc.ReadObject();
      }

   arc.ReadString( &currentBehavior );

   arc.ReadSafePointer( &path );

   arc.ReadInteger( &num );
   targetList.FreeObjectList();
   targetList.Resize( num );
   for( i = 1; i <= num; i++ )
      {
      EntityPtr tmp, *ptr;
      
      targetList.AddObject( tmp );
      ptr = targetList.AddressOfObjectAt( i );
      arc.ReadSafePointer( ptr );
      }

   arc.ReadInteger( &num );
   nearbyList.FreeObjectList();
   nearbyList.Resize( num );
   for( i = 1; i <= num; i++ )
      {
      EntityPtr tmp, *ptr;
      
      nearbyList.AddObject( tmp );
      ptr = nearbyList.AddressOfObjectAt( i );
      arc.ReadSafePointer( ptr );
      }

   arc.ReadInteger( &num );
   enemyList.FreeObjectList();
   enemyList.Resize( num );
   for( i = 1; i <= num; i++ )
      {
      EntityPtr tmp, *ptr;
      
      enemyList.AddObject( tmp );
      ptr = enemyList.AddressOfObjectAt( i );
      arc.ReadSafePointer( ptr );
      }

   arc.ReadSafePointer( &currentEnemy );
   arc.ReadBoolean( &seenEnemy );
   // cast as range_t on read
   temp = arc.ReadInteger();
   enemyRange = ( range_t )temp;
   arc.ReadSafePointer( &lastEnemy );

   arc.ReadFloat( &fov );
   arc.ReadFloat( &fovdot );
   arc.ReadFloat( &vision_distance );

   arc.ReadVector( &startpos );

   arc.ReadVector( &move );
   arc.ReadVector( &movedir );
   arc.ReadFloat( &movespeed );
   arc.ReadVector( &movevelocity );
   arc.ReadFloat( &totallen );
   arc.ReadFloat( &turnspeed );
   arc.ReadVector( &animdir );

   arc.ReadFloat( &chattime );
   arc.ReadFloat( &nextsoundtime );

   arc.ReadBoolean( &hasalert );

   arc.ReadSafePointer( &movegoal );
   arc.ReadSafePointer( &soundnode );
   arc.ReadSafePointer( &thread );

   arc.ReadSafePointer( &actorthread );
   arc.ReadString( &actorscript );
   arc.ReadString( &actorstart );
   arc.ReadSafePointer( &trig );

   arc.ReadBoolean( &has_melee );
   arc.ReadFloat( &melee_damage );
   arc.ReadFloat( &melee_range );
   arc.ReadFloat( &aim );
   arc.ReadFloat( &pain_threshold );

   arc.ReadBoolean( &checkStrafe );

   arc.ReadFloat( &next_drown_time );
   arc.ReadFloat( &air_finished );
   arc.ReadFloat( &attack_range );
   arc.ReadFloat( &shots_per_attack );
   arc.ReadBoolean( &deathgib );

   arc.ReadString( &kill_thread );
   arc.ReadVector( &eyeoffset );
   arc.ReadFloat( &last_jump_time );
   arc.ReadBoolean( &nodeathfade );
   arc.ReadBoolean( &nochatter );
   }


class EXPORT_FROM_DLL MonsterStart : public PathNode
	{
	private:
		str								spawngroup;
		MonsterStart					*groupchain;
		MonsterStart					*leader;
		static MonsterStart			*GetGroupLeader( str& groupname );

	public:
		CLASS_PROTOTYPE( MonsterStart );
		
											MonsterStart();
		static MonsterStart			*GetRandomSpot( str& groupname );
	   virtual void               Archive( Archiver &arc );
      virtual void               Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void MonsterStart::Archive
	(
	Archiver &arc
	)
   {
   PathNode::Archive( arc );

   arc.WriteString( spawngroup );
   arc.WriteObjectPointer( groupchain );
   arc.WriteObjectPointer( leader );
   }

inline EXPORT_FROM_DLL void MonsterStart::Unarchive
	(
	Archiver &arc
	)
   {
   PathNode::Unarchive( arc );

   arc.ReadString( &spawngroup );
   arc.ReadObjectPointer( ( Class ** )&groupchain );
   arc.ReadObjectPointer( ( Class ** )&leader );
   }

// Set destination to node with duck or cover set.  Class will find a path to that node, or a closer one.
class EXPORT_FROM_DLL FindCoverMovement : public StandardMovement
	{
	public:
		Actor			*self;

	inline qboolean validpath
		(
		PathNode *node,
		int i
		)

		{
		pathway_t *path;
		PathNode *n;

		path = &node->Child[ i ];

		if ( !StandardMovement::validpath( node, i ) )
			{
			return false;
			}

		n = AI_GetNode( path->node );
		if ( !n || self->CloseToEnemy( n->worldorigin, 128 ) )
			{
			return false;
			}

		return true;
		}

	inline qboolean done
		(
		PathNode *node,
		PathNode *end
		)

		{
		if ( node == end )
			{
			return true;
			}
		
		//if ( node->reject )
		if ( node->reject || !( node->nodeflags & ( AI_DUCK | AI_COVER ) ) )
			{
			return false;
			}

		if ( self )
			{
			node->reject = self->CanSeeEnemyFrom( node->worldorigin );
			return !node->reject;
			}

		return false;
		}
	};

// Set destination to node with flee set.  Class will find a path to that node, or a closer one.
class EXPORT_FROM_DLL FindFleeMovement : public StandardMovement
	{
	public:
		Actor			*self;

	inline qboolean validpath
		(
		PathNode *node,
		int i
		)

		{
		pathway_t *path;
		PathNode *n;

		path = &node->Child[ i ];

		if ( !StandardMovement::validpath( node, i ) )
			{
			return false;
			}

		n = AI_GetNode( path->node );
		if ( !n || self->CloseToEnemy( n->worldorigin, 128 ) )
			{
			return false;
			}

		return true;
		}

	inline qboolean done
		(
		PathNode *node,
		PathNode *end
		)

		{
		if ( node == end )
			{
			return true;
			}
		
		//if ( node->reject )
		if ( node->reject || !( node->nodeflags & AI_FLEE ) )
			{
			return false;
			}

		if ( self )
			{
			node->reject = self->CanSeeEnemyFrom( node->worldorigin );
			return !node->reject;
			}

		return false;
		}
	};

class EXPORT_FROM_DLL FindEnemyMovement : public StandardMovement
	{
	public:
		Actor			*self;

	inline qboolean done
		(
		PathNode *node,
		PathNode *end
		)

		{
		if ( node == end )
			{
			return true;
			}
		
		if ( node->reject )
			{
			return false;
			}

		if ( self )
			{
			if ( self->currentEnemy )
   			{
				node->reject = !self->CanShootFrom( node->worldorigin, self->currentEnemy, false );
			   }
			else
			   {
				node->reject = false;
			   }

         return !node->reject;
			}

		return false;
		}
	};

#ifdef EXPORT_TEMPLATE
template class EXPORT_FROM_DLL PathFinder<FindCoverMovement>;
template class EXPORT_FROM_DLL PathFinder<FindFleeMovement>;
template class EXPORT_FROM_DLL PathFinder<FindEnemyMovement>;
#endif

typedef PathFinder<FindCoverMovement> FindCoverPath;
typedef PathFinder<FindFleeMovement> FindFleePath;
typedef PathFinder<FindEnemyMovement> FindEnemyPath;

#endif /* actor.h */