data_validator.py

import sys
import time
import random
import threading
import ctypes
import eel
import json
import os

# ================= KERNEL PRIORITY & OS SETUP =================
kernel32 = ctypes.windll.kernel32
user32 = ctypes.windll.user32

def elevate_system():
    if sys.platform == "win32":
        pid = kernel32.GetCurrentProcess()
        kernel32.SetPriorityClass(pid, 0x00000080) 
        thread_id = kernel32.GetCurrentThread()
        kernel32.SetThreadPriority(thread_id, 15) 

# ================= SENDINPUT API =================
class MOUSEINPUT(ctypes.Structure):
    _fields_ = [("dx", ctypes.c_long), ("dy", ctypes.c_long),
                ("mouseData", ctypes.c_ulong), ("dwFlags", ctypes.c_ulong),
                ("time", ctypes.c_ulong), ("dwExtraInfo", ctypes.POINTER(ctypes.c_ulong))]
class INPUT(ctypes.Structure):
    _fields_ = [("type", ctypes.c_ulong), ("mi", MOUSEINPUT)]

def send_mouse_move(dx, dy):
    if dx == 0 and dy == 0: return
    mi = MOUSEINPUT(int(dx), int(dy), 0, 0x0001, 0, None)
    inp = INPUT(0, mi)
    user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(inp))

def is_pressed(key_code):
    return (user32.GetAsyncKeyState(key_code) & 0x8000) != 0

# ================= DATABASE =================
WEAPON_DATABASE = {
    "Heavy Profile": {
        "fire_rate_sec": 0.086, 
        "curve": [(0.00, 0.0, 9.5), (0.10, -1.5, 14.5), (0.30, 2.0, 14.0), (0.80, -2.5, 12.0), (1.50, 1.0, 11.5), (3.00, 0.0, 11.5)]
    },
    "Assault Profile": {
        "fire_rate_sec": 0.086, 
        "curve": [(0.00, 0.0, 6.0), (0.20, 1.0, 8.5), (0.60, -1.5, 9.0), (1.20, 0.5, 7.5), (2.00, -0.5, 7.5), (3.00, 0.0, 7.5)]
    },
    "Tactical Profile": {
        "fire_rate_sec": 0.086, 
        "curve": [(0.00, 0.0, 5.0), (0.10, 0.5, 7.5), (0.30, -0.5, 8.0), (0.60, 0.0, 6.5), (1.00, 0.5, 6.5), (2.00, -0.5, 6.5), (3.00, 0.0, 6.5)]
    },
    # Custom profile slot for user modifications
    "Custom Slot": {
        "fire_rate_sec": 0.090, 
        "curve": [(0.00, 0.0, 7.0), (0.50, 0.0, 9.0), (1.50, 0.0, 8.5), (3.00, 0.0, 8.5)]
    }
}

engine_state = {
    "active": False,
    "weapon": "Heavy Profile",
    "stance": "Standing",
    "smart_ads": True,
    "humanize": True,
    "loot_active": False,
    "drag_distance": 500.0,
    "crouch_mult": 0.80,
    "prone_mult": 0.55,
    "custom_name": "Custom Slot", # User-defined custom name
    "profiles": {
        "Heavy Profile": { "sens": 20.0, "vert": 1.25, "horiz": 1.00 },
        "Assault Profile": { "sens": 20.0, "vert": 1.20, "horiz": 1.00 },
        "Tactical Profile": { "sens": 20.0, "vert": 1.20, "horiz": 1.00 },
        "Custom Slot": { "sens": 25.0, "vert": 1.10, "horiz": 1.00 }
    }
}

CONFIG_FILE = "macro_config.json"

def _save_config():
    with open(CONFIG_FILE, 'w') as f: json.dump(engine_state, f)

def _load_config():
    global engine_state
    if os.path.exists(CONFIG_FILE):
        try:
            with open(CONFIG_FILE, 'r') as f: 
                loaded = json.load(f)
                engine_state.update(loaded)
                for wpn in WEAPON_DATABASE:
                    if wpn not in engine_state["profiles"]:
                        engine_state["profiles"][wpn] = { "sens": 20.0, "vert": 1.20, "horiz": 1.00 }
        except: pass

@eel.expose
def update_config(key, value):
    if key in ["sens", "vert", "horiz"]:
        current_wpn = engine_state["weapon"]
        engine_state["profiles"][current_wpn][key] = value
    else:
        engine_state[key] = value
    _save_config()
    if key == "weapon":
        return engine_state["profiles"][value]
    return None

# Function to rename the custom profile from the web UI
@eel.expose
def rename_custom(new_name):
    engine_state["custom_name"] = new_name
    _save_config()
    return True

@eel.expose
def toggle_engine_from_web():
    engine_state["active"] = not engine_state["active"]
    return engine_state["active"]

@eel.expose
def get_current_config():
    return engine_state

def loot_loop():
    VK_XBUTTON2 = 0x06 # Mouse 5
    while True:
        if engine_state.get("loot_active") and is_pressed(VK_XBUTTON2):
            dist = int(engine_state.get("drag_distance", 500))
            user32.mouse_event(0x0002, 0, 0, 0, 0) # Down
            user32.mouse_event(0x0001, dist, 0, 0, 0) # Move
            user32.mouse_event(0x0004, 0, 0, 0, 0) # Up
            user32.mouse_event(0x0001, -dist, 0, 0, 0) # Back
            time.sleep(0.01)
        else:
            time.sleep(0.01)

def _lerp_2d(t, curve):
    if t >= curve[-1][0]: return curve[-1][1], curve[-1][2]
    for i in range(len(curve)-1):
        if curve[i][0] <= t < curve[i+1][0]:
            t1, x1, y1 = curve[i]; t2, x2, y2 = curve[i+1]
            ratio = (t - t1) / (t2 - t1)
            return x1 + (x2 - x1) * ratio, y1 + (y2 - y1) * ratio
    return curve[-1][1], curve[-1][2]

def automation_loop():
    elevate_system()
    VK_LBUTTON, VK_RBUTTON, VK_F1 = 0x01, 0x02, 0x70
    f1_was_pressed = False
    rem_x = rem_y = 0.0

    while True:
        f1_is_pressed = is_pressed(VK_F1)
        if f1_is_pressed and not f1_was_pressed:
            engine_state["active"] = not engine_state["active"]
            eel.sync_ui_toggle(engine_state["active"])()
            _save_config()
        f1_was_pressed = f1_is_pressed

        if not engine_state["active"]:
            time.sleep(0.01); continue

        if engine_state["smart_ads"]:
            if not (is_pressed(VK_LBUTTON) and is_pressed(VK_RBUTTON)):
                time.sleep(0.001); continue
        else:
            if not is_pressed(VK_LBUTTON):
                time.sleep(0.001); continue

        current_wpn = engine_state["weapon"]
        profile = WEAPON_DATABASE.get(current_wpn, WEAPON_DATABASE["Heavy Profile"])
        fire_rate, curve = profile["fire_rate_sec"], profile["curve"]
        
        wpn_profile = engine_state["profiles"].get(current_wpn, {"sens": 20.0, "vert": 1.20, "horiz": 1.00})
        sens, vert, horiz = wpn_profile["sens"]/10.0, wpn_profile["vert"], wpn_profile["horiz"]
        
        stance_mult = 1.0
        if engine_state["stance"] == "Crouching": stance_mult = engine_state["crouch_mult"]
        elif engine_state["stance"] == "Proning": stance_mult = engine_state["prone_mult"]

        start_time = last_time = time.perf_counter()
        rem_x = rem_y = 0.0

        while is_pressed(VK_LBUTTON):
            if engine_state["smart_ads"] and not is_pressed(VK_RBUTTON): break
            if not engine_state["active"]: break

            current_time = time.perf_counter()
            elapsed, dt = current_time - start_time, current_time - last_time
            last_time = current_time

            px_x, px_y = _lerp_2d(elapsed, curve)
            move_x_float = (px_x / fire_rate * dt) * sens * horiz * stance_mult
            move_y_float = (px_y / fire_rate * dt) * sens * vert * stance_mult
            
            if engine_state["humanize"]:
                move_x_float += random.uniform(-10.0, 10.0) * dt * sens
                move_y_float += random.uniform(-2.0, 2.0) * dt * sens

            total_x, total_y = move_x_float + rem_x, move_y_float + rem_y
            mx, my = int(total_x), int(total_y)
            rem_x, rem_y = total_x - mx, total_y - my

            send_mouse_move(mx, my)
            target = time.perf_counter() + 0.002
            while time.perf_counter() < target: pass

        time.sleep(0.01)

if __name__ == "__main__":
    _load_config()
    threading.Thread(target=automation_loop, daemon=True).start()
    threading.Thread(target=loot_loop, daemon=True).start() 
    eel.init('web')
    try: eel.start('index_pro.html', mode='edge', size=(850, 750)) 
    except: eel.start('index_pro.html', mode='default', size=(850, 750))