v1.2

core/aimbot.py → cheat/features/aimbot.py

@@ -1,67 +1,74 @@
-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"])
+import pyMeow as pm
+import math, ctypes
+from config import *
+from core.offsets import *
+from cheat.features.entity import *
+
+class Aimbot:
+    def __init__(self, process, module):
+        self.process = process
+        self.module = module
+        self.entities = Entities(self.process, self.module)
+        self.mapping = {"shift": 16, "ctrl": 17, "mouse_1": 1}
+
+    def update(self):
+
+        if not ctypes.windll.user32.GetAsyncKeyState(self.mapping.get(Config.aimbot["key"])) or not Config.aimbot["enable"]:
+            return
+
+        try:
+            entity_pos = None
+            fov = Config.aimbot["fov"] / 10
+            smooth = Config.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.enumerate():
+                try:
+                    if entity.spotted() or not Config.aimbot["only_visible"]:
+                        if entity.health() != 0 and entity.team() != local_player_team or Config.misc["ignore_team"]:
+                            distance = self.get_distance(local_player_pos, entity.pos())
+
+                            if distance < Config.aimbot["distance"]:
+                                angles = self.calc_angle(local_player_pos, entity.pos())
+                                closest = self.get_fov(view_angles, angles)
+
+                                if closest < fov:
+                                    fov = closest
+                                    entity_pos = entity.pos()
+                except:
+                    continue
+
+            if entity_pos is not None:
+                angles = self.calc_angle(local_player_pos, entity_pos)
+                punch_y = pm.r_float(self.process, local_player_pawn + m_aimPunchAngle + 4)
+                angles["x"] -= punch_y * 2
+
+                if smooth > 0:
+                    angles["x"] = view_angles["x"] + (angles["x"] - view_angles["x"]) / smooth
+                    angles["y"] = view_angles["y"] + (angles["y"] - view_angles["y"]) / smooth
+                else:
+                    angles["y"] -= punch_y * 2
+
+                pm.w_vec3(self.process, self.module + dwViewAngles, angles)
+        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"]))
+        hyp = math.sqrt(delta["x"] ** 2 + delta["y"] ** 2)
+        pitch = -math.degrees(math.atan2(delta["z"], hyp))
+
+        return {"x": pitch, "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):
+        delta = {"x": target["x"] - view_angles["x"], "y": target["y"] - view_angles["y"]}
+        return math.sqrt(delta["x"] ** 2 + delta["y"] ** 2)

core/entity.py → cheat/features/entity.py

@@ -1,94 +1,95 @@
-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)
+import pyMeow as pm
+from core.offsets import *
+from core.utils import *
+
+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.weapon_icon(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 enumerate(self):
+        local_player_controller = pm.r_int64(self.process, self.module + dwLocalPlayerController)
+        # local_player_pawn = pm.r_int64(self.process, self.module + dwLocalPlayerPawn)
+
+        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 & 0x7FFF) >> 9) + 16)
+                entity_controller = pm.r_int64(self.process, entity_entry + 120 * (entity & 0x1FF))
+
+                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 & 0x7FFF) >> 9) + 16)
+                entity_pawn = pm.r_int64(self.process, entity_list_ptr + 120 * (entity_controller_pawn & 0x1FF))
+            except:
+                continue
+
+            yield Entity(entity_controller, entity_pawn, self.process)