Initial commit of Command & Conquer Renegade source code.

Code/Combat/weapons.h

@@ -0,0 +1,330 @@
+/*
+**	Command & Conquer Renegade(tm)
+**	Copyright 2025 Electronic Arts Inc.
+**
+**	This program is free software: you can redistribute it and/or modify
+**	it under the terms of the GNU General Public License as published by
+**	the Free Software Foundation, either version 3 of the License, or
+**	(at your option) any later version.
+**
+**	This program is distributed in the hope that it will be useful,
+**	but WITHOUT ANY WARRANTY; without even the implied warranty of
+**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+**	GNU General Public License for more details.
+**
+**	You should have received a copy of the GNU General Public License
+**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/***********************************************************************************************
+ ***                            Confidential - Westwood Studios                              ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : Commando                                                     *
+ *                                                                                             *
+ *                     $Archive:: /Commando/Code/Combat/weapons.h                             $*
+ *                                                                                             *
+ *                      $Author:: Byon_g                                                      $*
+ *                                                                                             *
+ *                     $Modtime:: 3/25/02 2:08p                                               $*
+ *                                                                                             *
+ *                    $Revision:: 108                                                         $*
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+#ifndef	WEAPONS_H
+#define	WEAPONS_H
+
+#ifndef	ALWAYS_H
+	#include "always.h"
+#endif
+
+#ifndef	GAMEOBJREF_H
+   #include "gameobjref.h"
+#endif
+
+#ifndef	MATRIX3D_H
+	#include "matrix3d.h"
+#endif
+
+#ifndef	WEAPONMANAGER_H
+	#include "weaponmanager.h"
+#endif
+
+#ifndef	SIMPLEVEC_H
+	#include "simplevec.h"
+#endif
+
+class	BitStreamClass;
+class	ChunkSaveClass;
+class	ChunkLoadClass;
+class	RenderObjClass;
+class	ArmedGameObj;
+class	ParticleEmitterClass;
+class	AudibleSoundClass;
+class	PhysicalGameObj;
+
+/*
+**
+*/
+typedef	enum {
+	WEAPON_HOLD_STYLE_C4					= 0,
+	WEAPON_HOLD_STYLE_NOT_USED,
+	WEAPON_HOLD_STYLE_AT_SHOULDER,	// 2
+	WEAPON_HOLD_STYLE_AT_HIP,
+	WEAPON_HOLD_STYLE_LAUNCHER,
+	WEAPON_HOLD_STYLE_HANDGUN,
+	WEAPON_HOLD_STYLE_BEACON,
+	WEAPON_HOLD_STYLE_EMPTY_HANDS,
+	WEAPON_HOLD_STYLE_AT_CHEST,
+	WEAPON_HOLD_STYLE_HANDS_DOWN,
+	NUM_WEAPON_HOLD_STYLES
+} WeaponHoldStyleType;
+
+
+/*
+**
+*/
+typedef	enum {
+	WEAPON_MODEL_UPDATE_WILL_BE_NEEDED,
+	WEAPON_MODEL_UPDATE_IS_NEEDED,
+	WEAPON_MODEL_UPDATE_NOT_NEEDED,
+} WeaponModelUpdateState;
+
+/*
+**
+*/
+typedef	enum {
+	WEAPON_ANIM_NOT_FIRING,
+	WEAPON_ANIM_FIRING_0,
+	WEAPON_ANIM_FIRING_1
+} WeaponAnimState;
+
+
+/*
+**
+*/
+class	MuzzleFlashClass {
+
+public:
+	MuzzleFlashClass( void );
+	~MuzzleFlashClass( void );
+
+	void	Init( RenderObjClass * robj );
+
+	void	Update( bool flashA0, bool flashA1 );
+
+private:
+
+	int					MuzzleA0Bone;
+	int					MuzzleA1Bone;
+	float					Rotation;
+	RenderObjClass *	Model;
+
+	bool					LastFlashA0;
+	bool					LastFlashA1;
+};
+
+/*
+**
+*/
+class	WeaponClass {
+
+public:
+	WeaponClass( const WeaponDefinitionClass *weapon_def = NULL );
+	~WeaponClass( void );
+
+	void				Init( const WeaponDefinitionClass *weapon_def );
+
+	bool				Save( ChunkSaveClass & csave );
+	bool				Load( ChunkLoadClass & cload );
+
+	void				Set_Model( RenderObjClass *model );
+	void				Set_Owner( ArmedGameObj *owner );
+	ArmedGameObj	*Get_Owner( void )				{ return (ArmedGameObj *)Owner.Get_Ptr();	}
+
+	enum {
+		MUZZLE_PRIMARY_0,
+		MUZZLE_PRIMARY_1,
+		MUZZLE_SECONDARY_0,
+		MUZZLE_SECONDARY_1,
+	};
+
+	void				Select( void );
+	void				Deselect( void );
+
+	void				Update( void );
+
+	bool				Is_Muzzle_Clear( void );
+	void				Compute_Bullet_Start_Point(const Matrix3D & muzzle,Vector3 * set_start_point);
+
+	void				Next_C4_Detonation_Mode( void );			// Take the weapon to the next state (for C4)
+
+	const WeaponDefinitionClass *Get_Definition( void )		{ return Definition; }
+	const char * 	Get_Name( void )		  		{ return Definition->Get_Name(); }
+	int				Get_ID( void )		  			{ return Definition->Get_ID(); }
+	const char *	Get_HUD_Icon_Texture_Name( void )	{ return Definition->HUDIconTextureName; }
+	const char *	Get_Model_Name( void ) 		{ return Definition->Model; }
+	const char *	Get_Back_Model_Name( void ){ return Definition->BackModel; }
+	const char *	Get_Anim_Name( void )  		{ return (NextAnimState != WEAPON_ANIM_NOT_FIRING) ? Definition->FireAnim : Definition->IdleAnim; }
+	int				Get_Style( void )		  		{ return Definition->Style; }
+	float			Get_Key_Number( void )		{ return Definition->KeyNumber; }
+	bool				Get_Can_Snipe( void )		{ return Definition->CanSnipe; }
+	float				Get_Rating( void )		  	{ return Definition->Rating; }
+	float				Get_Effective_Range( void ){ return PrimaryAmmoDefinition->EffectiveRange; }
+	float				Get_Primary_Fire_Rate( void ){ return PrimaryAmmoDefinition->RateOfFire; }
+
+	const char * 	Get_First_Person_Model_Name( void )	const		{ return Definition->FirstPersonModel; }
+	const Vector3& Get_First_Person_Model_Offset( void ) const	{ return Definition->FirstPersonOffset; }
+
+	float				Get_Recoil_Time( void )		{ return Definition->RecoilTime; }
+	float				Get_Recoil_Scale( void )	{ return Definition->RecoilScale; }
+
+	// =========== Ammo
+	void				Set_Total_Rounds( int num );
+	int				Get_Total_Rounds( void );
+	void				Add_Rounds( int num );
+	void				Set_Clip_Rounds( int rounds )			{ ClipRounds = rounds; }
+	int				Get_Clip_Rounds( void )					{ return ClipRounds; }
+	void				Set_Inventory_Rounds( int rounds )	{ InventoryRounds = rounds; }
+	int				Get_Inventory_Rounds( void )			{ return InventoryRounds; }
+	void				Do_Reload( void );
+	void				Decrement_Rounds( int rounds = 1 );
+	bool				Is_Ammo_Maxed( void );
+	bool				Is_Loaded( void )							{ return (ClipRounds != 0); }
+	bool				Is_Reload_OK( void );
+	bool				Is_Reload_Needed( void )				{ return !Is_Loaded() && Is_Reload_OK(); }
+	float				Get_Range( void );
+
+   bool				Is_Model_Update_Needed( void )	{ return (UpdateModel == WEAPON_MODEL_UPDATE_IS_NEEDED); }
+	void				Reset_Model_Update( void )			{ UpdateModel = WEAPON_MODEL_UPDATE_NOT_NEEDED; CurrentAnimState = (WeaponAnimState)-1; }
+   bool				Is_Anim_Update_Needed( void )		{ return ( NextAnimState != CurrentAnimState ); }
+	void				Reset_Anim_Update( void )			{ CurrentAnimState = NextAnimState; }
+	WeaponAnimState	Get_Anim_State( void )			{ return CurrentAnimState; }
+
+	int				Get_Total_Rounds_Fired( void )	{ return TotalRoundsFired; }
+
+	void				Display_Targeting( void );
+
+	void				Set_Target( const Vector3 &target)	{ Target = target; }
+	const Vector3 &Get_Target( void )						{ return Target; }
+
+	void				Set_Target_Object( PhysicalGameObj * obj );
+	PhysicalGameObj *	Get_Target_Object( PhysicalGameObj * obj );
+
+	/*
+	** Weapons States
+	*/
+	typedef	enum {
+		STATE_IDLE,
+		STATE_READY,
+		STATE_CHARGE,
+		STATE_FIRE_PRIMARY,
+		STATE_FIRE_SECONDARY,
+		STATE_RELOAD,
+		STATE_START_SWITCH,
+		STATE_END_SWITCH,
+//		NUM_STATES,
+	} WeaponStateType;
+
+	WeaponStateType	Get_State( void )					{ return State; }
+   bool				Is_Firing( void )						{ return DidFire; }
+   bool				Is_Reloading( void )					{ return (State == STATE_RELOAD); }
+   bool				Is_Switching( void )					{ return (State == STATE_START_SWITCH) || (State == STATE_END_SWITCH); }
+	void				Force_Reload( void );
+
+	// Trigger State
+	void				Set_Safety( bool saftey )			{ SafetySet = saftey; }
+	bool				Is_Safety_Set( void )				{ return SafetySet; }
+	void				Set_Primary_Triggered( bool triggered );
+	void				Set_Secondary_Triggered( bool triggered );
+	bool				Is_Triggered( void )	{ return IsSecondaryTriggered || IsPrimaryTriggered; }
+
+	void				Init_Muzzle_Flash( RenderObjClass * robj )	{ MuzzleFlash.Init( robj ); }
+	void				Update_Muzzle_Flash( bool flashA0, bool flashA1 ) 	{ MuzzleFlash.Update( flashA0, flashA1 ); }
+
+	bool				Does_Weapon_Exist( void )				{ return WeaponExists; }
+	void				Set_Weapon_Exists( bool exists )		{ WeaponExists = exists; }
+
+	PhysicalGameObj * Cast_Weapon( const Vector3 & target );
+	bool				Cast_Weapon_Down_Muzzle( Vector3 & hit_pos );
+
+	void				Make_Shell_Eject( const Matrix3D & tm );
+
+	//
+	//	Sound support
+	//
+	void				Stop_Firing_Sound( void );
+
+private:
+
+	void				Fire_C4( const AmmoDefinitionClass *ammo_def );
+	bool				Fire_Beacon( const AmmoDefinitionClass *ammo_def );
+	void				Fire_Bullet( const AmmoDefinitionClass *ammo_def, bool primary );
+
+	// Weapon Info
+	const WeaponDefinitionClass *Definition;
+	GameObjReference				Owner;				// who gets credit for this weapon's kills?
+	RenderObjClass					*Model;
+	int								C4DetonationMode;
+
+	// Ammo Info
+	const AmmoDefinitionClass *PrimaryAmmoDefinition;
+	const AmmoDefinitionClass *SecondaryAmmoDefinition;
+	safe_int							ClipRounds;
+	safe_int							InventoryRounds;		// -1 for unlimited
+	safe_float						BurstDelayTimer;
+	safe_int							BurstCount;
+	float								BulletBumpTime;
+	bool								WeaponExists;			// allows us to have ammo with no weapon
+
+	// Weapon States
+   WeaponStateType				State;				// The state of the weapon
+	float								StateTimer;			// in seconds. Used for switching, reloading, and idle
+	bool								DidFire;
+
+	bool								LastFrameIsPrimaryTriggered;		// is the Trigger pulled
+	bool								LastFrameIsSecondaryTriggered;	// is the Trigger pulled
+	bool								IsPrimaryTriggered;					// is the Trigger pulled
+	bool								IsSecondaryTriggered;				// is the Trigger pulled
+	int								TotalRoundsFired;
+	bool								SafetySet;
+	bool								LockTriggers;
+	float								EmptySoundTimer;
+
+	// Weapon Looks
+	WeaponAnimState				NextAnimState;		// Which anim should we be on
+	WeaponAnimState				CurrentAnimState;	// Which anim are we on
+	WeaponModelUpdateState		UpdateModel;		// Does the weapon Model need to be updated
+
+	Vector3							Target;
+	GameObjReference				TargetObject;
+
+	// Continuous Muzzle Effects (flames)
+	SimpleVecClass<ParticleEmitterClass *>	ContinuousEmitters;
+	AudibleSoundClass *			ContinuousSound;
+
+	AudibleSoundClass *			FiringSound;
+	int								FiringSoundDefID;
+
+	// Functions
+	const Matrix3D & Get_Muzzle( int index = MUZZLE_PRIMARY_0 );
+	void				Do_Fire( bool primary );
+
+	// Weapon State
+	void				Set_State( WeaponStateType new_state );
+	void				Update_State( float dtime );
+	void				Do_Firing_Effects( void );
+	void				Do_Continuous_Effects( bool enable );
+
+	// Muzzle Flash
+	MuzzleFlashClass		MuzzleFlash;
+
+	void				Ignore_Owner( void );
+	void				Unignore_Owner( void );
+
+};
+
+#endif		// WEAPONS_H