Skip to content

Commit eab7ec8

Browse files
Nico8340Dutchman101
Nico8340
authored and
Dutchman101
committed
Refactor bulletsync and add checks (#4381)
1 parent 5c17a80 commit eab7ec8

16 files changed

+640
-462
lines changed

‎Client/mods/deathmatch/logic/CNetAPI.cpp‎

Lines changed: 81 additions & 122 deletions
Original file line numberDiff line numberDiff line change
@@ -128,37 +128,29 @@ bool CNetAPI::ProcessPacket(unsigned char bytePacketID, NetBitStreamInterface& B
128128

129129
case PACKET_ID_PLAYER_BULLETSYNC:
130130
{
131-
// Read out the player ID
132-
ElementID PlayerID;
133-
if (BitStream.Read(PlayerID))
134-
{
135-
// Grab the player
136-
CClientPlayer* pPlayer = m_pPlayerManager->Get(PlayerID);
137-
if (pPlayer)
138-
{
139-
// Read out the bulletsync data
140-
ReadBulletsync(pPlayer, BitStream);
141-
}
142-
}
131+
ElementID id;
132+
if (!BitStream.Read(id))
133+
return true;
134+
135+
auto* player = m_pPlayerManager->Get(id);
136+
if (!player)
137+
return true;
143138

139+
ReadBulletsync(player, BitStream);
144140
return true;
145141
}
146142

147143
case PACKET_ID_WEAPON_BULLETSYNC:
148144
{
149-
// Read out the player ID
150-
ElementID PlayerID;
151-
if (BitStream.Read(PlayerID))
152-
{
153-
// Grab the player
154-
CClientPlayer* pPlayer = m_pPlayerManager->Get(PlayerID);
155-
if (pPlayer)
156-
{
157-
// Read out the bulletsync data
158-
ReadWeaponBulletsync(pPlayer, BitStream);
159-
}
160-
}
145+
ElementID id;
146+
if (!BitStream.Read(id))
147+
return true;
148+
149+
auto* player = m_pPlayerManager->Get(id);
150+
if (!player)
151+
return true;
161152

153+
ReadWeaponBulletsync(player, BitStream);
162154
return true;
163155
}
164156

@@ -2265,152 +2257,119 @@ void CNetAPI::ReadVehiclePartsState(CClientVehicle* pVehicle, NetBitStreamInterf
22652257
static_cast<CDeathmatchVehicle*>(pVehicle)->ResetDamageModelSync();
22662258
}
22672259

2268-
//
2269-
// Read bulletsync packet for a remote player
2270-
//
2271-
void CNetAPI::ReadBulletsync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream)
2260+
void CNetAPI::ReadBulletsync(CClientPlayer* player, NetBitStreamInterface& stream)
22722261
{
2273-
// Read the bulletsync data
2274-
uchar ucWeapon = 0;
2275-
if (!BitStream.Read(ucWeapon) || !CClientWeaponManager::HasWeaponBulletSync(ucWeapon))
2262+
std::uint8_t weapon = 0;
2263+
if (!stream.Read(weapon) || !CClientWeaponManager::HasWeaponBulletSync(weapon))
22762264
return;
22772265

2278-
eWeaponType weaponType = (eWeaponType)ucWeapon;
2266+
const auto type = static_cast<eWeaponType>(weapon);
22792267

2280-
CVector vecStart, vecEnd;
2281-
if (!BitStream.Read((char*)&vecStart, sizeof(CVector)) || !BitStream.Read((char*)&vecEnd, sizeof(CVector)))
2268+
CVector start;
2269+
CVector end;
2270+
if (!stream.Read(reinterpret_cast<char*>(&start), sizeof(CVector)) ||
2271+
!stream.Read(reinterpret_cast<char*>(&end), sizeof(CVector)) ||
2272+
!start.IsValid() || !end.IsValid())
22822273
return;
22832274

2284-
if (!vecStart.IsValid() || !vecEnd.IsValid())
2275+
std::uint8_t order = 0;
2276+
if (!stream.Read(order))
22852277
return;
22862278

2287-
uchar ucOrderCounter = 0;
2288-
if (!BitStream.Read(ucOrderCounter))
2289-
return;
2279+
float damage = 0.0f;
2280+
std::uint8_t zone = 0;
2281+
CClientPlayer* damaged = nullptr;
22902282

2291-
float fDamage = 0;
2292-
uchar ucHitZone = 0;
2293-
CClientPlayer* pDamagedPlayer = NULL;
2294-
if (BitStream.ReadBit())
2283+
if (stream.ReadBit())
22952284
{
2296-
ElementID DamagedPlayerID = INVALID_ELEMENT_ID;
2297-
if (!BitStream.Read(fDamage) || !BitStream.Read(ucHitZone) || !BitStream.Read(DamagedPlayerID))
2285+
ElementID id = INVALID_ELEMENT_ID;
2286+
if (!stream.Read(damage) || !stream.Read(zone) || !stream.Read(id))
22982287
return;
22992288

2300-
pDamagedPlayer = DynamicCast<CClientPlayer>(CElementIDs::GetElement(DamagedPlayerID));
2289+
damaged = DynamicCast<CClientPlayer>(CElementIDs::GetElement(id));
23012290
}
23022291

2303-
// Duplicate bullet check
2304-
{
2305-
bool bIsDuplicate = false;
2292+
bool duplicate = false;
23062293

2307-
// Check if duplicate by comparing with previously sent vectors
2308-
if (vecStart == pPlayer->m_vecPrevBulletSyncStart && vecEnd == pPlayer->m_vecPrevBulletSyncEnd)
2309-
{
2310-
bIsDuplicate = true;
2311-
}
2312-
pPlayer->m_vecPrevBulletSyncStart = vecStart;
2313-
pPlayer->m_vecPrevBulletSyncEnd = vecEnd;
2294+
if (start == player->m_vecPrevBulletSyncStart && end == player->m_vecPrevBulletSyncEnd)
2295+
duplicate = true;
23142296

2315-
// Verify if duplicate by comparing order counter
2316-
char cDif = ucOrderCounter - pPlayer->m_ucPrevBulletSyncOrderCounter;
2317-
if (cDif > 0)
2318-
bIsDuplicate = false;
2297+
player->m_vecPrevBulletSyncStart = start;
2298+
player->m_vecPrevBulletSyncEnd = end;
23192299

2320-
pPlayer->m_ucPrevBulletSyncOrderCounter = ucOrderCounter;
2300+
if (static_cast<char>(order - player->m_ucPrevBulletSyncOrderCounter) > 0)
2301+
duplicate = false;
23212302

2322-
if (bIsDuplicate)
2323-
return;
2324-
}
2303+
player->m_ucPrevBulletSyncOrderCounter = order;
23252304

2326-
pPlayer->DischargeWeapon(weaponType, vecStart, vecEnd, fDamage, ucHitZone, pDamagedPlayer);
2305+
if (duplicate)
2306+
return;
2307+
2308+
player->DischargeWeapon(type, start, end, damage, zone, damaged);
23272309
}
23282310

2329-
//
2330-
// Read bulletsync packet for a remote player
2331-
//
2332-
void CNetAPI::ReadWeaponBulletsync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream)
2311+
void CNetAPI::ReadWeaponBulletsync(CClientPlayer* player, NetBitStreamInterface& stream)
23332312
{
2334-
// Read the bulletsync data
2335-
ElementID elementID;
2336-
if (!BitStream.Read(elementID))
2337-
return;
2338-
2339-
CClientWeapon* pWeapon = DynamicCast<CClientWeapon>(CElementIDs::GetElement(elementID));
2340-
if (!pWeapon || !CClientWeaponManager::HasWeaponBulletSync(pWeapon->GetWeaponType()))
2313+
ElementID id;
2314+
if (!stream.Read(id))
23412315
return;
23422316

2343-
CVector vecStart, vecEnd;
2344-
if (!BitStream.Read((char*)&vecStart, sizeof(CVector)) || !BitStream.Read((char*)&vecEnd, sizeof(CVector)))
2317+
auto* weapon = DynamicCast<CClientWeapon>(CElementIDs::GetElement(id));
2318+
if (!weapon || !CClientWeaponManager::HasWeaponBulletSync(weapon->GetWeaponType()))
23452319
return;
23462320

2347-
if (!vecStart.IsValid() || !vecEnd.IsValid())
2321+
CVector start;
2322+
CVector end;
2323+
if (!stream.Read(reinterpret_cast<char*>(&start), sizeof(CVector)) || !stream.Read(reinterpret_cast<char*>(&end), sizeof(CVector)) || !start.IsValid() ||
2324+
!end.IsValid())
23482325
return;
23492326

2350-
uchar ucOrderCounter = 0;
2351-
if (!BitStream.Read(ucOrderCounter))
2327+
uint8_t order = 0;
2328+
if (!stream.Read(order))
23522329
return;
23532330

2354-
pWeapon->FireInstantHit(vecStart, vecEnd, false, true);
2331+
weapon->FireInstantHit(start, end, false, true);
23552332
}
23562333

2357-
//
2358-
// Send bulletsync fire button press packet to remote players
2359-
//
2360-
void CNetAPI::SendBulletSyncFire(eWeaponType weaponType, const CVector& vecStart, const CVector& vecEnd, float fDamage, uchar ucHitZone,
2361-
CClientPlayer* pRemoteDamagedPlayer)
2334+
void CNetAPI::SendBulletSyncFire(eWeaponType weapon, const CVector& start, const CVector& end, float damage, std::uint8_t zone, CClientPlayer* damaged)
23622335
{
2363-
// Send a bulletsync packet
2364-
NetBitStreamInterface* pBitStream = g_pNet->AllocateNetBitStream();
2365-
2366-
// Write the bulletsync data
2367-
pBitStream->Write((char)weaponType);
2336+
auto* stream = g_pNet->AllocateNetBitStream();
23682337

2369-
pBitStream->Write((const char*)&vecStart, sizeof(CVector));
2370-
pBitStream->Write((const char*)&vecEnd, sizeof(CVector));
2338+
stream->Write(static_cast<char>(weapon));
2339+
stream->Write(reinterpret_cast<const char*>(&start), sizeof(CVector));
2340+
stream->Write(reinterpret_cast<const char*>(&end), sizeof(CVector));
2341+
stream->Write(m_ucBulletSyncOrderCounter++);
23712342

2372-
pBitStream->Write(m_ucBulletSyncOrderCounter++);
2373-
2374-
if (fDamage > 0 && pRemoteDamagedPlayer)
2343+
if (damage > 0.0f && damaged)
23752344
{
2376-
pBitStream->WriteBit(true);
2377-
pBitStream->Write(fDamage);
2378-
pBitStream->Write(ucHitZone);
2379-
pBitStream->Write(pRemoteDamagedPlayer->GetID());
2345+
stream->WriteBit(true);
2346+
stream->Write(damage);
2347+
stream->Write(zone);
2348+
stream->Write(damaged->GetID());
23802349
}
23812350
else
23822351
{
2383-
pBitStream->WriteBit(false);
2352+
stream->WriteBit(false);
23842353
}
23852354

2386-
// Send the packet
2387-
g_pNet->SendPacket(PACKET_ID_PLAYER_BULLETSYNC, pBitStream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
2388-
g_pNet->DeallocateNetBitStream(pBitStream);
2355+
g_pNet->SendPacket(PACKET_ID_PLAYER_BULLETSYNC, stream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
2356+
g_pNet->DeallocateNetBitStream(stream);
23892357
}
23902358

2391-
//
2392-
// Send bulletsync fire button press packet to remote players
2393-
//
2394-
void CNetAPI::SendBulletSyncCustomWeaponFire(CClientWeapon* pWeapon, const CVector& vecStart, const CVector& vecEnd)
2359+
void CNetAPI::SendBulletSyncCustomWeaponFire(CClientWeapon* weapon, const CVector& start, const CVector& end)
23952360
{
2396-
// Ignore old bullet sync stuff
2397-
if (pWeapon->IsLocalEntity())
2361+
if (weapon->IsLocalEntity())
23982362
return;
23992363

2400-
// Send a bulletsync packet
2401-
NetBitStreamInterface* pBitStream = g_pNet->AllocateNetBitStream();
2402-
2403-
// Write the bulletsync data
2404-
pBitStream->Write(pWeapon->GetID());
2405-
2406-
pBitStream->Write((const char*)&vecStart, sizeof(CVector));
2407-
pBitStream->Write((const char*)&vecEnd, sizeof(CVector));
2364+
auto* stream = g_pNet->AllocateNetBitStream();
24082365

2409-
pBitStream->Write(m_ucCustomWeaponBulletSyncOrderCounter++);
2366+
stream->Write(weapon->GetID());
2367+
stream->Write(reinterpret_cast<const char*>(&start), sizeof(CVector));
2368+
stream->Write(reinterpret_cast<const char*>(&end), sizeof(CVector));
2369+
stream->Write(m_ucCustomWeaponBulletSyncOrderCounter++);
24102370

2411-
// Send the packet
2412-
g_pNet->SendPacket(PACKET_ID_WEAPON_BULLETSYNC, pBitStream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
2413-
g_pNet->DeallocateNetBitStream(pBitStream);
2371+
g_pNet->SendPacket(PACKET_ID_WEAPON_BULLETSYNC, stream, PACKET_PRIORITY_MEDIUM, PACKET_RELIABILITY_RELIABLE);
2372+
g_pNet->DeallocateNetBitStream(stream);
24142373
}
24152374

24162375
//

‎Client/mods/deathmatch/logic/CNetAPI.h‎

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -49,9 +49,8 @@ class CNetAPI
4949

5050
void AddInterpolation(const CVector& vecPosition);
5151
bool GetInterpolation(CVector& vecPosition, unsigned short usLatency);
52-
void SendBulletSyncFire(eWeaponType weaponType, const CVector& vecStart, const CVector& vecEnd, float fDamage, uchar ucHitZone,
53-
CClientPlayer* pRemoteDamagedPlayer);
54-
void SendBulletSyncCustomWeaponFire(CClientWeapon* pWeapon, const CVector& vecStart, const CVector& vecEnd);
52+
void SendBulletSyncFire(eWeaponType weapon, const CVector& start, const CVector& end, float damage, std::uint8_t zone, CClientPlayer* damaged);
53+
void SendBulletSyncCustomWeaponFire(CClientWeapon* weapon, const CVector& start, const CVector& end);
5554
bool IsNetworkTrouble() { return m_bIsNetworkTrouble; }
5655

5756
static bool IsWeaponIDAkimbo(unsigned char ucWeaponID);
@@ -64,8 +63,8 @@ class CNetAPI
6463
void ReadKeysync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream);
6564
void WriteKeysync(CClientPed* pPed, NetBitStreamInterface& BitStream);
6665

67-
void ReadBulletsync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream);
68-
void ReadWeaponBulletsync(CClientPlayer* pWeapon, NetBitStreamInterface& BitStream);
66+
void ReadBulletsync(CClientPlayer* player, NetBitStreamInterface& stream);
67+
void ReadWeaponBulletsync(CClientPlayer* player, NetBitStreamInterface& stream);
6968

7069
void ReadPlayerPuresync(CClientPlayer* pPlayer, NetBitStreamInterface& BitStream);
7170
void WritePlayerPuresync(CClientPlayer* pPed, NetBitStreamInterface& BitStream);

0 commit comments

Comments
 (0)