Synchronize changes from 1.6 master branch [ci skip]

45d6996 Refactor bulletsync and add checks (#4381)

Author: github-actions[bot]

Client/mods/deathmatch/logic/CNetAPI.cpp

@@ -128,37 +128,29 @@ bool CNetAPI::ProcessPacket(unsigned char bytePacketID, NetBitStreamInterface& B
 
         case PACKET_ID_PLAYER_BULLETSYNC:
         {
-            // Read out the player ID
-            ElementID PlayerID;
-            if (BitStream.Read(PlayerID))
-            {
-                // Grab the player
-                CClientPlayer* pPlayer = m_pPlayerManager->Get(PlayerID);
-                if (pPlayer)
-                {
-                    // Read out the bulletsync data
-                    ReadBulletsync(pPlayer, BitStream);
-                }
-            }
+            ElementID id;
+            if (!BitStream.Read(id))
+                return true;
+
+            auto* player = m_pPlayerManager->Get(id);
+            if (!player)
+                return true;
 
+            ReadBulletsync(player, BitStream);
             return true;
         }
 
         case PACKET_ID_WEAPON_BULLETSYNC:
         {
-            // Read out the player ID
-            ElementID PlayerID;
-            if (BitStream.Read(PlayerID))
-            {
-                // Grab the player
-                CClientPlayer* pPlayer = m_pPlayerManager->Get(PlayerID);
-                if (pPlayer)
-                {
-                    // Read out the bulletsync data
-                    ReadWeaponBulletsync(pPlayer, BitStream);
-                }
-            }
+            ElementID id;
+            if (!BitStream.Read(id))
+                return true;
+
+            auto* player = m_pPlayerManager->Get(id);
+            if (!player)
+                return true;
 
+            ReadWeaponBulletsync(player, BitStream);
             return true;
         }
 
@@ -2230,152 +2222,119 @@ void CNetAPI::ReadVehiclePartsState(CClientVehicle* pVehicle, NetBitStreamInterf
     static_cast<CDeathmatchVehicle*>(pVehicle)->ResetDamageModelSync();
 }
 
-//
-// Read bulletsync packet for a remote player
-//
-void CNetAPI::ReadBulletsync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream)
+void CNetAPI::ReadBulletsync(CClientPlayer* player, NetBitStreamInterface& stream)
 {
-    // Read the bulletsync data
-    uchar ucWeapon = 0;
-    if (!BitStream.Read(ucWeapon) || !CClientWeaponManager::HasWeaponBulletSync(ucWeapon))
+    std::uint8_t weapon = 0;
+    if (!stream.Read(weapon) || !CClientWeaponManager::HasWeaponBulletSync(weapon))
         return;
 
-    eWeaponType weaponType = (eWeaponType)ucWeapon;
+    const auto type = static_cast<eWeaponType>(weapon);
 
-    CVector vecStart, vecEnd;
-    if (!BitStream.Read((char*)&vecStart, sizeof(CVector)) || !BitStream.Read((char*)&vecEnd, sizeof(CVector)))
+    CVector start;
+    CVector end;
+    if (!stream.Read(reinterpret_cast<char*>(&start), sizeof(CVector)) ||
+        !stream.Read(reinterpret_cast<char*>(&end), sizeof(CVector)) ||
+        !start.IsValid() || !end.IsValid())
         return;
 
-    if (!vecStart.IsValid() || !vecEnd.IsValid())
+    std::uint8_t order = 0;
+    if (!stream.Read(order))
         return;
 
-    uchar ucOrderCounter = 0;
-    if (!BitStream.Read(ucOrderCounter))
-        return;
+    float          damage = 0.0f;
+    std::uint8_t   zone = 0;
+    CClientPlayer* damaged = nullptr;
 
-    float          fDamage = 0;
-    uchar          ucHitZone = 0;
-    CClientPlayer* pDamagedPlayer = NULL;
-    if (BitStream.ReadBit())
+    if (stream.ReadBit())
     {
-        ElementID DamagedPlayerID = INVALID_ELEMENT_ID;
-        if (!BitStream.Read(fDamage) || !BitStream.Read(ucHitZone) || !BitStream.Read(DamagedPlayerID))
+        ElementID id = INVALID_ELEMENT_ID;
+        if (!stream.Read(damage) || !stream.Read(zone) || !stream.Read(id))
             return;
 
-        pDamagedPlayer = DynamicCast<CClientPlayer>(CElementIDs::GetElement(DamagedPlayerID));
+        damaged = DynamicCast<CClientPlayer>(CElementIDs::GetElement(id));
     }
 
-    // Duplicate bullet check
-    {
-        bool bIsDuplicate = false;
+    bool duplicate = false;
 
-        // Check if duplicate by comparing with previously sent vectors
-        if (vecStart == pPlayer->m_vecPrevBulletSyncStart && vecEnd == pPlayer->m_vecPrevBulletSyncEnd)
-        {
-            bIsDuplicate = true;
-        }
-        pPlayer->m_vecPrevBulletSyncStart = vecStart;
-        pPlayer->m_vecPrevBulletSyncEnd = vecEnd;
+    if (start == player->m_vecPrevBulletSyncStart && end == player->m_vecPrevBulletSyncEnd)
+        duplicate = true;
 
-        // Verify if duplicate by comparing order counter
-        char cDif = ucOrderCounter - pPlayer->m_ucPrevBulletSyncOrderCounter;
-        if (cDif > 0)
-            bIsDuplicate = false;
+    player->m_vecPrevBulletSyncStart = start;
+    player->m_vecPrevBulletSyncEnd = end;
 
-        pPlayer->m_ucPrevBulletSyncOrderCounter = ucOrderCounter;
+    if (static_cast<char>(order - player->m_ucPrevBulletSyncOrderCounter) > 0)
+        duplicate = false;
 
-        if (bIsDuplicate)
-            return;
-    }
+    player->m_ucPrevBulletSyncOrderCounter = order;
 
-    pPlayer->DischargeWeapon(weaponType, vecStart, vecEnd, fDamage, ucHitZone, pDamagedPlayer);
+    if (duplicate)
+        return;
+
+    player->DischargeWeapon(type, start, end, damage, zone, damaged);
 }
 
-//
-// Read bulletsync packet for a remote player
-//
-void CNetAPI::ReadWeaponBulletsync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream)
+void CNetAPI::ReadWeaponBulletsync(CClientPlayer* player, NetBitStreamInterface& stream)
 {
-    // Read the bulletsync data
-    ElementID elementID;
-    if (!BitStream.Read(elementID))
-        return;
-
-    CClientWeapon* pWeapon = DynamicCast<CClientWeapon>(CElementIDs::GetElement(elementID));
-    if (!pWeapon || !CClientWeaponManager::HasWeaponBulletSync(pWeapon->GetWeaponType()))
+    ElementID id;
+    if (!stream.Read(id))
         return;
 
-    CVector vecStart, vecEnd;
-    if (!BitStream.Read((char*)&vecStart, sizeof(CVector)) || !BitStream.Read((char*)&vecEnd, sizeof(CVector)))
+    auto* weapon = DynamicCast<CClientWeapon>(CElementIDs::GetElement(id));
+    if (!weapon || !CClientWeaponManager::HasWeaponBulletSync(weapon->GetWeaponType()))
         return;
 
-    if (!vecStart.IsValid() || !vecEnd.IsValid())
+    CVector start;
+    CVector end;
+    if (!stream.Read(reinterpret_cast<char*>(&start), sizeof(CVector)) || !stream.Read(reinterpret_cast<char*>(&end), sizeof(CVector)) || !start.IsValid() ||
+        !end.IsValid())
         return;
 
-    uchar ucOrderCounter = 0;
-    if (!BitStream.Read(ucOrderCounter))
+    uint8_t order = 0;
+    if (!stream.Read(order))
         return;
 
-    pWeapon->FireInstantHit(vecStart, vecEnd, false, true);
+    weapon->FireInstantHit(start, end, false, true);
 }
 
-//
-// Send bulletsync fire button press packet to remote players
-//
-void CNetAPI::SendBulletSyncFire(eWeaponType weaponType, const CVector& vecStart, const CVector& vecEnd, float fDamage, uchar ucHitZone,
-                                 CClientPlayer* pRemoteDamagedPlayer)
+void CNetAPI::SendBulletSyncFire(eWeaponType weapon, const CVector& start, const CVector& end, float damage, std::uint8_t zone, CClientPlayer* damaged)
 {
-    // Send a bulletsync packet
-    NetBitStreamInterface* pBitStream = g_pNet->AllocateNetBitStream();
-
-    // Write the bulletsync data
-    pBitStream->Write((char)weaponType);
+    auto* stream = g_pNet->AllocateNetBitStream();
 
-    pBitStream->Write((const char*)&vecStart, sizeof(CVector));
-    pBitStream->Write((const char*)&vecEnd, sizeof(CVector));
+    stream->Write(static_cast<char>(weapon));
+    stream->Write(reinterpret_cast<const char*>(&start), sizeof(CVector));
+    stream->Write(reinterpret_cast<const char*>(&end), sizeof(CVector));
+    stream->Write(m_ucBulletSyncOrderCounter++);
 
-    pBitStream->Write(m_ucBulletSyncOrderCounter++);
-
-    if (fDamage > 0 && pRemoteDamagedPlayer)
+    if (damage > 0.0f && damaged)
     {
-        pBitStream->WriteBit(true);
-        pBitStream->Write(fDamage);
-        pBitStream->Write(ucHitZone);
-        pBitStream->Write(pRemoteDamagedPlayer->GetID());
+        stream->WriteBit(true);
+        stream->Write(damage);
+        stream->Write(zone);
+        stream->Write(damaged->GetID());
     }
     else
     {
-        pBitStream->WriteBit(false);
+        stream->WriteBit(false);
     }
 
-    // Send the packet
-    g_pNet->SendPacket(PACKET_ID_PLAYER_BULLETSYNC, pBitStream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
-    g_pNet->DeallocateNetBitStream(pBitStream);
+    g_pNet->SendPacket(PACKET_ID_PLAYER_BULLETSYNC, stream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
+    g_pNet->DeallocateNetBitStream(stream);
 }
 
-//
-// Send bulletsync fire button press packet to remote players
-//
-void CNetAPI::SendBulletSyncCustomWeaponFire(CClientWeapon* pWeapon, const CVector& vecStart, const CVector& vecEnd)
+void CNetAPI::SendBulletSyncCustomWeaponFire(CClientWeapon* weapon, const CVector& start, const CVector& end)
 {
-    // Ignore old bullet sync stuff
-    if (pWeapon->IsLocalEntity())
+    if (weapon->IsLocalEntity())
         return;
 
-    // Send a bulletsync packet
-    NetBitStreamInterface* pBitStream = g_pNet->AllocateNetBitStream();
-
-    // Write the bulletsync data
-    pBitStream->Write(pWeapon->GetID());
-
-    pBitStream->Write((const char*)&vecStart, sizeof(CVector));
-    pBitStream->Write((const char*)&vecEnd, sizeof(CVector));
+    auto* stream = g_pNet->AllocateNetBitStream();
 
-    pBitStream->Write(m_ucCustomWeaponBulletSyncOrderCounter++);
+    stream->Write(weapon->GetID());
+    stream->Write(reinterpret_cast<const char*>(&start), sizeof(CVector));
+    stream->Write(reinterpret_cast<const char*>(&end), sizeof(CVector));
+    stream->Write(m_ucCustomWeaponBulletSyncOrderCounter++);
 
-    // Send the packet
-    g_pNet->SendPacket(PACKET_ID_WEAPON_BULLETSYNC, pBitStream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
-    g_pNet->DeallocateNetBitStream(pBitStream);
+    g_pNet->SendPacket(PACKET_ID_WEAPON_BULLETSYNC, stream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
+    g_pNet->DeallocateNetBitStream(stream);
 }
 
 //

Client/mods/deathmatch/logic/CNetAPI.h

@@ -49,9 +49,8 @@ class CNetAPI
 
     void AddInterpolation(const CVector& vecPosition);
     bool GetInterpolation(CVector& vecPosition, unsigned short usLatency);
-    void SendBulletSyncFire(eWeaponType weaponType, const CVector& vecStart, const CVector& vecEnd, float fDamage, uchar ucHitZone,
-                            CClientPlayer* pRemoteDamagedPlayer);
-    void SendBulletSyncCustomWeaponFire(CClientWeapon* pWeapon, const CVector& vecStart, const CVector& vecEnd);
+    void SendBulletSyncFire(eWeaponType weapon, const CVector& start, const CVector& end, float damage, std::uint8_t zone, CClientPlayer* damaged);
+    void SendBulletSyncCustomWeaponFire(CClientWeapon* weapon, const CVector& start, const CVector& end);
     bool IsNetworkTrouble() { return m_bIsNetworkTrouble; }
 
     static bool IsWeaponIDAkimbo(unsigned char ucWeaponID);
@@ -64,8 +63,8 @@ class CNetAPI
     void ReadKeysync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream);
     void WriteKeysync(CClientPed* pPed, NetBitStreamInterface& BitStream);
 
-    void ReadBulletsync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream);
-    void ReadWeaponBulletsync(CClientPlayer* pWeapon, NetBitStreamInterface& BitStream);
+    void ReadBulletsync(CClientPlayer* player, NetBitStreamInterface& stream);
+    void ReadWeaponBulletsync(CClientPlayer* player, NetBitStreamInterface& stream);
 
     void ReadPlayerPuresync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream);
     void WritePlayerPuresync(CClientPlayer* pPed, NetBitStreamInterface& BitStream);