v1.1

core/aimbot.py

@@ -0,0 +1,67 @@
+from core.offsets import *
+from core.entity import *
+from core.utils import *
+import pyMeow as pm
+import math, ctypes
+
+class Aimbot:
+    def __init__(self, process, module):
+        self.process = process
+        self.module = module
+        self.entities = Entities(self.process, self.module)
+
+    def update(self, Toogle):
+        if not ctypes.windll.user32.GetAsyncKeyState(Utils.get_id("aimbot").get(Toogle.data["aimbot"]["key"])) or not Toogle.data["aimbot"]["enable"]:
+            return
+
+        try:
+            enemy_pos = None
+            best_fov = Toogle.data["aimbot"]["fov"]
+            smooth = Toogle.data["aimbot"]["smooth"]
+
+            local_player_pawn = pm.r_int64(self.process, self.module + dwLocalPlayerPawn)
+            local_player_controller = pm.r_int64(self.process, self.module + dwLocalPlayerController)
+            local_player_team = pm.r_int(self.process, local_player_controller + m_iTeamNum)
+            local_player_pos = pm.r_vec3(self.process, local_player_pawn + m_vOldOrigin)
+            view_angles = pm.r_vec3(self.process, self.module + dwViewAngles)
+
+            for entity in self.entities.get_list():
+                try:
+                    if entity.spotted() or not Toogle.data["aimbot"]["only_visible"]:
+                        if entity.health() != 0 and entity.team() != local_player_team or Toogle.data["misc"]["ignore_team"]:
+                            distance = self.get_distance(local_player_pos, entity.pos())
+
+                            if distance < Toogle.data["aimbot"]["distance"]:
+                                angles = self.calc_angle(local_player_pos, entity.pos())
+                                fov = self.get_fov(view_angles, angles)
+
+                                if fov < best_fov:
+                                    best_fov = fov
+                                    enemy_pos = entity.pos()
+                except:
+                    continue
+
+            if enemy_pos is not None:
+                angles = self.calc_angle(local_player_pos, enemy_pos)
+
+                punch_y = pm.r_float(self.process, local_player_pawn + m_aimPunchAngle + 4)
+                angles["y"] -= punch_y * 2
+
+                if smooth > 0:
+                    angles["y"] = view_angles["y"] + (angles["y"] - view_angles["y"]) / smooth
+
+                pm.w_float(self.process, self.module + dwViewAngles + 4, angles["y"])
+        except:
+            pass
+
+    def calc_angle(self, local, entity):
+        delta = {"x": entity["x"] - local["x"], "y": entity["y"] - local["y"], "z": entity["z"] - local["z"]}
+        yaw = math.degrees(math.atan2(delta["y"], delta["x"]))
+        return {"x": 0.0, "y": yaw, "z": 0.0}
+
+    def get_distance(self, local, entity):
+        return math.sqrt((local["x"] - entity["x"]) ** 2 + (local["y"] - entity["y"]) ** 2 + (local["z"] - entity["z"]) ** 2)
+
+    def get_fov(self, view_angles, target_angles):
+        delta = {"x": 0.0, "y": target_angles["y"] - view_angles["y"]}
+        return abs(delta["y"])

core/colors.py

@@ -0,0 +1,13 @@
+import pyMeow as pm
+
+colors = {
+    "red": pm.get_color("#bd2045"),
+    "blue": pm.get_color("#32ace5"),
+    "green": pm.get_color("#41e295"),
+    "black": pm.get_color("#000000"),
+    "white": pm.get_color("#ffffff"),
+    "orange": pm.get_color("#eb7d34"),
+    "yellow": pm.get_color("#ebdb34"),
+    "purple": pm.get_color("#7434eb"),
+    "pink": pm.get_color("#eb34a2")
+}

core/entity.py

@@ -0,0 +1,94 @@
+from core.offsets import *
+from core.utils import *
+import pyMeow as pm
+
+class Entity:
+    def __init__(self, entity_controller, entity_pawn, process):
+        self.entity_controller = entity_controller
+        self.entity_pawn = entity_pawn
+        self.process = process
+
+    def health(self):
+        return pm.r_int(self.process, self.entity_pawn + m_iHealth)
+
+    def armor(self):
+        return pm.r_int(self.process, self.entity_pawn + m_ArmorValue)
+
+    def team(self):
+        return pm.r_int(self.process, self.entity_pawn + m_iTeamNum)
+
+    def name(self):
+        return pm.r_string(self.process, self.entity_controller + m_iszPlayerName)
+
+    def weapon(self):
+        current = pm.r_int64(self.process, self.entity_pawn + m_pClippingWeapon)
+
+        if current == 0:
+            return ""
+
+        index = pm.r_int16(self.process, current + m_AttributeManager + m_Item + m_iItemDefinitionIndex)
+        return Utils.get_id("weapon").get(index, "")
+
+    def spotted(self):
+        return pm.r_bool(self.process, self.entity_pawn + m_entitySpottedState + m_bSpotted)
+
+    def ping(self):
+        return pm.r_int(self.process, self.entity_controller + m_iPing)
+
+    def score(self):
+        return pm.r_int(self.process, self.entity_controller + m_iScore)
+
+    def pos(self):
+        return pm.r_vec3(self.process, self.entity_pawn + m_vOldOrigin)
+
+    def bone_pos(self, index):
+        scene = pm.r_int64(self.process, self.entity_pawn + m_pGameSceneNode)
+        bone = pm.r_int64(self.process, scene + m_pBoneArray)
+        return pm.r_vec3(self.process, bone + index * 32)
+
+    def world_to_screen(self, view_matrix):
+        try:
+            self.pos_2d = pm.world_to_screen(view_matrix, self.pos(), 1)
+            self.head_pos_2d = pm.world_to_screen(view_matrix, self.bone_pos(6), 1)
+            self.neck = pm.world_to_screen(view_matrix, self.bone_pos(5), 1)
+            self.left_feet = pm.world_to_screen(view_matrix, self.bone_pos(27), 1)
+            self.right_feet = pm.world_to_screen(view_matrix, self.bone_pos(24), 1)
+            self.waist = pm.world_to_screen(view_matrix, self.bone_pos(0), 1)
+            self.left_knees = pm.world_to_screen(view_matrix, self.bone_pos(26), 1)
+            self.right_knees = pm.world_to_screen(view_matrix, self.bone_pos(23), 1)
+            self.left_hand = pm.world_to_screen(view_matrix, self.bone_pos(16), 1)
+            self.right_hand = pm.world_to_screen(view_matrix, self.bone_pos(11), 1)
+            self.left_arm = pm.world_to_screen(view_matrix, self.bone_pos(14), 1)
+            self.right_arm = pm.world_to_screen(view_matrix, self.bone_pos(9), 1)
+            self.left_shoulder = pm.world_to_screen(view_matrix, self.bone_pos(13), 1)
+            self.right_shoulder = pm.world_to_screen(view_matrix, self.bone_pos(8), 1)
+        except:
+            return False
+
+        return True
+
+class Entities:
+    def __init__(self, process, module):
+        self.process = process
+        self.module = module
+
+    def get_list(self):
+        local_player_controller = pm.r_int64(self.process, self.module + dwLocalPlayerController)
+
+        for entity in range(1, 65):
+            try:
+                entity_list = pm.r_int64(self.process, self.module + dwEntityList)
+
+                entity_entry = pm.r_int64(self.process, entity_list + (8 * (entity & 32767) >> 9) + 16)
+                entity_controller = pm.r_int64(self.process, entity_entry + 120 * (entity & 511))
+
+                if entity_controller == local_player_controller:
+                    continue
+
+                entity_controller_pawn = pm.r_int64(self.process, entity_controller + m_hPlayerPawn)
+                entity_list_ptr = pm.r_int64(self.process, entity_list + 8 * ((entity_controller_pawn & 32767) >> 9) + 16)
+                entity_pawn = pm.r_int64(self.process, entity_list_ptr + 120 * (entity_controller_pawn & 511))
+            except:
+                continue
+
+            yield Entity(entity_controller, entity_pawn, self.process)