cs2-entitylist-python-code/main.py at main · burakacar6/cs2-entitylist-python-code · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import requests
import pymem

class TargetPosition:
    def config(self):
        client_url = "https://raw.githubusercontent.com/a2x/cs2-dumper/refs/heads/main/output/client_dll.json"
        offset_url = "https://raw.githubusercontent.com/a2x/cs2-dumper/refs/heads/main/output/offsets.json"

        try:
            self.pm = pymem.Pymem("cs2.exe")
            self.module = pymem.process.module_from_name(self.pm.process_handle, "client.dll")
        except Exception as e:
            print(f"Error initializing Pymem: {e}")
            return None, None

        response_client = requests.get(client_url).json()
        response_offset = requests.get(offset_url).json()
        return response_client["client.dll"]["classes"], response_offset["client.dll"]

    def bones(self, entitypawn):
        bones = []
        client_dll, _ = self.config()
        m_vecOrigin_offset = client_dll["CGameSceneNode"]["fields"]["m_vecOrigin"]
        m_modelState_offset = client_dll["CSkeletonInstance"]["fields"]["m_modelState"]
        scene_offset = client_dll["C_BaseEntity"]["fields"]["m_pGameSceneNode"]
        scene = self.pm.read_ulonglong(entitypawn + scene_offset)
        bonearray = self.pm.read_ulonglong(scene +m_modelState_offset + m_vecOrigin_offset)
        for i in range(30):
            x = self.pm.read_float(bonearray)
            y = self.pm.read_float(bonearray + 0x4)
            z = self.pm.read_float(bonearray + 0x8)
            bones.append((x, y, z))
            bonearray += 0x20
        return bones

    def get_target_position(self):
        ent_list = []
        client_dll, offsets = self.config()
        dwEntityList = offsets["dwEntityList"]
        try:
            entity_list = self.pm.read_ulonglong(self.module.lpBaseOfDll + dwEntityList)

            if not entity_list or entity_list == 0:
                print(f"Error: Invalid entity_list address: {entity_list}")
                return ent_list

            for i in range(1, 64):
                chunk = (i >> 9)
                idx = i & 0x1FF

                try:
                    list_entry = self.pm.read_ulonglong(entity_list + 0x10 + 8 * chunk)
                    if not list_entry or list_entry < 0x1000:
                        continue

                    ent_ptr = self.pm.read_ulonglong(list_entry + 112 * idx)
                    if not ent_ptr or ent_ptr < 0x1000:
                        continue

                    m_hPlayerPawn = client_dll["CCSPlayerController"]["fields"]["m_hPlayerPawn"]
                    controller_pawn = self.pm.read_int(ent_ptr + m_hPlayerPawn)
                    if not controller_pawn or controller_pawn <= 0:
                        continue

                    entry_index = controller_pawn & 0x7FFF
                    chunk_idx = entry_index >> 9
                    entity_idx = entry_index & 0x1FF

                    list_entry_ptr = self.pm.read_ulonglong(entity_list + 0x8 * chunk_idx + 16)
                    if not list_entry_ptr or list_entry_ptr < 0x1000:
                        continue

                    pawn_ptr = self.pm.read_ulonglong(list_entry_ptr + 112 * entity_idx)
                    if not pawn_ptr or pawn_ptr < 0x1000:
                        continue
                    ent_list.append(self.bones(pawn_ptr))
                    return ent_list, self.bones
                except Exception as e:
                    print(f"Error reading entity {i}: {e}")
                    continue
        except Exception as e:
            print(f"Error retrieving target position: {e}")

        return ent_list