Removed GameSA includes from Client Deathmatch and minor code improvements

codenulls · codenulls · commit c54b8549ea83 · 2018-04-06T17:19:45.000+05:00
Replaced GameSA includes with interfaces
- Suggested by Jusonex

Removed #pragma from CIFPEngine.h
eRestoreType is now passed by const reference in CIFPEngine::EngineRestoreAnimation
diff --git a/Client/game_sa/CAnimBlendAssocGroupSA.h b/Client/game_sa/CAnimBlendAssocGroupSA.h
@@ -51,6 +51,7 @@ class CAnimBlendAssocGroupSA : public CAnimBlendAssocGroup
     int                               GetNumAnimations(void);
     CAnimBlock*                       GetAnimBlock(void);
     CAnimBlendStaticAssociation*      GetAnimation(unsigned int ID);
+    AssocGroupId                      GetGroupID(void) { return m_pInterface->groupID;};
     void                              CreateAssociations(const char* szBlockName);
 
     bool IsLoaded(void);
diff --git a/Client/game_sa/CAnimBlendSequenceSA.cpp b/Client/game_sa/CAnimBlendSequenceSA.cpp
@@ -58,6 +58,11 @@ void CAnimBlendSequenceSA::SetKeyFrames(size_t cKeyFrames, bool bRoot, bool bCom
     }
 }
 
+void CAnimBlendSequenceSA::CopySequenceProperties( CAnimBlendSequenceSAInterface * pAnimSequenceInterface )
+{
+    *m_pInterface = *pAnimSequenceInterface;
+}
+
 void* CAnimBlendSequenceSA::GetKeyFrame(size_t iFrame, uint32_t u32FrameSizeInBytes)
 {
     return (m_pInterface->pKeyFrames + u32FrameSizeInBytes * iFrame);
diff --git a/Client/game_sa/CAnimBlendSequenceSA.h b/Client/game_sa/CAnimBlendSequenceSA.h
@@ -44,6 +44,7 @@ class CAnimBlendSequenceSA : public CAnimBlendSequence
     BYTE*                          GetKeyFrames(void) { return m_pInterface->pKeyFrames; }
     unsigned short                 GetKeyFramesCount(void) { return m_pInterface->sNumKeyFrames; }
     bool                           IsBigChunkForAllSequences(void) { return ((m_pInterface->sFlags >> 3) & 1); }
+    void                           CopySequenceProperties(CAnimBlendSequenceSAInterface * pAnimSequenceInterface);
     CAnimBlendSequenceSAInterface* GetInterface(void) { return m_pInterface; }
 
 protected:
diff --git a/Client/game_sa/CAnimManagerSA.cpp b/Client/game_sa/CAnimManagerSA.cpp
@@ -764,6 +764,18 @@ std::unique_ptr<CAnimBlendSequence> CAnimManagerSA::GetCustomAnimBlendSequence(C
     return std::make_unique<CAnimBlendSequenceSA>(pInterface);
 }
 
+std::unique_ptr<CAnimBlendHierarchy> CAnimManagerSA::GetCustomAnimBlendHierarchy(void)
+{
+    auto pInterface = new CAnimBlendHierarchySAInterface;
+    return std::make_unique<CAnimBlendHierarchySA>(pInterface);
+}
+
+std::unique_ptr<CAnimBlendSequence> CAnimManagerSA::GetCustomAnimBlendSequence(void)
+{
+    auto pInterface = new CAnimBlendSequenceSAInterface;
+    return std::make_unique<CAnimBlendSequenceSA>(pInterface);
+}
+
 bool CAnimManagerSA::isGateWayAnimationHierarchy(CAnimBlendHierarchySAInterface* pInterface)
 {
     return pGame->GetKeyGen()->GetUppercaseKey(m_kGateWayAnimationName.c_str()) == pInterface->iHashKey;
diff --git a/Client/game_sa/CAnimManagerSA.h b/Client/game_sa/CAnimManagerSA.h
@@ -159,6 +159,10 @@ class CAnimManagerSA : public CAnimManager
     std::unique_ptr<CAnimBlendHierarchy> GetCustomAnimBlendHierarchy(CAnimBlendHierarchySAInterface *pInterface);
     std::unique_ptr<CAnimBlendSequence>  GetCustomAnimBlendSequence(CAnimBlendSequenceSAInterface *pInterface);
 
+    // Warning! These two functions will create a new interface ( dynamic memory memory allocation ) 
+    std::unique_ptr<CAnimBlendHierarchy> GetCustomAnimBlendHierarchy(void);
+    std::unique_ptr<CAnimBlendSequence>  GetCustomAnimBlendSequence(void);
+
     bool           isGateWayAnimationHierarchy(CAnimBlendHierarchySAInterface *pInterface);
     const SString &GetGateWayBlockName(void) { return m_kGateWayBlockName; };
     const SString &GetGateWayAnimationName(void) { return m_kGateWayAnimationName; };
diff --git a/Client/mods/deathmatch/logic/CClientGame.cpp b/Client/mods/deathmatch/logic/CClientGame.cpp
@@ -11,9 +11,9 @@
 
 #include "StdInc.h"
 #include <net/SyncStructures.h>
-#include <../Client/game_sa/CAnimBlendAssocGroupSA.h>
-#include <../Client/game_sa/CAnimBlendAssociationSA.h>
-#include <../game_sa/CAnimBlendHierarchySA.h>
+#include "game/CAnimBlendAssocGroup.h"
+#include "game/CAnimBlendAssociation.h"
+#include "game/CAnimBlendHierarchy.h"
 
 SString StringZeroPadout(const SString& strInput, uint uiPadoutSize)
 {
@@ -3961,11 +3961,12 @@ CAnimBlendAssociationSAInterface* CClientGame::AddAnimationAndSyncHandler(RpClum
 
 bool CClientGame::AssocGroupCopyAnimationHandler(CAnimBlendStaticAssociationSAInterface* pOutAnimStaticAssocInterface,
                                                  CAnimBlendAssociationSAInterface* pAnimAssoc, RpClump* pClump,
-                                                 CAnimBlendAssocGroupSAInterface* pAnimAssocGroup, AnimationId animID)
+                                                 CAnimBlendAssocGroupSAInterface* pAnimAssocGroupInterface, AnimationId animID)
 {
     bool          isCustomAnimationToPlay = false;
     CAnimManager* pAnimationManager = g_pGame->GetAnimManager();
-    auto          pOriginalAnimStaticAssoc = pAnimationManager->GetAnimStaticAssociation(pAnimAssocGroup->groupID, animID);
+    auto          pAnimAssocGroup   = pAnimationManager->GetAnimBlendAssocGroup (pAnimAssocGroupInterface);
+    auto          pOriginalAnimStaticAssoc = pAnimationManager->GetAnimStaticAssociation(pAnimAssocGroup->GetGroupID(), animID);
     auto          pOriginalAnimHierarchyInterface = pOriginalAnimStaticAssoc->GetAnimHierachyInterface();
     auto          pOutAnimStaticAssoc = pAnimationManager->GetAnimStaticAssociation(pOutAnimStaticAssocInterface);
     CClientPed*   pClientPed = GetClientPedByClump(*pClump);
diff --git a/Client/mods/deathmatch/logic/CClientIFP.cpp b/Client/mods/deathmatch/logic/CClientIFP.cpp
@@ -1,5 +1,6 @@
 #include <StdInc.h>
-#include "../game_sa/CAnimBlendSequenceSA.h"
+#include "game/CAnimBlendSequence.h"
+#include "game/CAnimBlendHierarchy.h"
 
 CClientIFP::CClientIFP(class CClientManager* pManager, ElementID ID) : CClientEntity(ID)
 {
@@ -70,14 +71,13 @@ void CClientIFP::ReadIFPVersion1()
         SDgan Dgan;
         ReadDgan(Dgan);
 
-        std::unique_ptr<CAnimBlendHierarchy> pAnimationHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy(&Animation.Hierarchy);
-        InitializeAnimationHierarchy(pAnimationHierarchy, Animation.Name, Dgan.Info.Entries);
-        Animation.pSequencesMemory = AllocateSequencesMemory(pAnimationHierarchy);
+        Animation.pHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy();
+        InitializeAnimationHierarchy(Animation.pHierarchy, Animation.Name, Dgan.Info.Entries);
+        Animation.pSequencesMemory = AllocateSequencesMemory(Animation.pHierarchy);
+        Animation.pHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));
 
-        pAnimationHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));
-
-        *(DWORD*)Animation.pSequencesMemory = ReadSequencesWithDummies(pAnimationHierarchy);
-        PreProcessAnimationHierarchy(pAnimationHierarchy);
+        *(DWORD*)Animation.pSequencesMemory = ReadSequencesWithDummies(Animation.pHierarchy);
+        PreProcessAnimationHierarchy(Animation.pHierarchy);
     }
 }
 
@@ -94,33 +94,31 @@ void CClientIFP::ReadIFPVersion2(bool bAnp3)
 
         Animation.Name = AnimationNode.Name;
         Animation.uiNameHash = HashString(Animation.Name.ToLower());
+        Animation.pHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy();
+        InitializeAnimationHierarchy(Animation.pHierarchy, AnimationNode.Name, AnimationNode.TotalObjects);
 
-        auto pAnimationHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy(&Animation.Hierarchy);
-        InitializeAnimationHierarchy(pAnimationHierarchy, AnimationNode.Name, AnimationNode.TotalObjects);
-
-        Animation.pSequencesMemory = AllocateSequencesMemory(pAnimationHierarchy);
-        pAnimationHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));
+        Animation.pSequencesMemory = AllocateSequencesMemory(Animation.pHierarchy);
+        Animation.pHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));
 
-        *(DWORD*)Animation.pSequencesMemory = ReadSequencesWithDummies(pAnimationHierarchy);
-        PreProcessAnimationHierarchy(pAnimationHierarchy);
+        *(DWORD*)Animation.pSequencesMemory = ReadSequencesWithDummies(Animation.pHierarchy);
+        PreProcessAnimationHierarchy(Animation.pHierarchy);
     }
 }
 
 WORD CClientIFP::ReadSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy)
 {
-    std::map<DWORD, CAnimBlendSequenceSAInterface> MapOfSequences;
-    WORD                                           wUnknownSequences = ReadSequences(pAnimationHierarchy, MapOfSequences);
-
-    CopySequencesWithDummies(pAnimationHierarchy, MapOfSequences);
+    SequenceMapType MapOfSequences;
+    WORD wUnknownSequences = ReadSequences(pAnimationHierarchy, MapOfSequences);
 
+    MoveSequencesWithDummies(pAnimationHierarchy, MapOfSequences);
     WORD cSequences = m_kcIFPSequences + wUnknownSequences;
 
     // As we need support for all 32 bones, we must change the total sequences count
     pAnimationHierarchy->SetNumSequences(cSequences);
     return cSequences;
 }
 
-WORD CClientIFP::ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences)
+WORD CClientIFP::ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& MapOfSequences)
 {
     if (m_bVersion1)
     {
@@ -129,8 +127,7 @@ WORD CClientIFP::ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationH
     return ReadSequencesVersion2(pAnimationHierarchy, MapOfSequences);
 }
 
-WORD CClientIFP::ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>&           pAnimationHierarchy,
-                                       std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences)
+WORD CClientIFP::ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& MapOfSequences)
 {
     WORD wUnknownSequences = 0;
     for (size_t SequenceIndex = 0; SequenceIndex < pAnimationHierarchy->GetNumSequences(); SequenceIndex++)
@@ -142,31 +139,31 @@ WORD CClientIFP::ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>&
             continue;
         }
 
-        CAnimBlendSequenceSAInterface  AnimationSequence;
-        CAnimBlendSequenceSAInterface* pAnimationSequenceInterface = &AnimationSequence;
-
+        std::unique_ptr<CAnimBlendSequence> pAnimationSequence;
         bool bUnknownSequence = iBoneID == eBoneType::UNKNOWN;
         if (bUnknownSequence)
         {
             size_t UnkownSequenceIndex = m_kcIFPSequences + wUnknownSequences;
-            pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);
+            auto pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);
+            pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);
             wUnknownSequences++;
         }
-
-        std::unique_ptr<CAnimBlendSequence> pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);
+        else
+        { 
+            pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence();
+        }
         InitializeAnimationSequence(pAnimationSequence, Anim.Name, iBoneID);
 
         eFrameType iFrameType = ReadKfrm();
         if ((ReadSequenceKeyFrames(pAnimationSequence, iFrameType, Anim.Frames)) && (!bUnknownSequence))
         {
-            MapOfSequences[iBoneID] = *pAnimationSequence->GetInterface();
+            MapOfSequences[iBoneID] = std::move (pAnimationSequence);
         }
     }
     return wUnknownSequences;
 }
 
-WORD CClientIFP::ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>&           pAnimationHierarchy,
-                                       std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences)
+WORD CClientIFP::ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy,SequenceMapType& MapOfSequences)
 {
     WORD wUnknownSequences = 0;
     for (size_t SequenceIndex = 0; SequenceIndex < pAnimationHierarchy->GetNumSequences(); SequenceIndex++)
@@ -176,22 +173,24 @@ WORD CClientIFP::ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>&
 
         bool bUnknownSequence = ObjectNode.BoneID == eBoneType::UNKNOWN;
 
-        CAnimBlendSequenceSAInterface  AnimationSequence;
-        CAnimBlendSequenceSAInterface* pAnimationSequenceInterface = &AnimationSequence;
+        std::unique_ptr<CAnimBlendSequence> pAnimationSequence;
         if (bUnknownSequence)
         {
             size_t UnkownSequenceIndex = m_kcIFPSequences + wUnknownSequences;
-            pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);
+            auto pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);
+            pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);
             wUnknownSequences++;
         }
-
-        std::unique_ptr<CAnimBlendSequence> pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);
+        else
+        {
+            pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence();
+        }
         InitializeAnimationSequence(pAnimationSequence, ObjectNode.Name, ObjectNode.BoneID);
 
         eFrameType iFrameType = static_cast<eFrameType>(ObjectNode.FrameType);
         if ((ReadSequenceKeyFrames(pAnimationSequence, iFrameType, ObjectNode.TotalFrames)) && (!bUnknownSequence))
         {
-            MapOfSequences[ObjectNode.BoneID] = *pAnimationSequence->GetInterface();
+            MapOfSequences[ObjectNode.BoneID] = std::move(pAnimationSequence);
         }
     }
     return wUnknownSequences;
@@ -443,23 +442,25 @@ void CClientIFP::PreProcessAnimationHierarchy(std::unique_ptr<CAnimBlendHierarch
     }
 }
 
-void CClientIFP::CopySequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>&           pAnimationHierarchy,
-                                          std::map<DWORD, CAnimBlendSequenceSAInterface>& mapOfSequences)
+void CClientIFP::MoveSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& mapOfSequences)
 {
     for (size_t SequenceIndex = 0; SequenceIndex < m_kcIFPSequences; SequenceIndex++)
     {
         SString BoneName = m_karrstrBoneNames[SequenceIndex];
         DWORD   BoneID = m_karruBoneIds[SequenceIndex];
 
-        CAnimBlendSequenceSAInterface* pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(SequenceIndex);
+        auto pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(SequenceIndex);
+        auto pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);
         auto                           it = mapOfSequences.find(BoneID);
         if (it != mapOfSequences.end())
         {
-            *pAnimationSequenceInterface = it->second;
+            auto pMapAnimSequenceInterface = it->second->GetInterface();
+            pAnimationSequence->CopySequenceProperties (pMapAnimSequenceInterface);
+            // Delete the interface because we are moving, not copying
+            delete pMapAnimSequenceInterface;
         }
         else
         {
-            std::unique_ptr<CAnimBlendSequence> pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);
             InsertAnimationDummySequence(pAnimationSequence, BoneName, BoneID);
         }
     }
@@ -1072,7 +1073,7 @@ CAnimBlendHierarchySAInterface* CClientIFP::GetAnimationHierarchy(const SString&
                            [&uiAnimationNameHash](SAnimation const& Animation) { return Animation.uiNameHash == uiAnimationNameHash; });
     if (it != m_pVecAnimations->end())
     {
-        return &it->Hierarchy;
+        return it->pHierarchy->GetInterface();
     }
     return nullptr;
 }
diff --git a/Client/mods/deathmatch/logic/CClientIFP.h b/Client/mods/deathmatch/logic/CClientIFP.h
@@ -9,6 +9,7 @@ class CClientIFP : public CClientEntity, CFileReader
 {
 public:
     typedef CIFPAnimations::SAnimation SAnimation;
+    typedef std::map<DWORD, std::unique_ptr<CAnimBlendSequence>> SequenceMapType;
 
     struct SBase
     {
@@ -212,9 +213,9 @@ class CClientIFP : public CClientEntity, CFileReader
     void ReadIFPVersion2(bool bAnp3);
 
     WORD ReadSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy);
-    WORD ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
-    WORD ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
-    WORD ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences);
+    WORD ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& MapOfSequences);
+    WORD ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& MapOfSequences);
+    WORD ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& MapOfSequences);
     std::int32_t ReadSequenceVersion1(SAnim& Anim);
     void         ReadSequenceVersion2(SSequenceHeaderV2& ObjectNode);
 
@@ -242,7 +243,7 @@ class CClientIFP : public CClientEntity, CFileReader
                                        const std::int32_t& iSequences);
     void  InitializeAnimationSequence(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, const SString& strName, const std::int32_t& iBoneID);
     void  PreProcessAnimationHierarchy(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy);
-    void  CopySequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& mapOfSequences);
+    void  MoveSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, std::unique_ptr<CAnimBlendSequence>>& mapOfSequences);
     BYTE* AllocateSequencesMemory(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy);
 
     void    InsertAnimationDummySequence(std::unique_ptr<CAnimBlendSequence>& pAnimationSequence, const SString& BoneName, const DWORD& dwBoneID);
diff --git a/Client/mods/deathmatch/logic/CClientPed.cpp b/Client/mods/deathmatch/logic/CClientPed.cpp
@@ -9,7 +9,7 @@
  *****************************************************************************/
 
 #include "StdInc.h"
-
+#include "game/CAnimBlendHierarchy.h"
 using std::list;
 using std::vector;
 
diff --git a/Client/mods/deathmatch/logic/CClientPed.h b/Client/mods/deathmatch/logic/CClientPed.h
@@ -19,7 +19,6 @@ class CClientPed;
 
 #include <multiplayer/CMultiplayer.h>
 #include "CClientPad.h"
-#include <../game_sa/CAnimBlendHierarchySA.h>
 #include <memory>
 
 class CClientCamera;
diff --git a/Client/mods/deathmatch/logic/CIFPAnimations.cpp b/Client/mods/deathmatch/logic/CIFPAnimations.cpp
@@ -1,5 +1,6 @@
 #include <StdInc.h>
-#include "../game_sa/CAnimBlendSequenceSA.h"
+#include "game/CAnimBlendSequence.h"
+#include "game/CAnimBlendHierarchy.h"
 
 CIFPAnimations::~CIFPAnimations(void)
 {
@@ -11,11 +12,10 @@ void CIFPAnimations::DeleteAnimations(void)
     CAnimManager* pAnimManager = g_pGame->GetAnimManager();
     for (auto& Animation : vecAnimations)
     {
-        auto pAnimationHierarchy = pAnimManager->GetCustomAnimBlendHierarchy(&Animation.Hierarchy);
-        for (unsigned short SequenceIndex = 0; SequenceIndex < pAnimationHierarchy->GetNumSequences(); SequenceIndex++)
+        for (unsigned short SequenceIndex = 0; SequenceIndex < Animation.pHierarchy->GetNumSequences(); SequenceIndex++)
         {
-            pAnimManager->RemoveFromUncompressedCache(pAnimationHierarchy->GetInterface());
-            auto  pAnimationSequence = pAnimManager->GetCustomAnimBlendSequence(pAnimationHierarchy->GetSequence(SequenceIndex));
+            pAnimManager->RemoveFromUncompressedCache(Animation.pHierarchy->GetInterface());
+            auto  pAnimationSequence = pAnimManager->GetCustomAnimBlendSequence(Animation.pHierarchy->GetSequence(SequenceIndex));
             void* pKeyFrames = pAnimationSequence->GetKeyFrames();
             if (!pAnimationSequence->IsBigChunkForAllSequences())
             {
@@ -33,5 +33,6 @@ void CIFPAnimations::DeleteAnimations(void)
             }
         }
         delete Animation.pSequencesMemory;
+        delete Animation.pHierarchy->GetInterface();
     }
 }
diff --git a/Client/mods/deathmatch/logic/CIFPAnimations.h b/Client/mods/deathmatch/logic/CIFPAnimations.h
@@ -1,6 +1,6 @@
 #ifndef __CIFPANIMATIONS_H
 #define __CIFPANIMATIONS_H
-#include "../Client/mods/deathmatch/logic/CClientIFP.h"
+#include "CClientIFP.h"
 
 class CIFPAnimations
 {
@@ -9,7 +9,7 @@ class CIFPAnimations
     {
         SString                        Name;
         unsigned int                   uiNameHash;
-        CAnimBlendHierarchySAInterface Hierarchy;
+        std::unique_ptr<CAnimBlendHierarchy> pHierarchy;
         BYTE*                          pSequencesMemory;
     };
 
diff --git a/Client/mods/deathmatch/logic/CIFPEngine.cpp b/Client/mods/deathmatch/logic/CIFPEngine.cpp
diff --git a/Client/mods/deathmatch/logic/CIFPEngine.h b/Client/mods/deathmatch/logic/CIFPEngine.h
diff --git a/Client/sdk/game/CAnimBlendAssocGroup.h b/Client/sdk/game/CAnimBlendAssocGroup.h
diff --git a/Client/sdk/game/CAnimBlendSequence.h b/Client/sdk/game/CAnimBlendSequence.h
diff --git a/Client/sdk/game/CAnimManager.h b/Client/sdk/game/CAnimManager.h

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,11 @@ void CAnimBlendSequenceSA::SetKeyFrames(size_t cKeyFrames, bool bRoot, bool bCom`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
	`61`	`+void CAnimBlendSequenceSA::CopySequenceProperties( CAnimBlendSequenceSAInterface * pAnimSequenceInterface )`
	`62`	`+{`
	`63`	`+ m_pInterface = pAnimSequenceInterface;`
	`64`	`+}`
	`65`	`+`
`61`	`66`	`void* CAnimBlendSequenceSA::GetKeyFrame(size_t iFrame, uint32_t u32FrameSizeInBytes)`
`62`	`67`	`{`
`63`	`68`	`return (m_pInterface->pKeyFrames + u32FrameSizeInBytes * iFrame);`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`#include <StdInc.h>`
`2`		`-#include "../game_sa/CAnimBlendSequenceSA.h"`
	`2`	`+#include "game/CAnimBlendSequence.h"`
	`3`	`+#include "game/CAnimBlendHierarchy.h"`
`3`	`4`
`4`	`5`	`CClientIFP::CClientIFP(class CClientManager* pManager, ElementID ID) : CClientEntity(ID)`
`5`	`6`	`{`
`@@ -70,14 +71,13 @@ void CClientIFP::ReadIFPVersion1()`
`70`	`71`	`SDgan Dgan;`
`71`	`72`	`ReadDgan(Dgan);`
`72`	`73`
`73`		`- std::unique_ptr<CAnimBlendHierarchy> pAnimationHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy(&Animation.Hierarchy);`
`74`		`- InitializeAnimationHierarchy(pAnimationHierarchy, Animation.Name, Dgan.Info.Entries);`
`75`		`- Animation.pSequencesMemory = AllocateSequencesMemory(pAnimationHierarchy);`
	`74`	`+ Animation.pHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy();`
	`75`	`+ InitializeAnimationHierarchy(Animation.pHierarchy, Animation.Name, Dgan.Info.Entries);`
	`76`	`+ Animation.pSequencesMemory = AllocateSequencesMemory(Animation.pHierarchy);`
	`77`	`+ Animation.pHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));`
`76`	`78`
`77`		`- pAnimationHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));`
`78`		`-`
`79`		`- (DWORD)Animation.pSequencesMemory = ReadSequencesWithDummies(pAnimationHierarchy);`
`80`		`- PreProcessAnimationHierarchy(pAnimationHierarchy);`
	`79`	`+ (DWORD)Animation.pSequencesMemory = ReadSequencesWithDummies(Animation.pHierarchy);`
	`80`	`+ PreProcessAnimationHierarchy(Animation.pHierarchy);`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`@@ -94,33 +94,31 @@ void CClientIFP::ReadIFPVersion2(bool bAnp3)`
`94`	`94`
`95`	`95`	`Animation.Name = AnimationNode.Name;`
`96`	`96`	`Animation.uiNameHash = HashString(Animation.Name.ToLower());`
	`97`	`+ Animation.pHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy();`
	`98`	`+ InitializeAnimationHierarchy(Animation.pHierarchy, AnimationNode.Name, AnimationNode.TotalObjects);`
`97`	`99`
`98`		`- auto pAnimationHierarchy = m_pAnimManager->GetCustomAnimBlendHierarchy(&Animation.Hierarchy);`
`99`		`- InitializeAnimationHierarchy(pAnimationHierarchy, AnimationNode.Name, AnimationNode.TotalObjects);`
`100`		`-`
`101`		`- Animation.pSequencesMemory = AllocateSequencesMemory(pAnimationHierarchy);`
`102`		`- pAnimationHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));`
	`100`	`+ Animation.pSequencesMemory = AllocateSequencesMemory(Animation.pHierarchy);`
	`101`	`+ Animation.pHierarchy->SetSequences(reinterpret_cast<CAnimBlendSequenceSAInterface*>(Animation.pSequencesMemory + 4));`
`103`	`102`
`104`		`- (DWORD)Animation.pSequencesMemory = ReadSequencesWithDummies(pAnimationHierarchy);`
`105`		`- PreProcessAnimationHierarchy(pAnimationHierarchy);`
	`103`	`+ (DWORD)Animation.pSequencesMemory = ReadSequencesWithDummies(Animation.pHierarchy);`
	`104`	`+ PreProcessAnimationHierarchy(Animation.pHierarchy);`
`106`	`105`	`}`
`107`	`106`	`}`
`108`	`107`
`109`	`108`	`WORD CClientIFP::ReadSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy)`
`110`	`109`	`{`
`111`		`- std::map<DWORD, CAnimBlendSequenceSAInterface> MapOfSequences;`
`112`		`- WORD wUnknownSequences = ReadSequences(pAnimationHierarchy, MapOfSequences);`
`113`		`-`
`114`		`- CopySequencesWithDummies(pAnimationHierarchy, MapOfSequences);`
	`110`	`+ SequenceMapType MapOfSequences;`
	`111`	`+ WORD wUnknownSequences = ReadSequences(pAnimationHierarchy, MapOfSequences);`
`115`	`112`
	`113`	`+ MoveSequencesWithDummies(pAnimationHierarchy, MapOfSequences);`
`116`	`114`	`WORD cSequences = m_kcIFPSequences + wUnknownSequences;`
`117`	`115`
`118`	`116`	`// As we need support for all 32 bones, we must change the total sequences count`
`119`	`117`	`pAnimationHierarchy->SetNumSequences(cSequences);`
`120`	`118`	`return cSequences;`
`121`	`119`	`}`
`122`	`120`
`123`		`-WORD CClientIFP::ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences)`
	`121`	`+WORD CClientIFP::ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& MapOfSequences)`
`124`	`122`	`{`
`125`	`123`	`if (m_bVersion1)`
`126`	`124`	`{`
`@@ -129,8 +127,7 @@ WORD CClientIFP::ReadSequences(std::unique_ptr<CAnimBlendHierarchy>& pAnimationH`
`129`	`127`	`return ReadSequencesVersion2(pAnimationHierarchy, MapOfSequences);`
`130`	`128`	`}`
`131`	`129`
`132`		`-WORD CClientIFP::ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy,`
`133`		`- std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences)`
	`130`	`+WORD CClientIFP::ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& MapOfSequences)`
`134`	`131`	`{`
`135`	`132`	`WORD wUnknownSequences = 0;`
`136`	`133`	`for (size_t SequenceIndex = 0; SequenceIndex < pAnimationHierarchy->GetNumSequences(); SequenceIndex++)`
`@@ -142,31 +139,31 @@ WORD CClientIFP::ReadSequencesVersion1(std::unique_ptr<CAnimBlendHierarchy>&`
`142`	`139`	`continue;`
`143`	`140`	`}`
`144`	`141`
`145`		`- CAnimBlendSequenceSAInterface AnimationSequence;`
`146`		`- CAnimBlendSequenceSAInterface* pAnimationSequenceInterface = &AnimationSequence;`
`147`		`-`
	`142`	`+ std::unique_ptr<CAnimBlendSequence> pAnimationSequence;`
`148`	`143`	`bool bUnknownSequence = iBoneID == eBoneType::UNKNOWN;`
`149`	`144`	`if (bUnknownSequence)`
`150`	`145`	`{`
`151`	`146`	`size_t UnkownSequenceIndex = m_kcIFPSequences + wUnknownSequences;`
`152`		`- pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);`
	`147`	`+ auto pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);`
	`148`	`+ pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);`
`153`	`149`	`wUnknownSequences++;`
`154`	`150`	`}`
`155`		`-`
`156`		`- std::unique_ptr<CAnimBlendSequence> pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);`
	`151`	`+ else`
	`152`	`+ {`
	`153`	`+ pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence();`
	`154`	`+ }`
`157`	`155`	`InitializeAnimationSequence(pAnimationSequence, Anim.Name, iBoneID);`
`158`	`156`
`159`	`157`	`eFrameType iFrameType = ReadKfrm();`
`160`	`158`	`if ((ReadSequenceKeyFrames(pAnimationSequence, iFrameType, Anim.Frames)) && (!bUnknownSequence))`
`161`	`159`	`{`
`162`		`- MapOfSequences[iBoneID] = *pAnimationSequence->GetInterface();`
	`160`	`+ MapOfSequences[iBoneID] = std::move (pAnimationSequence);`
`163`	`161`	`}`
`164`	`162`	`}`
`165`	`163`	`return wUnknownSequences;`
`166`	`164`	`}`
`167`	`165`
`168`		`-WORD CClientIFP::ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy,`
`169`		`- std::map<DWORD, CAnimBlendSequenceSAInterface>& MapOfSequences)`
	`166`	`+WORD CClientIFP::ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy,SequenceMapType& MapOfSequences)`
`170`	`167`	`{`
`171`	`168`	`WORD wUnknownSequences = 0;`
`172`	`169`	`for (size_t SequenceIndex = 0; SequenceIndex < pAnimationHierarchy->GetNumSequences(); SequenceIndex++)`
`@@ -176,22 +173,24 @@ WORD CClientIFP::ReadSequencesVersion2(std::unique_ptr<CAnimBlendHierarchy>&`
`176`	`173`
`177`	`174`	`bool bUnknownSequence = ObjectNode.BoneID == eBoneType::UNKNOWN;`
`178`	`175`
`179`		`- CAnimBlendSequenceSAInterface AnimationSequence;`
`180`		`- CAnimBlendSequenceSAInterface* pAnimationSequenceInterface = &AnimationSequence;`
	`176`	`+ std::unique_ptr<CAnimBlendSequence> pAnimationSequence;`
`181`	`177`	`if (bUnknownSequence)`
`182`	`178`	`{`
`183`	`179`	`size_t UnkownSequenceIndex = m_kcIFPSequences + wUnknownSequences;`
`184`		`- pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);`
	`180`	`+ auto pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(UnkownSequenceIndex);`
	`181`	`+ pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);`
`185`	`182`	`wUnknownSequences++;`
`186`	`183`	`}`
`187`		`-`
`188`		`- std::unique_ptr<CAnimBlendSequence> pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);`
	`184`	`+ else`
	`185`	`+ {`
	`186`	`+ pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence();`
	`187`	`+ }`
`189`	`188`	`InitializeAnimationSequence(pAnimationSequence, ObjectNode.Name, ObjectNode.BoneID);`
`190`	`189`
`191`	`190`	`eFrameType iFrameType = static_cast<eFrameType>(ObjectNode.FrameType);`
`192`	`191`	`if ((ReadSequenceKeyFrames(pAnimationSequence, iFrameType, ObjectNode.TotalFrames)) && (!bUnknownSequence))`
`193`	`192`	`{`
`194`		`- MapOfSequences[ObjectNode.BoneID] = *pAnimationSequence->GetInterface();`
	`193`	`+ MapOfSequences[ObjectNode.BoneID] = std::move(pAnimationSequence);`
`195`	`194`	`}`
`196`	`195`	`}`
`197`	`196`	`return wUnknownSequences;`
`@@ -443,23 +442,25 @@ void CClientIFP::PreProcessAnimationHierarchy(std::unique_ptr<CAnimBlendHierarch`
`443`	`442`	`}`
`444`	`443`	`}`
`445`	`444`
`446`		`-void CClientIFP::CopySequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy,`
`447`		`- std::map<DWORD, CAnimBlendSequenceSAInterface>& mapOfSequences)`
	`445`	`+void CClientIFP::MoveSequencesWithDummies(std::unique_ptr<CAnimBlendHierarchy>& pAnimationHierarchy, SequenceMapType& mapOfSequences)`
`448`	`446`	`{`
`449`	`447`	`for (size_t SequenceIndex = 0; SequenceIndex < m_kcIFPSequences; SequenceIndex++)`
`450`	`448`	`{`
`451`	`449`	`SString BoneName = m_karrstrBoneNames[SequenceIndex];`
`452`	`450`	`DWORD BoneID = m_karruBoneIds[SequenceIndex];`
`453`	`451`
`454`		`- CAnimBlendSequenceSAInterface* pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(SequenceIndex);`
	`452`	`+ auto pAnimationSequenceInterface = pAnimationHierarchy->GetSequence(SequenceIndex);`
	`453`	`+ auto pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);`
`455`	`454`	`auto it = mapOfSequences.find(BoneID);`
`456`	`455`	`if (it != mapOfSequences.end())`
`457`	`456`	`{`
`458`		`- *pAnimationSequenceInterface = it->second;`
	`457`	`+ auto pMapAnimSequenceInterface = it->second->GetInterface();`
	`458`	`+ pAnimationSequence->CopySequenceProperties (pMapAnimSequenceInterface);`
	`459`	`+ // Delete the interface because we are moving, not copying`
	`460`	`+ delete pMapAnimSequenceInterface;`
`459`	`461`	`}`
`460`	`462`	`else`
`461`	`463`	`{`
`462`		`- std::unique_ptr<CAnimBlendSequence> pAnimationSequence = m_pAnimManager->GetCustomAnimBlendSequence(pAnimationSequenceInterface);`
`463`	`464`	`InsertAnimationDummySequence(pAnimationSequence, BoneName, BoneID);`
`464`	`465`	`}`
`465`	`466`	`}`
`@@ -1072,7 +1073,7 @@ CAnimBlendHierarchySAInterface* CClientIFP::GetAnimationHierarchy(const SString&`
`1072`	`1073`	`[&uiAnimationNameHash](SAnimation const& Animation) { return Animation.uiNameHash == uiAnimationNameHash; });`
`1073`	`1074`	`if (it != m_pVecAnimations->end())`
`1074`	`1075`	`{`
`1075`		`- return &it->Hierarchy;`
	`1076`	`+ return it->pHierarchy->GetInterface();`
`1076`	`1077`	`}`
`1077`	`1078`	`return nullptr;`
`1078`	`1079`	`}`