Fix #467 Ped animations don't sync for new players

Client/mods/deathmatch/logic/CClientPed.h

@@ -553,6 +553,8 @@ class CClientPed : public CClientStreamElement, public CAntiCheatModule
 
     std::unique_ptr<CAnimBlendAssociation> GetAnimAssociation(CAnimBlendHierarchySAInterface* pHierarchyInterface);
 
+    void SetHasSyncedAnim(bool synced) noexcept { m_hasSyncedAnim = synced; };
+    bool HasSyncedAnim() const noexcept { return m_hasSyncedAnim; };
 protected:
     // This constructor is for peds managed by a player. These are unknown to the ped manager.
     CClientPed(CClientManager* pManager, unsigned long ulModelID, ElementID ID, bool bIsLocalPlayer);
@@ -788,4 +790,7 @@ class CClientPed : public CClientStreamElement, public CAntiCheatModule
     CClientPed*   m_pGettingJackedBy;                    // The ped that is jacking us
 
     std::shared_ptr<CClientModel> m_clientModel;
+
+    bool m_hasSyncedAnim;
+    bool m_animationOverridedByClient;
 };

Client/mods/deathmatch/logic/CPacketHandler.cpp

@@ -3990,6 +3990,39 @@ void CPacketHandler::Packet_EntityAdd(NetBitStreamInterface& bitStream)
                     // Collisions
                     pPed->SetUsesCollision(bCollisonsEnabled);
 
+                    // Animation
+                    if (bitStream.Can(eBitStreamVersion::AnimationsSync))
+                    {
+                        // Contains animation data?
+                        if (bitStream.ReadBit())
+                        {
+                            std::string blockName, animName;
+                            int time, blendTime;
+                            bool looped, updatePosition, interruptable, freezeLastFrame, taskRestore;
+                            float progress, speed;
+
+                            // Read data
+                            bitStream.ReadString(blockName);
+                            bitStream.ReadString(animName);
+                            bitStream.Read(time);
+                            bitStream.ReadBit(looped);
+                            bitStream.ReadBit(updatePosition);
+                            bitStream.ReadBit(interruptable);
+                            bitStream.ReadBit(freezeLastFrame);
+                            bitStream.Read(blendTime);
+                            bitStream.ReadBit(taskRestore);
+                            bitStream.Read(progress);
+                            bitStream.Read(speed);
+
+                            // Run anim
+                            CStaticFunctionDefinitions::SetPedAnimation(*pPed, blockName, animName.c_str(), time, blendTime, looped, updatePosition, interruptable, freezeLastFrame);
+                            CStaticFunctionDefinitions::SetPedAnimationProgress(*pPed, animName, progress);
+                            CStaticFunctionDefinitions::SetPedAnimationSpeed(*pPed, animName, speed);
+
+                            pPed->SetHasSyncedAnim(true);
+                        }
+                    }
+
                     break;
                 }
 

Client/mods/deathmatch/logic/CPedSync.cpp

@@ -307,6 +307,8 @@ void CPedSync::WritePedInformation(NetBitStreamInterface* pBitStream, CClientPed
         ucFlags |= 0x20;
     if (pPed->IsInWater() != pPed->m_LastSyncedData->bIsInWater)
         ucFlags |= 0x40;
+    if (pPed->HasSyncedAnim() && (!pPed->IsRunningAnimation() || pPed->m_animationOverridedByClient))
+        ucFlags |= 0x80;
 
     // Do we really have to sync this ped?
     if (ucFlags == 0)
@@ -395,4 +397,11 @@ void CPedSync::WritePedInformation(NetBitStreamInterface* pBitStream, CClientPed
         pBitStream->WriteBit(pPed->IsInWater());
         pPed->m_LastSyncedData->bIsInWater = pPed->IsInWater();
     }
+
+    // The animation has been overwritten or interrupted by the client
+    if (ucFlags & 0x80 && pBitStream->Can(eBitStreamVersion::AnimationsSync))
+    {
+        pPed->SetHasSyncedAnim(false);
+        pPed->m_animationOverridedByClient = false;
+    }
 }

Client/mods/deathmatch/logic/luadefs/CLuaPedDefs.cpp

@@ -2232,6 +2232,10 @@ int CLuaPedDefs::SetPedAnimation(lua_State* luaVM)
             }
 
             pPed->SetTaskToBeRestoredOnAnimEnd(bTaskToBeRestoredOnAnimEnd);
+
+            if (pPed->HasSyncedAnim())
+                pPed->m_animationOverridedByClient = true;
+
             lua_pushboolean(luaVM, true);
             return 1;
         }

Server/mods/deathmatch/logic/CPed.h

@@ -103,6 +103,41 @@ enum eBone
     BONE_RIGHTFOOT
 };
 
+struct SPlayerAnimData
+{
+    std::string blockName;
+    std::string animName;
+    int         time{-1};
+    bool        loop{true};
+    bool        updatePosition{true};
+    bool        interruptable{true};
+    bool        freezeLastFrame{true};
+    int         blendTime{250};
+    bool        taskToBeRestoredOnAnimEnd{false};
+
+    std::int64_t startedTick{0};
+
+    float progress{0.0f};
+    float speed{1.0f};
+
+    SPlayerAnimData() = default;
+
+    SPlayerAnimData(const std::string& block, const std::string& anim, int time, bool loop, bool updatePos, bool interrupt, bool freeze, int blend,
+                    bool taskRestore, std::int64_t tick)
+        : blockName(block),
+          animName(anim),
+          time(time),
+          loop(loop),
+          updatePosition(updatePos),
+          interruptable(interrupt),
+          freezeLastFrame(freeze),
+          blendTime(blend),
+          taskToBeRestoredOnAnimEnd(taskRestore),
+          startedTick(tick),
+          progress(0.0f),
+          speed(1.0f){};
+};
+
 class CWeapon
 {
 public:
@@ -278,6 +313,11 @@ class CPed : public CElement
     std::vector<CPlayer*>::const_iterator NearPlayersIterBegin() { return m_nearPlayersList.begin(); }
     std::vector<CPlayer*>::const_iterator NearPlayersIterEnd() { return m_nearPlayersList.end(); }
 
+    const SPlayerAnimData& GetAnimationData() const noexcept { return m_animData; };
+    void                   SetAnimationData(const SPlayerAnimData& animData) { m_animData = animData; };
+    void                   SetAnimationProgress(float progress) { m_animData.progress = progress; };
+    void                   SetAnimationSpeed(float speed) { m_animData.speed = speed; };
+
 protected:
     bool ReadSpecialData(const int iLine) override;
 
@@ -316,6 +356,7 @@ class CPed : public CElement
     bool                                 m_bFrozen;
     bool                                 m_bStealthAiming;
     CVehicle*                            m_pJackingVehicle;
+    SPlayerAnimData                      m_animData;
 
     CVehicle*    m_pVehicle;
     unsigned int m_uiVehicleSeat;

Server/mods/deathmatch/logic/CPedSync.cpp

@@ -272,6 +272,9 @@ void CPedSync::Packet_PedSync(CPedSyncPacket& Packet)
         if (Data.ucFlags & 0x40)
             pPed->SetInWater(Data.bIsInWater);
 
+        if (Data.ucFlags & 0x80)
+            pPed->SetAnimationData({});
+
         // Is it time to sync to everyone
         bool bDoFarSync = llTickCountNow - pPed->GetLastFarSyncTick() >= g_TickRateSettings.iPedFarSync;
 

Server/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp

@@ -4329,8 +4329,6 @@ bool CStaticFunctionDefinitions::SetPedAnimation(CElement* pElement, const SStri
         CPed* pPed = static_cast<CPed*>(pElement);
         if (pPed->IsSpawned())
         {
-            // TODO: save their animation?
-
             // Tell the players
             CBitStream BitStream;
             if (!blockName.empty() && !animName.empty())
@@ -4343,6 +4341,9 @@ bool CStaticFunctionDefinitions::SetPedAnimation(CElement* pElement, const SStri
                 if (pPed->IsChoking())
                     pPed->SetChoking(false);
 
+                // Store anim data
+                pPed->SetAnimationData({blockName, animName, iTime, bLoop, bUpdatePosition, bInterruptable, bFreezeLastFrame, iBlend, bTaskToBeRestoredOnAnimEnd, GetTickCount64_()});
+
                 BitStream.pBitStream->WriteString<unsigned char>(blockName);
                 BitStream.pBitStream->WriteString<unsigned char>(animName);
                 BitStream.pBitStream->Write(iTime);
@@ -4357,9 +4358,12 @@ bool CStaticFunctionDefinitions::SetPedAnimation(CElement* pElement, const SStri
             {
                 // Inform them to kill the current animation instead
                 BitStream.pBitStream->Write((unsigned char)0);
+
+                // Clear anim data
+                pPed->SetAnimationData({});
             }
-            m_pPlayerManager->BroadcastOnlyJoined(CElementRPCPacket(pPed, SET_PED_ANIMATION, *BitStream.pBitStream));
 
+            m_pPlayerManager->BroadcastOnlyJoined(CElementRPCPacket(pPed, SET_PED_ANIMATION, *BitStream.pBitStream));
             return true;
         }
     }
@@ -4381,14 +4385,17 @@ bool CStaticFunctionDefinitions::SetPedAnimationProgress(CElement* pElement, con
             {
                 BitStream.pBitStream->WriteString<unsigned char>(animName);
                 BitStream.pBitStream->Write(fProgress);
+
+                pPed->SetAnimationProgress(fProgress);
             }
             else
             {
                 // Inform them to kill the current animation instead
                 BitStream.pBitStream->Write((unsigned char)0);
+                pPed->SetAnimationData({});
             }
-            m_pPlayerManager->BroadcastOnlyJoined(CElementRPCPacket(pPed, SET_PED_ANIMATION_PROGRESS, *BitStream.pBitStream));
 
+            m_pPlayerManager->BroadcastOnlyJoined(CElementRPCPacket(pPed, SET_PED_ANIMATION_PROGRESS, *BitStream.pBitStream));
             return true;
         }
     }
@@ -4409,6 +4416,7 @@ bool CStaticFunctionDefinitions::SetPedAnimationSpeed(CElement* pElement, const
             BitStream.pBitStream->WriteString<unsigned char>(animName);
             BitStream.pBitStream->Write(fSpeed);
 
+            pPed->SetAnimationSpeed(fSpeed);
             m_pPlayerManager->BroadcastOnlyJoined(CElementRPCPacket(pPed, SET_PED_ANIMATION_SPEED, *BitStream.pBitStream));
 
             return true;

Server/mods/deathmatch/logic/packets/CEntityAddPacket.cpp

@@ -978,6 +978,42 @@ bool CEntityAddPacket::Write(NetBitStreamInterface& BitStream) const
                         BitStream.Write(currentWeaponSlot);
                     }
 
+                    // Animation
+                    if (BitStream.Can(eBitStreamVersion::AnimationsSync))
+                    {
+                        const SPlayerAnimData& animData = pPed->GetAnimationData();
+
+                        // Contains animation data?
+                        bool animRunning = !animData.blockName.empty() && !animData.animName.empty();
+
+                        // Is animation still running?
+                        float deltaTime = GetTickCount64_() - animData.startedTick;
+                        if (!animData.freezeLastFrame && animData.time > 0 && deltaTime >= animData.time)
+                        {
+                            animRunning = false;
+                            pPed->SetAnimationData({});
+                        }
+
+                        BitStream.WriteBit(animRunning);
+
+                        if (animRunning)
+                        {
+                            BitStream.WriteString(animData.blockName);
+                            BitStream.WriteString(animData.animName);
+                            BitStream.Write(animData.time);
+                            BitStream.WriteBit(animData.loop);
+                            BitStream.WriteBit(animData.updatePosition);
+                            BitStream.WriteBit(animData.interruptable);
+                            BitStream.WriteBit(animData.freezeLastFrame);
+                            BitStream.Write(animData.blendTime);
+                            BitStream.WriteBit(animData.taskToBeRestoredOnAnimEnd);
+
+                            // Write progress & speed
+                            BitStream.Write((deltaTime / animData.time) * animData.speed);
+                            BitStream.Write(animData.speed);
+                        }
+                    }
+
                     break;
                 }
 

Shared/sdk/net/bitstream.h

@@ -556,6 +556,10 @@ enum class eBitStreamVersion : unsigned short
     // 2024-06-16
     PedSync_Revision,
 
+    // Ped animations synchronization
+    // 2024-06-29
+    AnimationsSync,
+
     // Add "extendedwatercannons" to setWorldSpecialPropertyEnabled
     // 2024-06-30
     WorldSpecialProperty_TunnelWeatherBlend,