Merge remote-tracking branch 'origin/master' into feature/underwater-effect

Author: XJMLN

Client/game_sa/CGameSA.cpp

@@ -664,7 +664,7 @@ void CGameSA::SetCoronaZTestEnabled(bool isEnabled)
     m_isCoronaZTestEnabled = isEnabled;
 }
 
-void CGameSA::SetWaterCreaturesEnabled(bool isEnabled)
+void CGameSA::SetWaterCreaturesEnabled(bool isEnabled) 
 {
     if (isEnabled == m_areWaterCreaturesEnabled)
         return;
@@ -684,6 +684,29 @@ void CGameSA::SetWaterCreaturesEnabled(bool isEnabled)
     m_areWaterCreaturesEnabled = isEnabled;
 }
 
+void CGameSA::SetTunnelWeatherBlendEnabled(bool isEnabled)
+{
+    if (isEnabled == m_isTunnelWeatherBlendEnabled)
+        return;
+    // CWeather::UpdateInTunnelness
+    DWORD functionAddress = 0x72B630; 
+    if (isEnabled)
+    {
+        // Restore original bytes: 83 EC 20
+        MemPut<BYTE>(functionAddress, 0x83);                // Restore 83
+        MemPut<BYTE>(functionAddress + 1, 0xEC);            // Restore EC
+        MemPut<BYTE>(functionAddress + 2, 0x20);            // Restore 20
+    }
+    else
+    {
+        // Patch CWeather::UpdateInTunnelness               (Found By AlexTMjugador)
+        MemPut<BYTE>(functionAddress, 0xC3);                // Write C3 (RET)
+        MemPut<BYTE>(functionAddress + 1, 0x90);            // Write 90 (NOP)
+        MemPut<BYTE>(functionAddress + 2, 0x90);            // Write 90 (NOP)
+    }
+    m_isTunnelWeatherBlendEnabled = isEnabled;
+}
+
 void CGameSA::SetBurnFlippedCarsEnabled(bool isEnabled)
 {
     if (isEnabled == m_isBurnFlippedCarsEnabled)

Client/game_sa/CGameSA.h

@@ -244,6 +244,10 @@ class CGameSA : public CGame
     bool IsRoadSignsTextEnabled() const noexcept override { return m_isRoadSignsTextEnabled; }
     void SetRoadSignsTextEnabled(bool isEnabled) override;
 
+    bool IsTunnelWeatherBlendEnabled() const noexcept override { return m_isTunnelWeatherBlendEnabled; }
+    void SetTunnelWeatherBlendEnabled(bool isEnabled) override;
+
+
     unsigned long GetMinuteDuration();
     void          SetMinuteDuration(unsigned long ulTime);
 
@@ -363,6 +367,7 @@ class CGameSA : public CGame
     int          m_iCheckStatus;
     bool         m_bUnderworldWarp;
     bool         m_isCoronaZTestEnabled{true};
+    bool         m_isTunnelWeatherBlendEnabled{true}; 
     bool         m_areWaterCreaturesEnabled{true};
     bool         m_isBurnFlippedCarsEnabled{true};
     bool         m_isFireballDestructEnabled{true};

Client/game_sa/CPedSA.cpp

@@ -1108,3 +1108,34 @@ void CPedSA::StaticSetHooks()
     EZHookInstall(CPed_PreRenderAfterTest);
     EZHookInstall(CPed_PreRenderAfterTest_Mid);
 }
+
+void CPedSA::GetAttachedSatchels(std::vector<SSatchelsData>& satchelsList) const
+{
+    // Array of projectiles objects
+    CProjectileSAInterface** projectilesArray = (CProjectileSAInterface**)ARRAY_CProjectile;
+    CProjectileSAInterface*  pProjectileInterface;
+
+    // Array of projectiles infos
+    CProjectileInfoSAInterface* projectilesInfoArray = (CProjectileInfoSAInterface*)ARRAY_CProjectileInfo;
+    CProjectileInfoSAInterface* pProjectileInfoInterface;
+
+    // Loop through all projectiles
+    for (size_t i = 0; i < PROJECTILE_COUNT; i++)
+    {
+        pProjectileInterface = projectilesArray[i];
+
+        // is attached to our ped?
+        if (!pProjectileInterface || pProjectileInterface->m_pAttachedEntity != m_pInterface)
+            continue;
+
+        // index is always the same for both arrays
+        pProjectileInfoInterface = &projectilesInfoArray[i];
+
+        // We are only interested in satchels
+        if (!pProjectileInfoInterface || pProjectileInfoInterface->dwProjectileType != eWeaponType::WEAPONTYPE_REMOTE_SATCHEL_CHARGE)
+            continue;
+
+        // Push satchel into the array. There is no need to check the counter because for satchels it restarts until the player detonates the charges
+        satchelsList.push_back({pProjectileInterface, &pProjectileInterface->m_vecAttachedOffset, &pProjectileInterface->m_vecAttachedRotation});
+    }
+}

Client/game_sa/CPedSA.h

@@ -408,4 +408,6 @@ class CPedSA : public virtual CPed, public virtual CPhysicalSA
     void*                   GetPedNodeInterface(std::int32_t nodeId) { return reinterpret_cast<CPedSAInterface*>(m_pInterface)->pedNodes[nodeId]; }
     std::unique_ptr<CPedIK> GetPedIK() { return std::make_unique<CPedIKSA>(GetPedIKInterface()); }
     static void             StaticSetHooks();
+
+    void GetAttachedSatchels(std::vector<SSatchelsData> &satchelsList) const override;
 };

Client/game_sa/CVehicleSA.cpp

@@ -11,6 +11,7 @@
 
 #include "StdInc.h"
 #include "CAutomobileSA.h"
+#include "CBikeSA.h"
 #include "CCameraSA.h"
 #include "CColModelSA.h"
 #include "CFxManagerSA.h"
@@ -494,6 +495,37 @@ void CVehicleSA::SetPlaneRotorSpeed(float fSpeed)
     pInterface->m_fPropSpeed = fSpeed;
 }
 
+bool CVehicleSA::SetVehicleWheelRotation(float fWheelRot1, float fWheelRot2, float fWheelRot3, float fWheelRot4) noexcept
+{ 
+    VehicleClass m_eVehicleType = static_cast<VehicleClass>(GetVehicleInterface()->m_vehicleSubClass);
+    switch (m_eVehicleType)
+    {
+        case VehicleClass::AUTOMOBILE:
+        case VehicleClass::MONSTER_TRUCK:
+        case VehicleClass::QUAD:
+        case VehicleClass::TRAILER:
+        {
+            auto pInterface = static_cast<CAutomobileSAInterface*>(GetInterface());
+            pInterface->m_wheelRotation[0] = fWheelRot1;
+            pInterface->m_wheelRotation[1] = fWheelRot2;
+            pInterface->m_wheelRotation[2] = fWheelRot3;
+            pInterface->m_wheelRotation[3] = fWheelRot4;
+            return true;
+        }
+        case VehicleClass::BIKE:
+        case VehicleClass::BMX:
+        {
+            auto pInterface = static_cast<CBikeSAInterface*>(GetInterface());
+            pInterface->m_afWheelRotationX[0] = fWheelRot1;
+            pInterface->m_afWheelRotationX[1] = fWheelRot2;
+            return true;
+        }
+        default:
+            return false;
+    }
+    return false;
+}
+
 float CVehicleSA::GetPlaneRotorSpeed() 
 {
     auto pInterface = static_cast<CPlaneSAInterface*>(GetInterface());

Client/game_sa/CVehicleSA.h

@@ -568,6 +568,7 @@ class CVehicleSA : public virtual CVehicle, public virtual CPhysicalSA
     };
     void SetHeliRotorSpeed(float fSpeed) { *reinterpret_cast<float*>(reinterpret_cast<unsigned int>(m_pInterface) + 2124) = fSpeed; };
     void SetPlaneRotorSpeed(float fSpeed);
+    bool SetVehicleWheelRotation(float fWheelRot1, float fWheelRot2, float fWheelRot3, float fWheelRot4) noexcept;
     void SetExplodeTime(unsigned long ulTime) { *reinterpret_cast<unsigned long*>(reinterpret_cast<unsigned int>(m_pInterface) + 1240) = ulTime; };
     void SetRadioStatus(bool bStatus) { *reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned int>(m_pInterface) + 0x1D3) = bStatus; };
 

Client/game_sa/CWeatherSA.cpp

@@ -62,3 +62,169 @@ void CWeatherSA::ResetAmountOfRain()
     MemCpy((LPVOID)0x72BC92, &originalFstp1, 6);
     MemCpy((LPVOID)0x72C686, &originalFstp2, 6);
 }
+
+float CWeatherSA::GetWetRoads() const
+{
+    return *(float*)0xC81308;
+}
+
+bool CWeatherSA::SetWetRoads(float fAmount)
+{
+    MemSet((LPVOID)(0x72BB9F + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72BBB7 + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72BBD0 + 1), 0x90, 3);
+    MemSet((LPVOID)(0x72BBD7 + 2), 0x90, 3);
+
+    MemPutFast<float>(0xC81308, fAmount);
+    return true;
+}
+
+bool CWeatherSA::ResetWetRoads()
+{
+    BYTE originalCodes[3] = {0x08, 0x13, 0xC8};
+    MemCpy((LPVOID)(0x72BB9F + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BBB7 + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BBD0 + 1), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BBD7 + 2), &originalCodes, 3);
+    return true;
+}
+
+float CWeatherSA::GetFoggyness() const
+{
+    return *(float*)0xC81300;
+}
+
+bool CWeatherSA::SetFoggyness(float fAmount)
+{
+    MemSet((LPVOID)(0x72BDF5 + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72BDDD + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72BE13 + 2), 0x90, 3);
+
+    MemPutFast<float>(0xC81300, fAmount);
+    return true;
+}
+
+bool CWeatherSA::ResetFoggyness()
+{
+    BYTE originalCodes[3] = {0x00, 0x13, 0xC8};
+    MemCpy((LPVOID)(0x72BDF5 + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BDDD + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BE13 + 2), &originalCodes, 3);
+    return true;
+}
+
+float CWeatherSA::GetFog() const
+{
+    return *(float*)0xC812FC;
+}
+
+bool CWeatherSA::SetFog(float fAmount)
+{
+    MemSet((LPVOID)(0x72BE37 + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72BE1F + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72BE4F + 2), 0x90, 3);
+
+    MemPutFast<float>(0xC812FC, fAmount);
+    return true;
+}
+
+bool CWeatherSA::ResetFog()
+{
+    BYTE originalCodes[3] = {0xFC, 0x12, 0xC8};
+    MemCpy((LPVOID)(0x72BE37 + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BE1F + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BE4F + 2), &originalCodes, 3);
+    return true;
+}
+
+float CWeatherSA::GetRainFog() const
+{
+    return *(float*)0xC81410;
+}
+
+bool CWeatherSA::SetRainFog(float fAmount)
+{
+    MemSet((LPVOID)(0x72ADD8 + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72ADE4 + 2), 0x90, 3);
+
+    MemPutFast<float>(0xC81410, fAmount);
+    return true;
+}
+
+bool CWeatherSA::ResetRainFog()
+{
+    BYTE originalCodes[3] = {0x10, 0x14, 0xC8};
+    MemCpy((LPVOID)(0x72ADD8 + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72ADE4 + 2), &originalCodes, 3);
+    return true;
+}
+
+float CWeatherSA::GetWaterFog() const
+{
+    return *(float*)0xC81338;
+}
+
+bool CWeatherSA::SetWaterFog(float fAmount)
+{
+    MemSet((LPVOID)(0x72C35C + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72C38E + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72C36F + 2), 0x90, 3);
+
+    MemPutFast<float>(0xC81338, fAmount);
+    return true;
+}
+
+bool CWeatherSA::ResetWaterFog()
+{
+    BYTE originalCodes[3] = {0x38, 0x13, 0xC8};
+    MemCpy((LPVOID)(0x72C35C + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72C38E + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72C36F + 2), &originalCodes, 3);
+    return true;
+}
+
+float CWeatherSA::GetSandstorm() const
+{
+    return *(float*)0xC812F4;
+}
+
+bool CWeatherSA::SetSandstorm(float fAmount)
+{
+    MemSet((LPVOID)(0x72A4B6 + 1), 0x90, 3);
+    MemSet((LPVOID)(0x72BCEB + 1), 0x90, 3);
+    MemSet((LPVOID)(0x72BD0B + 2), 0x90, 3);
+
+    MemPutFast<float>(0xC812F4, fAmount);
+    return true;
+}
+
+bool CWeatherSA::ResetSandstorm()
+{
+    BYTE originalCodes[3] = {0xF4, 0x12, 0xC8};
+    MemCpy((LPVOID)(0x72A4B6 + 1), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BCEB + 1), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BD0B + 2), &originalCodes, 3);
+    return true;
+}
+
+float CWeatherSA::GetRainbow() const
+{
+    return *(float*)0xC812E4;
+}
+
+bool CWeatherSA::SetRainbow(float fAmount)
+{
+    MemSet((LPVOID)(0x72BF51 + 2), 0x90, 3);
+    MemSet((LPVOID)(0x72BF59 + 2), 0x90, 3);
+
+    MemPutFast<float>(0xC812E4, fAmount);
+    return true;
+}
+
+bool CWeatherSA::ResetRainbow()
+{
+    BYTE originalCodes[3] = {0xE4, 0x12, 0xC8};
+    MemCpy((LPVOID)(0x72BF51 + 2), &originalCodes, 3);
+    MemCpy((LPVOID)(0x72BF59 + 2), &originalCodes, 3);
+    return true;
+}

Client/game_sa/CWeatherSA.h

@@ -26,4 +26,39 @@ class CWeatherSA : public CWeather
     float GetAmountOfRain();
     void  SetAmountOfRain(float fAmount);
     void  ResetAmountOfRain();
+
+    float GetWetRoads() const;
+    bool  SetWetRoads(float fAmount);
+    bool  ResetWetRoads();
+
+    float GetFoggyness() const;
+    bool  SetFoggyness(float fAmount);
+    bool  ResetFoggyness();
+
+    float GetFog() const;
+    bool  SetFog(float fAmount);
+    bool  ResetFog();
+
+    float GetRainFog() const;
+    bool  SetRainFog(float fAmount);
+    bool  ResetRainFog();
+
+    float GetWaterFog() const;
+    bool  SetWaterFog(float fAmount);
+    bool  ResetWaterFog();
+
+    float GetSandstorm() const;
+    bool  SetSandstorm(float fAmount);
+    bool  ResetSandstorm();
+
+    float GetRainbow() const;
+    bool  SetRainbow(float fAmount);
+    bool  ResetRainbow();
+
+private:
+    static unsigned char* VAR_CWeather__ForcedWeatherType;
+    static unsigned char* VAR_CWeather__OldWeatherType;
+    static unsigned char* VAR_CWeather__NewWeatherType;
+    static float*         VAR_CWeather__Rain;
+
 };