Restore "Fix anim progress & speed (PR #4245)"

botder · botder · commit 1e24eac340be · 2025-07-31T22:11:08.000+02:00
diff --git a/Client/mods/deathmatch/logic/CClientPed.cpp b/Client/mods/deathmatch/logic/CClientPed.cpp
@@ -2893,6 +2893,11 @@ void CClientPed::StreamedInPulse(bool bDoStandardPulses)
             }
         }
 
+        // Are we need to update anim speed & progress?
+        // We need to do it here because the anim starts on the next frame after calling RunNamedAnimation
+        if (m_pAnimationBlock && m_AnimationCache.progressWaitForStreamIn && IsAnimationInProgress())
+            UpdateAnimationProgressAndSpeed();
+
         // Update our alpha
         unsigned char ucAlpha = m_ucAlpha;
         // Are we in a different interior to the camera? set our alpha to 0
@@ -3683,8 +3688,8 @@ void CClientPed::_CreateModel()
             Kill(WEAPONTYPE_UNARMED, 0, false, true);
         }
 
-        // Are we still playing animation?
-        if ((m_AnimationCache.bLoop || m_AnimationCache.bFreezeLastFrame || m_AnimationCache.progressWaitForStreamIn) && m_pAnimationBlock)
+        // Are we still playing a animation?
+        if (m_pAnimationBlock && IsAnimationInProgress())
         {
             if (m_bisCurrentAnimationCustom)
             {
@@ -3961,8 +3966,8 @@ void CClientPed::_ChangeModel()
             }
             m_bDontChangeRadio = false;
 
-            // Are we still playing a looped animation?
-            if ((m_AnimationCache.bLoop || m_AnimationCache.bFreezeLastFrame || m_AnimationCache.progressWaitForStreamIn) && m_pAnimationBlock)
+            // Are we still playing a animation?
+            if (m_pAnimationBlock && IsAnimationInProgress())
             {
                 if (m_bisCurrentAnimationCustom)
                 {
@@ -5729,7 +5734,23 @@ bool CClientPed::IsRunningAnimation()
         }
         return false;
     }
-    return (m_AnimationCache.bLoop && m_pAnimationBlock);
+    return (m_AnimationCache.bLoop || m_AnimationCache.bFreezeLastFrame) && m_pAnimationBlock;
+}
+
+bool CClientPed::IsAnimationInProgress()
+{
+    bool constAnim = m_AnimationCache.bLoop || m_AnimationCache.bFreezeLastFrame;
+
+    if (!m_pAnimationBlock)
+        return constAnim;
+
+    float elapsedTime = static_cast<float>(GetTimestamp() - m_AnimationCache.startTime) / 1000.0f;
+
+    auto animBlendHierarchy = g_pGame->GetAnimManager()->GetAnimation(m_AnimationCache.strName.c_str(), m_pAnimationBlock);
+    if (!animBlendHierarchy)
+        return constAnim;
+
+    return constAnim || elapsedTime < animBlendHierarchy->GetTotalTime();
 }
 
 void CClientPed::RunNamedAnimation(std::unique_ptr<CAnimBlock>& pBlock, const char* szAnimName, int iTime, int iBlend, bool bLoop, bool bUpdatePosition,
@@ -5817,10 +5838,6 @@ void CClientPed::RunNamedAnimation(std::unique_ptr<CAnimBlock>& pBlock, const ch
     m_AnimationCache.bUpdatePosition = bUpdatePosition;
     m_AnimationCache.bInterruptable = bInterruptable;
     m_AnimationCache.bFreezeLastFrame = bFreezeLastFrame;
-    m_AnimationCache.progress = 0.0f;
-    m_AnimationCache.speed = 1.0f;
-    m_AnimationCache.progressWaitForStreamIn = false;
-    m_AnimationCache.elapsedTime = 0.0f;
 }
 
 void CClientPed::KillAnimation()
@@ -5859,39 +5876,45 @@ void CClientPed::RunAnimationFromCache()
     if (!m_pAnimationBlock)
         return;
 
-    bool  needCalcProgress = m_AnimationCache.progressWaitForStreamIn;
-    float elapsedTime = m_AnimationCache.elapsedTime;
-
     // Copy our name incase it gets deleted
     std::string animName = m_AnimationCache.strName;
 
     // Run our animation
     RunNamedAnimation(m_pAnimationBlock, animName.c_str(), m_AnimationCache.iTime, m_AnimationCache.iBlend, m_AnimationCache.bLoop, m_AnimationCache.bUpdatePosition, m_AnimationCache.bInterruptable, m_AnimationCache.bFreezeLastFrame);
 
-    auto animAssoc = g_pGame->GetAnimManager()->RpAnimBlendClumpGetAssociation(GetClump(), animName.c_str());
+    // Set anim progress & speed
+    m_AnimationCache.progressWaitForStreamIn = true;
+}
+
+void CClientPed::UpdateAnimationProgressAndSpeed()
+{
+    if (!m_AnimationCache.progressWaitForStreamIn)
+        return;
+
+    // Get current anim
+    auto animAssoc = g_pGame->GetAnimManager()->RpAnimBlendClumpGetAssociation(GetClump(), m_AnimationCache.strName.c_str());
     if (!animAssoc)
         return;
 
-    // If the anim is synced from the server side, we need to calculate the progress
-    float progress = m_AnimationCache.progress;
-    if (needCalcProgress)
-    {
-        float animLength = animAssoc->GetLength();
+    float animLength = animAssoc->GetLength();
+    float progress = 0.0f;
+    float elapsedTime = static_cast<float>(GetTimestamp() - m_AnimationCache.startTime) / 1000.0f;
 
-        if (m_AnimationCache.bFreezeLastFrame) // time and loop is ignored if freezeLastFrame is true
-            progress = (elapsedTime / animLength) * m_AnimationCache.speed;
+    if (m_AnimationCache.bFreezeLastFrame) // time and loop is ignored if freezeLastFrame is true
+        progress = (elapsedTime / animLength) * m_AnimationCache.speed;
+    else
+    {
+        if (m_AnimationCache.bLoop)
+            progress = std::fmod(elapsedTime * m_AnimationCache.speed, animLength) / animLength;
         else
-        {
-            if (m_AnimationCache.bLoop)
-                progress = std::fmod(elapsedTime * m_AnimationCache.speed, animLength) / animLength;
-            else
-                // For non-looped animations, limit duration to animLength if time exceeds it
-                progress = (elapsedTime / (m_AnimationCache.iTime <= animLength ? m_AnimationCache.iTime : animLength)) * m_AnimationCache.speed;
-        }
+            // For non-looped animations, limit duration to animLength if time exceeds it
+            progress = (elapsedTime / (m_AnimationCache.iTime <= animLength ? m_AnimationCache.iTime : animLength)) * m_AnimationCache.speed;
     }
 
     animAssoc->SetCurrentProgress(std::clamp(progress, 0.0f, 1.0f));
     animAssoc->SetCurrentSpeed(m_AnimationCache.speed);
+
+    m_AnimationCache.progressWaitForStreamIn = false;
 }
 
 void CClientPed::PostWeaponFire()
diff --git a/Client/mods/deathmatch/logic/CClientPed.h b/Client/mods/deathmatch/logic/CClientPed.h
@@ -129,17 +129,17 @@ struct SReplacedAnimation
 
 struct SAnimationCache
 {
-    std::string strName;
-    int         iTime{-1};
-    bool        bLoop{false};
-    bool        bUpdatePosition{false};
-    bool        bInterruptable{false};
-    bool        bFreezeLastFrame{true};
-    int         iBlend{250};
-    float       progress{0.0f};
-    float       speed{1.0f};
-    bool        progressWaitForStreamIn{false}; // for sync anim only
-    float       elapsedTime{0.0f}; // for sync anim only
+    std::string  strName;
+    int          iTime{-1};
+    bool         bLoop{false};
+    bool         bUpdatePosition{false};
+    bool         bInterruptable{false};
+    bool         bFreezeLastFrame{true};
+    int          iBlend{250};
+    float        progress{0.0f};
+    float        speed{1.0f};
+    bool         progressWaitForStreamIn{false};
+    std::int64_t startTime{0};
 };
 
 class CClientObject;
@@ -456,13 +456,18 @@ class CClientPed : public CClientStreamElement, public CAntiCheatModule
 
     bool GetRunningAnimationName(SString& strBlockName, SString& strAnimName);
     bool IsRunningAnimation();
+
+    // It checks whether the animation is still playing based on time, not on task execution.
+    bool IsAnimationInProgress();
+
     void RunNamedAnimation(std::unique_ptr<CAnimBlock>& pBlock, const char* szAnimName, int iTime = -1, int iBlend = 250, bool bLoop = true,
                            bool bUpdatePosition = true, bool bInterruptable = false, bool bFreezeLastFrame = true, bool bRunInSequence = false,
                            bool bOffsetPed = false, bool bHoldLastFrame = false);
     void KillAnimation();
     std::unique_ptr<CAnimBlock> GetAnimationBlock();
     const SAnimationCache&      GetAnimationCache() const noexcept { return m_AnimationCache; }
     void                        RunAnimationFromCache();
+    void                        UpdateAnimationProgressAndSpeed();
 
     bool IsUsingGun();
 
diff --git a/Client/mods/deathmatch/logic/CPacketHandler.cpp b/Client/mods/deathmatch/logic/CPacketHandler.cpp
@@ -3929,7 +3929,8 @@ void CPacketHandler::Packet_EntityAdd(NetBitStreamInterface& bitStream)
                         std::string blockName, animName;
                         int time, blendTime;
                         bool looped, updatePosition, interruptable, freezeLastFrame, taskRestore;
-                        float elapsedTime, speed;
+                        float speed;
+                        double startTime;
 
                         // Read data
                         bitStream.ReadString(blockName);
@@ -3941,15 +3942,14 @@ void CPacketHandler::Packet_EntityAdd(NetBitStreamInterface& bitStream)
                         bitStream.ReadBit(freezeLastFrame);
                         bitStream.Read(blendTime);
                         bitStream.ReadBit(taskRestore);
-                        bitStream.Read(elapsedTime);
+                        bitStream.Read(startTime);
                         bitStream.Read(speed);
 
                         // Run anim
                         CStaticFunctionDefinitions::SetPedAnimation(*pPed, blockName, animName.c_str(), time, blendTime, looped, updatePosition, interruptable, freezeLastFrame);
-                        pPed->m_AnimationCache.progressWaitForStreamIn = true;
-                        pPed->m_AnimationCache.elapsedTime = elapsedTime;
-
-                        CStaticFunctionDefinitions::SetPedAnimationSpeed(*pPed, animName, speed);
+                        pPed->m_AnimationCache.startTime = static_cast<std::int64_t>(startTime);
+                        pPed->m_AnimationCache.speed = speed;
+                        pPed->m_AnimationCache.progress = 0.0f;
 
                         pPed->SetHasSyncedAnim(true);
                     }
diff --git a/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp b/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp
@@ -2276,6 +2276,8 @@ bool CStaticFunctionDefinitions::SetPedAnimation(CClientEntity& Entity, const SS
                     }
                 }
             }
+
+            Ped.m_AnimationCache.startTime = GetTimestamp();
         }
         else
         {
diff --git a/Client/mods/deathmatch/logic/rpc/CPedRPCs.cpp b/Client/mods/deathmatch/logic/rpc/CPedRPCs.cpp
@@ -273,6 +273,12 @@ void CPedRPCs::SetPedAnimation(CClientEntity* pSource, NetBitStreamInterface& bi
                         pPed->RunNamedAnimation(pBlock, animName.c_str(), iTime, iBlend, bLoop, bUpdatePosition, bInterruptable, bFreezeLastFrame);
                         pPed->SetTaskToBeRestoredOnAnimEnd(bTaskToBeRestoredOnAnimEnd);
                         pPed->SetTaskTypeToBeRestoredOnAnimEnd((eTaskType)TASK_SIMPLE_DUCK);
+
+                        pPed->m_AnimationCache.startTime = GetTimestamp();
+                        pPed->m_AnimationCache.speed = 1.0f;
+                        pPed->m_AnimationCache.progress = 0.0f;
+
+                        pPed->SetHasSyncedAnim(true);
                     }
                 }
             }
@@ -304,6 +310,7 @@ void CPedRPCs::SetPedAnimationProgress(CClientEntity* pSource, NetBitStreamInter
                     if (pAnimAssociation)
                     {
                         pAnimAssociation->SetCurrentProgress(fProgress);
+                        pPed->m_AnimationCache.progress = fProgress;
                     }
                 }
             }
@@ -331,6 +338,7 @@ void CPedRPCs::SetPedAnimationSpeed(CClientEntity* pSource, NetBitStreamInterfac
                 if (pAnimAssociation)
                 {
                     pAnimAssociation->SetCurrentSpeed(fSpeed);
+                    pPed->m_AnimationCache.speed = fSpeed;
                 }
             }
         }
diff --git a/Server/mods/deathmatch/logic/CPed.h b/Server/mods/deathmatch/logic/CPed.h
@@ -115,7 +115,7 @@ struct SPlayerAnimData
     int         blendTime{250};
     bool        taskToBeRestoredOnAnimEnd{false};
 
-    std::int64_t startedTick{0};
+    std::int64_t startTime{0};
 
     float progress{0.0f};
     float speed{1.0f};
diff --git a/Server/mods/deathmatch/logic/CPedSync.cpp b/Server/mods/deathmatch/logic/CPedSync.cpp
@@ -82,7 +82,7 @@ void CPedSync::OverrideSyncer(CPed* pPed, CPlayer* pPlayer, bool bPersist)
 
 void CPedSync::UpdateAllSyncer()
 {
-    auto currentTick = GetTickCount64_();
+    auto currentTimestamp = GetTimestamp();
 
     // Update all the ped's sync states
     for (auto iter = m_pPedManager->IterBegin(); iter != m_pPedManager->IterEnd(); iter++)
@@ -91,7 +91,7 @@ void CPedSync::UpdateAllSyncer()
         const SPlayerAnimData& animData = (*iter)->GetAnimationData();
         if (animData.IsAnimating())
         {
-            float deltaTime = currentTick - animData.startedTick;
+            float deltaTime = static_cast<float>(currentTimestamp - animData.startTime);
             if (!animData.freezeLastFrame && animData.time > 0 && deltaTime >= animData.time)
                 (*iter)->SetAnimationData({});
         }
diff --git a/Server/mods/deathmatch/logic/packets/CEntityAddPacket.cpp b/Server/mods/deathmatch/logic/packets/CEntityAddPacket.cpp
@@ -973,9 +973,8 @@ bool CEntityAddPacket::Write(NetBitStreamInterface& BitStream) const
                         BitStream.Write(animData.blendTime);
                         BitStream.WriteBit(animData.taskToBeRestoredOnAnimEnd);
 
-                        // Write elapsed time & speed
-                        float elapsedTime = GetTickCount64_() - animData.startedTick;
-                        BitStream.Write(elapsedTime);
+                        // Write start time & speed
+                        BitStream.Write(static_cast<double>(animData.startTime));
                         BitStream.Write(animData.speed);
                     }
 
diff --git a/Shared/sdk/SharedUtil.Time.h b/Shared/sdk/SharedUtil.Time.h
@@ -41,6 +41,8 @@ namespace SharedUtil
     //
     double GetSecondCount();
 
+    std::int64_t GetTimestamp();
+
     //
     // Get the time as a sortable string.
     // Set bDate to include the date, bMs to include milliseconds
diff --git a/Shared/sdk/SharedUtil.Time.hpp b/Shared/sdk/SharedUtil.Time.hpp
@@ -86,6 +86,15 @@ double SharedUtil::GetSecondCount()
     return GetTickCount64_() * (1 / 1000.0);
 }
 
+//
+// Returns a timestamp in ms
+//
+std::int64_t SharedUtil::GetTimestamp()
+{
+    auto now = std::chrono::system_clock::now();
+    return std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+}
+
 //
 // Get the time as a sortable string.
 // Set bDate to include the date, bMs to include milliseconds

Original file line number	Diff line number	Diff line change
`@@ -2276,6 +2276,8 @@ bool CStaticFunctionDefinitions::SetPedAnimation(CClientEntity& Entity, const SS`
`2276`	`2276`	`}`
`2277`	`2277`	`}`
`2278`	`2278`	`}`
	`2279`	`+`
	`2280`	`+ Ped.m_AnimationCache.startTime = GetTimestamp();`
`2279`	`2281`	`}`
`2280`	`2282`	`else`
`2281`	`2283`	`{`
Original file line number	Diff line number	Diff line change
`@@ -273,6 +273,12 @@ void CPedRPCs::SetPedAnimation(CClientEntity* pSource, NetBitStreamInterface& bi`
`273`	`273`	`pPed->RunNamedAnimation(pBlock, animName.c_str(), iTime, iBlend, bLoop, bUpdatePosition, bInterruptable, bFreezeLastFrame);`
`274`	`274`	`pPed->SetTaskToBeRestoredOnAnimEnd(bTaskToBeRestoredOnAnimEnd);`
`275`	`275`	`pPed->SetTaskTypeToBeRestoredOnAnimEnd((eTaskType)TASK_SIMPLE_DUCK);`
	`276`	`+`
	`277`	`+ pPed->m_AnimationCache.startTime = GetTimestamp();`
	`278`	`+ pPed->m_AnimationCache.speed = 1.0f;`
	`279`	`+ pPed->m_AnimationCache.progress = 0.0f;`
	`280`	`+`
	`281`	`+ pPed->SetHasSyncedAnim(true);`
`276`	`282`	`}`
`277`	`283`	`}`
`278`	`284`	`}`
`@@ -304,6 +310,7 @@ void CPedRPCs::SetPedAnimationProgress(CClientEntity* pSource, NetBitStreamInter`
`304`	`310`	`if (pAnimAssociation)`
`305`	`311`	`{`
`306`	`312`	`pAnimAssociation->SetCurrentProgress(fProgress);`
	`313`	`+ pPed->m_AnimationCache.progress = fProgress;`
`307`	`314`	`}`
`308`	`315`	`}`
`309`	`316`	`}`
`@@ -331,6 +338,7 @@ void CPedRPCs::SetPedAnimationSpeed(CClientEntity* pSource, NetBitStreamInterfac`
`331`	`338`	`if (pAnimAssociation)`
`332`	`339`	`{`
`333`	`340`	`pAnimAssociation->SetCurrentSpeed(fSpeed);`
	`341`	`+ pPed->m_AnimationCache.speed = fSpeed;`
`334`	`342`	`}`
`335`	`343`	`}`
`336`	`344`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ void CPedSync::OverrideSyncer(CPed* pPed, CPlayer* pPlayer, bool bPersist)`
`82`	`82`
`83`	`83`	`void CPedSync::UpdateAllSyncer()`
`84`	`84`	`{`
`85`		`- auto currentTick = GetTickCount64_();`
	`85`	`+ auto currentTimestamp = GetTimestamp();`
`86`	`86`
`87`	`87`	`// Update all the ped's sync states`
`88`	`88`	`for (auto iter = m_pPedManager->IterBegin(); iter != m_pPedManager->IterEnd(); iter++)`
`@@ -91,7 +91,7 @@ void CPedSync::UpdateAllSyncer()`
`91`	`91`	`const SPlayerAnimData& animData = (*iter)->GetAnimationData();`
`92`	`92`	`if (animData.IsAnimating())`
`93`	`93`	`{`
`94`		`- float deltaTime = currentTick - animData.startedTick;`
	`94`	`+ float deltaTime = static_cast<float>(currentTimestamp - animData.startTime);`
`95`	`95`	`if (!animData.freezeLastFrame && animData.time > 0 && deltaTime >= animData.time)`
`96`	`96`	`(*iter)->SetAnimationData({});`
`97`	`97`	`}`