IlDivinoGlade

GTA V 1.27 – Random Stuff 2

Jul 16th, 2025 (edited)
495
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 21.09 KB | None | 0 0
  1. struct CFriendsMenu {
  2.     char padding[0x44];
  3.     char name[0x14];//0x44
  4.     char region[0x8];//0x58
  5. };
  6.  
  7. struct GameScriptId {
  8.     uint32_t unknown;
  9.     char scriptName[32];
  10. };
  11.  
  12. struct GameThread {
  13.     uint32_t threadID;
  14.     uint32_t nameHash;
  15.     char pad_0[0x54 - 0xC];
  16.     void* localData;
  17.     char pad_1[0x68 - 0x58];
  18.     char threadName[24];
  19.  
  20. };
  21.  
  22. struct GameScriptHandlerNetwork {
  23.     char pad_0[0x8];                             // 0x4
  24.     GameThread* associatedThread;                // 0xC
  25.     char pad_1[0x14];                            // 0x10
  26.     GameScriptHandlerNetComponent* syncPlayers;  // 0x24
  27.     char pad_2[0x30];                            // 0x28
  28.     GameScriptHandlerNetComponent* syncHost;     // 0x58
  29.     char pad_3[0x10];                            // 0x5C
  30.     GameScriptId scriptId;                       // 0x6C
  31. };
  32.  
  33. struct GameScriptHandlerNetComponent {
  34. public:
  35.     GameScriptHandlerNetwork* parentHandler; // 0x4
  36.     uint32_t unknown1;                       // 0x8
  37. };
  38.  
  39.  
  40.  
  41.  
  42.  
  43. /*
  44. tip: use 0x1850C9C for change server, example: writeString(0x1850C9C, "gta.Server.net");
  45. use when you're in session. It could be don't work bc when you change server, as I listen, server have different game saves. So it could be don't work
  46. */
  47.  
  48.  
  49.  
  50.  
  51. class datBitBuffer
  52. {
  53. public:
  54.     inline datBitBuffer(uint8_t* data, uint32_t size)
  55.     {
  56.         m_data = data;
  57.         m_f8 = 0;
  58.         m_maxBit = size * 8;
  59.         m_unkBit = 0;
  60.         m_curBit = 0;
  61.         m_unk2Bit = 0;
  62.         m_flagBits = 0;
  63.     }
  64.  
  65.     inline uint32_t GetPosition()
  66.     {
  67.         return m_unkBit;
  68.     }
  69.  
  70.     inline bool Seek(uint32_t bits)
  71.     {
  72.         if (bits >= 0)
  73.         {
  74.             uint32_t length = (m_flagBits & 1) ? m_maxBit : m_curBit;
  75.  
  76.             if (bits <= length)
  77.             {
  78.                 m_unkBit = bits;
  79.             }
  80.         }
  81.  
  82.         return false;
  83.     }
  84.  
  85.     inline int GetDataLength()
  86.     {
  87.         int leftoverBit = (m_curBit % 8) ? 1 : 0;
  88.  
  89.         return (m_curBit / 8) + leftoverBit;
  90.     }
  91.  
  92.     inline bool ReadByte(uint8_t* integer, int bits)
  93.     {
  94.         //uint32_t read;
  95.         //if (big::g_pointers->m_read_bitbuf_dword(this, &read, bits))
  96.         //{
  97.         //  *integer = read;
  98.         //  return true;
  99.         //}
  100.         return false;
  101.     }
  102.  
  103.     inline bool ReadWord(uint16_t* integer, int bits)
  104.     {
  105.         //uint32_t read;
  106.         //if (big::g_pointers->m_read_bitbuf_dword(this, &read, bits))
  107.         //{
  108.         //  *integer = read;
  109.         //  return true;
  110.         //}
  111.         return false;
  112.     }
  113.  
  114.     inline bool ReadDword(uint32_t* integer, int bits)
  115.     {
  116.         return false;// big::g_pointers->m_read_bitbuf_dword(this, integer, bits);
  117.     }
  118.  
  119.     inline bool ReadInt32(int32_t* integer, int bits)
  120.     {
  121.         int32_t v8;
  122.         int32_t v9;
  123.         if (ReadDword((uint32_t*)&v8, 1u) && ReadDword((uint32_t*)&v9, bits - 1))
  124.         {
  125.             *integer = v8 + (v9 ^ -v8);
  126.             return true;
  127.         }
  128.         return false;
  129.     }
  130.  
  131.     inline bool ReadQWord(uint64_t* integer, int bits)
  132.     {
  133.         if (bits <= 32)
  134.         {
  135.             uint32_t v10{};
  136.             if (ReadDword(&v10, bits))
  137.             {
  138.                 *integer = v10;
  139.                 return true;
  140.             }
  141.             return false;
  142.         }
  143.         else
  144.         {
  145.             uint32_t v10{}, v11{};
  146.             if (ReadDword(&v11, 32u) && ReadDword(&v10, bits - 32u))
  147.             {
  148.                 *integer = v11 | ((uint64_t)v10 << 32);
  149.                 return true;
  150.             }
  151.             return false;
  152.         }
  153.     }
  154.  
  155.     inline bool ReadInt64(int64_t* integer, int bits)
  156.     {
  157.         uint32_t v8;
  158.         uint64_t v9;
  159.         if (ReadDword(&v8, 1u) && ReadQWord(&v9, bits - 1))
  160.         {
  161.             *integer = v8 + (v9 ^ -(int64_t)v8);
  162.             return true;
  163.         }
  164.         return false;
  165.     }
  166.  
  167.     inline bool ReadArray(void* array, int size)
  168.     {
  169.         return false;// big::g_pointers->m_read_bitbuf_array(this, array, size, 0);
  170.     }
  171.  
  172. public:
  173.     uint8_t* m_data; //0x0000
  174.     uint32_t m_f8; //0x0008
  175.     int32_t m_maxBit; //0x000C
  176.     int32_t m_unkBit; //0x0010
  177.     uint32_t m_curBit; //0x0014
  178.     uint32_t m_unk2Bit; //0x0018
  179.     uint8_t m_flagBits; //0x001C
  180. };
  181.  
  182.  
  183. typedef struct NetObject
  184. {
  185.     char pad_00[0x40];
  186.     void* owner;         // +0x40
  187.     uint32_t timestamp;  // +0x48
  188.     uint16_t syncCount;  // +0x4C
  189.     uint16_t syncFlag;   // +0x4E
  190.     char pad_50[0x08];
  191.     uint8_t* syncBuffer; // +0x58
  192. } NetObject;
  193.  
  194. class netSyncTree {
  195. public:
  196.     char pad_0000[48]; //0x0000
  197.     class netSyncTreeNode* m_sync_tree_node; //0x0030
  198. }; //Size: 0x0038
  199.  
  200.  
  201. class netSyncTreeNode {
  202. public:
  203.     char pad_0000[192]; //0x0000
  204.     uint32_t m_player_model; //0x00C0
  205.     uint32_t m_ped_model; //0x00C4
  206.     uint32_t m_vehicle_model; //0x00C8
  207.     char pad_00CC[84]; //0x00CC
  208.     uint32_t m_pickup_model; //0x0120
  209.     char pad_0124[44]; //0x0124
  210.     uint32_t m_object_model; //0x0150
  211.     char pad_0154[692]; //0x0154
  212. }; //Size: 0x0408
  213.  
  214.  
  215.  
  216.  
  217. /*credit of this classes: https://github.com/tecel007/Salty/blob/aeb574379dd39cb384ec2210a0422ca3358c9c4c/Salty/src/hooking.cpp Can be is little bit different gta pc - gta ps3, check self
  218. */
  219.  
  220.  
  221.  
  222. #define getNetObjectFromNetworkId(cNetworkObjectMgr, netId, flag) call<netObject*>(0x9F8C38)(cNetworkObjectMgr, netId, flag)
  223.  
  224. #define getSyncTreeForType(networkObjectMgr, syncTreeType) call<uint32_t>(0x13398D4)(networkObjectMgr, syncTreeType)
  225.  
  226. typedef enum AckCode
  227. {
  228.     ACKCODE_NONE = 8,
  229.     ACKCODE_MATCH_NOT_STARTED = 7,
  230.     ACKCODE_CANT_APPLY_DATA = 6,
  231.     ACKCODE_TOO_MANY_OBJECTS = 5,
  232.     ACKCODE_NO_OBJECT = 4,
  233.     ACKCODE_WRONG_OWNER = 2,
  234.     ACKCODE_OUT_OF_SEQUENCE = 3,
  235.     ACKCODE_FAIL = -1,
  236.     ACKCODE_SUCCESS = 0
  237. } AckCode;
  238.  
  239. enum SyncTreeType
  240. {
  241.     NET_OBJ_TYPE_AUTOMOBILE,             // sync for CAutomobileSyncTree_ptr  
  242.     NET_OBJ_TYPE_BIKE,                   // sync for CBikeSyncTree_ptr
  243.     NET_OBJ_TYPE_BOAT,                   // sync for CBoatSyncTree_ptr
  244.     NET_OBJ_TYPE_DOOR,                   // sync for CDoorSyncTree_ptr
  245.     NET_OBJ_TYPE_HELI,                   // sync for CHeliSyncTree_ptr
  246.     NET_OBJ_TYPE_OBJECT,                 // sync for CObjectSyncTree_ptr
  247.     NET_OBJ_TYPE_PED,                    // sync for CPedSyncTree_ptr
  248.     NET_OBJ_TYPE_PICKUP,                 // sync for CPickupSyncTree_ptr
  249.     NET_OBJ_TYPE_PICKUP_PLACEMENT,       // sync for CPickupPlacementSyncTree_ptr
  250.     NET_OBJ_TYPE_PLANE,                  // sync for CPlaneSyncTree_ptr
  251.     NET_OBJ_TYPE_SUBMARINE,              // sync for CSubmarineSyncTree_ptr
  252.     NET_OBJ_TYPE_PLAYER,                 // sync for CPlayerSyncTree_ptr
  253.     NET_OBJ_TYPE_TRAILER,                // sync for trailer but seems like can't block
  254.     NET_OBJ_TYPE_TRAIN                   // sync for CTrainSyncTree_ptr
  255. };
  256.  
  257. //could be wrong type of hook (bool), check self by debugging...
  258. bool hook::netSyncTree::ReadFromBuffer(netSyncTree* netSyncTree, uint16_t sync_type, uint16_t sync_flag, datBitBuffer* buffer, void* netLogStub)
  259. {
  260.  
  261.     if (!netSyncTree || !buffer)
  262.     {
  263.         printf("ReadFromBuffer: netSyncTree: %X - buffer: %X\n", netSyncTree, buffer);
  264.         return false;
  265.     }
  266.  
  267.     // return original func...
  268. }
  269.  
  270.  
  271. //could be wrong type of hook, check self by debugging...
  272. void CNetworkObjectMgr::UnregisterNetworkObject(void* CNetworkObjectMgr, netObject* netObject, int reason, bool force1, bool force2)
  273. {
  274.     if (!CNetworkObjectMgr || !netObject)
  275.     {
  276.         printf("UnregisterNetworkObject: CNetworkObjectMgr: %X - netObject: %X\n", CNetworkObjectMgr, netObject);
  277.         return;
  278.     }
  279.  
  280.  
  281.     call<void>(0x13396E4)(CNetworkObjectMgr, netObject, reason, force1, force2);
  282. }
  283.  
  284.  
  285. //could be wrong type of hook, check self by debugging...
  286. void CNetworkObjectMgr::HandleCloneCreateAck(void* CNetworkObjectMgr, uint32_t CNetGamePlayerSrc, uint32_t _CNetGamePlayerDst, uint16_t object_id, uint16_t ack_code)
  287. {
  288.     netObject* netObject = getNetObjectFromNetworkId(CNetworkObjectMgr, object_id, true);
  289.  
  290.     int16_t entity_type = netObject ? netObject->entity_type : -1;
  291.  
  292.    
  293.     if (!netObject)
  294.     {
  295.         printf("HandleCloneCreateAck: type=%X id=%X ack=%X - netObject: %X", entity_type, object_id, ack_code, netObject);
  296.         return;
  297.     }
  298.  
  299.     call<void>(0x133D26C)(CNetworkObjectMgr, CNetGamePlayerSrc, _CNetGamePlayerDst, object_id, ack_code);
  300. }
  301.  
  302.  
  303. //could be wrong type of hook, check self by debugging...
  304. void CNetworkObjectMgr::HandleCloneSyncAck(void* CNetworkObjectMgr, uint32_t CNetGamePlayerSrc, uint32_t _CNetGamePlayerDst, datBitBuffer* buffer, uint16_t object_id, uint16_t ack_code)
  305. {
  306.     netObject* netObject = getNetObjectFromNetworkId(CNetworkObjectMgr, object_id, true);
  307.  
  308.     int16_t entity_type = netObject ? netObject->entity_type : -1;
  309.  
  310.  
  311.     if (!netObject || !buffer)
  312.     {
  313.         printf("HandleCloneSyncAck: entity_type=%X object_id=%X ack_code=%X\n", entity_type, object_id, ack_code);
  314.         return;
  315.     }
  316.  
  317.     call<void>(0x133DA7C)(CNetworkObjectMgr, CNetGamePlayerSrc, _CNetGamePlayerDst, buffer, object_id, ack_code);
  318. }
  319.  
  320.  
  321. //could be wrong type of hook, check self by debugging...
  322. void CNetworkObjectMgr::HandleCloneRemoveAck(void* CNetworkObjectMgr, uint32_t CNetGamePlayerSrc, uint32_t _CNetGamePlayerDst, uint16_t object_id, uint16_t ack_code)
  323. {
  324.     netObject* netObject = getNetObjectFromNetworkId(CNetworkObjectMgr, object_id, true);
  325.     int16_t entity_type = netObject ? netObject->entity_type : -1;
  326.  
  327.  
  328.     if (!netObject)
  329.     {
  330.         printf("HandleCloneRemoveAck: entity_type=%X object_id=%d ack_code=%X - netObject: %X\n", entity_type, object_id, ack_code, netObject);
  331.         return;
  332.     }
  333.  
  334.     call<void>(0x133E150)(CNetworkObjectMgr, CNetGamePlayerSrc, _CNetGamePlayerDst, object_id, ack_code);
  335. }
  336.  
  337.  
  338. //could be wrong type of hook, check self by debugging...
  339. void CNetworkObjectMgr::PackedCloneCreate(void* CNetworkObjectMgr, netObject* netObject, uint32_t CNetGamePlayerSrc, datBitBuffer* buffer)
  340. {
  341.     if (!netObject || !buffer)
  342.     {
  343.         printf("PackedCloneCreate: netObject: %X - PACK: type=%X - buffer: %X\n", netObject, netObject->entity_type, buffer);
  344.         return;
  345.     }
  346.  
  347.  
  348.     call<void>(0x133A9B8)(CNetworkObjectMgr, netObject, CNetGamePlayerSrc, buffer);
  349. }
  350.  
  351.  
  352. //has been work fine for me, fix self if you have issues.
  353. uint32_t hook::HandleCloneCreate(
  354.     void* netObjMgr,
  355.     uint32_t netGamePlayerSrc,
  356.     uint32_t netGamePlayerSelf,
  357.     uint16_t syncTreeType,
  358.     uint16_t objectId,
  359.     int32_t flags,
  360.     void* buffer,
  361.     int timestamp)
  362. {
  363.     if (!netObjMgr || !buffer) return ACKCODE_FAIL;
  364.  
  365.     const char* senderName = "Unknown";
  366.     if (netGamePlayerSrc)
  367.         senderName = (char*)(*(uint32_t*)(netGamePlayerSrc + 0x78) + 0x10);
  368.  
  369.     // SyncTree check
  370.     uint32_t syncTreePool = getSyncTreeForType(netObjMgr, syncTreeType);
  371.     if (!syncTreePool)
  372.     {
  373.         printf("[HandleCloneCreate] Invalid SyncTree type 0x%X from %s\n", syncTreeType, senderName);
  374.         return ACKCODE_FAIL;
  375.     }
  376.  
  377.     // NetObj valid check
  378.     netObject* obj = getNetObjectFromNetworkId(netObjMgr, objectId, true);
  379.     if (!obj)
  380.     {
  381.         printf("[HandleCloneCreate] No netObject (ID %X) from %s\n", objectId, senderName);
  382.         return ACKCODE_FAIL;
  383.     }
  384.  
  385.     // Model spoof validation
  386.     uint32_t modelHash = *(uint32_t*)((uint8_t*)buffer + 0x20);
  387.     const char* type = NULL;
  388.  
  389.     switch (syncTreeType)
  390.     {
  391.     case NET_OBJ_TYPE_PLANE:
  392.         if (!VEHICLE::IS_THIS_MODEL_A_PLANE(modelHash)) type = "PLANE"; break;
  393.     case NET_OBJ_TYPE_HELI:
  394.         if (!VEHICLE::IS_THIS_MODEL_A_HELI(modelHash)) type = "HELI"; break;
  395.     case NET_OBJ_TYPE_BIKE:
  396.         if (!VEHICLE::IS_THIS_MODEL_A_BIKE(modelHash)) type = "BIKE"; break;
  397.     case NET_OBJ_TYPE_AUTOMOBILE:
  398.         if (!VEHICLE::IS_THIS_MODEL_A_CAR(modelHash)) type = "CAR"; break;
  399.     default:
  400.         if (syncTreeType > NET_OBJ_TYPE_TRAIN)
  401.         {
  402.             printf("[HandleCloneCreate] Out-of-range type 0x%X from %s\n", syncTreeType, senderName);
  403.             return ACKCODE_CANT_APPLY_DATA;
  404.         }
  405.     }
  406.  
  407.     if (type)
  408.     {
  409.         printf("[HandleCloneCreate] %s tried to spoof a %s (invalid hash: 0x%X)\n", senderName, type, modelHash);
  410.         *(uint32_t*)((uint8_t*)buffer + 0x20) = 0; // safe nullify model
  411.         return ACKCODE_SUCCESS; // silently accept to prevent crash
  412.     }
  413.  
  414.     return call<uint32_t>(0x133C430)(netObjMgr, netGamePlayerSrc, netGamePlayerSelf, syncTreeType, objectId, flags, buffer, timestamp);
  415. }
  416.  
  417.  
  418. /*
  419. note: freeze detected by hooking netObjectMgrBase__GetNetworkObject
  420. 012C3914 - weapons
  421. 012C3978 - weapons
  422. 012C3C28 - weapons
  423. 012C3DA0 - weapons
  424. 012C3E04 - weapons
  425. 012C3ED4 - CVehicleComponentControlEvent
  426. 012C3F34 - CVehicleComponentControlEvent
  427. 012C3FB0 - CVehicleComponentControlEvent
  428. 012C403C - CVehicleComponentControlEvent
  429. ...continue
  430. */
  431. /*
  432. 01729DA8                 lhz       r4, 0x1C(r30)
  433. 01729E08                 lwz       r4, 0x20(r30)
  434. WEAPON::REMOVE_WEAPON_FROM_PED(PLAYER::GET_PLAYER_PED(PIndex), 0xA2719263); // weapons_unarmed
  435. 0x3C6001F5 or NOP
  436. */
  437.  
  438. /*
  439. Protection for Remove_Invalid_Weapons:
  440. *(uint32_t *)(0x12C3C40) = bool Example invalid Weapons ? 0x4800002C : 0x889E0027;
  441. *(uint32_t *)(0x12C3C58) = bool Example invalid Weapons ? 0x4800002C : 0x80630BD4;
  442.  
  443. Protection for Invalid Clear Ped Task:
  444. 0x12CCB9C 0x4800002C
  445. 2* part find you :)
  446. */
  447.  
  448. void FreezeConsole::Remove_Invalid_Weapons(int targetPlayer)
  449. {
  450.     if (targetPlayer == PLAYER::PLAYER_ID())
  451.         return;
  452.  
  453.     uint32_t* addr1 = (uint32_t*)0x1729DA8;
  454.     uint32_t* addr2 = (uint32_t*)0x1729E08;
  455.  
  456.     uint32_t original1 = *addr1;
  457.     uint32_t original2 = *addr2;
  458.  
  459.     *addr1 = 0x60000000;
  460.     *addr2 = 0x60000000;
  461.  
  462.     Ped ped = PLAYER::GET_PLAYER_PED(targetPlayer);
  463.     if (ENTITY::DOES_ENTITY_EXIST(ped)){
  464.         WEAPON::REMOVE_ALL_PED_WEAPONS(ped, true);
  465.         WEAPON::REMOVE_WEAPON_FROM_PED(PLAYER::GET_PLAYER_PED(ped), 0xA2719263);
  466.     }
  467.  
  468.     *addr1 = original1;
  469.     *addr2 = original2;
  470. }
  471.  
  472.  
  473. //Not tested
  474. void FreezeConsole::Invalid_Clear_Task(int targetPlayer)
  475. {
  476.     if (targetPlayer == PLAYER::PLAYER_ID())
  477.         return;
  478.  
  479.     uint32_t* addr1 = (uint32_t*)0x172FE04;
  480.     uint32_t* addr2 = (uint32_t*)0x172FE04;
  481.  
  482.     uint32_t original1 = *addr1;
  483.     uint32_t original2 = *addr2;
  484.  
  485.     *addr1 = 0x60000000;
  486.     *addr2 = 0x60000000;
  487.  
  488.     Ped ped = PLAYER::GET_PLAYER_PED(targetPlayer);
  489.     if (ENTITY::DOES_ENTITY_EXIST(ped)){
  490.         AI::CLEAR_PED_TASKS_IMMEDIATELY(ped);
  491.     }
  492.  
  493.     *addr1 = original1;
  494.     *addr2 = original2;
  495. }
  496.  
  497.  
  498.  
  499.  
  500.  
  501.  
  502.  
  503.  
  504. 0x130A2B4 CGameHostBroadcastDataHandler_VerifyScriptDataEvent just blr
  505. 0x12CA6E0 something regard CScriptWorldStateEvent, blr
  506.  
  507. /*
  508. info for CNetworkWorldStateData_Update (for protect use 0x12CA758, arg just r3 and r4)
  509. r3 CNetworkCarGenWorldStateData
  510. r4 CGameScriptId_Ctor_opd
  511.  
  512. uint32_t m_carGenHandle; // 0x00 - Car generator identifier handle
  513. uint32_t m_modelHash; // 0x04 - Vehicle model hash
  514. float m_heading; // 0x08 - Rotation/spawn direction
  515. float m_positionX; // 0x0C - X coordinates
  516. float m_positionY; // 0x10 - Y coordinates
  517. float m_positionZ; // 0x14 - Z coordinates
  518. uint8_t m_primaryColor; // 0x18 - Primary color
  519. uint8_t m_secondaryColor; // 0x19 - Secondary color
  520. uint8_t m_popGroup; // 0x1A - Population group (e.g., civilian zone, police, etc.)
  521. uint8_t m_flags; // 0x1B - Generic flags (e.g., locked, bomb, regenerable, etc.)
  522. uint8_t m_plateIndex; // 0x1C - Plate type
  523. char m_numberPlate[8]; // 0x1D - Plate
  524. uint32_t m_timeStamp; // 0x25 - Synchronization timestamp
  525. uint32_t m_padding; // 0x29 - Alignment (not always used)
  526. */
  527.  
  528.  
  529. //revised version
  530.  
  531.  
  532. enum NetEventType {
  533.     OBJECT_ID_FREED_EVENT = 0x0,
  534.     OBJECT_ID_REQUEST_EVENT = 0x1,
  535.     ARRAY_DATA_VERIFY_EVENT = 0x2,
  536.     SCRIPT_ARRAY_DATA_VERIFY_EVENT = 0x3,
  537.     REQUEST_CONTROL_EVENT = 0x4,
  538.     GIVE_CONTROL_EVENT = 0x5,
  539.     WEAPON_DAMAGE_EVENT = 0x6,
  540.     REQUEST_PICKUP_EVENT = 0x7,
  541.     REQUEST_MAP_PICKUP_EVENT = 0x8,
  542.     CLOCK_EVENT = 0x9,
  543.     WEATHER_EVENT = 0xA,
  544.     RESPAWN_PLAYER_PED_EVENT = 0xB,
  545.     GIVE_WEAPON_EVENT = 0xC,
  546.     REMOVE_WEAPON_EVENT = 0xD,
  547.     REMOVE_ALL_WEAPONS_EVENT = 0xE,
  548.     VEHICLE_COMPONENT_CONTROL_EVENT = 0xF,
  549.     FIRE_EVENT = 0x10,
  550.     EVENT_EXPLOSION = 0x11,
  551.     START_PROJECTILE_EVENT = 0x12,
  552.     ALTER_WANTED_LEVEL_EVENT = 0x13,
  553.     CHANGE_RADIO_STATION_EVENT = 0x14,
  554.     RAGDOLL_REQUEST_EVENT = 0x15,
  555.     PLAYER_TAUNT_EVENT = 0x16,
  556.     PLAYER_CARD_STAT_EVENT = 0x17,
  557.     DOOR_BREAK_EVENT = 0x18,
  558.     SCRIPTED_GAME_EVENT = 0x19,
  559.     REMOTE_SCRIPT_INFO_EVENT = 0x1A,
  560.     REMOTE_SCRIPT_LEAVE_EVENT = 0x1B,
  561.     MARK_AS_NO_LONGER_NEEDED_EVENT = 0x1C,
  562.     CONVERT_TO_SCRIPT_ENTITY_EVENT = 0x1D,
  563.     SCRIPT_WORLD_STATE_EVENT = 0x1E,
  564.     INCIDENT_ENTITY_EVENT = 0x24,
  565.     CLEAR_AREA_EVENT = 0x1F,
  566.     NETWORK_REQUEST_SYNCED_SCENE_EVENT = 0x20,
  567.     NETWORK_START_SYNCED_SCENE_EVENT = 0x21,
  568.     NETWORK_UPDATE_SYNCED_SCENE_EVENT = 0x23,
  569.     NETWORK_STOP_SYNCED_SCENE_EVENT = 0x22,
  570.     GIVE_PED_SCRIPTED_TASK_EVENT = 0x25,
  571.     GIVE_PED_SEQUENCE_TASK_EVENT = 0x26,
  572.     NETWORK_CLEAR_PED_TASKS_EVENT = 0x27,
  573.     NETWORK_START_PED_ARREST_EVENT = 0x28,
  574.     NETWORK_START_PED_UNCUFF_EVENT = 0x29,
  575.     NETWORK_SOUND_CAR_HORN_EVENT = 0x2A,
  576.     NETWORK_ENTITY_AREA_STATUS_EVENT = 0x2B,
  577.     NETWORK_GARAGE_OCCUPIED_STATUS_EVENT = 0x2C,
  578.     PED_CONVERSATION_LINE_EVENT = 0x2D,
  579.     SCRIPT_ENTITY_STATE_CHANGE_EVENT = 0x2E,
  580.     NETWORK_PLAY_SOUND_EVENT = 0x2F,
  581.     NETWORK_STOP_SOUND_EVENT = 0x30,
  582.     NETWORK_BANK_REQUEST_EVENT = 0x31,
  583.     REQUEST_DOOR_EVENT = 0x32,
  584.     NETWORK_TRAIN_REQUEST_EVENT = 0x34,
  585.     NETWORK_TRAIN_REPORT_EVENT = 0x33,
  586.     NETWORK_INCREMENT_STAT_EVENT = 0x35,
  587.     MODIFY_VEHICLE_LOCK_WORD_STATE_DATA = 0x36,
  588.     REQUEST_PHONE_EXPLOSION_EVENT = 0x37,
  589.     REQUEST_DETACHMENT_EVENT = 0x38,
  590.     KICK_VOTES_EVENT = 0x39,
  591.     GIVE_PICKUP_REWARDS_EVENT = 0x3A,
  592.     NETWORK_CRC_HASH_CHECK_EVENT = 0x3B,
  593.     BLOW_UP_VEHICLE_EVENT = 0x3C,
  594.     NETWORK_SPECIAL_FIRE_EQUIPPED_WEAPON = 0x3D,
  595.     NETWORK_RESPONDED_TO_THREAT_EVENT = 0x3E,
  596.     NETWORK_SHOUT_TARGET_POSITION = 0x3F,
  597.     VOICE_DRIVEN_MOUTH_MOVEMENT_FINISHED_EVENT = 0x40,
  598.     PICKUP_DESTROYED_EVENT = 0x41,
  599.     UPDATE_PLAYER_SCARS_EVENT = 0x42,
  600.     NETWORK_CHECK_EXE_SIZE_EVENT = 0x43,
  601.     NETWORK_PTFX_EVENT = 0x44
  602. };
  603.  
  604. bool LOG_EVENT = false;
  605.  
  606.  
  607. bool hook::HandleIncomingEvent(
  608.     void* event_manager,
  609.     uint32_t CNetGamePlayer_from,
  610.     uint32_t CNetGamePlayer_to,
  611.     int32_t _event_type,
  612.     int32_t event_id,
  613.     int32_t bitset,
  614.     int64_t unk,
  615.     void* buffer)
  616. {
  617.     int16_t event_type = _event_type;
  618.  
  619.     const char* name = "Unknown";
  620.     if (CNetGamePlayer_from)
  621.         name = (char*)(*(uint32_t*)(CNetGamePlayer_from + 0x78) + 0x10);
  622.  
  623.     if (event_type < 0)
  624.     {
  625.         printf("[NetEvent] Event type out of range! ID: 0x%X from %s\n", event_type, name);
  626.         return false;
  627.     }
  628.  
  629.     if (LOG_EVENT)
  630.     {
  631.         printf("[NetEvent] received type: 0x%X from %s (EventID: %X, BitSet: %X)\n", event_type, name, event_id, bitset);
  632.     }
  633.  
  634.     if (BlockscriptEvent)
  635.     {
  636.         switch (event_type)
  637.         {
  638.         case GIVE_CONTROL_EVENT: // example
  639.             printf("[NetEvent] blocked event GIVE_CONTROL_EVENT from %s\n", name);
  640.             return false;
  641.  
  642.             // you can add other event here:
  643.             // case REMOVE_STICKY_BOMB:
  644.             // case GIVE_PICKUP_REWARDS:
  645.         }
  646.     }
  647.  
  648.     return call<uint32_t>(0xA033F4)(event_manager, CNetGamePlayer_from, CNetGamePlayer_to, _event_type, event_id, bitset, unk, buffer);
  649. }
  650.  
  651.  
  652.  
  653.  
  654. #define ABS_DIFF(a, b) ((a) > (b) ? ((a) - (b)) : ((b) - (a))) // I have not found other method
  655.  
  656. //https://github.com/lonelybud/YimMenuV2/blob/ef93bd15c47be0afe6aa7cc4fc3a750263976d47/src/types/network/rlSessionDetail.hpp#L8
  657.  
  658. class rlGamerHandle
  659. {
  660. public:
  661.     uint64_t m_rockstar_id; //0x0000
  662.     uint8_t m_platform; //0x0008
  663.     uint8_t unk_0009; //0x0009
  664.  
  665. }; //Size: 0x0010
  666.  
  667. union netAddress {
  668.     uint32_t m_packed; //0x0000
  669.     struct {
  670.         uint8_t m_field4; //0x0000
  671.         uint8_t m_field3; //0x0001
  672.         uint8_t m_field2; //0x0002
  673.         uint8_t m_field1; //0x0003
  674.     };
  675. };
  676.  
  677. class rlSessionInfo
  678. {    
  679. public:
  680.     uint64_t m_unk; //0x0000
  681.     uint64_t m_session_token; //0x0008
  682.     rlGamerInfoBase m_net_player_data; //0x0010
  683. };
  684.  
  685. class rlGamerInfoBase
  686. {
  687. public:
  688.     uint64_t m_peer_id; //0x0000
  689.     rlGamerHandle m_gamer_handle; //0x008
  690.     char m_aes_key[32]; //0x0018
  691.     uint8_t unk_0038; //0x0038
  692.     netAddress m_unk_ip; //0x003C
  693.     uint16_t m_unk_port; //0x0040
  694.     netAddress m_relay_ip; //0x0044
  695.     uint16_t m_relay_port; //0x0048
  696.     netAddress m_external_ip; //0x004C
  697.     uint16_t m_external_port; //0x0050
  698.     netAddress m_internal_ip; //0x0054
  699.     uint16_t m_internal_port; //0x0058
  700.     uint32_t unk_005C; //0x005C
  701. };
  702.  
  703. class rlSessionDetail
  704. {
  705. public:
  706.     class rlGamerInfoBase m_base_gamer_info;
  707.     char pad_0060[8]; //0x0060
  708.     class rlSessionInfo m_session_info; //0x0068
  709.     char pad_00D8[14]; //0x00D8
  710.     uint16_t m_session_type; //0x00E6
  711.     char pad_00E8[324]; //0x00E8
  712.     uint32_t m_player_count; //0x022C
  713.     uint32_t m_unk_player_count; //0x0230
  714.     char pad_0234[2]; //0x0234
  715.     int16_t m_unk_pos_x; //0x0236
  716.     int16_t m_unk_pos_y; //0x0238
  717.     int16_t m_unk_pos_z; //0x023A
  718.     uint8_t m_matchmaking_property_ids[32]; //0x023C
  719.     char pad_025C[2]; //0x025C
  720.     uint16_t m_rank; //0x025E
  721.     char pad_0260[1]; //0x0260
  722.     uint8_t m_mental_state; //0x0261
  723.     char pad_0262[21]; //0x0262
  724.     uint8_t m_population_density; //0x0277
  725.     char pad_0278[320]; //0x0278
  726. };
  727.  
  728. class SessionSortEntry
  729. {
  730. public:
  731.     class rlSessionDetail* m_session_detail; //0x0000
  732.     char pad_0008[4]; //0x0008
  733.     float m_score; //0x000C
  734.     char pad_0010[8]; //0x0010
  735. };
  736.  
  737. // 00D1D02C allocateMemoryForSessionDetails
  738. bool hook::SortSessionDetails(SessionSortEntry* s1, SessionSortEntry* s2)
  739. {
  740.     if (!s1 || !s2 || !s1->m_session_detail || !s2->m_session_detail)
  741.         return false;
  742.  
  743.     if (player_magnet_enabled)
  744.     {
  745.         int targetCount = 4; // The ideal number of players you want to find in a session (e.g. 4, 12, 18...). Do it in custom on your menu
  746.         int diff1 = ABS_DIFF((int)s1->m_session_detail->m_player_count - targetCount);
  747.         int diff2 = ABS_DIFF((int)s2->m_session_detail->m_player_count - targetCount);
  748.        
  749.         printf("[PlayerMagnet] Session1 player count: %d, diff: %d | Session2 player count: %d, diff: %d\n",
  750.                s1->m_session_detail->m_player_count, diff1,
  751.                s2->m_session_detail->m_player_count, diff2);
  752.  
  753.         return diff1 < diff2;
  754.     }
  755.  
  756.     //return Original Sort Session Details(s1, s2);
  757. }
  758.  
  759.  
Advertisement
Add Comment
Please, Sign In to add comment