Revert "Fix anim progress & speed (#4245)"

botder · botder · commit 7ebe31a17947 · 2025-07-18T21:40:38.000+02:00
This reverts commit ad0d6bf. The new code started reading a 'double' instead of a 'float', which is incompatible with older servers, that only sent a 'float' value.
diff --git a/Client/mods/deathmatch/logic/CClientPed.cpp b/Client/mods/deathmatch/logic/CClientPed.cpp
@@ -2895,11 +2895,6 @@ 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
@@ -3690,8 +3685,8 @@ void CClientPed::_CreateModel()
             Kill(WEAPONTYPE_UNARMED, 0, false, true);
         }
 
-        // Are we still playing a animation?
-        if (m_pAnimationBlock && IsAnimationInProgress())
+        // Are we still playing animation?
+        if ((m_AnimationCache.bLoop || m_AnimationCache.bFreezeLastFrame || m_AnimationCache.progressWaitForStreamIn) && m_pAnimationBlock)
         {
             if (m_bisCurrentAnimationCustom)
             {
@@ -3968,8 +3963,8 @@ void CClientPed::_ChangeModel()
             }
             m_bDontChangeRadio = false;
 
-            // Are we still playing a animation?
-            if (m_pAnimationBlock && IsAnimationInProgress())
+            // Are we still playing a looped animation?
+            if ((m_AnimationCache.bLoop || m_AnimationCache.bFreezeLastFrame || m_AnimationCache.progressWaitForStreamIn) && m_pAnimationBlock)
             {
                 if (m_bisCurrentAnimationCustom)
                 {
@@ -5736,23 +5731,7 @@ bool CClientPed::IsRunningAnimation()
         }
         return false;
     }
-    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();
+    return (m_AnimationCache.bLoop && m_pAnimationBlock);
 }
 
 void CClientPed::RunNamedAnimation(std::unique_ptr<CAnimBlock>& pBlock, const char* szAnimName, int iTime, int iBlend, bool bLoop, bool bUpdatePosition,
@@ -5840,6 +5819,10 @@ 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()
@@ -5878,45 +5861,39 @@ 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);
 
-    // 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());
+    auto animAssoc = g_pGame->GetAnimManager()->RpAnimBlendClumpGetAssociation(GetClump(), animName.c_str());
     if (!animAssoc)
         return;
 
-    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;
-    else
+    // If the anim is synced from the server side, we need to calculate the progress
+    float progress = m_AnimationCache.progress;
+    if (needCalcProgress)
     {
-        if (m_AnimationCache.bLoop)
-            progress = std::fmod(elapsedTime * m_AnimationCache.speed, animLength) / animLength;
+        float animLength = animAssoc->GetLength();
+
+        if (m_AnimationCache.bFreezeLastFrame) // time and loop is ignored if freezeLastFrame is true
+            progress = (elapsedTime / animLength) * m_AnimationCache.speed;
         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;
+        {
+            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;
+        }
     }
 
     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};
-    std::int64_t startTime{0};
+    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
 };
 
 class CClientObject;
@@ -456,18 +456,13 @@ 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
@@ -4011,8 +4011,7 @@ void CPacketHandler::Packet_EntityAdd(NetBitStreamInterface& bitStream)
                             std::string blockName, animName;
                             int time, blendTime;
                             bool looped, updatePosition, interruptable, freezeLastFrame, taskRestore;
-                            float speed;
-                            double startTime;
+                            float elapsedTime, speed;
 
                             // Read data
                             bitStream.ReadString(blockName);
@@ -4024,14 +4023,15 @@ void CPacketHandler::Packet_EntityAdd(NetBitStreamInterface& bitStream)
                             bitStream.ReadBit(freezeLastFrame);
                             bitStream.Read(blendTime);
                             bitStream.ReadBit(taskRestore);
-                            bitStream.Read(startTime);
+                            bitStream.Read(elapsedTime);
                             bitStream.Read(speed);
 
                             // Run anim
                             CStaticFunctionDefinitions::SetPedAnimation(*pPed, blockName, animName.c_str(), time, blendTime, looped, updatePosition, interruptable, freezeLastFrame);
-                            pPed->m_AnimationCache.startTime = static_cast<std::int64_t>(startTime);
-                            pPed->m_AnimationCache.speed = speed;
-                            pPed->m_AnimationCache.progress = 0.0f;
+                            pPed->m_AnimationCache.progressWaitForStreamIn = true;
+                            pPed->m_AnimationCache.elapsedTime = elapsedTime;
+
+                            CStaticFunctionDefinitions::SetPedAnimationSpeed(*pPed, animName, speed);
 
                             pPed->SetHasSyncedAnim(true);
                         }
diff --git a/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp b/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp
@@ -2247,8 +2247,6 @@ 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
@@ -276,12 +276,6 @@ 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);
                     }
                 }
             }
@@ -313,7 +307,6 @@ void CPedRPCs::SetPedAnimationProgress(CClientEntity* pSource, NetBitStreamInter
                     if (pAnimAssociation)
                     {
                         pAnimAssociation->SetCurrentProgress(fProgress);
-                        pPed->m_AnimationCache.progress = fProgress;
                     }
                 }
             }
@@ -341,7 +334,6 @@ 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 startTime{0};
+    std::int64_t startedTick{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 currentTimestamp = GetTimestamp();
+    auto currentTick = GetTickCount64_();
 
     // 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 = static_cast<float>(currentTimestamp - animData.startTime);
+            float deltaTime = currentTick - animData.startedTick;
             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
@@ -1005,8 +1005,9 @@ bool CEntityAddPacket::Write(NetBitStreamInterface& BitStream) const
                             BitStream.Write(animData.blendTime);
                             BitStream.WriteBit(animData.taskToBeRestoredOnAnimEnd);
 
-                            // Write start time & speed
-                            BitStream.Write(static_cast<double>(animData.startTime));
+                            // Write elapsed time & speed
+                            float elapsedTime = GetTickCount64_() - animData.startedTick;
+                            BitStream.Write(elapsedTime);
                             BitStream.Write(animData.speed);
                         }
                     }
diff --git a/Shared/sdk/SharedUtil.Time.h b/Shared/sdk/SharedUtil.Time.h
@@ -41,8 +41,6 @@ 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,15 +86,6 @@ 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
`@@ -2247,8 +2247,6 @@ bool CStaticFunctionDefinitions::SetPedAnimation(CClientEntity& Entity, const SS`
`2247`	`2247`	`}`
`2248`	`2248`	`}`
`2249`	`2249`	`}`
`2250`		`-`
`2251`		`- Ped.m_AnimationCache.startTime = GetTimestamp();`
`2252`	`2250`	`}`
`2253`	`2251`	`else`
`2254`	`2252`	`{`
Original file line number	Diff line number	Diff line change
`@@ -276,12 +276,6 @@ void CPedRPCs::SetPedAnimation(CClientEntity* pSource, NetBitStreamInterface& bi`
`276`	`276`	`pPed->RunNamedAnimation(pBlock, animName.c_str(), iTime, iBlend, bLoop, bUpdatePosition, bInterruptable, bFreezeLastFrame);`
`277`	`277`	`pPed->SetTaskToBeRestoredOnAnimEnd(bTaskToBeRestoredOnAnimEnd);`
`278`	`278`	`pPed->SetTaskTypeToBeRestoredOnAnimEnd((eTaskType)TASK_SIMPLE_DUCK);`
`279`		`-`
`280`		`- pPed->m_AnimationCache.startTime = GetTimestamp();`
`281`		`- pPed->m_AnimationCache.speed = 1.0f;`
`282`		`- pPed->m_AnimationCache.progress = 0.0f;`
`283`		`-`
`284`		`- pPed->SetHasSyncedAnim(true);`
`285`	`279`	`}`
`286`	`280`	`}`
`287`	`281`	`}`
`@@ -313,7 +307,6 @@ void CPedRPCs::SetPedAnimationProgress(CClientEntity* pSource, NetBitStreamInter`
`313`	`307`	`if (pAnimAssociation)`
`314`	`308`	`{`
`315`	`309`	`pAnimAssociation->SetCurrentProgress(fProgress);`
`316`		`- pPed->m_AnimationCache.progress = fProgress;`
`317`	`310`	`}`
`318`	`311`	`}`
`319`	`312`	`}`
`@@ -341,7 +334,6 @@ void CPedRPCs::SetPedAnimationSpeed(CClientEntity* pSource, NetBitStreamInterfac`
`341`	`334`	`if (pAnimAssociation)`
`342`	`335`	`{`
`343`	`336`	`pAnimAssociation->SetCurrentSpeed(fSpeed);`
`344`		`- pPed->m_AnimationCache.speed = fSpeed;`
`345`	`337`	`}`
`346`	`338`	`}`
`347`	`339`	`}`
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 currentTimestamp = GetTimestamp();`
	`85`	`+ auto currentTick = GetTickCount64_();`
`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 = static_cast<float>(currentTimestamp - animData.startTime);`
	`94`	`+ float deltaTime = currentTick - animData.startedTick;`
`95`	`95`	`if (!animData.freezeLastFrame && animData.time > 0 && deltaTime >= animData.time)`
`96`	`96`	`(*iter)->SetAnimationData({});`
`97`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1005,8 +1005,9 @@ bool CEntityAddPacket::Write(NetBitStreamInterface& BitStream) const`
`1005`	`1005`	`BitStream.Write(animData.blendTime);`
`1006`	`1006`	`BitStream.WriteBit(animData.taskToBeRestoredOnAnimEnd);`
`1007`	`1007`
`1008`		`- // Write start time & speed`
`1009`		`- BitStream.Write(static_cast<double>(animData.startTime));`
	`1008`	`+ // Write elapsed time & speed`
	`1009`	`+ float elapsedTime = GetTickCount64_() - animData.startedTick;`
	`1010`	`+ BitStream.Write(elapsedTime);`
`1010`	`1011`	`BitStream.Write(animData.speed);`
`1011`	`1012`	`}`
`1012`	`1013`	`}`