sin-2015/thug.h

//-----------------------------------------------------------------------------
//
// Thug header file by Boon, created 11-11-98
//
// DESCRIPTION:
// Contains the code which causes enemies to be able to shoot around walls
// and stuff when they are ducked
// 

#ifndef __THUG_H__
#define __THUG_H__

#include "g_local.h"
#include "actor.h"

extern Event EV_Behavior_AnimDone;

/*
class EXPORT_FROM_DLL Thug : public Actor
	{
	public:
		CLASS_PROTOTYPE( Thug );
		
								Mortician::Mortician();
		virtual float		MJumpTo(	Vector targ,
										float speed
										);
		virtual float		MJumpTo(	PathNode *goal,
										float speed
										);
		virtual float		MJumpTo(	Entity *goal,
										float speed
										);
		float				JumpTo( Vector targ ); //Subtle alteration of regular jumpto
		virtual void		DuckShootEvent(Event *ev);
	};
*/		

///////////////////////////////////////////
// DuckAttack stuff by Boon
///////////////////////////////////////////

class EXPORT_FROM_DLL DuckAttack : public Behavior
	{
	private:
		int						state;
		TurnTo					turn;
		qboolean				animdone;

	public:
      CLASS_PROTOTYPE( DuckAttack );

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

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

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

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

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

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



	public:
      CLASS_PROTOTYPE( Lean_AimAndShoot );

								Lean_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 Lean_AimAndShoot::Archive (Archiver &arc)
   {
   AimAndShoot::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( moveanim );
   arc.WriteString( readyfireanim );
   arc.WriteString( aimanim );
   arc.WriteString( fireanim );
   }

inline EXPORT_FROM_DLL void Lean_AimAndShoot::Unarchive
	(
	Archiver &arc
	)
   {
   AimAndShoot::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( &moveanim );
   arc.ReadString( &readyfireanim );
   arc.ReadString( &aimanim );
   arc.ReadString( &fireanim );
   }


////////////////////////
// Slim's concussion gun
////////////////////////

//#include "g_local.h"
#include "item.h"
#include "weapon.h"
#include "concussion.h"

class EXPORT_FROM_DLL Slimconcussion : public ConcussionGun
	{
	public:
		CLASS_PROTOTYPE( Slimconcussion );
		
								Slimconcussion::Slimconcussion();
//		virtual void		Shoot( Event *ev );
	};


/*
///////////////
// Paddle
///////////////

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

	public:
      CLASS_PROTOTYPE( Paddle );

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

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

*/



#endif