Merge branch 'master' into ResourceCache

Author: MohabCodeX

Client/game_sa/CPedSA.h

@@ -261,7 +261,7 @@ class CPedSAInterface : public CPhysicalSAInterface
     int                              unk_52C;
 
     int                              pedState;
-    int                              moveState;
+    PedMoveState::Enum               moveState;
     int                              swimmingMoveState;
 
     int                              unk_53C;
@@ -276,10 +276,10 @@ class CPedSAInterface : public CPhysicalSAInterface
     float                            fRotationSpeed;
     float                            fMoveAnim;
 
-    CEntitySAInterface*              pContactEntity;
+    CEntitySAInterface*              pContactEntity; // m_standingOnEntity
     CVector                          unk_56C;
     CVector                          unk_578;
-    CEntitySAInterface*              pLastContactEntity;
+    CEntitySAInterface*              pLastContactEntity; // m_contactEntity
 
     CVehicleSAInterface*             pLastVehicle;
     CVehicleSAInterface*             pVehicle;
@@ -421,8 +421,9 @@ class CPedSA : public virtual CPed, public virtual CPhysicalSA
     void           SetFightingStyle(eFightingStyle style, std::uint8_t styleExtra = 6) override;
 
     CEntity* GetContactEntity() const override;
+    bool     IsStandingOnEntity() const override { return GetPedInterface()->pContactEntity != nullptr; };
 
-    int GetRunState() const override { return GetPedInterface()->moveState; }
+    PedMoveState::Enum GetMoveState() const override { return GetPedInterface()->moveState; }
 
     bool GetCanBeShotInVehicle() const override{ return GetPedInterface()->pedFlags.bCanBeShotInVehicle; }
     bool GetTestForShotInVehicle() const override { return GetPedInterface()->pedFlags.bTestForShotInVehicle; }

Client/loader/MainFunctions.cpp

@@ -977,7 +977,7 @@ void CheckDataFiles()
 //////////////////////////////////////////////////////////
 void CheckLibVersions()
 {
-#if MTASA_VERSION_TYPE < VERSION_TYPE_UNTESTED
+#if MTASA_VERSION_TYPE >= VERSION_TYPE_UNTESTED
 
     const char* moduleList[] = {"MTA\\loader.dll",
                                 "MTA\\cgui.dll",

Client/mods/deathmatch/logic/CClientGame.cpp

@@ -3551,9 +3551,9 @@ void CClientGame::StaticDeathHandler(CPed* pKilledPed, unsigned char ucDeathReas
     g_pClientGame->DeathHandler(pKilledPed, ucDeathReason, ucBodyPart);
 }
 
-void CClientGame::StaticFireHandler(CFire* pFire)
+bool CClientGame::StaticFireHandler(CEntitySAInterface* target, CEntitySAInterface* creator)
 {
-    g_pClientGame->FireHandler(pFire);
+    return g_pClientGame->FireHandler(target, creator);
 }
 
 void CClientGame::StaticRender3DStuffHandler()
@@ -3813,10 +3813,22 @@ bool CClientGame::BreakTowLinkHandler(CVehicle* pTowedVehicle)
     return true;
 }
 
-void CClientGame::FireHandler(CFire* pFire)
+bool CClientGame::FireHandler(CEntitySAInterface* target, CEntitySAInterface* creator)
 {
-    // Disable spreading fires
-    pFire->SetNumGenerationsAllowed(0);
+    CClientEntity* creatorClientEntity = g_pGame->GetPools()->GetClientEntity((DWORD*)creator);
+    CClientEntity* targetClientEntity = g_pGame->GetPools()->GetClientEntity((DWORD*)target);
+
+    if (creatorClientEntity && targetClientEntity && IS_PLAYER(targetClientEntity) && IS_PLAYER(creatorClientEntity))
+    {
+        CClientPlayer* targetPlayer = static_cast<CClientPlayer*>(targetClientEntity);
+        CClientPlayer* creatorPlayer = static_cast<CClientPlayer*>(creatorClientEntity);
+
+        CClientTeam* targetPlayerTeam = targetPlayer->GetTeam();
+        if (targetPlayerTeam && targetPlayer->IsOnMyTeam(creatorPlayer) && !targetPlayerTeam->GetFriendlyFire() && creatorPlayer != targetPlayer)
+            return false;
+    }
+
+    return true;
 }
 
 void CClientGame::ProjectileInitiateHandler(CClientProjectile* pProjectile)

Client/mods/deathmatch/logic/CClientGame.h

@@ -53,6 +53,7 @@ class CClientModelCacheManager;
 class CDebugHookManager;
 class CResourceFileDownloadManager;
 class CServerInfo;
+class CFire;
 enum class eAnimID;
 
 struct SVehExtrapolateSettings
@@ -522,7 +523,7 @@ class CClientGame
 
     static bool                              StaticDamageHandler(CPed* pDamagePed, CEventDamage* pEvent);
     static void                              StaticDeathHandler(CPed* pKilledPed, unsigned char ucDeathReason, unsigned char ucBodyPart);
-    static void                              StaticFireHandler(CFire* pFire);
+    static bool                              StaticFireHandler(CEntitySAInterface* target, CEntitySAInterface* creator);
     static bool                              StaticBreakTowLinkHandler(CVehicle* pTowedVehicle);
     static void                              StaticDrawRadarAreasHandler();
     static void                              StaticRender3DStuffHandler();
@@ -573,7 +574,7 @@ class CClientGame
 
     bool                              DamageHandler(CPed* pDamagePed, CEventDamage* pEvent);
     void                              DeathHandler(CPed* pKilledPed, unsigned char ucDeathReason, unsigned char ucBodyPart);
-    void                              FireHandler(CFire* pFire);
+    bool                              FireHandler(CEntitySAInterface* target, CEntitySAInterface* creator);
     bool                              BreakTowLinkHandler(CVehicle* pTowedVehicle);
     void                              DrawRadarAreasHandler();
     void                              Render3DStuffHandler();

Client/mods/deathmatch/logic/CClientPed.cpp

@@ -231,12 +231,16 @@ void CClientPed::Init(CClientManager* pManager, unsigned long ulModelID, bool bI
     m_MovementStateNames[MOVEMENTSTATE_JOG] = "jog";
     m_MovementStateNames[MOVEMENTSTATE_SPRINT] = "sprint";
     m_MovementStateNames[MOVEMENTSTATE_CROUCH] = "crouch";
-    // These two are inactive for now
     m_MovementStateNames[MOVEMENTSTATE_CRAWL] = "crawl";
     m_MovementStateNames[MOVEMENTSTATE_ROLL] = "roll";
     m_MovementStateNames[MOVEMENTSTATE_JUMP] = "jump";
     m_MovementStateNames[MOVEMENTSTATE_FALL] = "fall";
     m_MovementStateNames[MOVEMENTSTATE_CLIMB] = "climb";
+    m_MovementStateNames[MOVEMENTSTATE_SWIM] = "swim";
+    m_MovementStateNames[MOVEMENTSTATE_WALK_TO_POINT] = "walk_to_point";
+    m_MovementStateNames[MOVEMENTSTATE_ASCENT_JETPACK] = "ascent_jetpack";
+    m_MovementStateNames[MOVEMENTSTATE_DESCENT_JETPACK] = "descent_jetpack";
+    m_MovementStateNames[MOVEMENTSTATE_JETPACK] = "jetpack_flying";
 
     // Create the player model
     if (m_bIsLocalPlayer)
@@ -2420,53 +2424,63 @@ eMovementState CClientPed::GetMovementState()
         const char* szComplexTaskName = GetTaskManager()->GetActiveTask()->GetTaskName();
         const char* szSimpleTaskName = GetTaskManager()->GetSimplestActiveTask()->GetTaskName();
 
-        // Is he climbing?
-        if (strcmp(szSimpleTaskName, "TASK_SIMPLE_CLIMB") == 0)
+        // Check tasks
+        if (strcmp(szSimpleTaskName, "TASK_SIMPLE_CLIMB") == 0) // Is he climbing?
             return MOVEMENTSTATE_CLIMB;
-
-        // Is he jumping?
-        else if (strcmp(szComplexTaskName, "TASK_COMPLEX_JUMP") == 0)
+        else if (strcmp(szComplexTaskName, "TASK_COMPLEX_JUMP") == 0) // Is he jumping?
             return MOVEMENTSTATE_JUMP;
+        else if (strcmp(szSimpleTaskName, "TASK_SIMPLE_GO_TO_POINT") == 0) // Entering vehicle (walking to the doors)?
+            return MOVEMENTSTATE_WALK_TO_POINT;
+        else if (strcmp(szSimpleTaskName, "TASK_SIMPLE_SWIM") == 0) // Is he swimming?
+            return MOVEMENTSTATE_SWIM;
+        else if (strcmp(szSimpleTaskName, "TASK_SIMPLE_JETPACK") == 0) // Is he flying?
+        {
+            if (cs.ButtonCross != 0)
+                return MOVEMENTSTATE_ASCENT_JETPACK;
+            else if (cs.ButtonSquare != 0)
+                return MOVEMENTSTATE_DESCENT_JETPACK;
+            else
+                return MOVEMENTSTATE_JETPACK;
+        }
 
-        // Is he falling?
-        else if (!IsOnGround() && !GetContactEntity())
+        // Check movement state
+        if (!IsOnGround() && !GetContactEntity() && !m_pPlayerPed->IsStandingOnEntity() && !m_pPlayerPed->IsInWater() && (strcmp(szSimpleTaskName, "TASK_SIMPLE_IN_AIR") == 0 || strcmp(szSimpleTaskName, "TASK_SIMPLE_FALL") == 0)) // Is he falling?
             return MOVEMENTSTATE_FALL;
 
-        // Grab his controller state
-        bool bWalkKey = false;
-        if (GetType() == CCLIENTPLAYER)
-            bWalkKey = CClientPad::GetControlState("walk", cs, true);
-        else
-            m_Pad.GetControlState("walk", bWalkKey);
+        // Sometimes it returns 'fall' or 'walk', so it's better to return false instead
+        if (IsEnteringVehicle() || IsLeavingVehicle())
+            return MOVEMENTSTATE_UNKNOWN;
 
-        // Is he standing up?
         if (!IsDucked())
         {
-            unsigned int iRunState = m_pPlayerPed->GetRunState();
+            bool walking = false;
+            if (GetType() == CCLIENTPLAYER)
+                walking = CClientPad::GetControlState("walk", cs, true);
+            else
+                m_Pad.GetControlState("walk", walking);
 
-            // Is he moving the contoller at all?
-            if (iRunState == 1 && cs.LeftStickX == 0 && cs.LeftStickY == 0)
-                return MOVEMENTSTATE_STAND;
-
-            // Is he either pressing the walk key, or has run state 1?
-            if (iRunState == 1 || bWalkKey && iRunState == 6)
-                return MOVEMENTSTATE_WALK;
-            else if (iRunState == 4)
-                return MOVEMENTSTATE_POWERWALK;
-            else if (iRunState == 6)
-                return MOVEMENTSTATE_JOG;
-            else if (iRunState == 7)
-                return MOVEMENTSTATE_SPRINT;
+            switch (m_pPlayerPed->GetMoveState())
+            {
+                case PedMoveState::PEDMOVE_STILL:
+                    return MOVEMENTSTATE_STAND;
+                case PedMoveState::PEDMOVE_WALK:
+                    return (cs.LeftStickX == 0 && cs.LeftStickY == 0) ? MOVEMENTSTATE_STAND : MOVEMENTSTATE_WALK;
+                case PedMoveState::PEDMOVE_SPRINT:
+                    return MOVEMENTSTATE_SPRINT;
+                case PedMoveState::PEDMOVE_RUN:
+                    return walking ? MOVEMENTSTATE_WALK : MOVEMENTSTATE_JOG; // FileEX: It should be MOVEMENTSTATE_RUN, but we're keeping JOG for backward compatibility (PEDMOVE_JOG is unused in SA)
+            }
         }
         else
         {
             // Is he moving the contoller at all?
             if (cs.LeftStickX == 0 && cs.LeftStickY == 0)
                 return MOVEMENTSTATE_CROUCH;
             else
-                return MOVEMENTSTATE_CRAWL;
+                return (cs.LeftStickX != 0 && cs.RightShoulder1 != 0) ? MOVEMENTSTATE_ROLL : MOVEMENTSTATE_CRAWL;
         }
     }
+
     return MOVEMENTSTATE_UNKNOWN;
 }
 
@@ -2893,6 +2907,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 +3702,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 +3980,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 +5748,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 +5852,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 +5890,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()
@@ -6096,7 +6133,7 @@ bool CClientPed::ShouldBeStealthAiming()
                 {
                     // We need to be either crouched, walking or standing
                     SBindableGTAControl* pWalkControl = pKeyBinds->GetBindableFromControl("walk");
-                    if (m_pPlayerPed->GetRunState() == 1 || m_pPlayerPed->GetRunState() == 4 || pWalkControl && pWalkControl->bState)
+                    if (m_pPlayerPed->GetMoveState() == PedMoveState::PEDMOVE_STILL || m_pPlayerPed->GetMoveState() == PedMoveState::PEDMOVE_WALK || pWalkControl && pWalkControl->bState)
                     {
                         // Do we have a target ped?
                         CClientPed* pTargetPed = GetTargetedPed();