behavior.h

this keik game source

	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadObject( &chase );
   arc.ReadString( &anim );
   arc.ReadVector( &goal );
   arc.ReadFloat( &curioustime );
   }

class EXPORT_FROM_DLL Flee : public Behavior
	{
	private:
		FollowPath				follow;
		PathPtr					path;
		ObstacleAvoidance		avoid;
		float						avoidtime;
		str						anim;

	public:
      CLASS_PROTOTYPE( Flee );

		void						SetArgs( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void Flee::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &follow );
   arc.WriteSafePointer( path );
   arc.WriteObject( &avoid );
   arc.WriteFloat( avoidtime );
   arc.WriteString( anim );
   }

inline EXPORT_FROM_DLL void Flee::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadObject( &follow );
   arc.ReadSafePointer( &path );
   arc.ReadObject( &avoid );
   arc.ReadFloat( &avoidtime );
   arc.ReadString( &anim );
   }

class EXPORT_FROM_DLL OpenDoor : public Behavior
	{
	private:
		float						time;
		float						endtime;
		qboolean					usedir;
		Vector					dir;

	public:
      CLASS_PROTOTYPE( OpenDoor );

									OpenDoor();
		void						SetArgs( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void OpenDoor::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteFloat( time );
   arc.WriteFloat( endtime );
   arc.WriteBoolean( usedir );
   arc.WriteVector( dir );
   }

inline EXPORT_FROM_DLL void OpenDoor::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadFloat( &time );
   arc.ReadFloat( &endtime );
   arc.ReadBoolean( &usedir );
   arc.ReadVector( &dir );
   }

class EXPORT_FROM_DLL PlayAnim : public Behavior
	{
	private:
		str						anim;
		
	public:
      CLASS_PROTOTYPE( PlayAnim );

		void						SetArgs( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void PlayAnim::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteString( anim );
   }

inline EXPORT_FROM_DLL void PlayAnim::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadString( &anim );
   }

class EXPORT_FROM_DLL FindCover : public Behavior
	{
	private:
		str						anim;
		Chase						chase;
		int						state;
		float						nextsearch;
		
	public:
      CLASS_PROTOTYPE( FindCover );

		void						SetArgs( Event *ev );
		PathNode					*FindCoverNode( Actor &self );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void FindCover::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteString( anim );
   arc.WriteObject( &chase );
   arc.WriteInteger( state );
   arc.WriteFloat( nextsearch );
   }

inline EXPORT_FROM_DLL void FindCover::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadString( &anim );
   arc.ReadObject( &chase );
   arc.ReadInteger( &state );
   arc.ReadFloat( &nextsearch );
   }

class EXPORT_FROM_DLL FindFlee : public Behavior
	{
	private:
		str						anim;
		Chase						chase;
		int						state;
		float						nextsearch;
		
	public:
      CLASS_PROTOTYPE( FindFlee );

		void						SetArgs( Event *ev );
		PathNode					*FindFleeNode( Actor &self );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void FindFlee::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteString( anim );
   arc.WriteObject( &chase );
   arc.WriteInteger( state );
   arc.WriteFloat( nextsearch );
   }

inline EXPORT_FROM_DLL void FindFlee::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadString( &anim );
   arc.ReadObject( &chase );
   arc.ReadInteger( &state );
   arc.ReadFloat( &nextsearch );
   }

class EXPORT_FROM_DLL FindEnemy : public Behavior
	{
	private:
		str						anim;
		Chase						chase;
		int						state;
		float						nextsearch;
      PathNodePtr          lastSearchNode;
      Vector               lastSearchPos;
		
	public:
      CLASS_PROTOTYPE( FindEnemy );

		PathNode					*FindClosestSightNode( Actor &self );
		void						SetArgs( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void FindEnemy::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteString( anim );
   arc.WriteObject( &chase );
   arc.WriteInteger( state );
   arc.WriteFloat( nextsearch );
   arc.WriteSafePointer( lastSearchNode );
   arc.WriteVector( lastSearchPos );
   }

inline EXPORT_FROM_DLL void FindEnemy::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadString( &anim );
   arc.ReadObject( &chase );
   arc.ReadInteger( &state );
   arc.ReadFloat( &nextsearch );
   arc.ReadSafePointer( &lastSearchNode );
   arc.ReadVector( &lastSearchPos );
   }

class EXPORT_FROM_DLL Hide : public Behavior
	{
	private:
		FindCover				hide;
		str						anim;
		int						state;
		float						checktime;
		
	public:
      CLASS_PROTOTYPE( Hide );

		void						SetArgs( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void Hide::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &hide );
   arc.WriteString( anim );
   arc.WriteInteger( state );
   arc.WriteFloat( checktime );
   }

inline EXPORT_FROM_DLL void Hide::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadObject( &hide );
   arc.ReadString( &anim );
   arc.ReadInteger( &state );
   arc.ReadFloat( &checktime );
   }


class EXPORT_FROM_DLL FleeAndRemove : public Behavior
	{
	private:
		FindFlee				   flee;
		str						anim;
		int						state;
		float						checktime;
		
	public:
      CLASS_PROTOTYPE( FleeAndRemove );

		void						SetArgs( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void FleeAndRemove::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &flee );
   arc.WriteString( anim );
   arc.WriteInteger( state );
   arc.WriteFloat( checktime );
   }

inline EXPORT_FROM_DLL void FleeAndRemove::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadObject( &flee );
   arc.ReadString( &anim );
   arc.ReadInteger( &state );
   arc.ReadFloat( &checktime );
   }


class EXPORT_FROM_DLL AimAndShoot : public Behavior
	{
	private:
		Aim						aim;
		int						mode;
		int						maxshots;
		int						numshots;
		qboolean					animdone;
      float                enemy_health;
      float                aim_time;
      str                  animprefix;
      str                  readyfireanim;
      str                  aimanim;
      str                  fireanim;

	public:
      CLASS_PROTOTYPE( AimAndShoot );

									AimAndShoot();
		void						SetMaxShots( int num );
		void						SetArgs( Event *ev );
		void						AnimDone( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void AimAndShoot::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &aim );
   arc.WriteInteger( mode );
   arc.WriteInteger( maxshots );
   arc.WriteInteger( numshots );
   arc.WriteBoolean( animdone );
   arc.WriteFloat( enemy_health );
   arc.WriteFloat( aim_time );
   arc.WriteString( animprefix );
   arc.WriteString( readyfireanim );
   arc.WriteString( aimanim );
   arc.WriteString( fireanim );
   }

inline EXPORT_FROM_DLL void AimAndShoot::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadObject( &aim );
   arc.ReadInteger( &mode );
   arc.ReadInteger( &maxshots );
   arc.ReadInteger( &numshots );
   arc.ReadBoolean( &animdone );
   arc.ReadFloat( &enemy_health );
   arc.ReadFloat( &aim_time );
   arc.ReadString( &animprefix );
   arc.ReadString( &readyfireanim );
   arc.ReadString( &aimanim );
   arc.ReadString( &fireanim );
   }

class EXPORT_FROM_DLL AimAndMelee : public Behavior
	{
	private:
		Aim						aim;
		int						mode;
		int						maxshots;
		int						numshots;
		qboolean					animdone;

	public:
      CLASS_PROTOTYPE( AimAndMelee );

									AimAndMelee();
		void						SetArgs( Event *ev );
		void						AnimDone( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void AimAndMelee::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &aim );
   arc.WriteInteger( mode );
   arc.WriteInteger( maxshots );
   arc.WriteInteger( numshots );
   arc.WriteBoolean( animdone );
   }

inline EXPORT_FROM_DLL void AimAndMelee::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadObject( &aim );
   arc.ReadInteger( &mode );
   arc.ReadInteger( &maxshots );
   arc.ReadInteger( &numshots );
   arc.ReadBoolean( &animdone );
   }


class EXPORT_FROM_DLL Melee : public Behavior
	{
	private:
		int						mode;
		qboolean					animdone;

	public:
      CLASS_PROTOTYPE( Melee );

									Melee();
		void						SetArgs( Event *ev );
		void						AnimDone( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void Melee::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteInteger( mode );
   arc.WriteBoolean( animdone );
   }

inline EXPORT_FROM_DLL void Melee::Unarchive
	(
	Archiver &arc
	)
   {
   Behavior::Unarchive( arc );

   arc.ReadInteger( &mode );
   arc.ReadBoolean( &animdone );
   }

class EXPORT_FROM_DLL Repel : public Behavior
	{
	private:
		str						anim;
		float						dist;
		float						len;
		float						speed;
		Vector					goal;
		Vector					start;
		Vector					dir;
		
	public:
      CLASS_PROTOTYPE( Repel );

		void						SetArgs( Event *ev );
      void                 ShowInfo( Actor &self );
		void						Begin( Actor &self );
		qboolean					Evaluate( Actor &self );
		void						End( Actor &self );
	   virtual void         Archive( Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
	};

inline EXPORT_FROM_DLL void Repel::Archive
	(