@@ -1398,41 +1398,17 @@ static CScenarioInfo* GetTaskScenarioInfo(void* task)
1398
1398
1399
1399
static constexpr int kPlayerNetIdLength = 16 ;
1400
1400
1401
- namespace rage
1402
- {
1403
- struct CSyncDataBase
1404
- {
1405
- char m_pad[24 ];
1406
- };
1407
-
1408
- struct CSyncDataReader : CSyncDataBase
1409
- {
1410
- datBitBuffer* m_buffer;
1411
- };
1412
-
1413
- struct CSyncDataWriter : CSyncDataBase
1414
- {
1415
- datBitBuffer* m_buffer;
1416
- };
1417
-
1418
- struct CSyncDataSizeCalculator : CSyncDataBase
1419
- {
1420
- uint32_t m_size;
1421
- };
1422
- }
1423
-
1424
- static hook::cdecl_stub<void (rage::CSyncDataBase*, uint8_t *, char *)> _syncDataBaseSerializePlayerIndex ([]()
1401
+ static hook::cdecl_stub<void (rage::CSyncDataBase*, uint8_t *, char *)> _syncDataBase_SerializePlayerIndex ([]()
1425
1402
{
1426
1403
return hook::get_call (hook::get_pattern (" 0F B6 12 48 8B 05 ? ? ? ? 44" , 0x1D ));
1427
1404
});
1428
1405
1429
- static void (*g_origSyncDataReaderSerializePlayerIndex)(rage::CSyncDataReader*, uint8_t *, char *);
1430
-
1431
- static void SyncDataReaderSerializePlayerIndex (rage::CSyncDataReader* syncData, uint8_t * index, char * prefix)
1406
+ static void (*g_origSyncDataReader_SerializePlayerIndex)(rage::CSyncDataReader*, uint8_t *, char *);
1407
+ static void SyncDataReader_SerializePlayerIndex (rage::CSyncDataReader* syncData, uint8_t * index, char * prefix)
1432
1408
{
1433
1409
if (!icgi->OneSyncEnabled )
1434
1410
{
1435
- return g_origSyncDataReaderSerializePlayerIndex (syncData, index, prefix);
1411
+ return g_origSyncDataReader_SerializePlayerIndex (syncData, index, prefix);
1436
1412
}
1437
1413
1438
1414
uint32_t playerNetId = -1 ;
@@ -1448,16 +1424,15 @@ static void SyncDataReaderSerializePlayerIndex(rage::CSyncDataReader* syncData,
1448
1424
1449
1425
*index = playerIndex;
1450
1426
1451
- _syncDataBaseSerializePlayerIndex (syncData, index, prefix);
1427
+ _syncDataBase_SerializePlayerIndex (syncData, index, prefix);
1452
1428
}
1453
1429
1454
- static void (*g_origSyncDataWriterSerializePlayerIndex)(rage::CSyncDataWriter*, uint8_t *, char *);
1455
-
1456
- static void SyncDataWriterSerializePlayerIndex (rage::CSyncDataWriter* syncData, uint8_t * index, char * prefix)
1430
+ static void (*g_origSyncDataWriter_SerializePlayerIndex)(rage::CSyncDataWriter*, uint8_t *, char *);
1431
+ static void SyncDataWriter_SerializePlayerIndex (rage::CSyncDataWriter * syncData, uint8_t * index, char * prefix)
1457
1432
{
1458
1433
if (!icgi->OneSyncEnabled )
1459
1434
{
1460
- return g_origSyncDataWriterSerializePlayerIndex (syncData, index, prefix);
1435
+ return g_origSyncDataWriter_SerializePlayerIndex (syncData, index, prefix);
1461
1436
}
1462
1437
1463
1438
uint16_t playerNetId = -1 ;
@@ -1467,25 +1442,98 @@ static void SyncDataWriterSerializePlayerIndex(rage::CSyncDataWriter* syncData,
1467
1442
playerNetId = g_netIdsByPlayer[player];
1468
1443
}
1469
1444
1470
- _syncDataBaseSerializePlayerIndex (syncData, index, prefix);
1445
+ _syncDataBase_SerializePlayerIndex (syncData, index, prefix);
1471
1446
1472
1447
syncData->m_buffer ->WriteUns (playerNetId, kPlayerNetIdLength );
1473
1448
}
1474
1449
1475
- static void (*g_origSyncDataSizeCalculatorSerializePlayerIndex)(rage::CSyncDataSizeCalculator*);
1476
-
1477
- static void SyncDataSizeCalculatorSerializePlayerIndex (rage::CSyncDataSizeCalculator* syncData)
1450
+ static void (*g_origSyncDataSizeCalculator_SerializePlayerIndex)(rage::CSyncDataSizeCalculator*);
1451
+ static void SyncDataSizeCalculator_SerializePlayerIndex (rage::CSyncDataSizeCalculator* syncData)
1478
1452
{
1479
1453
static_assert (offsetof (rage::CSyncDataSizeCalculator, m_size) == 0x18 );
1480
1454
1481
1455
if (!icgi->OneSyncEnabled )
1482
1456
{
1483
- return g_origSyncDataSizeCalculatorSerializePlayerIndex (syncData);
1457
+ return g_origSyncDataSizeCalculator_SerializePlayerIndex (syncData);
1484
1458
}
1485
1459
1486
1460
syncData->m_size += kPlayerNetIdLength ;
1487
1461
}
1488
1462
1463
+ static void (*g_origSyncDataSizeCalculator_SerializeObjectId)(rage::CSyncDataSizeCalculator*);
1464
+ static void SyncDataSizeCalculator_SerializeObjectId (rage::CSyncDataSizeCalculator* syncData)
1465
+ {
1466
+ if (!icgi->OneSyncEnabled )
1467
+ {
1468
+ return g_origSyncDataSizeCalculator_SerializeObjectId (syncData);
1469
+ }
1470
+
1471
+ syncData->m_size += (icgi->OneSyncBigIdEnabled ? 16 : 13 );
1472
+ }
1473
+
1474
+ static hook::cdecl_stub<void (rage::CSyncDataBase*, uint16_t *, char *)> _syncDataBaseSerializeObjectId ([]()
1475
+ {
1476
+ return hook::get_call (hook::get_pattern (" 0F B7 03 B9 3F 1F 00 00 66 FF C8 66 3B C1 76 04" , -5 ));
1477
+ });
1478
+
1479
+ static void (*g_origSyncDataWriter_SerializeObjectIdPrefix)(rage::CSyncDataWriter*, uint16_t *, char *);
1480
+ static void SyncDataWriter_SerializeObjectIdPrefix (rage::CSyncDataWriter* syncData, uint16_t * objectId, char * prefix)
1481
+ {
1482
+ if (!icgi->OneSyncEnabled )
1483
+ {
1484
+ return g_origSyncDataWriter_SerializeObjectIdPrefix (syncData, objectId, prefix);
1485
+ }
1486
+
1487
+ _syncDataBaseSerializeObjectId (syncData, objectId, prefix);
1488
+
1489
+ syncData->m_buffer ->WriteUns (*objectId, icgi->OneSyncBigIdEnabled ? 16 : 13 );
1490
+ }
1491
+
1492
+ static void (*g_origSyncDataReader_SerializeObjectIdPrefix)(rage::CSyncDataReader*, uint16_t *, char *);
1493
+ static void SyncDataReader_SerializeObjectIdPrefix (rage::CSyncDataReader* syncData, uint16_t * objectId, char * prefix)
1494
+ {
1495
+ if (!icgi->OneSyncEnabled )
1496
+ {
1497
+ return g_origSyncDataReader_SerializeObjectIdPrefix (syncData, objectId, prefix);
1498
+ }
1499
+
1500
+ uint32_t netObjectId = 0 ;
1501
+
1502
+ if (syncData->m_buffer ->ReadInteger (&netObjectId, icgi->OneSyncBigIdEnabled ? 16 : 13 ))
1503
+ {
1504
+ *objectId = netObjectId;
1505
+ }
1506
+
1507
+ _syncDataBaseSerializeObjectId (syncData, objectId, prefix);
1508
+ }
1509
+
1510
+ static void (*g_origSyncDataWriter_SerializeObjectIdStatic)(rage::CSyncDataWriter*, uint16_t *);
1511
+ static void SyncDataWriter_SerializeObjectIdStatic (rage::CSyncDataWriter* syncData, uint16_t * objectId)
1512
+ {
1513
+ if (!icgi->OneSyncEnabled )
1514
+ {
1515
+ return g_origSyncDataWriter_SerializeObjectIdStatic (syncData, objectId);
1516
+ }
1517
+
1518
+ syncData->m_buffer ->WriteUns (*objectId, icgi->OneSyncBigIdEnabled ? 16 : 13 );
1519
+ }
1520
+
1521
+ static void (*g_origSyncDataReader_SerializeObjectIdStatic)(rage::CSyncDataReader*, uint16_t *);
1522
+ static void SyncDataReader_SerializeObjectIdStatic (rage::CSyncDataReader* syncData, uint16_t * objectId)
1523
+ {
1524
+ if (!icgi->OneSyncEnabled )
1525
+ {
1526
+ return g_origSyncDataReader_SerializeObjectIdStatic (syncData, objectId);
1527
+ }
1528
+
1529
+ uint32_t netObjectId = 0 ;
1530
+
1531
+ if (syncData->m_buffer ->ReadInteger (&netObjectId, icgi->OneSyncBigIdEnabled ? 16 : 13 ))
1532
+ {
1533
+ *objectId = netObjectId;
1534
+ }
1535
+ }
1536
+
1489
1537
static rlGamerInfo* (*g_origNetGamePlayerGetGamerInfo)(CNetGamePlayer*);
1490
1538
1491
1539
static rlGamerInfo* NetGamePlayerGetGamerInfo (CNetGamePlayer* self)
@@ -2024,22 +2072,43 @@ static HookFunction hookFunction([]()
2024
2072
hook::call (location, playerPedGetterStub.GetCode ());
2025
2073
}
2026
2074
2027
- // patch SerializePlayerIndex methods of sync data reader/writer
2028
- MH_CreateHook (hook::get_pattern (" 80 3B 20 73 ? 65 4C 8B 0C" , -0x2F ), SyncDataReaderSerializePlayerIndex, (void **)&g_origSyncDataReaderSerializePlayerIndex);
2029
- MH_CreateHook (xbr::IsGameBuildOrGreater<1436 >() ? hook::get_pattern (" 41 B2 3F 48 8D 54 24 30 44 88" , -30 ) : hook::get_pattern (" 80 3A 20 48 8B D9 C6 44" , -6 ), SyncDataWriterSerializePlayerIndex, (void **)&g_origSyncDataWriterSerializePlayerIndex);
2075
+ // CSyncedDataWriter/CSyncedDataReader::SerializeObjectID (static).
2076
+ MH_CreateHook (hook::get_pattern (" 66 3B C1 76 ? 33 C0 EB ? 0F B7 0A" , -0xE ), SyncDataWriter_SerializeObjectIdStatic, (void **)&g_origSyncDataWriter_SerializeObjectIdStatic);
2077
+ MH_CreateHook (hook::get_call (hook::get_pattern (" E8 ? ? ? ? 48 8D 53 0A" )), SyncDataReader_SerializeObjectIdStatic, (void **)&g_origSyncDataReader_SerializeObjectIdStatic);
2078
+
2079
+ // CSyncedDataWriter/CSyncedDataReader::SerializeObjectID (prefixed).
2080
+ MH_CreateHook (hook::get_pattern (" E8 ? ? ? ? 0F B7 03 B9" , -0x10 ), SyncDataWriter_SerializeObjectIdPrefix, (void **)&g_origSyncDataWriter_SerializeObjectIdPrefix);
2081
+ MH_CreateHook (hook::get_pattern (" B9 ? ? ? ? 49 8B 04 ? 8A 14 01" , xbr::IsGameBuildOrGreater<1491 >() ? -0x36 : -0x3E ), SyncDataReader_SerializeObjectIdPrefix, (void **)&g_origSyncDataReader_SerializeObjectIdPrefix);
2030
2082
2031
- // also patch sync data size calculator allowing more bits
2083
+ // patch sync data size calculator allowing more bits
2032
2084
{
2033
- auto sizeCalculatorVtable = hook::get_address<uintptr_t *>(hook::get_pattern (" B8 BF FF 00 00 48 8B CF 66 21 87" , 27 ));
2034
- g_origSyncDataSizeCalculatorSerializePlayerIndex = (decltype (g_origSyncDataSizeCalculatorSerializePlayerIndex))sizeCalculatorVtable[25 ];
2035
- hook::put (&sizeCalculatorVtable[25 ], (uintptr_t )SyncDataSizeCalculatorSerializePlayerIndex);
2085
+ static constexpr int kSizeCalculatorSerializePlayerIndex = 25 ;
2086
+ static constexpr int kSizeCalculatorSerializeObjectId1 = 26 ;
2087
+ static constexpr int kSizeCalculatorSerializeObjectId2 = 27 ;
2088
+ static constexpr int kSizeCalculatorSerializeObjectId3 = 28 ;
2089
+
2090
+ const auto sizeCalculatorVtable = hook::get_address<uintptr_t *>(hook::get_pattern (" B8 BF FF 00 00 48 8B CF 66 21 87" , 27 ));
2091
+
2092
+ g_origSyncDataSizeCalculator_SerializePlayerIndex = (decltype (g_origSyncDataSizeCalculator_SerializePlayerIndex))sizeCalculatorVtable[kSizeCalculatorSerializePlayerIndex ];
2093
+ hook::put (&sizeCalculatorVtable[kSizeCalculatorSerializePlayerIndex ], (uintptr_t )SyncDataSizeCalculator_SerializePlayerIndex);
2094
+
2095
+ g_origSyncDataSizeCalculator_SerializeObjectId = (decltype (g_origSyncDataSizeCalculator_SerializeObjectId))sizeCalculatorVtable[kSizeCalculatorSerializeObjectId1 ];
2096
+ hook::put (&sizeCalculatorVtable[kSizeCalculatorSerializeObjectId1 ], (uintptr_t )SyncDataSizeCalculator_SerializeObjectId);
2097
+ hook::put (&sizeCalculatorVtable[kSizeCalculatorSerializeObjectId2 ], (uintptr_t )SyncDataSizeCalculator_SerializeObjectId);
2098
+ hook::put (&sizeCalculatorVtable[kSizeCalculatorSerializeObjectId3 ], (uintptr_t )SyncDataSizeCalculator_SerializeObjectId);
2036
2099
}
2037
2100
2101
+ // patch SerializePlayerIndex methods of sync data reader/writer
2102
+ MH_CreateHook (hook::get_pattern (" 80 3B 20 73 ? 65 4C 8B 0C" , -0x2F ), SyncDataReader_SerializePlayerIndex, (void **)&g_origSyncDataReader_SerializePlayerIndex);
2103
+ MH_CreateHook (xbr::IsGameBuildOrGreater<1436 >() ? hook::get_pattern (" 41 B2 3F 48 8D 54 24 30 44 88" , -30 ) : hook::get_pattern (" 80 3A 20 48 8B D9 C6 44" , -6 ), SyncDataWriter_SerializePlayerIndex, (void **)&g_origSyncDataWriter_SerializePlayerIndex);
2104
+
2038
2105
// attempt to get some information about CNetGamePlayer::GetGamerInfo related crashes
2039
2106
{
2107
+ static constexpr int kNetGamePlayerGetGamerInfoIndex = 12 ;
2108
+
2040
2109
auto netGamePlayerVtable = hook::get_address<uintptr_t *>(hook::get_pattern (" E8 ? ? ? ? 33 F6 48 8D 05 ? ? ? ? 48 8D 8B" , 10 ));
2041
- g_origNetGamePlayerGetGamerInfo = (decltype (g_origNetGamePlayerGetGamerInfo))netGamePlayerVtable[12 ];
2042
- hook::put (&netGamePlayerVtable[12 ], (uintptr_t )NetGamePlayerGetGamerInfo);
2110
+ g_origNetGamePlayerGetGamerInfo = (decltype (g_origNetGamePlayerGetGamerInfo))netGamePlayerVtable[kNetGamePlayerGetGamerInfoIndex ];
2111
+ hook::put (&netGamePlayerVtable[kNetGamePlayerGetGamerInfoIndex ], (uintptr_t )NetGamePlayerGetGamerInfo);
2043
2112
}
2044
2113
2045
2114
// patch CAIConditionIsLocalPlayerVisibleToAnyPlayer behavior to properly handle scoping players
@@ -2422,14 +2491,6 @@ static void SkipCopyIf1s(void* a1, void* a2, void* a3, void* a4, void* a5)
2422
2491
}
2423
2492
}
2424
2493
2425
- #ifdef IS_RDR3
2426
- static uint64_t CSyncedVarBase__GetMaxBits (void * self)
2427
- {
2428
- // object id length + 1 extra bit
2429
- return ((icgi->OneSyncBigIdEnabled ) ? 16 : 13 ) + 1 ;
2430
- }
2431
- #endif
2432
-
2433
2494
static HookFunction hookFunction2 ([]()
2434
2495
{
2435
2496
// 2 matches, 1st is data, 2nd is parent
@@ -2457,7 +2518,6 @@ static HookFunction hookFunction2([]()
2457
2518
auto location = hook::get_pattern<char >(" 49 89 43 C8 E8 ? ? ? ? 84 C0 0F 95 C0 48 83 C4 58" , -0x3E );
2458
2519
hook::set_call (&g_origWriteDataNode, location + 0x42 );
2459
2520
#endif
2460
-
2461
2521
hook::jump (location, WriteDataNodeStub);
2462
2522
#endif
2463
2523
}
0 commit comments