Battlefield 3 Hack Source Code / Reversal Thread

#ifndef __GameClient_h
#define __GameClient_h

#include <windows.h>
#include <tchar.h>
#include <d3d11.h>
#include <d3dx11.h>
#include <d3d10.h>
#include <d3dx10.h>

#define OFFSET_CLIENTGAMECONTEXT				0x02368964
#define OFFSET_GAMERENDERER						0x0236C674
#define OFFSET_DXRENDERER						0x023399E4
#define OFFSET_UPDATEMATRICES					0x006C9410

// ClientMeleeWeapon::giveDamage(ClientControllableEntity* target)		0x81D920

//////////////////////////////////////////////////////////////////////////
// Generic replacements for the EASTL libraries
//////////////////////////////////////////////////////////////////////////
template<class T>
class eastl_vector
{
	T* first_element;
	T* last_element;
	T* buffer_size;
	T* pad;

public:
	UINT size() { return (((DWORD)last_element - (DWORD)first_element) / 4); }
	T at(int index) { return *(T*)((DWORD)first_element+(4*index)); }
};

template<class T>
class eastl_basic_string
{
	T* first_char;
	T* last_char;
	T* buffer_size;
	T* pad;

public:
	T* getString() { return first_char; }
};

template<class T>
class WeakPtr
{
public:
	T** m_data;

	T* getData()
	{
		if(m_data)
		{
			T* ptr = *m_data;
			return (T*)((DWORD)ptr - 0x4);
		}

		return NULL;
	}
};

//////////////////////////////////////////////////////////////////////////
// FrostBite classes
// ClientGameContext, GameRender, and GameDxRender are at the top of their
// respected heirarchies, and are accessible via the Singleton() function.
//////////////////////////////////////////////////////////////////////////
namespace fb
{
	class AimAssist;
	class AimingConstraints;
	class AmmoConfigData;
	class AmmunitionDepot;
	class AnimatedWeaponGS;
	class BoltActionData;
	class BoneCollisionComponent;
	class CharacterEntity;
	class CharacterPhysicsEntity;
	class CharacterPhysicsEntityCallbacks;
	class CharacterPhysicsEntityState;
	class ClientAimingReplication;
	class ClientAnimatedSoldierWeaponHandler;
	class ClientBoneCollisionComponent;
	class ClientCharacterEntity;
	class ClientComponent;
	class ClientControllableEntity;
	class ClientGameContext;
	class ClientGameEntity;
	class ClientGameView;
	class ClientPhysicsEntity;
	class ClientPlayer;
	class ClientPlayerManager;
	class ClientPlayerShooter;
	class ClientPlayerView;
	class ClientSoldierAimingSimulation;
	class ClientSoldierEntity;
	class ClientSoldierPrediction;
	class ClientSoldierReplication;
	class ClientSoldierSimulation;
	class ClientSoldierWeapon;
	class ClientSoldierWeaponsComponent;
	class ClientSpawnEntity;
	class ClientWeapon;
	class ControllableEntity;
	class ControllableFinder;
	class DxRenderer;
	class FireEffectData;
	class FireLogicData;
	class FiringDispersionData;
	class FiringFunctionData;
	class GameContext;
	class GamePhysicsEntity;
	class GameRenderer;
	class GameRenderViewParams;
	class GameTime;
	class GameView;
	class HoldAndReleaseData;
	class IGameRenderer;
	class OnlineId;
	class OverHeatData;
	class Player;
	class PlayerManager;
	class ProjectileEntityData;
	class RayCastHit;
	class RecoilData;
	class RenderScreenInfo;
	class RenderView;
	class RenderViewDesc;
	class ShotConfigData;
	class SoldierAimingEnvironment;
	class SoldierEntity;
	class SoldierWeaponDispersion;
	class SoldierWeaponsComponent;
	class SpatialEntityWithBusAndData;
	class Weapon;
	class WeaponAimingSimulationModifier;
	class WeaponAnimTypeModifier;
	class WeaponFiring;
	class WeaponFiringCallbackHandler;
	class WeaponFiringCallbacks;
	class WeaponFiringData;
	class WeaponFiringDataModifier;
	class WeaponFiringEffectsModifier;
	class WeaponFiringShooter;
	class WeaponLagEffect;
	class WeaponMagazineModifier;
	class WeaponMiscModifierSettings;
	class WeaponModifier;
	class WeaponModifierBase;
	class WeaponProjectileModifier;
	class WeaponShotModifier;
	class WeaponSoundModifier;
	class WeaponState;
	class WeaponSway;
	class WeaponSwayCallbackImpl;
	class WeaponSwitching;
	class WeaponSwitchingCallbacks;
	class WeaponSwitchingState;
	class WeaponZoomModifier;

	enum SoldierEntityActionState
	{
		Jumping,                     
		Walking,                     
		Sliding,                     
		Air,                     
		Falling,                     
		Parachute,                     
		Swim,                     
		Climb,                     
		AnimationDriven,                     
		NumberOfBits,                     
	};

	enum CharacterPoseType
	{

		CharacterPoseType_Stand,                     
		CharacterPoseType_Crouch,                     
		CharacterPoseType_Prone,                     
		CharacterPoseTypeCount                     
	};

	enum CharacterStateType
	{
		CharacterStateType_OnGround,                     
		CharacterStateType_Jumping,                     
		CharacterStateType_InAir,                     
		CharacterStateType_Climbing,                     
		CharacterStateType_Falling,                     
		CharacterStateType_User_0,                     
		CharacterStateType_User_1,                     
		CharacterStateType_User_2,                     
		CharacterStateType_User_3,                     
		CharacterStateType_User_4,                     
		CharacterStateType_User_5,                     
		CharacterStateType_StateCount,                     
		CharacterStateType_Parachute,                     
		CharacterStateType_Swimming,                     
		CharacterStateType_AnimationControlled,                     
		CharacterStateType_Sliding,                     
	};

	enum PersonViewEnum
	{

		FirstPerson,
		ThirdPerson,
		PersonViewCount,
	};

	class ClientComponent
	{
		BYTE pad_000[0x10];
	};

	class RenderScreenInfo
	{
	public:
		UINT m_nWidth;					// this+0x0
		UINT m_nHeight;					// this+0x4
		UINT m_nWindowWidth;			// this+0x8
		UINT m_nWindowHeight;			// this+0xC
		FLOAT fRefreshRate;				// this+0x10
	};

	class DxRenderer
	{
	public:
		BYTE Pad_000[0x8];				// 0x00
		UINT m_nFrameCounter;			// 0x08
		BOOL m_bFrameInProgress;		// 0x0C
		HWND* m_hWnd;					// 0x10
		BYTE Pad_014[0x4];				// 0x14
		BYTE m_bFullscreenWanted;		// 0x18
		BYTE m_bFullscreenActive;		// 0x19
		BYTE m_bMinimized;				// 0x1A
		BYTE m_bMinimizing;				// 0x1B
		BYTE m_bResizing;				// 0x1C
		BYTE m_bOccluded;				// 0x1D
		BYTE m_bVSync;					// 0x1E
		BYTE Pad_01F[0x1];				// 0x1F
		RenderScreenInfo m_screenInfo;	// 0x20
		BYTE Pad_034[0xA4];				// 0x34
		ID3D11Device* pDevice;			// 0xD8
		ID3D11DeviceContext* pContext;  // 0xDC
		BYTE Pad_0E0[0x14];				// 0xE0
		IDXGISwapChain* pSwapChain;		// 0xF4

	public:
		static DxRenderer* Singleton()
		{
			return *(DxRenderer**)OFFSET_DXRENDERER;
		}
	};

	class RenderViewDesc
	{
	public:
		D3DXMATRIX transform;					// 0x00
		INT type;								// 0x40
		BYTE pad_044[4];						// 0x44
		FLOAT fovY;								// 0x48
		FLOAT defaultFovY;						// 0x4C
		FLOAT nearPlane;						// 0x50
		FLOAT farPlane;							// 0x54
		FLOAT aspect;							// 0x58
		FLOAT orthoWidth;						// 0x5C
		FLOAT orthoHeight;						// 0x60
		FLOAT stereoSeparation;					// 0x64
		FLOAT stereoConvergence;				// 0x68
		D3DXVECTOR2 viewportOffset;				// 0x6C
		D3DXVECTOR2 viewportScale;				// 0x74
	};

	class RenderView
	{
	public:
		RenderViewDesc m_desc;						// 0x00
		BYTE pad_07C[4];							// 0x7C
		INT m_dirtyFlags;							// 0x80
		BYTE pad_084[0x16C];						// 0x84
		FLOAT m_fovX;								// 0x1F0
		FLOAT m_depthToWidthRatio;					// 0x1F4
		FLOAT m_fovScale;							// 0x1F8
		FLOAT m_fovScaleSqr;						// 0x1FC
		D3DXMATRIX m_viewMatrix;					// 0x200
		D3DXMATRIX m_viewMatrixTranspose;			// 0x240
		D3DXMATRIX m_viewMatrixInverse;				// 0x280
		D3DXMATRIX m_projecti********;				// 0x2C0
		D3DXMATRIX m_viewMatrixAtOrigin;			// 0x300
		D3DXMATRIX m_projecti********Transpose;		// 0x340
		D3DXMATRIX m_projecti********Inverse;		// 0x380
		D3DXMATRIX m_viewProjecti********;			// 0x3C0
		D3DXMATRIX m_viewProjecti********Transpose;	// 0x400
		D3DXMATRIX m_viewProjecti********Inverse;	// 0x440

	public:
		BOOL update()
		{
			DxRenderer* dxRenderer = DxRenderer::Singleton();
			if(dxRenderer == NULL)
				return FALSE;

			FLOAT screenX = static_cast<FLOAT>(dxRenderer->m_screenInfo.m_nWindowWidth);
			FLOAT screenY = static_cast<FLOAT>(dxRenderer->m_screenInfo.m_nWindowHeight);
			this->m_desc.aspect = screenX / screenY;

			((VOID (__fastcall *)(RenderView*, LPVOID))OFFSET_UPDATEMATRICES)(this, NULL);
			return TRUE;
		}
	};

	class GameRenderViewParams
	{
	public:
		RenderView view;						// 0x00
		RenderView prevView;					// 0x480
		RenderView secondaryStreamingView;		// 0x900
		INT secondaryStreamingViewEnable;		// 0xD80
		BYTE pad_0xD84[0xC];					// 0xD84
		D3DXMATRIX firstPersonTransform;		// 0xD90
	};

	class IGameRenderer
	{
	public:
		virtual VOID Function0();												// V: 0x0
		virtual VOID Function1();												// V: 0x4
		virtual VOID init();													// V: 0x8
		virtual VOID postLoadInit();											// V: 0xC
		virtual VOID createUpdateJob(FLOAT, FLOAT, LPVOID, LPVOID, LPVOID);		// V: 0x10
		virtual VOID joinUpdateJob();											// V: 0x14
		virtual VOID setJobEnable(BOOL);										// V: 0x18
		virtual BOOL getJobEnable();											// V: 0x1C
		virtual VOID onUnloadLevel();											// V: 0x20
		virtual INT getAffinity();												// V: 0x24
		virtual D3DXVECTOR2 getResolution();									// V: 0x28
		virtual VOID addModule(INT, LPVOID);									// V: 0x2C
		virtual VOID removeModule(INT);											// V: 0x30
		virtual const class GameRenderSettings* getSettings();					// V: 0x34
		virtual class ScreenRenderer* getScreenRenderer();						// V: 0x38
		virtual VOID updatePerfOverlay(BOOL, FLOAT);							// V: 0x3C
		virtual VOID resetPerfOverlay();										// V: 0x40
		virtual BOOL isFadeInAllowed();											// V: 0x44
		virtual VOID setVsyncEnable(BOOL);										// V: 0x48
		virtual BOOL getVsyncEnable();											// V: 0x4C
		virtual VOID setPresentEnable(BOOL);									// V: 0x50
		virtual VOID getAdapterInformation(LPVOID, UINT&, UINT&);				// V: 0x54
		virtual const RenderView& getTempDeprecatedView();						// V: 0x58

		INT m_refCount;															// 0x04
	};

	class GameRenderer :
		public IGameRenderer
	{
	public:
		BYTE pad_008[0x48];					// 0x08
		GameRenderViewParams m_viewParams;	// 0x50

	public:
		static GameRenderer* Singleton()
		{
			return *(GameRenderer**)(OFFSET_GAMERENDERER);
		}
	};

	class PlayerManager
	{
	public:
		virtual VOID Function0();								// V:00
		virtual const eastl_vector<Player*> getPlayers();		// V:04
		virtual const eastl_vector<Player*> getSpectators();	// V:08

		DWORD m_playerData;										// 0x04 PlayerData*
		UINT m_maxPlayerCount;									// 0x08
		UINT m_playerCountBitCount;								// 0x0C
		UINT m_playerIdBitCount;								// 0x10
	};

	class ClientPlayerManager : 
		public PlayerManager
	{
	public:
		BYTE pad_014[0x84];							// 0x14
		eastl_vector<ClientPlayer*> m_players;		// 0x98
		eastl_vector<ClientPlayer*> m_spectators;	// 0xA8
		ClientPlayer* m_localPlayer;				// 0xB8
		ClientPlayer** m_idToPlayersMap;			// 0xBC
	};

	class GameTime
	{
	public:
		DWORD m_ticks;						// 0x00
		DWORD m_tickFrequency;				// 0x04
		DWORD m_tickIndexInFrame;			// 0x08
		DWORD m_lastTickIndexInFrame;		// 0x0C
		DWORD m_tickCountInFrame;			// 0x10
		FLOAT m_deltaTime;					// 0x14
		FLOAT m_passedDeltaTimeInFrame;		// 0x18
	};

	class GameView
	{
	public:
		class EntryUnspawnCallback
		{
		public:
			BYTE pad_000[0x4];				// 0x00
			ClientGameView* m_gameView;		// 0x04
			DWORD m_entry;					// 0x08 EntryComponent*
		};

		BYTE pad_000[0x4];					// 0x00
		INT m_currentGameplayCameraId;		// 0x04
	};

	class ClientGameView : 
		public GameView
	{
	public:
		class InputUnspawnCallback
		{
		public:
			BYTE pad_000[0x4];				// 0x00
			ClientGameView* m_gameView;		// 0x04	
		};

		BYTE pad_008[0x8];												// 0x08
		D3DXMATRIX m_cameraTargetOffset;								// 0x10
		D3DXVECTOR4 m_cameraTargetDistance;								// 0x50
		DWORD m_freeCameraScene;										// 0x60 CameraScene*
		DWORD m_freeCamera;												// 0x64	FreeCamera*
		INT m_freeCameraMode;											// 0x68
		INT m_freeCameraPriority;										// 0x6C
		BYTE m_cameraPosInitialized[3];									// 0x70
		BYTE m_freeCameraActivated;										// 0x73
		INT m_previousCameraId;											// 0x74
		DWORD m_inputTarget;											// 0x78 ClientEntryComponent*
		ClientGameView::InputUnspawnCallback* m_inputUnspawnCallback;	// 0x7C
		DWORD m_cameraTarget;											// 0x80 ClientGameEntity*
		DWORD m_cameraEntryTarget;										// 0x84 ClientEntryComponent*
		GameView::EntryUnspawnCallback* m_entryUnspawnCallback;			// 0x88
		DWORD m_cameraContext;											// 0x8C ClientCameraContext*
	};

	class OnlineId
	{
	public:
		ULONGLONG m_nativeData;	// 0x00
		CHAR m_id[0x11];		// 0x08
		BYTE pad_019[0x7];		// 0x19
	};

	class Player
	{
	public:
		BYTE pad_000[0x8];					// 0x00
		DWORD m_data;						// 0x08 PlayerData*
		DWORD m_memoryArena;				// 0x0C
		eastl_basic_string<CHAR> m_name;	// 0x10
		OnlineId m_onlineId;				// 0x20	
		OnlineId m_groupId;					// 0x40
		OnlineId m_clubId;					// 0x60
		INT m_teamPreference;				// 0x80
		BYTE pad_084[0x298];				// 0x84
		INT m_teamId;						// 0x31C
	};

	class ClientPlayer : 
		public Player
	{
	public:

		BYTE pad_320[0x9C];										// 0x320
		WeakPtr<ClientSoldierEntity> m_soldier;					// 0x3BC
		WeakPtr<ClientSoldierEntity> m_corpse;					// 0x3C0
		WeakPtr<ClientCharacterEntity> m_character;				// 0x3C4
		BYTE pad_3C8[0x4];										// 0x3C8
		ClientControllableEntity* m_attachedControllable;		// 0x3CC
		DWORD m_attachedEntryId;								// 0x3D0
		ClientControllableEntity* m_controlledControllable;		// 0x3D4
		DWORD m_controlledEntryId;								// 0x3D8
		DWORD m_input;											// 0x3DC EntryInput*
		DWORD m_inputState;										// 0x3E0 EntryInputState*
		DWORD m_externalInputState;								// 0x3E4 EntryInputState*
		DWORD m_id;												// 0x3E8
		DWORD m_connectionId;									// 0x3EC
		INT m_lastTeamHit;										// 0x3F0
		INT m_inputNetworkId;									// 0x3F4
		DWORD m_oldEntry;										// 0x3F8 ClientEntryComponent*
		ClientPlayerShooter* m_shooter;							// 0x3FC
		ClientPlayerManager* m_playerManager;					// 0x400
		ClientPlayerView* m_ownPlayerView;						// 0x404
		ClientPlayerView* m_playerView;							// 0x408
		DWORD m_digitalInputEnableMask;							// 0x40C
		DWORD m_inputActionMap;									// 0x410 EntryInputActionMap*
		DWORD m_inputTranslator;								// 0x414 EntryInputTranslator*
		WORD m_finalScore;										// 0x418
		BYTE m_finalScoreSet;									// 0x41A

	public:
		ClientSoldierEntity* getSoldier()
		{
			if(m_attachedControllable)
				return m_soldier.getData();

			return (ClientSoldierEntity*)m_controlledControllable;
		}
	};

	class ClientGameEntity
	{
	public:
		BYTE pad_000[0x10];		// 0x00
		DWORD m_entityBus;		// 0x10 EntityBus*
		DWORD m_data;			// 0x14 GameEntityData*
		INT m_updateInterval;	// 0x18
		DWORD m_collection;		// 0x1C Collection*
	};

	class GamePhysicsEntity :
		public ClientGameEntity
	{
	public:
		FLOAT m_health;			// 0x20
	};

	class ClientPhysicsEntity : 
		public GamePhysicsEntity
	{
	public:
		BYTE pad_024[0x48];		// 0x24
	};

	class ControllableEntity
	{
	public:
		BYTE pad_000[0x4];					// 0x00
		DWORD m_material;					// 0x04 MaterialContainerPair*
		INT m_teamId;						// 0x08
		INT m_defaultTeamId;				// 0x0C
	};

	class ClientControllableEntity : 
		public ClientPhysicsEntity,
		public ControllableEntity
	{
	public:
		eastl_vector<DWORD> m_entries;			// 0x7C <ClientEntryComponent*>
		DWORD m_currentVelocityNormalizedOut;	// 0x8C PropertyWriter<FLOAT>
		DWORD m_currentHealthNormalizedOut;		// 0x90 PropertyWriter<FLOAT>
		FLOAT m_oldVelocity;					// 0x94
		FLOAT m_oldHealth;						// 0x98
		ClientSpawnEntity* m_owner;				// 0x9C
		DWORD m_entryCorrectionTask;			// 0xA0 EntryCorrectionTask*
		DWORD m_remoteGhostId;					// 0xA4
		DWORD m_correctingEntry;				// 0xA8
		BYTE m_predictionEnabled;				// 0xAC
		BYTE m_correctionEnabled;				// 0xAD
		BYTE m_isCorrecting;					// 0xAE 
		BYTE pad_0AF[0x1];						// 0xAF
	};

	class ClientCharacterEntity :
		public ClientControllableEntity
	{
	public:
		BYTE pad_0B0[0x4];								// 0xB0
		ClientPlayer* m_player;							// 0xB4
		DWORD m_animatableComponent[2];					// 0xB8 ClientAntAnimatableComponent*
		DWORD m_collisionComponent;						// 0xC0 ClientCharacterPhysicsComponent*
		DWORD m_healthComponent;						// 0xC4 ClientCharacterHealthComponent*
		WORD m_lightProbeHandle;						// 0xC8
		BYTE pad_0CA[0x2];								// 0xCA
		eastl_vector<DWORD> m_inputFilters;				// 0xCC <IInputFilter*>
		DWORD m_hasLocalPlayer;							// 0xDC PropertyWriter<BOOL>
		PersonViewEnum m_activeView;					// 0xE0
		DWORD m_ownedEntities;							// 0xE4 Entity**
		WORD m_ownedEntityCount;						// 0xE8
		BYTE m_mustBeRemotePlayer;						// 0xEA
		BYTE pad_0EB[0x5];								// 0xEB
	};

	class CharacterPhysicsEntity
	{
	public:
		class CharacterInput
		{
		public:
			D3DXVECTOR4 m_forwardVector;		// 0x00
			D3DXVECTOR4 m_upVector;				// 0x10
			D3DXVECTOR4 m_characterGravity;		// 0x20
			FLOAT m_waterLevel;					// 0x30
			FLOAT m_speedScale;					// 0x34
			FLOAT m_yaw;						// 0x38
			FLOAT m_pitch;						// 0x3C
			FLOAT m_forwardInput;				// 0x40
			FLOAT m_strafeInput;				// 0x44
			FLOAT m_sprintMultiplier;			// 0x48
			BYTE m_tryJump;						// 0x4C
			BYTE m_changePose;					// 0x4D
			BYTE m_toggleParachute;				// 0x4E
			BYTE m_sprint;						// 0x4F
			BYTE pad_050[0x10];					// 0x50
		};
	};

	class SoldierEntity
	{
	public:
		enum DeathType
		{
			Shot,                     
			ShotInVehicleEntry,                     
			InsideExplodingVehicle,                     
			DeathTypeCount,                     
		};

		enum SoldierInteractedStatus
		{
			SoldierInteractedStatus_None,                     
			SoldierInteractedStatus_BeingInteracted,                     
			SoldierInteractedStatus_BeingInteractedCancelled,                     
			SoldierInteractedStatus_BeingInteractedFinished,                     
			SoldierInteractedStatus_Count,                     
		};

		BYTE pad_000[0x10];														// 0x00
		DWORD m_soldierData;													// 0x10
		DWORD m_autoAimData[3];													// 0x14
		INT m_overrideLook;														// 0x20
		BYTE pad_024[0xC];														// 0x24
		D3DXVECTOR4 m_lookTarget;												// 0x30
		FLOAT m_headRotationSpeed;												// 0x40
		INT m_allowedToMoveEyes;												// 0x44
		FLOAT m_waterLevelUpdateTimer;											// 0x48
		BYTE pad_04C[0x4];														// 0x4C
		D3DXVECTOR4 m_hitDirection;												// 0x50
		DWORD m_headMaterial;													// 0x60
		DWORD m_space;															// 0x64
		DWORD m_supportedShootingCallback;										// 0x68
		DWORD m_eyePositionCallback;											// 0x6C
		FLOAT m_maxHealth;														// 0x70
		DWORD m_characterPhysicsEntity;											// 0x74
		BYTE pad_078[0x8];														// 0x78
		CharacterPhysicsEntity::CharacterInput m_characterPhysicsEntityInput;	// 0x80
		INT m_beingInteractedStatus;											// 0xE0
		FLOAT m_waterLevel;														// 0xE4
		BYTE m_entryPoseEnabled;												// 0xE8
		BYTE m_physicsControlled;												// 0xE9
		BYTE m_isShielded;														// 0xEA
		BYTE pad_0EB[0x1];														// 0xEB
		CharacterEntity* m_character;											// 0xEC
	};

	class CharacterPhysicsEntityCallbacks
	{
		BYTE pad_000[0x4];		// 0x00
	};

	class ClientSoldierSimulation
	{
	public:
		virtual D3DXVECTOR4 position();								// V:0x4
		virtual VOID setPosition(  D3DXVECTOR4 &);					// V:0x8
		virtual D3DXVECTOR4 surfaceVelocity();						// V:0xC
		virtual D3DXVECTOR4 & velocity();							// V:0x10
		virtual FLOAT maxSpeed();									// V:0x14
		virtual enum CharacterPoseType pose();						// V:0x18
		virtual enum CharacterPoseType changingToPose();			// V:0x1C
		virtual D3DXVECTOR4 aimingLocalPosition();					// V:0x20
		virtual enum SoldierEntityActionState actionState();		// V:0x24
		virtual BOOL isSprinting();									// V:0x28
		virtual BOOL isJumping();									// V:0x2C
		virtual BOOL nearBashableObject();							// V:0x30
		virtual UINT groundMaterialIndex();							// V:0x34
		virtual FLOAT ladderHeightClimbed();						// V:0x3C
		virtual FLOAT ladderHeightLeft();							// V:0x40
		CharacterPhysicsEntity* m_characterEntity;					// 0x04
	};

	class CharacterPhysicsEntityState
	{
	public:
		D3DXVECTOR4 m_parachuteRotation;			// 0x00
		FLOAT m_parachuteDeployTime;				// 0x10
		BYTE m_parachuteEnabled;					// 0x14
		BYTE pad_015[0xB];							// 0x15
		D3DXVECTOR4 m_position;						// 0x20
		D3DXVECTOR4 m_surfaceVelocity;				// 0x30
		D3DXVECTOR4 m_linearVelocity;				// 0x40
		D3DXVECTOR4 m_groundNormal;					// 0x50
		DWORD m_pose;								// 0x60
		DWORD m_changingToPose;						// 0x64
		FLOAT m_poseTransitionTimer;				// 0x68
		DWORD m_currentState;						// 0x6C
		BYTE m_enabled;								// 0x70
		BYTE pad_071[0xF];							// 0x71
		D3DXVECTOR4 m_currentLocalEyePosition;		// 0x80
		DWORD m_groundSupported;					// 0x90
		FLOAT m_groundHeight;						// 0x94
		FLOAT m_timeToJump;							// 0x98
		FLOAT m_stamina;							// 0x9C
		FLOAT m_ladderHeightClimbed;				// 0xA0
		FLOAT m_ladderHeightLeft;					// 0xA4
		FLOAT m_ladderTransitionProgress;			// 0xA8
		DWORD m_contactMaterialIndex;				// 0xAC
		FLOAT m_jumpPenaltyFactor;					// 0xB0
		DWORD m_jumpCounter;						// 0xB4
		FLOAT m_forceToGroundTimer;					// 0xB8
		BYTE m_jumpInProgress;						// 0xBC
		BYTE m_applyLandingPenalty;					// 0xBD
		BYTE m_sprinting;							// 0xBE
		BYTE m_sprintHold;							// 0xBF
		BYTE pad_0C0[0x40];							// 0xC0
	};

	class ClientSoldierPrediction : 
		public ClientSoldierSimulation
	{
	public:
		class DeltaState
		{
		public:
			D3DXVECTOR4 position;							// 0x00
			D3DXVECTOR4 velocity;							// 0x10
			D3DXVECTOR4 eyePosition;						// 0x20
		};

		BYTE pad_008[0x8];									// 0x08
		DeltaState m_correctionDelta;						// 0x10
		DeltaState m_frameCorrectionDelta;					// 0x40
		D3DXVECTOR4 m_velocity;								// 0x70
		FLOAT m_correctionInterpolationTime;				// 0x80
		FLOAT m_correctionInterpolationTimer;				// 0x84
		FLOAT m_frameInterpolationFactor;					// 0x88
		INT m_noInterpolateNextCorrection;					// 0x8C
		CharacterPhysicsEntityState* m_currentState;		// 0x90
		BYTE pad_094[0xC];									// 0x94
		CharacterPhysicsEntityState m_predictionState;		// 0xA0
		CharacterPhysicsEntityState m_correctionState;		// 0x1A0
		SoldierEntityActionState m_actionState;				// 0x2A0
		DWORD m_predictionDebugger;							// 0x2A4
		DWORD m_proximityHook;								// 0x2A8
	};

	class ClientSoldierReplication :
		public ClientSoldierSimulation
	{
	public:
		class State
		{
		public:
			D3DXVECTOR4 parachuteRotation;				// 0x00
			D3DXVECTOR4 position;						// 0x10
			D3DXVECTOR4 surfaceVelocity;				// 0x20
			D3DXVECTOR4 velocity;						// 0x30
			D3DXVECTOR4 groundNormal;					// 0x40
			INT groundSupported;						// 0x50
			INT groundMaterialIndex;					// 0x54
			CharacterStateType state;					// 0x58
			CharacterPoseType pose;						// 0x5C
			CharacterPoseType changingToPose;			// 0x60
			FLOAT groundHeight;							// 0x64
			FLOAT ladderHeightClimbed;					// 0x68
			FLOAT ladderHeightLeft;						// 0x6C
			FLOAT ladderTransitionProgress;				// 0x70
			BYTE pad_074[0x4];							// 0x74
			SoldierEntityActionState actionState;		// 0x78
		};

		DWORD m_interpolator;							// 0x8
		BYTE pad_00C[4];								// 0xC
		State m_state;									// 0x10
	};

	class SoldierWeaponsComponent
	{
	public:
		virtual BOOL isZooming();				// V:0x00
		virtual VOID weaponComponentData();		// V:0x04
		FLOAT m_weaponDispersion;				// 0x04
	};

	class WeaponSwitchingCallbacks
	{
	public:
		virtual void changeWeaponEvent(INT, INT, BOOL, BOOL, BOOL);		// V:0x00
		virtual bool isSelectedWeaponIdValid(INT);						// V:0x04
		virtual bool isFiring();										// V:0x08
	};

	class WeaponSway
	{
	public:
		class AbilityCallback
		{
			virtual BOOL isFunctionOn(INT);											// V: 0x0
		};

		class SuppressionCallback
		{
			virtual FLOAT getSuppressionValue();									// V: 0x0
		};

		class SoldierAttributesCallback
		{
		public:
			virtual CharacterPoseType getPose();									// V: 0x0
			virtual CharacterPoseType getChangingToPose();							// V: 0x4
			virtual D3DXVECTOR4 getSoldierSpeed();									// V: 0x8
			virtual FLOAT getSoldierMaxSpeed();										// V: 0xC
			virtual BOOL isWeaponZoomed();											// V: 0x10
			virtual SoldierEntityActionState actionState();							// V: 0x14
			virtual FLOAT getYawInputLevel();										// V: 0x18
			virtual FLOAT getPitchInputLevel();										// V: 0x1C
			virtual FLOAT getStrafeInputLevel();									// V: 0x20
			virtual FLOAT getThrottleInputLevel();									// V: 0x24
			virtual UINT getSeed();													// V: 0x28
			virtual BOOL isSupported();												// V: 0x2C
			virtual BOOL isWeaponLightEnabled();									// V: 0x30
			virtual void onDispersionUpdated();										// V: 0x34
			virtual BOOL isSprinting();												// V: 0x38
			virtual WeaponSway::AbilityCallback * getAbilityCallback();				// V: 0x3C
			virtual WeaponSway::SuppressionCallback * getSuppressionCallback();		// V: 0x40
		};
	};

	class WeaponSwayCallbackImpl : 
		public WeaponSway::SoldierAttributesCallback
	{
		FLOAT m_yawInputLevel;										// 0x04
		FLOAT m_pitchInputLevel;									// 0x08
		FLOAT m_strafeInputLevel;									// 0x0C
		FLOAT m_throttleInputLevel;									// 0x10
		DWORD m_seed;												// 0x14
		BYTE pad_018[0x8];											// 0x18
		D3DXVECTOR4 m_soldierSpeed;									// 0x20
		FLOAT m_soldierMaxSpeed;									// 0x30
		WeaponSway::AbilityCallback* m_abilityCallback;				// 0x34
		WeaponSway::SuppressionCallback* m_suppressionCallback;		// 0x38
		FLOAT m_currentSuppressionLevel;								// 0x3C
		CharacterPoseType m_pose;									// 0x40
		CharacterPoseType m_changingToPose;							// 0x44
		SoldierEntityActionState m_soldierActionState;				// 0x48
		BYTE m_isSupported;											// 0x4C
		BYTE m_isSprinting;											// 0x4D
		BYTE m_isWeaponLightEnabled;								// 0x4E
		BYTE m_isZooming;											// 0x4F
	};

	class WeaponSwitchingState
	{
	public:
		INT m_weaponCount;							// 0x00
		INT m_currentWeaponId;						// 0x04
		INT m_previousWeaponId;						// 0x08
		INT m_lastPrimary;							// 0x0C
		FLOAT m_weaponSwitchTimer;					// 0x10
		FLOAT m_switchBackToPrevMaxTimePressed;		// 0x14
		INT m_fireAndSwitchBackToPrevAction;		// 0x18
		BYTE m_automaticFire;						// 0x1C
		BYTE m_playerSwitchedWeapon;				// 0x1D
		BYTE m_quickSwitch;							// 0x1E
		BYTE pad_01F[0x1];							// 0x1F
	};

	class WeaponsState
	{
	public:
		DWORD m_weaponResourceIds[10];		// 0x00
		WORD m_weaponInstanceIds[10];		// 0x28
		DWORD m_weaponUnlockIds[28];		// 0x3C
		BYTE pad_0AC[0xC];
	};

	class AnimatedWeaponGS
	{
	public:
		FLOAT disableZoomToggleWeight;	// 0x00
		INT aiAllowFire;				// 0x04
		INT aiAltFireFromtAnt;			// 0x08
		BYTE pad_00C[0x10];				// 0x0C
		BYTE deploy;					// 0x1C
		BYTE altDeploy;					// 0x1D
		BYTE undeploy;					// 0x1E
		BYTE quickSwitch;				// 0x1F
		BYTE reload;					// 0x20
		BYTE reloadShotgun;				// 0x21
		BYTE fire;						// 0x22
		BYTE fireSingle;				// 0x23
		BYTE fireHoldAndRelease;		// 0x24
		BYTE fireSimple;				// 0x25
		BYTE fireShotSpawned;			// 0x26
		BYTE boltAction;				// 0x27
		BYTE pumpAction;				// 0x28
		BYTE meleeAction;				// 0x29
		BYTE quickThrow;				// 0x2A
		BYTE pad_01B[0x1];				// 0x2B
		INT quickThrowType;				// 0x2C
		BYTE aimBody;					// 0x30
		BYTE alwaysAimHead;				// 0x31
		BYTE oneHanded;					// 0x32
		BYTE oneHandedAiming;			// 0x33
		BYTE aimingEnabled;				// 0x34
		BYTE lowerGun;					// 0x35
		BYTE breathControl;				// 0x36
		BYTE rflType;					// 0x37
		BYTE pstlType;					// 0x38
		BYTE hgrType;					// 0x39
		BYTE atType;					// 0x3A
		BYTE sghType;					// 0x3B
		BYTE lmgType;					// 0x3C
		BYTE bagType;					// 0x3D
		BYTE snpType;					// 0x3E
		BYTE zoom;						// 0x3F
		FLOAT aimBodyWeight;			// 0x40
		FLOAT zoomParameter;			// 0x44
		FLOAT zoomScaleFactor;			// 0x48
		FLOAT dispersion;				// 0x4C
		BYTE pad_040[0xC];				// 0x50
		D3DXVECTOR4 aimTargetPosBody;	// 0x5C
		FLOAT zoomOutSpeed;				// 0x6C
		FLOAT zoomInSpeed;				// 0x70
		FLOAT unDeploySpeed;			// 0x74
		FLOAT deploySpeed;				// 0x78
		BYTE lightEnabled;				// 0x7C
		BYTE fireModeChanged;			// 0x7D
		BYTE pad_06E[0x2];				// 0x7E
		INT animType;					// 0x80
		INT gunDown;					// 0x84
		FLOAT numberOfBulletsLeftInGun;	// 0x88
		BYTE bulletsLeftInGun;			// 0x8C
		BYTE weaponActionESIG;			// 0x8D
		BYTE isSprinting;				// 0x8E
		BYTE preparingToBash;			// 0x8F
		INT justStartedSprinting;		// 0x90
		FLOAT kickBackInIronSight;		// 0x94
		FLOAT zoomingTime;				// 0x98
		INT triggerZoomGunTwitch;		// 0x9C
		INT weaponChooserSignal;		// 0xA0
		INT weaponClassSignal;			// 0xA4
		FLOAT offsetX;					// 0xA8
		FLOAT offsetY;					// 0xAC
		FLOAT offsetZ;					// 0xB0
	};

	class ClientAnimatedSoldierWeaponHandler
	{
	public:
		BYTE pad_000[0x4];								// 0x00
		BYTE m_weaponDeployRequested;					// 0x04
		BYTE m_altDeploy;								// 0x05
		BYTE m_quickSwitch;								// 0x06
		BYTE pad_007[0x1];								// 0x07
		FLOAT m_weaponUndeployTimer;					// 0x08
		FLOAT m_spamDetectTimer;						// 0x0C
		BYTE pad_010[0x4];								// 0x10
		ClientSoldierWeapon* m_currentAnimatedWeapon;	// 0x14
		INT m_deleteCurrentAnimationWeapon;				// 0x18
		INT m_currentAnimatedWeaponIndex;				// 0x1C
		INT m_currentAnimatedWeaponState;				// 0x20
		ClientSoldierWeapon* m_wantedAnimatedWeapon;	// 0x24
		INT m_wantedAnimatedWeaponIndex;				// 0x28
		ClientSoldierEntity* m_soldier;					// 0x2C
		INT m_lastPredicted;							// 0x30
	};

	class ClientSoldierWeaponsComponent
	{
	public:
		class ClientWeaponSwayCallbackImpl : 
			public WeaponSwayCallbackImpl
		{
		public:
			INT m_hasBeenLocalPlayer;			// 0x50
		};

		class CorrectionCallbackHandler : 
			public WeaponSwitchingCallbacks
		{
			ClientSoldierWeaponsComponent* m_weaponsComponent;		// 0x04
		};

		class ZoomCorrectionState
		{
		public:
			INT hasZoom;
			UINT zoomLevel;
		};

		class State
		{
		public:
			WeaponSwitchingState weaponSwitchingState;		// 0x00
			ZoomCorrectionState zoomState;					// 0x20
			BYTE pad_028[0x4];								// 0x28
		};

		BYTE pad_000[0x68];														// 0x00
		CorrectionCallbackHandler* m_correctionCallbackHandler;					// 0x68
		BYTE pad_06C[0x4];														// 0x6C
		D3DXMATRIX m_weaponTransform;											// 0x70
		DWORD m_animatableComponent[2];											// 0xB0 ClientAntAnimatableComponent*
		ClientSoldierEntity* m_soldier;											// 0xB8
		eastl_vector<ClientSoldierWeapon*> m_weapons;							// 0xBC
		ClientAnimatedSoldierWeaponHandler* m_currentAnimatedWeaponHandler;		// 0xCC
		BYTE pad_0D0[0x4];														// 0xD0
		WeaponSwitching* m_replicatedWeaponSwitching;							// 0xD4
		WeaponSwitching* m_predictedWeaponSwitching;							// 0xD8
		ClientWeaponSwayCallbackImpl* m_weaponSwayCallback;						// 0xDC
		BYTE pad_0E0[0x4];														// 0xE0
		SoldierAimingEnvironment* m_aimingEnvironment;							// 0xE4
		AimingConstraints* m_swimAimingConstraints;								// 0xE8
		BYTE pad_0EC[0x64];														// 0xEC
		FLOAT m_oldZoomState;													// 0x150
		FLOAT m_lastZoomLevel;													// 0x154
		FLOAT m_timeSinceWeaponFire;											// 0x158
		BYTE m_needsWeapon1pResources;											// 0x15C
		BYTE m_weaponLightDisabled;												// 0x15D
		BYTE pad_15E[0x2];														// 0x15E
		State m_correctionState;												// 0x160
		State m_predictionState;												// 0x18C
		State* m_currentState;													// 0x1B8
		WeaponsState m_currentWeaponsState;										// 0x1BC
		AnimatedWeaponGS m_gameState;											// 0x274
		BYTE pad_328[0x28];														// 0x328
		D3DXMATRIX m_globalAimOverride;											// 0x350
		INT m_globalAimOverrideMode;											// 0x390
		BYTE m_animationsDisabledForCurrentWeapon;								// 0x394
		BYTE m_instanceReloadEnabled;											// 0x395
		BYTE m_flaggedForLowAmmo;												// 0x396
		BYTE pad_397[0x1];														// 0x397
		DWORD m_lastAnimatedSoldierWeapon;										// 0x398 AnimatedSoldierWeapon*
		DWORD m_1pWeaponAsset;													// 0x39C EA::Ant::Tool::DicePlugins::WeaponAsset*
		DWORD m_3pWeaponAsset;													// 0x3A0 EA::Ant::Tool::DicePlugins::WeaponAsset*
		DWORD m_gunDownRaycast;													// 0x3A4 SafeQueryResult*
		DWORD m_enqueuedPostPhysicsEntityEvents[2];								// 0x3A8 EntityEvent*
		BYTE m_enqueuedPostPhysicsEntityEventCount;								// 0x3B0
		BYTE m_waitForRelease1pWeapons;											// 0x3B1
	};

	class ClientSoldierEntity :
		public ClientCharacterEntity, 
		public SoldierEntity
	{
	public:
		class PersonView
		{
			eastl_vector<DWORD> m_meshModels;		// 0x00 <MeshModel*>
			INT m_weaponBoneIndex;					// 0x10
		};

		class SprintInputHandler
		{
		public:
			enum State
			{
				WaitForward,
				WaitReleaseForward,
				DoubleTapSprint,
				ButtonSprint,
				WaitReleaseButtonSprint,
				PostSprint
			};

			State m_currentState;			// 0x00
			FLOAT m_doubleTapTimer;			// 0x04
			FLOAT m_sprintReleaseTimer;		// 0x08
			INT m_waitForSprintRelease;		// 0x0C
		};

		class BreathControlHandler
		{
		public:
			LPVOID m_data;								// 0x00 BreathControlData*
			FLOAT m_breathControlTimer;					// 0x04
			FLOAT m_breathControlMultiplier;			// 0x08
			FLOAT m_breathControlPenaltyTimer;			// 0x0C
			FLOAT m_breathControlPenaltyMultiplier;		// 0x10
			BYTE m_breathControlActive;					// 0x14
			BYTE m_breathControlInputDown;				// 0x15
		};

		BYTE pad_1E0[0x44];											// 0x1E0
		ClientPlayer* m_previousPlayer;								// 0x224
		ClientPlayer* m_corpsePlayer;								// 0x228
		DWORD m_vehicleEntry;										// 0x22C
		BYTE pad_230[0x4];											// 0x230
		DWORD m_blueprint;											// 0x234
		ClientSoldierPrediction* m_predictedController;				// 0x238
		ClientSoldierReplication* m_replicatedController;			// 0x23C
		DWORD m_vegetationLocalInfluenceInfo;						// 0x240
		BYTE pad_244[0x4];											// 0x244
		FLOAT m_movementPenalty;									// 0x248
		FLOAT m_clearMovementTimer;									// 0x24C
		DWORD m_customizationComponent;								// 0x250
		INT m_received1pHint;										// 0x254
		DWORD m_cameraComponent;									// 0x258
		DWORD m_footMaterial;										// 0x25C
		PersonView m_personViews[2];								// 0x260
		BYTE pad_288[0x18];											// 0x288
		INT m_aimingEnabled;										// 0x2A0
		FLOAT m_authoritativePitch;									// 0x2A4
		DWORD m_soldierSound;										// 0x2A8
		BYTE pad_2AC[0x4];											// 0x2AC
		D3DXMATRIX m_meshTransform;									// 0x2B0
		SoldierEntityActionState m_oldActionState;					// 0x2F0
		CharacterPoseType m_previousPose;							// 0x2F4
		BYTE m_forceInivisble;										// 0x2F8
		BYTE m_derivedStatusUpdated;								// 0x2F9
		BYTE m_visualTransformUpdated;								// 0x2FA
		BYTE pad_2FB[0x1];											// 0x2FB
		FLOAT m_lastAnimFrameTime;									// 0x2FC
		D3DXVECTOR4 m_lastAnimFramePos;								// 0x300
		FLOAT m_orderStatusTime;									// 0x310
		FLOAT m_targetTime;											// 0x314
		eastl_vector<DWORD> m_fakePhysics;							// 0x318
		FLOAT m_aiDamageHumanCooldown;								// 0x328
		FLOAT m_speedPenaltyOnDamageTimer;							// 0x32C
		FLOAT m_speedPenaltyOnDamage;								// 0x330
		DWORD m_proximityHook;										// 0x334
		DWORD m_orientationCallback;								// 0x338
		INT m_isUnspawning;											// 0x33C
		FLOAT m_effectVolumeAccumulated;							// 0x340
		DWORD m_healthModule;										// 0x344 IClientSoldierHealthModule*
		FLOAT m_healthTimer;										// 0x348
		ClientSoldierWeaponsComponent* m_soldierWeaponsComponent;	// 0x34C
		DWORD m_bodyComponent;										// 0x350 ClientSoldierBodyComponent*
		ClientBoneCollisionComponent* m_boneCollisionComponent;		// 0x354
		DWORD m_ragdollComponent;									// 0x358 ClientRagdollComponent*
		DWORD m_replicatedAiming;									// 0x35C ClientAimingReplication*
		BreathControlHandler* m_breathControlHandler;				// 0x360
		SprintInputHandler* m_sprintInputHandler;					// 0x364
		INT m_sprintInterruptAction;								// 0x368
		FLOAT m_sprintRecoveryTimer;								// 0x36C
		BYTE m_wasSprinting;										// 0x370
		BYTE m_isOccluded;											// 0x371
		BYTE pad_372[0x2];											// 0x372
		DWORD m_soldierBoundsChecker;								// 0x374 ClientSoldierBoundsChecker*
		FLOAT m_criticalHealthThreshold;							// 0x378
		BYTE m_enableWeaponMesh;									// 0x37C
		BYTE m_isCustomizationSoldier;								// 0x37D
		BYTE m_isImmortalFromData;									// 0x37E
		BYTE m_isFakeImmortalFromData;								// 0x37F
		DWORD m_manDownTimeLeft;									// 0x380
		DWORD m_debugInputRecorder;									// 0x384

	public:
		BOOL getPosition(LPD3DXVECTOR4 posBuffer)
		{
			if(m_replicatedController && posBuffer)
			{
				memcpy_s(posBuffer, sizeof(D3DXVECTOR4), &(m_replicatedController->m_state.position), sizeof(D3DXVECTOR4));
				return TRUE;
			}

			return FALSE;
		}

		ClientSoldierWeapon* getCurrentWeapon()
		{
			if(m_soldierWeaponsComponent)
				if(m_soldierWeaponsComponent->m_currentAnimatedWeaponHandler)
					return m_soldierWeaponsComponent->m_currentAnimatedWeaponHandler->m_currentAnimatedWeapon;

			return NULL;
		}
	};

	class SoldierAimingEnvironment
	{
	public:
		ClientSoldierEntity* m_soldier;					// 0x00
		WeakPtr<ClientControllableEntity> m_target;		// 0x04
		BYTE m_hasTarget;								// 0x08
		BYTE m_hasFriendlyTarget;						// 0x09
		BYTE m_hasChangedTarget;						// 0x0A
		BYTE m_hasStickyBoxTarget;						// 0x0B
		BYTE m_hasSnapBoxTarget;						// 0x0C
	};

	class AimingConstraints
	{
	public:
		FLOAT m_minYaw;				// 0x00
		FLOAT m_maxYaw;				// 0x04
		FLOAT m_minPitch;			// 0x08
		FLOAT m_maxPitch;			// 0x0C
		FLOAT m_pitchOffset;		// 0x10
		FLOAT m_yawOffset;			// 0x14
		FLOAT m_minYawDefault;		// 0x18
		FLOAT m_minPitchDefault;	// 0x1C
	};

	class WeaponSwitching
	{
	public:
		virtual int cycleWeaponId(INT);							// V: 0x4
		virtual int cyclePrimaryWeaponId(INT, BOOL, BOOL);      // V: 0x8
		virtual int cycleSecondaryWeaponId(INT);				// V: 0xC
		
		INT m_currentWeaponId;									// 0x04
		INT m_previousWeaponId;									// 0x08
		INT m_lastPrimary;										// 0x0C
		INT m_weaponCount;										// 0x10
		INT m_fireAndSwitchBackToPreviousAction;				// 0x14
		FLOAT m_weaponSwitchTimer;								// 0x18
		FLOAT m_switchBackToPrevMaxTimePressed;					// 0x1C
		BYTE m_playerSwitchedWeapons;							// 0x20
		BYTE m_quickSwitch;										// 0x21
		BYTE m_automaticFire;									// 0x22
		BYTE pad_023[0x1];										// 0x23
		WeaponSwitchingCallbacks* m_callbackHandler;			// 0x24
	};

	class WeaponModifierBase
	{
		BYTE pad_000[0x8];			// 0x00
	};

	class WeaponFiringDataModifier :
		public WeaponModifierBase
	{
	public:
		DWORD m_weaponFiring;		// 0x8
	};

	class WeaponFiringEffectsModifier :
		public WeaponModifierBase
	{
	public:
		DWORD m_fireEffects1p;		// 0x08
		DWORD m_fireEffects3p;		// 0x0C
	};

	class WeaponSoundModifier :
		public WeaponModifierBase
	{
	public:
		DWORD m_sound;				// 0x08
	};

	class WeaponShotModifier :
		public WeaponModifierBase
	{
	public:
		BYTE pad_008[0x8];				// 0x08
		D3DXVECTOR4 m_initialSpeed;		// 0x10
		INT m_numberOfBulletsPerShell;	// 0x20
	};

	class WeaponProjectileModifier :
		public WeaponModifierBase
	{
	public:
		DWORD m_projectileData;		// 0x08
	};

	class WeaponAimingSimulationModifier :
		public WeaponModifierBase
	{
	public:
		DWORD m_aimingController;	// 0x08
	};

	class WeaponAnimTypeModifier :
		public WeaponModifierBase
	{
	public:
		INT m_weaponAnimType;		// 0x08
	};

	class WeaponMagazineModifier :
		public WeaponModifierBase
	{
	public:
		INT m_magazineCapacity;		// 0x08
		INT m_numberOfMagazines;	// 0x0C
	};

	class WeaponZoomModifier :
		public WeaponModifierBase
	{
	public:
		FLOAT m_zoomRenderFov;		// 0x08
	};

	class WeaponMiscModifierSettings
	{
	public:
		BYTE m_enableBreathControl;				// 0x00
		BYTE m_canBeInSupportedShooting;		// 0x01
		BYTE m_unZoomOnBoltAction;				// 0x02
		BYTE m_holdBoltActionUntilZoomRelease;	// 0x03
	};

	class WeaponModifier
	{
	public:
		BYTE pad_000[0xA8];													// 0x00
		WeaponMiscModifierSettings m_miscWeaponSettings;					// 0xA8
		BYTE pad_0AC[0x4];													// 0xAC
		WeaponFiringDataModifier* m_weaponFiringDataModifier;				// 0xB0
		WeaponFiringEffectsModifier* m_weaponFiringEffectsModifier;			// 0xB4
		WeaponSoundModifier* m_weaponSoundModifier;							// 0xB8
		WeaponShotModifier* m_weaponShotModifier;							// 0xBC
		WeaponProjectileModifier* m_weaponProjectileModifier;				// 0xC0
		WeaponAimingSimulationModifier* m_weaponAimingSimulationModifier;	// 0xC4
		DWORD m_weaponAnimationConfigurationModifier;						// 0xC8
		WeaponAnimTypeModifier* m_weaponAnimTypeModifier;					// 0xCC
		WeaponMagazineModifier* m_weaponMagazineModifier;					// 0xD0
		WeaponZoomModifier* m_weaponZoomModfier;							// 0xD4
	};

	class ClientSoldierWeapon
	{
	public:
		BYTE pad_010[0x20];										// 0x10
		DWORD m_ownedEntities;									// 0x20
		INT m_ownedEntityCount;									// 0x24
		eastl_vector<DWORD>	m_weaponStates1p;					// 0x28
		eastl_vector<DWORD> m_weaponStates3p;					// 0x38
		eastl_vector<DWORD> m_socketPoints;						// 0x48
		WeaponModifier m_weaponModifier;						// 0x7C
		BYTE pad_130[0xC];										// 0x130
		WeaponLagEffect* m_cameraLagEffect;						// 0x13C
		ClientSoldierAimingSimulation* m_authorativeAiming;		// 0x140
		ClientAimingReplication* m_replicatedAiming;			// 0x144
		DWORD m_lockingController;								// 0x148
		DWORD m_secondaryLockingController;						// 0x14C
		ClientWeapon* m_weapon;									// 0x150
		DWORD m_replicatedFiring;								// 0x154 ClientWeaponFiringReplication
		DWORD m_correctionCallbackHandler;						// 0x158
		WeaponFiring* m_predictedFiring;						// 0x15C
		WeaponFiring* m_correctedFiring;						// 0x160
		INT m_compartment;										// 0x164
		WORD m_weaponInstanceId;								// 0x168
		BYTE pad_16A[0x2];										// 0x16A
		INT m_projectileBoneIndex;								// 0x16C
		DWORD m_lpResourceCompartment;							// 0x170
		BYTE m_hasAttachedEntities;								// 0x174
		BYTE m_willAlwaysBe3p;									// 0x175
	};

	class WeaponLagEffect
	{
	public:
		DWORD m_data;						// 0x00 FirstPersonCameraData*
		BYTE pad_004[0xC];					// 0x04
		D3DXVECTOR4 m_weaponOffsetMod;		// 0x10
		D3DXVECTOR4 m_weaponRotationMod;	// 0x20
		D3DXVECTOR4 m_weaponLagOffset;		// 0x30
		D3DXVECTOR4 m_weaponLagRotation;	// 0x40
		D3DXVECTOR4 m_cameraOffsetMod;		// 0x50
		D3DXVECTOR4 m_cameraRotationMod;	// 0x60
		DWORD m_weaponSpringEffect;			// 0x70 WeaponLagEffect::SpringEffect*
		DWORD m_cameraSpringEffect;			// 0x74 WeaponLagEffect::SpringEffect*
		FLOAT m_timeOfLastStateChange;		// 0x78
		INT m_wasZooming;					// 0x7C
	};

	class AimAssist
	{
	public:
		class UpdateContext
		{
			FLOAT deltaTime;				// 0x00
			D3DXVECTOR2 movementInput;		// 0x04
			D3DXVECTOR2 aimingInput;		// 0x0C
			FLOAT  minimumPitch;			// 0x14
			FLOAT maximumPitch;				// 0x18
			FLOAT lookSpeedMultiplier;		// 0x1C
			FLOAT aimScale;					// 0x20
			BYTE pad_024[0xC];				// 0x24
			D3DXMATRIX reticuleSpace;		// 0x30
			D3DXVECTOR4 reticuleSpeed;		// 0x70
			FLOAT reticuleFieldOfView;		// 0x80
			BYTE hasStickyTarget;			// 0x84
			BYTE hasSnapTarget;				// 0x85
			BYTE forceAimSnap;				// 0x86
			BYTE usePitchZoomSnap;			// 0x87
			FLOAT attractZoomMultiplier;	// 0x88
			FLOAT targetRadius;				// 0x8C
			D3DXVECTOR4 targetPosition;		// 0x90
			D3DXVECTOR4 targetSpeed;		// 0xA0
			INT zoomLevel;					// 0xB0
			FLOAT zoomTransitionTimer;		// 0xB4
			INT isMouseInput;				// 0xB8
			BYTE pad_0BC[0x4];				// 0xBC
		};

		DWORD m_data;								// 0x00 SoldierAimAssistData*
		AimingConstraints* m_aimingConstraints;		// 0x04
		INT m_lastZoomLevel;						// 0x08
		FLOAT m_yaw;								// 0x0C
		FLOAT m_pitch;								// 0x10
		D3DXVECTOR2 m_speed;						// 0x14
		FLOAT m_acceleration;						// 0x1C
		FLOAT m_accelerationTimer;					// 0x20
		FLOAT m_attractZoomingPostTimer;			// 0x24
		FLOAT m_targetDistance;						// 0x28
		FLOAT m_softZoneLambda;						// 0x2C
		FLOAT m_polynomialFactor;					// 0x30
		BYTE m_useAimAssist;						// 0x34
		BYTE m_useInputPolynomials;					// 0x35
		BYTE m_hasChangedZoomed;					// 0x36
		BYTE m_isSnapZoomed;						// 0x37
	};

	class ClientSoldierAimingSimulation
	{
	public:
		DWORD m_data;								// 0x00 SoldierAimingSimulationData*
		SoldierAimingEnvironment* m_environment;	// 0x04
		AimAssist* m_fpsAimer;						// 0x08
		FLOAT m_yaw;								// 0x0C
		FLOAT m_pitch;								// 0x10
		FLOAT m_aimYawTimer;						// 0x14
		FLOAT m_aimPitchTimer;						// 0x18
		D3DXVECTOR2 m_sway;							// 0x1C
		BYTE pad_024[0xC];							// 0x24
		AimAssist::UpdateContext m_updateContext;	// 0x30
		INT m_zoomLevel;							// 0xF0
		INT m_oldZoomLevel;							// 0xF4
		INT m_switchToZoomLevel;					// 0xF8
		FLOAT m_zoomTransitionTimer;				// 0xFC
		FLOAT m_fovMultiplier;						// 0x100
		FLOAT m_fovTransitionTimer;					// 0x104
		BYTE m_zoomLevelLocked;						// 0x108
		BYTE m_zoomDisabled;						// 0x109
		BYTE m_trySwitchOnNextUpdate;				// 0x10A
		BYTE m_forceZoom;							// 0x10B
		INT m_fadeState;							// 0x10C
		FLOAT m_fadeTimer;							// 0x110
		eastl_vector<DWORD> m_modifierData;			// 0x114
		FLOAT m_currentZoomTransitionTimer;			// 0x124
		FLOAT m_currentFovTransitionTimer;			// 0x128
	};

	class ClientAimingReplication
	{
	public:
		FLOAT m_yaw;			// 0x00
		FLOAT m_pitch;			// 0x04
		FLOAT m_deltaYaw;		// 0x08
		FLOAT m_deltaPitch;		// 0x0C
		INT m_activated;		// 0x10
	};

	class Weapon
	{
	public:
		BYTE pad_000[0x4];					// 0x00
		DWORD m_data;						// 0x04
		BYTE pad_008[0x4];					// 0x08
		WeaponFiringData* m_firingData;		// 0x0C
		WeaponModifier* m_weaponModifier;	// 0x10
		BYTE pad_014[0xC];					// 0x14
		D3DXVECTOR4 m_moveSpeed;			// 0x20
		D3DXMATRIX m_shootSpace;			// 0x30
		D3DXMATRIX m_shootSpaceDelta;		// 0x70
		BYTE pad_0B0[0x68];					// 0xB0
		FLOAT m_externalDispersionAngle;	// 0x118
		BYTE m_currentPose;					// 0x11C
		BYTE m_useSecondaryProjectile;		// 0x11D
		BYTE pad_11E[0x2];					// 0x11E
	};

	class RayCastHit
	{
	public:
		D3DXVECTOR4 m_position;		// 0x00
		D3DXVECTOR4 m_normal;		// 0x10
		DWORD m_rigidBody;			// 0x20
		DWORD m_material;			// 0x24
		UINT m_part;				// 0x28
		UINT m_bone;				// 0x2C
		FLOAT m_lambda;				// 0x30
	};

	class ControllableFinder
	{
	public:
		BYTE pad_000[0x468];									// 0x00
		class GameWorld* m_gameWorld;							// 0x468
		WeakPtr<ClientControllableEntity> m_ignoredPlayer;		// 0x46C
		WeakPtr<ClientControllableEntity> m_controllableInAim;	// 0x470
		BYTE pad_474[0xC];										// 0x474
		D3DXVECTOR4 m_lastRayBegin;								// 0x480
		D3DXVECTOR4 m_lastRayEnd;								// 0x490
		RayCastHit m_lastHit;									// 0x4A0
	};

	class ClientWeapon :
		public Weapon
	{
	public:
		class FireFxEffectHandle
		{
			DWORD fireEffect;
			INT handle;
		};

		class ProjectileSyncInfo
		{
		public:
			DWORD projectile;						// 0x00 ProjectileBlueprint*
			ProjectileEntityData* projectileData;	// 0x04
			INT localPlayer;						// 0x08
			WeaponFiringShooter* shooterArg;		// 0x0C
			D3DXMATRIX shootSpace;					// 0x10
			D3DXMATRIX visualShootSpace;			// 0x50
			D3DXVECTOR4 initialSpeed;				// 0x90
			UINT randomSeed;						// 0xA0
			INT trace;								// 0xA4
			LPD3DXVECTOR4 targetPosition;			// 0xA8
			FLOAT damageMultiplier;					// 0xAC
			FLOAT explosionDamageMultiplier;		// 0xB0
			DWORD weaponUnlockAsset;				// 0xB4 SoldierWeaponUnlockAsset*
		};

		BYTE pad_120[0x90];												// 0x120
		DWORD m_entityBus;												// 0x1B0 EntityBus*
		AmmunitionDepot* m_ammoDepot;									// 0x1B4
		FLOAT m_cameraFov;												// 0x1B8
		FLOAT m_weaponFov;												// 0x1BC
		FLOAT fovScaleFactor;											// 0x1C0
		DWORD m_primaryWeaponSound;										// 0x1C4 WeaponSound*
		INT m_zoomLevel;												// 0x1C8
		BYTE m_zoomLevelLocked;											// 0x1CC
		BYTE m_playFire;												// 0x1CD
		BYTE m_stopFire;												// 0x1CE
		BYTE pad_1CF[0x1];												// 0x1CF
		ControllableFinder m_controllableFinder;						// 0x1D0
		INT m_overheadEffectHandle;										// 0x6B0
		FireFxEffectHandle m_fireFxEffectHandles[8];					// 0x6B4
		DWORD m_fireFxEffectHandlesSz;									// 0x6F4
		BYTE m_callbackCalledThisFrame[2];								// 0x6F8
		BYTE pad_6FA[0x2];												// 0x6FA
		WeakPtr<WeaponFiringShooter> m_shooter;							// 0x6FC
		WeakPtr<ClientGameEntity> m_targetEntity;						// 0x700
		FLOAT m_lockTime;												// 0x704
		FLOAT m_aimUpdateTimer;											// 0x708
		FLOAT m_fireRateCounter;										// 0x70C
		BYTE m_hasFriendlyTarget;										// 0x710
		BYTE m_hasEnemyTarget;											// 0x711
		BYTE m_hasVehicleTarget;										// 0x712
		BYTE m_hasSoldierTarget;										// 0x713
		DWORD m_weakTokenHolder;										// 0x714
		eastl_vector<ProjectileSyncInfo*> m_bulletsToSpawnOnSyncUpdate;	// 0x718
		WeakPtr<ClientControllableEntity> m_owner;						// 0x728
	};

	class AmmoConfigData
	{
	public:
		INT m_magazineCapacity;					// 0x00
		INT m_numberOfMagazines;				// 0x04
		UINT m_traceFrequency;					// 0x08
		UINT m_ammoPickupMinAmount;				// 0x0C
		UINT m_ammoPickupMaxAmount;				// 0x10
		FLOAT m_autoReplenishDelay;				// 0x14
		INT m_ammoBagPickupAmount;				// 0x18
		FLOAT m_ammoBagPickupDelayMultiplier;	// 0x1C
		INT m_autoReplenishMagazine;			// 0x20
	};

	class WeaponFiring
	{
	public:
		enum WeaponState
		{
			Deploy,                     
			AltDeploy,                     
			TriggerReleaseWait,                     
			NoTrigger,                     
			PreFireDelay,                     
			PrimarySingleDelay,                     
			PrimarySingle,                     
			BoltActionDelay,                     
			BoltAction,                     
			PrimaryAutomaticFire,                     
			ReloadDelay,                     
			Reload,                     
			PostReload,                     
			PrimaryHoldAndRelease_Hold,                     
			PrimaryHoldAndRelease_ReleaseDelay,                     
			PrimaryHoldAndRelease_Release,                     
			NumWeaponStates,                     
			WeaponStateSizeInBits,                     
		};

		class Function
		{
		public:
			INT projectilesLoaded;						// 0x0
			INT projectilesInMagazines;					// 0x4
			INT numberOfProjectilesToFire;				// 0x8
			BOOL hasStoppedFiring;						// 0xC
			BOOL primaryFireTriggeredLastFrame;			// 0xD
			BOOL isOverheated;							// 0xE
			FLOAT heat;									// 0x10
			FLOAT overheatTimer;						// 0x14
			UINT ticks;									// 0x18
			UINT currentFireModeIndex;                  // 0x1C
			INT externalMagazineCapacity;               // 0x20
			DWORD m_firingHolderData;					// 0x24
			class eastl_vector<DWORD> m_fireModes;      // 0x28
		};

		BYTE pad_000[0x94];							// 0x00
		WeaponFiringData* m_data;					// 0x94
		AmmoConfigData* m_ammoData;					// 0x98
		DWORD m_firingHolderData;					// 0x9C
		WeaponSway* m_weaponSway;					// 0xA0
		WeaponState m_weaponState;					// 0xA4
		WeaponState m_lastWeaponState;				// 0xA8
		WeaponState m_nextWeaponState;				// 0xAC
		FLOAT m_switchCooldownTimer;				// 0xB0
		FLOAT m_autoReplenishTime;					// 0xB4
		FLOAT m_timeToWait;							// 0xB8
		FLOAT m_stateData;							// 0xBC
		FLOAT m_holdReleaseMinDelay;				// 0xC0
		FLOAT m_recoilTimer;						// 0xC4
		FLOAT m_recoilAngleX;						// 0xC8
		FLOAT m_recoilAngleY;						// 0xCC
		FLOAT m_recoilAngleZ;						// 0xD0
		FLOAT m_recoilFovAngle;						// 0xD4
		FLOAT m_primaryAmmoReplenishDelay;			// 0xD8
		FLOAT m_reloadTimeMultiplier;				// 0xDC
		FLOAT m_overheatDropMultiplier;				// 0xE0
		INT m_primaryAmmoToFill;					// 0xE4
		DWORD m_characterMeleeEntity;				// 0xE8
		INT m_externalPrimaryMagazineCapacity;		// 0xEC
		Function m_primaryFire;						// 0xF0
		WeaponModifier* m_weaponModifier;			// 0x128
		DWORD m_activeContext;						// 0x12C
		INT m_additionalMagazines;					// 0x130
	};

	class FiringDispersionData
	{
	public:
		FLOAT m_minAngle;			// 0x00
		FLOAT m_maxAngle;			// 0x04
		FLOAT m_increasePerShot;	// 0x08
		FLOAT m_decreasePerShot;	// 0x0C
	};

	class SoldierWeaponDispersion
	{
	public:
		FiringDispersionData m_standDispersion;		// 0x00
		FiringDispersionData m_crouchDispersion;	// 0x10
		FiringDispersionData m_proneDispersion;		// 0x20
		FLOAT m_jumpDispersionAngle;				// 0x30
		FLOAT m_proneTransitionDispersionAngle;		// 0x34
		FLOAT m_moveDispersionAngle;				// 0x38
		FLOAT m_moveZoomedDispersionAngle;			// 0x3C
		FLOAT m_decreasePerSecond;					// 0x40
	};

	class ShotConfigData
	{
	public:
		D3DXVECTOR4 m_initialPosition;						// 0x00
		D3DXVECTOR4 m_initialDirection;						// 0x10
		D3DXVECTOR4 m_initialSpeed;							// 0x20
		FLOAT m_inheritWeaponSpeedAmount;					// 0x30
		DWORD m_muzzleExplosion;							// 0x34
		ProjectileEntityData* m_projectileData;				// 0x38
		ProjectileEntityData* m_secondaryProjectileData;	// 0x3C
		DWORD m_projectile;									// 0x40
		DWORD m_secondaryProejctile;						// 0x44
		FLOAT m_spawnDelay;									// 0x48
		INT m_numberOfBulletsPerShell;						// 0x4C
		INT m_numberOfBulletsPerShot;						// 0x50
		INT m_numberOfBulletsPerBurst;						// 0x54
		BYTE m_relativeTargetAiming;						// 0x58
		BYTE m_forceSpawnToCamera;							// 0x59
		BYTE m_spawnVisualAtWeaponBone;						// 0x5A
		BYTE m_activeForceSpawnToCamera;					// 0x5B
	};

	class HoldAndReleaseData
	{
	public:
		FLOAT m_maxHoldTime;					// 0x00
		FLOAT m_minPowerModifier;				// 0x04
		FLOAT m_maxPowerModifier;				// 0x08
		FLOAT m_powerIncreasePerSecond;			// 0x0C
		FLOAT m_delay;							// 0x10
		FLOAT m_killedHoldingPowerModifier;		// 0x14
		INT m_forceFireWhenKilledHolding;		// 0x18
	};

	class BoltActionData
	{
	public:
		FLOAT m_boltActionDelay;				// 0x00
		FLOAT m_boltActionTime;					// 0x04
		BYTE m_holdBoltActionUntilFireRelease;	// 0x08
		BYTE m_holdBoltActionUntilZoomRelease;	// 0x09
		BYTE m_forceBoltActionOnFireTrigger;	// 0x0A
		BYTE m_unZoomOnBoltAction;				// 0x0B
		BYTE m_returnToZoomAfterBoltAction;		// 0x0C
		BYTE pad_00D[3];						// 0x0D
	};

	class RecoilData
	{
	public:
		FLOAT m_maxRecoilAngleX;			// 0x00
		FLOAT m_minRecoilAngleX;			// 0x04
		FLOAT m_maxRecoilAngleY;			// 0x08
		FLOAT m_minRecoilAngleY;			// 0x0C
		FLOAT m_maxRecoilAngleZ;			// 0x10
		FLOAT m_minRecoilAngleZ;			// 0x14
		FLOAT m_maxRecoilFov;				// 0x18
		FLOAT m_minRecoilFov;				// 0x1C
		INT m_recoilFollowsDispersion;		// 0x20
	};

	class FireEffectData
	{
	public:
		D3DXVECTOR4 m_rotation;			// 0x00
		D3DXVECTOR4 m_offset;			// 0x10
		D3DXVECTOR4 m_zoomRotation;		// 0x20
		D3DXVECTOR4 m_zoomOffset;		// 0x30
		DWORD m_effect;					// 0x40
		BYTE m_useZoomOffset;			// 0x44
		BYTE m_useZoomRotation;			// 0x45
		BYTE m_disableDuringZoom;		// 0x46
		BYTE m_updateTransform;			// 0x47
		BYTE m_stopLoopingEffects;		// 0x48
		BYTE pad_049[0x3];				// 0x49
	};

	class OverHeatData
	{
	public:
		FLOAT m_heatPerBullet;				// 0x00
		FLOAT m_heatDropPerSecond;			// 0x04
		FLOAT m_overHeatPenaltyTime;		// 0x08
		FLOAT m_overHeatThreshold;			// 0x0C
		FireEffectData m_overheatEffect;	// 0x10
	};

	class FireLogicData
	{
	public:
		HoldAndReleaseData m_holdAndRelease;		// 0x00
		BoltActionData m_boltAction;				// 0x1C
		RecoilData m_recoil;						// 0x2C
		INT m_fireInputAction;						// 0x50
		INT m_reloadInputAction;					// 0x54
		INT m_cycleFireModeInputAction;				// 0x58
		FLOAT m_triggerPullWeight;					// 0x5C
		FLOAT m_rateOfFire;							// 0x60
		FLOAT m_RateOfFireForBurst;					// 0x64
		FLOAT m_clientFireRateMultiplier;			// 0x68
		FLOAT m_reloadDelay;						// 0x6C
		DWORD m_fireLogicTypeArray;					// 0x70
		FLOAT m_reloadTheshold;						// 0x74
		FLOAT m_preFireDelay;						// 0x78
		FLOAT m_reloadTime;							// 0x7C
		FLOAT m_reloadTimeBulletsLeft;				// 0x80
		INT m_fireLogicType;						// 0x84
		INT m_reloadLogic;							// 0x88
		FLOAT m_automaticDelay;						// 0x8C
		INT m_reloadType;							// 0x90
		BYTE m_holdOffReloadUntilZoomRelease;		// 0x94
		BYTE m_forceReloadActionOnFireTrigger;		// 0x95
		BYTE m_holdOffReloadUntilFireRelease;		// 0x96
		BYTE m_alwaysAutoReload;					// 0x97
	};

	class FiringFunctionData
	{
	public:
		BYTE pad_000[0x8];								// 0x00
		DWORD m_dispersion;								// 0x08
		SoldierWeaponDispersion m_weaponDispersion;		// 0x0C
		DWORD m_fireEffects1p;							// 0x50
		DWORD m_fireEffects3p;							// 0x54
		DWORD m_sound;									// 0x58
		BYTE pad_05C[0x4];								// 0x5C
		ShotConfigData m_shot;							// 0x60
		BYTE pad_0BC[0x4];								// 0xBC
		FireLogicData m_fireLogic;						// 0xC0
		AmmoConfigData m_ammo;							// 0x158
		BYTE pad_17C[0x4];								// 0x17C
		OverHeatData m_overHeat;						// 0x180
		BYTE pad_1DC[0x4];								// 0x1DC
		FLOAT m_selfHealTimeWhenDeployed;				// 0x1E0
		FLOAT m_ammoCreateReloadDelay;					// 0x1E4
		BYTE m_unlimitedAmmoForAI;						// 0x1E8
		BYTE m_usePrimaryAmmo;							// 0x1E9
	};

	class WeaponFiringData
	{
	public:
		BYTE pad_000[0x8];					// 0x00
		FiringFunctionData* m_primaryFire;	// 0x08
	};

	class ProjectileEntityData
	{
	public:
		BYTE pad_000[0x74];					// 0x00
		DWORD m_hitReactionWeaponType;		// 0x74
		FLOAT m_initialSpeed;				// 0x78
		FLOAT m_initMeshHideTime;			// 0x7C
		FLOAT m_visualConvergeDistance;		// 0x80
		DWORD m_materialPair;				// 0x84	MaterialPair*
		DWORD m_explosion;					// 0x88
		DWORD m_suppressionData;			// 0x8C
		DWORD m_ammunitionType;				// 0x90 String (LPSTR at +0x20)
		BYTE m_serverProjectileDisabled;	// 0x94
		BYTE m_detonateOnTimeout;			// 0x95
	};

	class BoneCollisionComponent
	{
	public:
		enum
		{
			Bone_RightShoulder,
			Bone_LeftShoulder,
			Bone_Pelvis,
			Bone_Head,
			Bone_RightThigh,
			Bone_LeftThigh,
			Bone_RightKnee,
			Bone_LeftKnee,
			Bone_Total
		};

		class BoneTransformInfo
		{
		public:
			D3DXMATRIX transform;			// 0x00
			BYTE visible;					// 0x40
			BYTE pad_041[0xE];				// 0x41
		};

		DWORD m_boneCollisionData;					// 0x00
		BYTE pad_004[0x28];							// 0x04
		DWORD m_skeleton;							// 0x2C AnimationSkeleton*
		BoneTransformInfo* m_transforms;			// 0x30
		eastl_vector<DWORD> m_boneCollisionInfo;	// 0x34
		FLOAT m_latencyBufferTime;					// 0x44
		FLOAT m_latencyBufferInterval;				// 0x48
		BYTE pad_04C[0x174];						// 0x4C
		BoneTransformInfo* m_latencyTransforms;		// 0x1C0
		BYTE m_hiLod;								// 0x1C4
		BYTE pad_1C5[0x3];							// 0x1C5
		DWORD m_debugColor;							// 0x1C8
		INT m_collisionBoneCount;					// 0x1CC
		BYTE m_collisionEnabled;					// 0x1D0
		BYTE m_collisionUpdated;					// 0x1D1
		BYTE m_isServer;							// 0x1D2
		BYTE pad_1D3[0x1];							// 0x1D3
		DWORD m_weakTokenHolder;					// 0x1D4
	};

	class ClientBoneCollisionComponent :
		public ClientComponent,
		public BoneCollisionComponent
	{
	};

	class ClientSpawnEntity
	{
	public:
		BYTE pad_000[0x5C];													// 0x00
		eastl_vector<ClientControllableEntity*> m_spawnedControllables;		// 0x5C
		DWORD m_peerBus;													// 0x6C EntityBus*
		BYTE pad_070[0x10];													// 0x70
		D3DXMATRIX m_transform;												// 0x80
		DWORD m_interpolator;												// 0xC0
		INT m_teamId;														// 0xC4
		INT m_enabled;														// 0xC8
		eastl_vector<ClientControllableEntity*> m_controllableListeners;	// 0xCC
	};

	class ClientPlayerView
	{
	public:
		BYTE pad_084[0xA8];			// 0x00
		ClientPlayer* m_player;		// 0xA8
	};

	class WeaponFiringShooter
	{
	public:
		BYTE pad_000[0x8];
	};

	class ClientPlayerShooter : 
		public WeaponFiringShooter
	{
	public:
		ClientPlayer* m_player;		// 0x8
	};

	class GameContext
	{
	public:
		BYTE pad_000[0x4];					// 0x00
		INT m_realm;						// 0x04
		PlayerManager* m_playerManager;		// 0x08
		GameTime* m_gameTime;				// 0x0C
		DWORD m_level;						// 0x10
		BYTE pad_014[0x1C];					// 0x14
	};

	class ClientGameContext : 
		public GameContext
	{
	public:
		ClientPlayerManager* m_clientPlayerManager;			// 0x30
		DWORD m_onlineManager;								// 0x34 OnlineManager*
		ClientGameView* m_gameView;							// 0x38
		BYTE pad_03C[0x8];									// 0x3C

	public:
		static ClientGameContext* Singleton()
		{
			return *(ClientGameContext**)(OFFSET_CLIENTGAMECONTEXT);
		}
	};
};

#endif //__GameClient_h