Results 1 to 8 of 8
  1. #1
    Helper's Avatar
    Join Date
    Jan 2007
    Gender
    male
    Posts
    114
    Reputation
    10
    Thanks
    3,545

    Battlefield 3 Hack Source Code / Reversal Thread

    This is our official reverse engineering thread, it will contain source code, addresses and other relevant information related to BF3. ONLY POST CONTRIBUTING CONTENT. EVERYTHING ELSE WILL BE DELETED.

    Open Beta Related Source Code - 09/27/2011:
    ClientGameContext - 0x23022E0
    RenderView - 0x2305C20

    Code:
    class fb::ClientGameContext
    {
    
    	class fb::GameContext // Inherited class at offset 0x0
    	{
    
    				class fb::PlayerManager * m_playerManager;                     // this+0x0
    		class fb::GameTime * m_gameTime;                     // this+0x4
    		class fb::Level * m_level;                     // this+0x8
    		class fb::MaterialGridManager * m_materialGridManager;                     // this+0xC
    		class fb::ant::AnimationManager * m_animationManager;                     // this+0x10
    		class fb::ModelAnimationManager * m_modelAnimationManager;                     // this+0x14
    		class fb::MessageManager * m_messageManager;                     // this+0x18
    		class fb::BlueprintBundleManager * m_blueprintBundleManager;                     // this+0x1C
    		class fb::DLCManager * m_dlcManager;                     // this+0x20
    		class fb::DemoControl * m_demoControl;                     // this+0x24
    		enum fb::Realm m_realm;                     // this+0x28
    		class fb::GameContext * s_currentGameContext;                    
    		
    	}; // fb::GameContext
    
    	class fb::ClientPlayerManager * m_clientPlayerManager;                     // this+0x2C
    	class fb::online::OnlineManager * m_onlineManager;                     // this+0x30
    	class fb::ClientGameView * m_gameView;                     // this+0x34
    	class fb::network::InterpolationManager * m_interpolationManager;                     // this+0x38
    	class fb::ClientPlayerScoreManager * m_clientPlayerScoreManager;                     // this+0x3C
    	class fb::Client * m_client;                     // this+0x40
    	
    }; // fb::ClientGameContext
    Code:
        class PlayerManager
        {
        public:
            virtual void unknown000();
    
            /*class fb::SmartRef<fb::PlayerData const >*/unsigned int m_playerData; // this+0x4
            unsigned int m_maxPlayerCount; // this+0x8
            unsigned int m_playerCountBitCount; // this+0xC
            unsigned int m_playerIdBitCount; // this+0x10
    
            __forceinline ClientPlayer* getLocalPlayer()
            {
                return *(ClientPlayer**) ((DWORD)this + 0xB8);
            }
    
            __forceinline ClientPlayer** getIdToPlayerMap()
            {
                return *(ClientPlayer***) ((DWORD)this + 0xBC);
            }
    
            __forceinline ClientPlayer* getPlayerFromId(unsigned int id)
            {
                fb::ClientPlayer *result = 0;
    
                if (id < this->m_maxPlayerCount)
                    result = this->getIdToPlayerMap()[id];
    
                return result;
            }
    
        };
    
    
        .
        .
        .
        .
    
        fb::GameContext* g_gameContext = (fb::GameContext*)0x23022E0;
        printf("%s\n", g_gameContext->m_clientPlayerManager->getLocalPlayer()->m_name);
    
    
        for (int i = 0; i < 64; i++)
        {
            printf("testing ent %i ", i);
            if (g_gameContext->m_clientPlayerManager->getPlayerFromId(i) == NULL)
            {
                printf("\n");
                continue;
            }
    
            if (!IsBadReadPtr( (PVOID)g_gameContext->m_clientPlayerManager->getPlayerFromId(i)->m_name, 4))
            {
                printf("%s\n", g_gameContext->m_clientPlayerManager->getPlayerFromId(i)->m_name);
            }
        }
    Credits: batfitch

    Code:
    class ClientGameContext
    {
    public:
        PlayerManager* m_playerManager; //0x0000  
            char unknown4[40]; //0x0004
        ClientPlayerManager* m_clientPlayerManager; //0x002C  
            char unknown48[208]; //0x0030
    }//Size=0x0100(256)
    
    class ClientPlayerManager
    {
    public:
            char unknown0[8]; //0x0000
        __int32 m_maxPlayerCount; //0x0008  
        __int32 m_playerCountBitCount; //0x000C  
        __int32 m_playerIdBitCount; //0x0010  
            char unknown20[164]; //0x0014
        ClientPlayer* m_localPlayer; //0x00B8  
        ClientPlayer ** m_idToPlayerMap; //0x00BC  
        BYTE m_idToPlayerMapIsDirty; //0x00C0  
            char unknown193[63]; //0x00C1
    }//Size=0x0100(256)'
    Credits: CypherPresents

  2. The Following 3 Users Say Thank You to Helper For This Useful Post:

    ending2012 (06-25-2012),Fogest (10-02-2011),raskofshadows (10-09-2011)

  3. #2
    distiny's Avatar
    Join Date
    Mar 2011
    Gender
    male
    Posts
    560
    Reputation
    67
    Thanks
    560
    My Mood
    Cynical
    ServerPlayer

    Code:
    class fb::ServerPlayer
    {
    
    	class fb::Player // Inherited class at offset 0x0
    	{
    
    		class fb::SupportsWeakPtr // Inherited class at offset 0x8
    		{
    
    
    		}; // fb::SupportsWeakPtr
    
    		virtual class fb::SoldierEntity * getSoldier();	// V: 0x4
    		virtual class fb::EntryComponent * getEntry();	// V: 0x8
    		virtual bool isInVehicle();	// V: 0xC
    		virtual unsigned int getId();	// V: 0x10
    		virtual bool isUnlocked(const class fb::UnlockAssetBase *);	// V: 0x18
    				class fb::SmartRef<fb::PlayerData const > m_data;                     // this+0x8
    		class fb::MemoryArena * m_memoryArena;                     // this+0xC
    		class eastl::basic_string<char,fb::eastl_arena_allocator> m_name;                     // this+0x10
    		class fb::OnlineId m_onlineId;                     // this+0x20
    		class fb::OnlineId m_groupId;                     // this+0x40
    		class fb::OnlineId m_clubId;                     // this+0x60
    		enum fb::TeamId m_teamPreference;                     // this+0x80
    		unsigned int m_lastVehicleCameraIndex;                     // this+0x84
    		unsigned int m_analogInputEnableMask;                     // this+0x88
    		unsigned __int64 m_digitalInputEnableMask;                     // this+0x90
    		class fb::SmartRef<fb::CharacterCustomizationAsset const > m_selectedCustomizationAsset;                     // this+0x98
    		class eastl::fixed_set<fb::UnlockAssetBase const *,37,0,eastl::less<fb::UnlockAssetBase const *>,fb::eastl_arena_allocator> m_selectedActiveUnlocks;                     // this+0x9C
    		bool m_isAIPlayer;                     // this+0x320
    		bool m_isSpectator;                     // this+0x321
    		enum fb::TeamId m_teamId;                     // this+0x324
    				virtual void * __vecDelDtor(unsigned int);	// V: 0x0
    
    	}; // fb::Player
    
    	class fb::network::Serve****** // Inherited class at offset 0x328
    	{
    
    		class fb::network::Ghost // Inherited class at offset 0x0
    		{
    
    			enum <unnamed-tag>
    			{
    
    				int GhostMaskInit;                     // constant 0x1
    				int GhostMaskDelete;                     // constant 0x2
    				int ReservedStates;                     // constant 0x2
    
    			}; // <unnamed-tag>
    
    						virtual const char * getNetName();	// V: 0x4
    			virtual const char * getNetClassName();	// V: 0x8
    			virtual unsigned char getNetClassId();	// V: 0xC
    			virtual class fb::Entity * entityCast();	// V: 0x10
    						class eastl::hash_set<fb::network::GhostInfo *,eastl::hash<fb::network::GhostInfo *>,eastl::equal_to<fb::network::GhostInfo *>,fb::eastl_arena_allocator,0> m_ghostInfos;                     // this+0x4
    			class eastl::vector<fb::network::INetworkable *,fb::eastl_arena_allocator> m_networkables;                     // this+0x24
    			unsigned int m_networkableDescriptorSum;                     // this+0x34
    			unsigned int m_supportsDeltaCompression;                     // this+0x38, len(0x1)
    			unsigned int m_allowChangeMask;                     // this+0x39, len(0x1)
    			unsigned int m_baselineChanged;                     // this+0x3A, len(0x1)
    			unsigned int m_ownedByGhostFactory;                     // this+0x3B, len(0x1)
    			unsigned int m_isStaticGhost;                     // this+0x3C, len(0x1)
    									virtual void * __vecDelDtor(unsigned int);	// V: 0x0
    
    		}; // fb::network::Ghost
    
    						class fb::network::Serve******Filter * m_filter;                     // this+0x3C
    		class fb::SmartRef<fb::network::NetworkableBaseline> m_currentBaseline;                     // this+0x40
    		class fb::SmartRef<fb::network::NetworkableBaseline> m_defaultBaseline;                     // this+0x44
    		unsigned int m_serverId;                     // this+0x48
    		float m_frequency;                     // this+0x4C
    						virtual void * __vecDelDtor(unsigned int);	// V: 0x0
    
    	}; // fb::network::Serve******
    
    	class fb::network::IServerNetworkable // Inherited class at offset 0x378
    	{
    
    		class fb::network::INetworkable // Inherited class at offset 0x0
    		{
    
    									unsigned int m_networkableDescriptorSize;                     // this+0x4
    									virtual void * __vecDelDtor(unsigned int);	// V: 0x0
    
    		}; // fb::network::INetworkable
    
    				virtual unsigned int ghostWrite(unsigned int, class fb::IBitStreamWrite *, const struct fb::network::ServerNetworkableWriteParameters &);	// V: 0x10
    		class fb::network::Serve****** * m_parentGhost;                     // this+0x8
    		unsigned int m_maskInfo;                     // this+0xC
    						virtual void * __vecDelDtor(unsigned int);	// V: 0x0
    
    	}; // fb::network::IServerNetworkable
    
    	class fb::MessageListener // Inherited class at offset 0x388
    	{
    
    				enum <unnamed-tag>
    		{
    
    			int DefaultOrdering;                     // constant 0x64
    
    		}; // <unnamed-tag>
    
    		virtual void onMessage(const class fb::Message &);	// V: 0x0
    		int m_refCntListener;                     // this+0x4
    				
    	}; // fb::MessageListener
    
    																	class fb::BitArray m_unlocksBitArray;                     // this+0x390
    	class fb::ScopedPtr<fb::ServerPlayerView> m_ownPlayerView;                     // this+0x3A4
    	class fb::ServerPlayerView * m_playerView;                     // this+0x3A8
    	unsigned int m_id;                     // this+0x3AC
    	unsigned char m_connectionId;                     // this+0x3B0
    	class fb::EntryInput * m_entryInput;                     // this+0x3B4
    	class fb::ServerSoldierEntity * m_soldier;                     // this+0x3B8
    	class fb::ServerCharacterEntity * m_character;                     // this+0x3BC
    	class fb::WeakPtr<fb::ServerSoldierEntity> m_soldierCorpse;                     // this+0x3C0
    	class fb::ServerSoldierEntity * m_customizationSoldier;                     // this+0x3C4
    	unsigned int m_attachedPartId;                     // this+0x3C8
    	unsigned int m_attachedEntryId;                     // this+0x3CC
    	class fb::ServerControllableEntity * m_attachedControllable;                     // this+0x3D0
    	unsigned int m_oldAttachedPartId;                     // this+0x3D4
    	unsigned int m_oldAttachedEntryId;                     // this+0x3D8
    	class fb::WeakPtr<fb::ServerControllableEntity> m_oldAttachedControllable;                     // this+0x3DC
    	unsigned int m_controlledEntryId;                     // this+0x3E0
    	class fb::ServerControllableEntity * m_controlledControllable;                     // this+0x3E4
    	bool m_isIngame;                     // this+0x3E8
    	float m_timeAlive;                     // this+0x3EC
    	class fb::WeakPtr<fb::ServerVehicleEntity> m_currentVehicleInteractionEntity;                     // this+0x3F0
    	class fb::WeakPtr<fb::ServerVehicleEntity> m_oldVehicleInteractionEntity;                     // this+0x3F4
    	bool m_voicePluggedIn;                     // this+0x3F8
    	bool m_voiceThroughSpeakers;                     // this+0x3F9
    	bool m_isTalking;                     // this+0x3FA
    	bool m_isTalkingOnTheRadio;                     // this+0x3FB
    	class ViewGhostFilter
    	{
    
    		class fb::network::Serve******Filter // Inherited class at offset 0x0
    		{
    
    			virtual bool onGhost(class fb::network::Serve****** *, class fb::network::EngineConnectionPeer *);	// V: 0x0
    						
    		}; // fb::network::Serve******Filter
    
    				class fb::ServerPlayerView * m_view;                     // this+0x4
    		
    	}; // ViewGhostFilter
    
    	class fb::ScopedPtr<fb::ServerPlayer::ViewGhostFilter> m_viewGhostFilter;                     // this+0x3FC
    	class fb::ScopedPtr<fb::ServerGameView> m_gameView;                     // this+0x400
    	bool m_clientControlledCamera;                     // this+0x404
    	struct fb::LinearTransform m_clientCameraTransform;                     // this+0x410
    	struct fb::Vec3 m_deathPosition;                     // this+0x450
    	class fb::SmartRef<fb::SoldierBlueprint const > m_selectedKit;                     // this+0x460
    	float m_ammoCrateTimer;                     // this+0x464
    	float m_ammoPickupTimer;                     // this+0x468
    	float m_vehicleInteractTimer;                     // this+0x46C
    	float m_switchTeamTimer;                     // this+0x470
    	float m_forcedSwitchTeamTimer;                     // this+0x474
    	float m_joinedTeamTimer;                     // this+0x478
    	bool m_isLevelLoaded;                     // this+0x47C
    	bool m_isLevelLinked;                     // this+0x47D
    	bool m_hasEnteredLevel;                     // this+0x47E
    	bool m_isAllowedToSpawn;                     // this+0x47F
    	bool m_isLoadingFromSave;                     // this+0x480
    	float m_ghostCreationWaitingTime;                     // this+0x484
    	int m_ghostCreationCount;                     // this+0x488
    	float m_interactionTimer;                     // this+0x48C
    	bool m_gotChangeVehicleAction;                     // this+0x490
    	class fb::WeakTokenHolder m_weakTokenHolder;                     // this+0x494
    	enum fb::TeamId m_lastKilledByTeamId;                     // this+0x498
    	class PlayerWeaponSelection
    	{
    
    		const class fb::SoldierWeaponUnlockAsset * m_weapon;                     // this+0x0
    		const class fb::UnlockAssetBase *[0x5] m_unlocks;                     // this+0x4
    		unsigned int m_unlockCount;                     // this+0x18
    
    	}; // PlayerWeaponSelection
    
    	class <unnamed-type-m_soldierCustomization>
    	{
    
    		class eastl::fixed_vector<fb::UnlockAsset const *,16,1,fb::eastl_arena_allocator> visual;                     // this+0x0
    		class eastl::fixed_vector<fb::ServerPlayer::PlayerWeaponSelection,10,1,fb::eastl_arena_allocator> weapons;                     // this+0x54
    						
    	}; // <unnamed-type-m_soldierCustomization>
    
    	struct fb::ServerPlayer::<unnamed-type-m_soldierCustomization> m_soldierCustomization;                     // this+0x49C
    	virtual void * __vecDelDtor(unsigned int);	// V: 0x0
    
    }; // fb::ServerPlayer
    RecoilData

    Code:
    class fb::RecoilData
    {
    
    	class ArrayTypeInfo
    	{
    
    		class fb::ArrayTypeInfo // Inherited class at offset 0x0
    		{
    
    			class fb::TypeInfo // Inherited class at offset 0x4
    			{
    
    				class fb::MemberInfo // Inherited class at offset 0x0
    				{
    
    					class fb::Noncopyable // Inherited class at offset 0x0
    					{
    
    																		
    					}; // fb::Noncopyable
    
    					class MemberInfoData
    					{
    
    						const char * name;                     // this+0x0
    						struct fb::MemberInfoFlags flags;                     // this+0x4
    
    					}; // MemberInfoData
    
    															const void * m_infoData;                     // this+0x0
    										
    				}; // fb::MemberInfo
    
    																								class CompareParams
    				{
    
    					bool deepCompare;                     // this+0x0
    					bool asMember;                     // this+0x1
    					struct fb::ICompareFilter * compareFilter;                     // this+0x4
    
    				}; // CompareParams
    
    				class CompareState
    				{
    
    					bool asMember;                     // this+0x0
    
    				}; // CompareState
    
    				class TypeInfoData
    				{
    
    					const char * name;                     // this+0x0
    					struct fb::MemberInfoFlags flags;                     // this+0x4
    					unsigned short totalSize;                     // this+0x6
    					class fb::ModuleInfo * module;                     // this+0x8
    					unsigned char alignment;                     // this+0xC
    					unsigned char fieldCount;                     // this+0xD
    					unsigned char pad1;                     // this+0xE
    					unsigned char pad2;                     // this+0xF
    
    				}; // TypeInfoData
    
    				class fb::TypeInfo * m_pNext;                     // this+0x4
    				unsigned short m_runtimeId;                     // this+0x8
    				unsigned short m_flags;                     // this+0xA
    								
    			}; // fb::TypeInfo
    
    									
    		}; // fb::ArrayTypeInfo
    
    						
    	}; // ArrayTypeInfo
    
    	class ArrayTypeInfo_t
    	{
    
    		class fb::ArrayTypeInfo // Inherited class at offset 0x0
    		{
    
    			class fb::TypeInfo // Inherited class at offset 0x4
    			{
    
    				class fb::MemberInfo // Inherited class at offset 0x0
    				{
    
    					class fb::Noncopyable // Inherited class at offset 0x0
    					{
    
    																		
    					}; // fb::Noncopyable
    
    					class MemberInfoData
    					{
    
    						const char * name;                     // this+0x0
    						struct fb::MemberInfoFlags flags;                     // this+0x4
    
    					}; // MemberInfoData
    
    															const void * m_infoData;                     // this+0x0
    										
    				}; // fb::MemberInfo
    
    																								class CompareParams
    				{
    
    					bool deepCompare;                     // this+0x0
    					bool asMember;                     // this+0x1
    					struct fb::ICompareFilter * compareFilter;                     // this+0x4
    
    				}; // CompareParams
    
    				class CompareState
    				{
    
    					bool asMember;                     // this+0x0
    
    				}; // CompareState
    
    				class TypeInfoData
    				{
    
    					const char * name;                     // this+0x0
    					struct fb::MemberInfoFlags flags;                     // this+0x4
    					unsigned short totalSize;                     // this+0x6
    					class fb::ModuleInfo * module;                     // this+0x8
    					unsigned char alignment;                     // this+0xC
    					unsigned char fieldCount;                     // this+0xD
    					unsigned char pad1;                     // this+0xE
    					unsigned char pad2;                     // this+0xF
    
    				}; // TypeInfoData
    
    				class fb::TypeInfo * m_pNext;                     // this+0x4
    				unsigned short m_runtimeId;                     // this+0x8
    				unsigned short m_flags;                     // this+0xA
    								
    			}; // fb::TypeInfo
    
    									
    		}; // fb::ArrayTypeInfo
    
    						
    	}; // ArrayTypeInfo_t
    
    											enum <unnamed-tag>
    	{
    
    		int field_MaxRecoilAngleX;                     // constant 0x0
    		int field_MinRecoilAngleX;                     // constant 0x1
    		int field_MaxRecoilAngleY;                     // constant 0x2
    		int field_MinRecoilAngleY;                     // constant 0x3
    		int field_MaxRecoilAngleZ;                     // constant 0x4
    		int field_MinRecoilAngleZ;                     // constant 0x5
    		int field_MaxRecoilFov;                     // constant 0x6
    		int field_MinRecoilFov;                     // constant 0x7
    		int field_RecoilFollowsDispersion;                     // constant 0x8
    		int field__Count;                     // constant 0x9
    
    	}; // <unnamed-tag>
    
    	float m_maxRecoilAngleX;                     // this+0x0
    	float m_minRecoilAngleX;                     // this+0x4
    	float m_maxRecoilAngleY;                     // this+0x8
    	float m_minRecoilAngleY;                     // this+0xC
    	float m_maxRecoilAngleZ;                     // this+0x10
    	float m_minRecoilAngleZ;                     // this+0x14
    	float m_maxRecoilFov;                     // this+0x18
    	float m_minRecoilFov;                     // this+0x1C
    	bool m_recoilFollowsDispersion;                     // this+0x20
    
    }; // fb::RecoilData
    Last edited by distiny; 10-02-2011 at 02:57 PM.

  4. The Following 3 Users Say Thank You to distiny For This Useful Post:

    Fogest (10-02-2011),ODST0034 (04-27-2012),raskofshadows (10-09-2011)

  5. #3
    distiny's Avatar
    Join Date
    Mar 2011
    Gender
    male
    Posts
    560
    Reputation
    67
    Thanks
    560
    My Mood
    Cynical
    to draw using the engine rather then d3d/dx (for the noobs use these functions to draw text, etc the same way the engine draws info on your hud)

    UIHud

    Code:
    class fb::UIHud
    {
     
            class fb::UIEngine::UIEngineDrawComp // Inherited class at offset 0x0
            {
     
                                                                    virtual void * __vecDelDtor(unsigned int);      // V: 0x0
     
            }; // fb::UIEngine::UIEngineDrawComp
     
            class HudRenderState
            {
     
                    struct fb::UIVertex2d * vertices;                     // this+0x0
                    unsigned short * indices;                     // this+0x4
                    unsigned int vertexBufferOffset;                     // this+0x8
                    unsigned int indexBufferOffset;                     // this+0xC
                    unsigned int count;                     // this+0x10
                    unsigned int lastBufferSize;                     // this+0x14
                    float alpha;                     // this+0x18
                    function  * cb;                     // this+0x1C
     
            }; // HudRenderState
     
            class UIHudDraw
            {
     
                                                                    virtual void * __vecDelDtor(unsigned int);      // V: 0x0
     
            }; // UIHudDraw
     
            enum eHudRenderState
            {
     
                    int eHudRenderState_alpha;                     // constant 0x0
                    int eHudRenderState_add;                     // constant 0x1
                    int eHudRenderState_count;                     // constant 0x2
                    int eHudRenderState_notUsed;                     // constant 0x3
     
            }; // eHudRenderState
     
            class UIHudIconDrawParams
            {
     
                    struct fb::Vec2 pos;                     // this+0x0
                    struct fb::Vec2 size;                     // this+0x8
                    struct fb::Vec2 flip;                     // this+0x10
                    enum fb::UIHudIcon icon;                     // this+0x18
                    enum fb::UIIconState state;                     // this+0x1C
                    float scale;                     // this+0x20
                    struct fb::Color32 color;                     // this+0x24
     
            }; // UIHudIconDrawParams
     
            class Text
            {
     
                    unsigned int hash;                     // this+0x0
                    float timeSinceUsed;                     // this+0x4
                    float textSize;                     // this+0x8
                    float glowSize;                     // this+0xC
                    struct fb::Color32 color;                     // this+0x10
                    struct fb::Vec2 pos;                     // this+0x14
                    unsigned char justCreated;                     // this+0x1C
                    unsigned char textLen;                     // this+0x1D
                    unsigned short pad;                     // this+0x1E
                    class GRect<float> textRect;                     // this+0x20
                    class GPtr<GFxDrawText> text;                     // this+0x30
                    struct GFxDrawText::Filter filter;                     // this+0x34
                                                   
            }; // Text
     
                            struct fb::Vec4 m_currentTextColor;                     // this+0x10
            bool m_bIsMultiplayer;                     // this+0x20
            bool m_bIsCoop;                     // this+0x21
            bool m_bCreateNewText;                     // this+0x22
            class fb::UIMinimapIconTextureAtlas m_atlas;                     // this+0x24
            enum fb::UIHud::eHudRenderState m_currRenderState;                     // this+0x50
            struct fb::UIHud::HudRenderState[0x2] m_renderState;                     // this+0x54
            class eastl::vector<fb::UIHud::Text *,fb::eastl_arena_allocator> m_text;                     // this+0x94
            class eastl::vector<fb::UIHud::UIHudDraw *,fb::eastl_arena_allocator> m_drawObjects;                     // this+0xA4
            float m_lastDelta;                     // this+0xB4
                            virtual void * __vecDelDtor(unsigned int);      // V: 0x0
     
    }; // fb::UIHud

  6. The Following 2 Users Say Thank You to distiny For This Useful Post:

    Helper (10-04-2011),raskofshadows (10-09-2011)

  7. #4
    Helper's Avatar
    Join Date
    Jan 2007
    Gender
    male
    Posts
    114
    Reputation
    10
    Thanks
    3,545
    Code:
    class ClientPlayerManager
    {
    public:
        char unknown00[8]; //0x0000
        INT32 m_maxPlayerCount; //0x0008  
        INT32 m_playerCountBitCount; //0x000C  
        INT32 m_playerIdBitCount; //0x0010  
        char unknown01[0x84]; //0x0014
        class eastl::vector<fb::ClientPlayer *,fb::eastl_arena_allocator> m_players; //0x0098 Player iteration starts here
        ClientPlayer* m_localPlayer; //0x00B8  
        ClientPlayer ** m_idToPlayerMap; //0x00BC  
    
    };
    
    
    class ClientPlayer
    {
           //VFT to VFunctions
        virtual class SoldierEntity * getSoldier();    // VFT: 0x4
        virtual class EntryComponent * getEntry();    // VFT: 0x8
        virtual bool isInVehicle();    // V: 0xC
        virtual unsigned int getId();    // V: 0x10
        //virtual bool isUnlocked(const class UnlockAssetBase *);    // V: 0x18
    
        //-------------------------------------------------------------
        char unknown1[0xC];        // 0x04
        char m_name[20];        // 0x10
        char unknown4[0x304];
        INT32 m_teamId;            // 0x324, 1 for Attacker, 2 for Defender
    
        int m_refCount;                     // this+0x3C0
            ...
        unsigned int m_id;                     // this+0x3F0
    
        unsigned int m_connectionId;           // this+0x3F4
    
    }; // fb::ClientPlayer  
    
        for (int i = 0; i<64; i++)
        {
            INT32 PlayerPtr = pPlayersMapPtr + (i*4);
            if ( PlayerPtr == FirstBadPlayerPtr ) {
                printf("---- Player list end, we have %d players ----\n", i);
                break;
            }
    
            //read name, team, ID, refCount, connectionID, etc
            ... ...
            
            printf("Player%d name:%s, teamID:%d, ID:%d, refCount:%d, connectID:%d\n", i, theName, theTeamID, m_ID, refCount,m_connectionID );
    
    
        }//end of FOR loop
    renderview - 0x2305C20

  8. The Following User Says Thank You to Helper For This Useful Post:

    raskofshadows (10-09-2011)

  9. #5
    Helper's Avatar
    Join Date
    Jan 2007
    Gender
    male
    Posts
    114
    Reputation
    10
    Thanks
    3,545
    Use of "physicsRayQuery" \ Credits: x22

    Code:
    struct RayCastHit
    {
        Vec3 m_position; // 0x0
        Vec3 m_normal; // 0x10
        class PhysicsEntityBase* m_rigidBody; // 0x20
        const class MaterialContainerPair* m_material; // 0x24
        unsigned int m_part; // 0x28
        unsigned int m_bone; // 0x2C
        float m_lambda; // 0x30
    };
    
    class IPhysicsRayCaster
    {
    public:
        virtual bool physicsRayQuery(char* text, Vec3 &from, Vec3 &to, RayCastHit &hit, int flag, void* PhysicsEntityList);
    };
    
    class GameWorld
    {
    public:
        char Unknowns01[0x840]; // 0x0
        class IPhysicsRayCaster m_rayCaster; // 0x840
    };
    
    class HavokPhysicsManager
    {
    public:
        char Unknowns01[0x40]; // 0x0
        class IPhysicsRayCaster* m_rayCaster; // 0x40 <- it points to GameWorld->m_rayCaster
    };
    
    class Level
    {
    public:
        char Unknowns01[0xbc]; // 0x0
        class HavokPhysicsManager* hkPhysicsManager; // 0xbc
        class GameWorld* m_gameWorld; // 0xc0
    };

  10. The Following User Says Thank You to Helper For This Useful Post:

    raskofshadows (10-09-2011)

  11. #6
    distiny's Avatar
    Join Date
    Mar 2011
    Gender
    male
    Posts
    560
    Reputation
    67
    Thanks
    560
    My Mood
    Cynical
    Code:
    class fb::PunkbusterScreenshot
    {
    
    class fb::IScreenshotCallback // Inherited class at offset 0x0
    {
    
    virtual void screenshotDone(unsigned char *, unsigned int);// V: 0x0
    
    }; // fb::IScreenshotCallback
    
    unsigned int m_width;                     // this+0x4
    unsigned int m_height;                     // this+0x8
    
    }; // fb::PunkbusterScreenshot

  12. The Following User Says Thank You to distiny For This Useful Post:

    Fogest (10-31-2011)

  13. #7
    Helper's Avatar
    Join Date
    Jan 2007
    Gender
    male
    Posts
    114
    Reputation
    10
    Thanks
    3,545
    g_BorderInput = 0x23428f0

    Code:
    class BorderInputNode
    {
    public:
     virtual void init();
     virtual void exit();
     virtual void clear();
     virtual void Function3();
     virtual void Function4();
     virtual void Function5();
     virtual void Function6();
     virtual void Function7();
     virtual void Function8();
     virtual void Function9();
     virtual void Function10();
     virtual void Function11();
     virtual void Function12();
     virtual void Function13();
     virtual void Function14();
     virtual void Function15();
     virtual void Function16();
     virtual void Function17(); 
     virtual void Function18();
     virtual void Function19();
     virtual void Function20();
     virtual void Function21(); 
     virtual void Function22();
     virtual void Function23();
     virtual void Function24();
     virtual int preFrameUpdate(float fDeltaTime); 
     char unknown0[4];
     ScopedPtr<InputCache> m_inputCache; 
    };
     
    class InputCache
    {
    public:
    char unknown0[1];
    float m_conceptCache[0x7B]; 
    float m_juiceConceptCache[0x7B]; 
    float m_prevJuiceConceptCache[0x7B]; 
    };

  14. #8
    RhinIsTooShortOfAName's Avatar
    Join Date
    Jan 2012
    Gender
    male
    Posts
    1
    Reputation
    10
    Thanks
    0
    My game client header.

    Code:
    #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

Similar Threads

  1. CF Hack Source Code Rules
    By KING in forum CrossFire Hack Coding / Programming / Source Code
    Replies: 69
    Last Post: 01-20-2011, 03:23 PM
  2. Speed Hack Source Code
    By jeevin in forum Combat Arms Hack Coding / Programming / Source Code
    Replies: 8
    Last Post: 04-20-2010, 06:01 PM
  3. Hack source code cpp
    By carlosmamoura in forum C++/C Programming
    Replies: 16
    Last Post: 01-14-2010, 09:27 PM
  4. <releasing 2 morrow> new opk hack ~source code~ C++
    By pikamew4 in forum Combat Arms Hack Coding / Programming / Source Code
    Replies: 21
    Last Post: 12-02-2009, 03:59 PM
  5. hey all you noobs free hack source codes here!!
    By cnttuchme in forum C++/C Programming
    Replies: 6
    Last Post: 10-22-2009, 06:52 PM