weapon.h

this keik game source

typedef enum
	{
	WEAPON_MELEE,  				// For hands only weapons
	WEAPON_1HANDED,				// For short, lightweight weapons fired high (Magnum, pistols, etc.)
	WEAPON_2HANDED_HI,			// For long, aimed weapons fired high (sniper rifle, shotgun, etc.)
	WEAPON_2HANDED_LO				// For long, heavy weapons fired low (rocket launcher)
	} weapontype_t;

typedef enum
   {
   PRIMARY,
   SECONDARY
   } weaponmode_t;

class EXPORT_FROM_DLL Weapon : public Item
	{
	private:
      qboolean					attached;
		float						nextweaponsoundtime;

   protected:
		float						maxrange;				// maximum effective firing distance (for AI)
		float						minrange;				// minimum safe firing distance (for AI)
		float						projectilespeed;		// speed of the projectile (0 == infinite speed)

		float						attack_finished;
		float						flashtime;
		float						flashdecay;
		weaponstate_t			weaponstate;
      weaponmode_t         weaponmode;
      qboolean             dualmode;
      str                  primary_ammo_type;
      str                  secondary_ammo_type;
      str						viewmodel;
		str						worldmodel;
		str						ammotype;
		int						ammorequired;
      int                  secondary_ammorequired;
		int						startammo;
		int						rank;
		int						order;
      int						ammo_clip_size;
      int						ammo_in_clip;
      float						last_attack_time;
		weapontype_t			weapontype;
		SentientPtr				last_owner;
      float						last_owner_trigger_time;
      int                  kick;
      int                  action_level_increment;
      qboolean             silenced;
      qboolean             notdroppable;
      int                  aimanim;
      int                  aimframe;

		void						SetMaxRangeEvent( Event *ev );
		void						SetMinRangeEvent( Event *ev );
		void						SetProjectileSpeedEvent( Event *ev );
      void                 SetSecondaryAmmo( const char *type, int amount, int startamount );

      virtual void			DetachGun( void );
		virtual void			AttachGun( void );

		virtual void			PickupWeapon( Event *ev );
		virtual void			DoneLowering( Event *ev );
		virtual void			DoneRaising( Event *ev );
		virtual void			DoneFiring( Event *ev );
		virtual void			Idle( Event *ev );
      virtual qboolean		CheckReload( void );
		virtual void			DoneReloading( Event *ev );
		virtual void			FinishAttack( Event *ev );
		virtual void			EventMuzzleFlash( Event *ev );
      virtual void			MuzzleFlash( float r, float g, float b, float radius, float decay, float life );
      virtual void			BulletHole( trace_t *trace );
      virtual void         SetAimAnim( Event *ev );

	public:
      CLASS_PROTOTYPE( Weapon );

									Weapon();
		virtual					~Weapon();

		virtual void         CreateSpawnArgs( void );

		virtual int				Rank( void );
		virtual int				Order( void );
		virtual void			SetRank( int order, int rank );

		virtual void			SetType( weapontype_t type );
		virtual weapontype_t GetType( void );

		float						GetMaxRange( void );
		float						GetMinRange( void );
		float						GetProjectileSpeed( void );

		void						SetMaxRange( float val );
		void						SetMinRange( float val );
		void						SetProjectileSpeed( float val );

      virtual void         ForceIdle( void );
      virtual void         NextAttack( double rate );

		virtual void			SetAmmo( const char *type, int amount, int startamount );
		virtual void			SetAmmoAmount( int amount );
      virtual void         UseAmmo( int amount );
      virtual void			SetAmmoClipSize( Event * ev );
		virtual void			SetModels( const char *world, const char *view );

		virtual void			SetOwner( Sentient *ent );

		virtual int				AmmoAvailable( void );
      virtual qboolean     UnlimitedAmmo( void );
		virtual qboolean		HasAmmo( void );
      virtual qboolean     HasAmmoInClip( void );
		virtual qboolean		AttackDone( void );
		virtual qboolean		ReadyToFire( void );
		virtual qboolean		ReadyToChange( void );
      virtual qboolean     ReadyToUse( void );
		virtual qboolean		ChangingWeapons( void );
		virtual qboolean		Reloading( void );
      virtual qboolean     WeaponRaising(	void );
      virtual qboolean     WeaponPuttingAway(	void );

		virtual void			PutAway( void );
		virtual void			ReadyWeapon( void );
		virtual qboolean		Drop( void );
		virtual void			Fire( void );
      virtual void			ReleaseFire( float holdfiretime ) { /* No action for base class */ };

		virtual qboolean	   Removable( void );
      virtual qboolean     Pickupable( Entity *other );
      virtual void         DetachFromOwner( void );
      virtual void         AttachToOwner( void );

		virtual void			WeaponSound( Event *ev );

		virtual Vector			MuzzleOffset( void );
		virtual void			GetMuzzlePosition( Vector *position, Vector *forward = NULL, Vector *right = NULL, Vector *up = NULL );

      virtual qboolean     AutoChange( void );
      virtual int          ClipAmmo( void );
      virtual qboolean     ForceReload( void );

      virtual void         ProcessWeaponCommandsEvent(Event *ev);
      virtual void         SetKick( Event *ev );
      virtual void         SecondaryUse( Event *ev );
      virtual void         PrimaryMode( Event *ev );
      virtual void         SecondaryMode( Event *ev );

      virtual qboolean     IsDroppable( void );
      virtual int          ActionLevelIncrement( void );
      virtual void         SetActionLevelIncrement( Event *ev );
      virtual void         PutAwayAndRaise( Event *ev );
      virtual void         Raise( Event *ev );
      virtual qboolean     IsSilenced( void );
      virtual void         ForceState( weaponstate_t state );
      virtual void         NotDroppableEvent( Event *ev );

      virtual void         Archive(	Archiver &arc );
      virtual void         Unarchive( Archiver &arc );
   };


inline EXPORT_FROM_DLL void Weapon::Archive
	(
	Archiver &arc
	)
   {
   Item::Archive( arc );
   arc.WriteBoolean( attached );
   arc.WriteFloat( nextweaponsoundtime );
   arc.WriteFloat( maxrange );
   arc.WriteFloat( minrange );
   arc.WriteFloat( projectilespeed );
   arc.WriteFloat( attack_finished );
   arc.WriteFloat( flashtime );
   arc.WriteFloat( flashdecay );
   arc.WriteInteger( weaponstate );
   arc.WriteInteger( weaponmode );
   arc.WriteBoolean( dualmode );
   arc.WriteString( primary_ammo_type );
   arc.WriteString( secondary_ammo_type );
   arc.WriteString( viewmodel );
   arc.WriteString( worldmodel );
   arc.WriteString( ammotype );
   arc.WriteInteger( ammorequired );
   arc.WriteInteger( secondary_ammorequired );
   arc.WriteInteger( startammo );
   arc.WriteInteger( rank );
   arc.WriteInteger( order );
   arc.WriteInteger( ammo_clip_size );
   arc.WriteInteger( ammo_in_clip );
   arc.WriteFloat( last_attack_time );
   arc.WriteInteger( weapontype );
	arc.WriteSafePointer( last_owner );
   arc.WriteFloat( last_owner_trigger_time );
   arc.WriteInteger( kick );
   arc.WriteInteger( action_level_increment );
   arc.WriteBoolean( silenced );
   arc.WriteBoolean( notdroppable );
   arc.WriteInteger( aimanim );
   arc.WriteInteger( aimframe );
   }

inline EXPORT_FROM_DLL void Weapon::Unarchive
	(
	Archiver &arc
	)
   {
   int temp;

   Item::Unarchive( arc );
   arc.ReadBoolean( &attached );
   arc.ReadFloat( &nextweaponsoundtime );
   arc.ReadFloat( &maxrange );
   arc.ReadFloat( &minrange );
   arc.ReadFloat( &projectilespeed );
   arc.ReadFloat( &attack_finished );
   arc.ReadFloat( &flashtime );
   arc.ReadFloat( &flashdecay );

   arc.ReadInteger( &temp );
   weaponstate = ( weaponstate_t )temp;
   arc.ReadInteger( &temp );
   weaponmode = ( weaponmode_t )temp;

   arc.ReadBoolean( &dualmode );
   arc.ReadString( &primary_ammo_type );
   arc.ReadString( &secondary_ammo_type );
   arc.ReadString( &viewmodel );
   arc.ReadString( &worldmodel );
   arc.ReadString( &ammotype );
   arc.ReadInteger( &ammorequired );
   arc.ReadInteger( &secondary_ammorequired );
   arc.ReadInteger( &startammo );
   arc.ReadInteger( &rank );
   arc.ReadInteger( &order );
   arc.ReadInteger( &ammo_clip_size );
   arc.ReadInteger( &ammo_in_clip );
   arc.ReadFloat( &last_attack_time );

   arc.ReadInteger( &temp );
   weapontype = ( weapontype_t )temp;

	arc.ReadSafePointer( &last_owner );
   arc.ReadFloat( &last_owner_trigger_time );
   arc.ReadInteger( &kick );
   arc.ReadInteger( &action_level_increment );
   arc.ReadBoolean( &silenced );
   arc.ReadBoolean( &notdroppable );
   arc.ReadInteger( &aimanim );
   arc.ReadInteger( &aimframe );
   }

#ifdef EXPORT_TEMPLATE
template class EXPORT_FROM_DLL SafePtr<Weapon>;
#endif
typedef SafePtr<Weapon> WeaponPtr;

EXPORT_FROM_DLL void ResetBulletHoles( void );

#endif /* weapon.h */