behavior.h

this keik game source

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

   arc.WriteString( anim );
   arc.WriteFloat( dist );
   arc.WriteFloat( len );
   arc.WriteFloat( speed );
   arc.WriteVector( goal );
   arc.WriteVector( start );
   arc.WriteVector( dir );
   }

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

   arc.ReadString( &anim );
   arc.ReadFloat( &dist );
   arc.ReadFloat( &len );
   arc.ReadFloat( &speed );
   arc.ReadVector( &goal );
   arc.ReadVector( &start );
   arc.ReadVector( &dir );
   }


class EXPORT_FROM_DLL PickupAndThrow : public Behavior
	{
	private:
		Aim						aim;
		int						mode;
		qboolean					animdone;
      EntityPtr            pickup_target;


	public:
      CLASS_PROTOTYPE( PickupAndThrow );

									PickupAndThrow();
		void						SetArgs( Event *ev );
		void						AnimDone( Event *ev );
		void						Pickup( Event *ev );
		void						Throw( 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 PickupAndThrow::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &aim );
   arc.WriteInteger( mode );
   arc.WriteBoolean( animdone );
   arc.WriteSafePointer( pickup_target );
   }

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

   arc.ReadObject( &aim );
   arc.ReadInteger( &mode );
   arc.ReadBoolean( &animdone );
   arc.ReadSafePointer( &pickup_target );
   }

class EXPORT_FROM_DLL StrafeAttack : public Behavior
	{
	private:
		int						state;
		TurnTo					turn;

	public:
      CLASS_PROTOTYPE( StrafeAttack );

      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 StrafeAttack::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteInteger( state );
   arc.WriteObject( &turn );
   }

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

   arc.ReadInteger( &state );
   arc.ReadObject( &turn );
   }

class EXPORT_FROM_DLL StrafeTo : public Behavior
	{
	private:
      Vector               goal;
      Seek                 seek;
      int                  fail;

	public:
      CLASS_PROTOTYPE( StrafeTo );

      void                 ShowInfo( Actor &self );
      void						SetArgs( Event *ev );
		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 StrafeTo::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteVector( goal );
   arc.WriteObject( &seek );
   arc.WriteInteger( fail );
   }

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

   arc.ReadVector( &goal );
   arc.ReadObject( &seek );
   arc.ReadInteger( &fail );
   }

class EXPORT_FROM_DLL Swim : public Behavior
	{
	private:
      Seek                 seek;
		ObstacleAvoidance2   avoid;
		str						anim;
      float                avoidtime;
      Vector               avoidvec;

	public:
      CLASS_PROTOTYPE( Swim );

		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 Swim::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &seek );
   arc.WriteObject( &avoid );
   arc.WriteString( anim );
   arc.WriteFloat( avoidtime );
   arc.WriteVector( avoidvec );
   }

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

   arc.ReadObject( &seek );
   arc.ReadObject( &avoid );
   arc.ReadString( &anim );
   arc.ReadFloat( &avoidtime );
   arc.ReadVector( &avoidvec );
   }

class EXPORT_FROM_DLL SwimCloseAttack : public Behavior
	{
	private:
      Seek                 seek;
		ObstacleAvoidance2   avoid;
      qboolean             avoiding;
		str						anim;
      float                avoidtime;
      Vector               avoidvec;

	public:
      CLASS_PROTOTYPE( SwimCloseAttack );

		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 SwimCloseAttack::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &seek );
   arc.WriteObject( &avoid );
   arc.WriteBoolean( avoiding );
   arc.WriteString( anim );
   arc.WriteFloat( avoidtime );
   arc.WriteVector( avoidvec );
   }

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

   arc.ReadObject( &seek );
   arc.ReadObject( &avoid );
   arc.ReadBoolean( &avoiding );
   arc.ReadString( &anim );
   arc.ReadFloat( &avoidtime );
   arc.ReadVector( &avoidvec );
   }

class EXPORT_FROM_DLL Fly : public Behavior
	{
	private:
      Seek                 seek;
		ObstacleAvoidance2   avoid;
		str						anim;
      float                avoidtime;
      Vector               avoidvec;

	public:
      CLASS_PROTOTYPE( Fly );

		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 Fly::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &seek );
   arc.WriteObject( &avoid );
   arc.WriteString( anim );
   arc.WriteFloat( avoidtime );
   arc.WriteVector( avoidvec );
   }

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

   arc.ReadObject( &seek );
   arc.ReadObject( &avoid );
   arc.ReadString( &anim );
   arc.ReadFloat( &avoidtime );
   arc.ReadVector( &avoidvec );
   }

class EXPORT_FROM_DLL FlyCloseAttack : public Behavior
	{
	private:
      Seek                 seek;
		ObstacleAvoidance2   avoid;
      qboolean             avoiding;
		str						anim;
      float                avoidtime;
      Vector               avoidvec;

	public:
      CLASS_PROTOTYPE( FlyCloseAttack );

		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 FlyCloseAttack::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &seek );
   arc.WriteObject( &avoid );
   arc.WriteBoolean( avoiding );
   arc.WriteString( anim );
   arc.WriteFloat( avoidtime );
   arc.WriteVector( avoidvec );
   }

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

   arc.ReadObject( &seek );
   arc.ReadObject( &avoid );
   arc.ReadBoolean( &avoiding );
   arc.ReadString( &anim );
   arc.ReadFloat( &avoidtime );
   arc.ReadVector( &avoidvec );
   }

class EXPORT_FROM_DLL Wander : public Behavior
	{
	private:
      Seek                 seek;
		ObstacleAvoidance2   avoid;
		str						anim;
      float                avoidtime;
      Vector               avoidvec;

	public:
      CLASS_PROTOTYPE( Wander );

		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 Wander::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &seek );
   arc.WriteObject( &avoid );
   arc.WriteString( anim );
   arc.WriteFloat( avoidtime );
   arc.WriteVector( avoidvec );
   }

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

   arc.ReadObject( &seek );
   arc.ReadObject( &avoid );
   arc.ReadString( &anim );
   arc.ReadFloat( &avoidtime );
   arc.ReadVector( &avoidvec );
   }


class EXPORT_FROM_DLL WanderCloseAttack : public Behavior
	{
	private:
      Seek                 seek;
		ObstacleAvoidance2   avoid;
      qboolean             avoiding;
		str						anim;
      float                avoidtime;
      Vector               avoidvec;

	public:
      CLASS_PROTOTYPE( WanderCloseAttack );

		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 WanderCloseAttack::Archive
	(
	Archiver &arc
	)
   {
   Behavior::Archive( arc );

   arc.WriteObject( &seek );
   arc.WriteObject( &avoid );
   arc.WriteBoolean( avoiding );
   arc.WriteString( anim );
   arc.WriteFloat( avoidtime );
   arc.WriteVector( avoidvec );
   }

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

   arc.ReadObject( &seek );
   arc.ReadObject( &avoid );
   arc.ReadBoolean( &avoiding );
   arc.ReadString( &anim );
   arc.ReadFloat( &avoidtime );
   arc.ReadVector( &avoidvec );
   }

class EXPORT_FROM_DLL GetCloseToEnemy : public Behavior
	{
	private:
      float                howclose;
		str						anim;
		Chase						chase;
		int						state;
		float						nextsearch;
		
	public:
      CLASS_PROTOTYPE( GetCloseToEnemy );
                        
                           GetCloseToEnemy();
		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 GetCloseToEnemy::Archive
	(
	Archiver &arc
	)

   {
   Behavior::Archive( arc );

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

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

   {
   Behavior::Unarchive( arc );

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

class EXPORT_FROM_DLL PlayAnimSeekEnemy : public Behavior
	{
	private:
		Aim						aim;
		int						mode;
		qboolean					animdone;
      str                  anim;
		str						oldanim;

	public:
      CLASS_PROTOTYPE( PlayAnimSeekEnemy );

		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 PlayAnimSeekEnemy::Archive
	(
	Archiver &arc
	)

   {
   Behavior::Archive( arc );

   arc.WriteObject( &aim );
   arc.WriteInteger( mode );
   arc.WriteBoolean( animdone );
   arc.WriteString( anim );
   arc.WriteString( oldanim );
   }

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

   {
   Behavior::Unarchive( arc );

   arc.ReadObject( &aim );
   arc.ReadInteger( &mode );
   arc.ReadBoolean( &animdone );
   arc.ReadString( &anim );
   arc.ReadString( &oldanim );
   }

#endif /* behavior.h */