cerabot v6.py

#WIP -- FUCKING PERFECT KITING
import os
import pydirectinput
import time
import pymem
import pymem.exception
import threading
import frida
import pyautogui
import bresenham
import json
import random
import tkinter as tk
from pynput import mouse, keyboard
from tkinter import ttk
from queue import PriorityQueue

CONFIG_PATH = "cerabot_config.json"

walkAddress = "0xEDC35"
npcAddress = "0x1EFC8E"
directionalAddress = "0x6CAEE"
varOffset = 0xA0
totalExp = None
WEIGHT_WRITE_ADDRS = [0xFC3C9, 0xFCD40]

START_ADDR = 0x00180000
END_ADDR   = 0x0019FFFF
STEP       = 4         

DEBUG_PROTECTED = True        
STALE_NPC_SECONDS = 12 

# --- attack state + grace windows ---
ATTACK_RECENCY_S = 0.3   # treat as "attacking" for this long after we start/continue
PRE_HIT_GRACE_S = 0.3     # delay protection this long after a hit to avoid locking our own hit
ctrl_engaged = False
last_attack_time = 0.0
last_attack_addr = None

# --- Flank/kiting settings ---
FLANK_RANGE = 3          # desired distance from target (try 2–4)
RECOVER_SECS = 0.6       # after a backstep, wait this long before holding again
recover_to_range_until = 0.0
HOLD_AT_RANGE_LOCK = True   # set False to return to normal kiting
flank_hold_target = None    

AGRO_OFFSET = -90          # byte offset from NPC base ("npc data")
AGRO_VALUE = 2             # 0 = not agro, 2 = agro
AGRO_TIMEOUT_S = 4.0      # seconds to wait after pressing Ctrl
BOTCHECK_PAUSE_S = 300.0   # 5 minutes

x_address = None
y_address = None
directional_address = None
combat_baseline_exp = None
current_target_npc = None
xstarted = 0
debug = 0
pyautogui.PAUSE = 0
last_direction = None
wandering_target = None
pm = None  # Global pymem instance
POST_PROTECT_GRACE_S = 2.0
botcheck_guard = threading.Event()

def initialize_pymem():
    global pm
    if pm is None:
        pm = pymem.Pymem("Endless.exe")

def press_key(key, presses=2, delay=0.1):
    """
    Presses a key and optionally waits for a specified delay.
    """
    pydirectinput.press(key, presses)
    time.sleep(delay)

def hold_key(key):
    pydirectinput.keyDown(key)

def release_key(key):
    pydirectinput.keyUp(key)

attack_lock = threading.Lock()

def load_config():
    if os.path.exists(CONFIG_PATH):
        try:
            with open(CONFIG_PATH, "r") as f:
                return json.load(f)
        except Exception:
            return {}
    return {}


def save_config(cfg: dict):
    try:
        with open(CONFIG_PATH, "w") as f:
            json.dump(cfg, f, indent=2)
    except Exception:
        pass

# --- Apply saved config values ---
try:
    _cfg = load_config()
    if isinstance(_cfg.get("FLANK_RANGE"), int):
        FLANK_RANGE = max(1, _cfg["FLANK_RANGE"])  # clamp to >=1
    if isinstance(_cfg.get("HOLD_AT_RANGE_LOCK"), bool):
        HOLD_AT_RANGE_LOCK = _cfg["HOLD_AT_RANGE_LOCK"]
except Exception:
    pass

class UniversalStuck:
    def __init__(self, step_timeout_s=1.2, fire_cooldown_s=0.2, arrive_eps=0):
        self.step_timeout_s = step_timeout_s
        self.fire_cooldown_s = fire_cooldown_s
        self.arrive_eps = arrive_eps
        self.goal = None          # (x, y)
        self.started_at = None    # time we began trying this goal
        self.last_fire_at = 0.0   # to prevent duplicate fires

    def _same_tile(self, a, b):
        if a is None or b is None: return False
        # integer tiles; keep eps if you sometimes use floats
        return abs(a[0]-b[0]) <= self.arrive_eps and abs(a[1]-b[1]) <= self.arrive_eps

    def begin_or_continue(self, goal_xy, player_xy, now):
        """Call every tick with the pathfinder's next_step (goal_xy) and real player_xy.
        Returns: None or ('timeout', blocked_tile_xy) exactly once per timeout window."""
        # If goal changed or we arrived, reset timer.
        arrived = self._same_tile(goal_xy, player_xy)
        if self.goal != goal_xy or arrived:
            self.goal = goal_xy
            self.started_at = now if not arrived else None
            return None

        # No goal? nothing to do.
        if self.goal is None or self.started_at is None:
            return None

        # Timeout check.
        if (now - self.started_at) >= self.step_timeout_s:
            # Debounce so we only fire once per goal.
            if (now - self.last_fire_at) >= self.fire_cooldown_s:
                self.last_fire_at = now
                # Reset so next tick can pick a fresh route/goal.
                timed_out_tile = self.goal
                self.goal = None
                self.started_at = None
                return ('timeout', timed_out_tile)

        return None

def pause_for(seconds: float, reason: str = "bot_check"):
    global pause_flag
    try:
        print(f"[pause] Reason={reason}. Pausing for {int(seconds)}s...")
        pause_flag = True            # <<< set first
        set_attack(False)            # then release
        release_key('ctrl')          # belt-and-suspenders
        time.sleep(seconds)
    finally:
        pause_flag = False
        print("[pause] Resuming combat/wandering.")

def pause_for_and_clear_guard():
    try:
        pause_for(BOTCHECK_PAUSE_S, reason="bot_check")  # your existing pause function
    finally:
        botcheck_guard.clear()        

def read_agro(addr_hex: str) -> int | None:
    """Reads 1 byte at (npc_base + AGRO_OFFSET). Returns int or None on failure."""
    global pm
    if not addr_hex:
        return None
    try:
        npc_base = int(addr_hex, 16)
        agro_addr = npc_base + AGRO_OFFSET
        return pm.read_bytes(agro_addr, 1)[0]
    except Exception as e:
        # Optional: print(f"[agro] read failed @ {addr_hex} ({e})")
        return None

def agro_watchdog(target_addr_hex: str, started_at: float):
    global pause_flag
    """Within AGRO_TIMEOUT_S of starting Ctrl, ensure target's agro==2; else pause."""
    if not target_addr_hex:
        return
    deadline = started_at + AGRO_TIMEOUT_S
    while time.time() < deadline:
        val = read_agro(target_addr_hex)
        if val == AGRO_VALUE:
            # target went agro; we're good
            # Optional: print(f"[agro] target {target_addr_hex} went agro (2).")
            return
        time.sleep(0.2)

    # Timed out: only trigger if we're still attacking and target hasn't changed
    # (avoid false positives if you disengaged or retargeted)
    if is_attacking() and target_addr_hex == last_attack_addr:
        # Debounce: if another trigger already fired, bail.
        if botcheck_guard.is_set():
            return
        botcheck_guard.set()
        print(f"[agro] target {target_addr_hex} did NOT go agro (2) within {AGRO_TIMEOUT_S}s.")
        pause_flag = True
        set_attack(False)
        release_key('ctrl')
        threading.Thread(target=pause_for_and_clear_guard, daemon=True).start()

def set_attack(state: bool):
    """Hold/release Ctrl and stamp last-attack info atomically."""
    global ctrl_engaged, last_attack_time, last_attack_addr, current_target_npc, pause_flag
    with attack_lock:
        if state:
            # Don't allow Ctrl engage while paused
            if pause_flag:
                if ctrl_engaged:
                    release_key('ctrl')
                    ctrl_engaged = False
                return
            # Engage only on transition
            if not ctrl_engaged:
                hold_key('ctrl')
                ctrl_engaged = True
                last_attack_time = time.time()
                last_attack_addr = current_target_npc
                threading.Thread(
                    target=agro_watchdog,
                    args=(current_target_npc, last_attack_time),
                    daemon=True
                ).start()
        else:
            # Clean release on transition
            if ctrl_engaged:
                release_key('ctrl')
                ctrl_engaged = False

def is_attacking() -> bool:
    return ctrl_engaged

def recently_attacking(addr: str | None, window: float = ATTACK_RECENCY_S) -> bool:
    return (addr is not None
            and addr == last_attack_addr
            and (time.time() - last_attack_time) < window)

def get_flank_candidates(npc_x, npc_y, r):
    # four tiles exactly r away on same row/col
    return [(npc_x - r, npc_y), (npc_x + r, npc_y),
            (npc_x, npc_y - r), (npc_x, npc_y + r)]

def on_message_xy(message, data):
    global xstarted, x_address, y_address
    if message['type'] == 'send':
        addresses = message['payload']
        x_address = int(addresses['x_address'], 16)
        y_address = int(addresses['y_address'], 16)
        if debug == 1:
            print(f"X Address: {hex(x_address)}, Y Address: {hex(y_address)}")
        # Mark as completed and detach session
        xstarted = 1
        session.detach()
    else:
        print(f"Error: {message}")

def scan_for_exp_address(pm: pymem.Pymem, search_value: int) -> int:
    """
    Scan memory from START_ADDR up to END_ADDR in 4‑byte steps.
    Returns the first address where pm.read_int(addr) == search_value.
    """
    for addr in range(START_ADDR, END_ADDR, STEP):
        try:
            value = pm.read_int(addr)
        except pymem.exception.MemoryReadError:
            # some pages can’t be read—just skip them
            continue

        if value == search_value:
            print(f"[+] Found EXP value {search_value} at {hex(addr)}")
            return addr

    raise RuntimeError(f"Couldn’t find {search_value} in 0x{START_ADDR:X}–0x{END_ADDR:X}")

def start_frida_session_xy(walk_address):
    global session
    session = frida.attach("Endless.exe")
    print("XY Started - Waiting for you to move to begin")
    script_code = f"""
    var baseAddress = Module.findBaseAddress("Endless.exe").add(ptr({walk_address}));
    Interceptor.attach(baseAddress, {{
        onEnter: function(args) {{
            var xAddress = this.context.ecx.add(0x08);
            var yAddress = xAddress.add(0x04);
            send({{x_address: xAddress.toString(), y_address: yAddress.toString()}});
        }}
    }});
    """
    script = session.create_script(script_code)
    script.on('message', on_message_xy)
    script.load()

    while xstarted == 0:
        continue

    print("Session completed and detached.")

def on_message_directional(message, data):
    global directional_address, xstarted
    if message['type'] == 'send':
        payload = message['payload']
        directional_address = int(payload.get('directional_address'), 16)
        character_direction = payload.get('character_direction')
        if debug == 1:
            print(f"Character Direction Address: {directional_address}")
            print(f"Character Direction Value: {character_direction}")
        xstarted = 2
        session.detach()
    elif message['type'] == 'error':
        print(f"Error: {message['stack']}")

def start_frida_session_directional(target_address):
    global session
    session = frida.attach("Endless.exe")
    print("Directional Started - Waiting for mov [ebx+55],dl to execute")
    script_code = f"""
    var baseAddress = Module.findBaseAddress("Endless.exe").add(ptr("{target_address}"));
    Interceptor.attach(baseAddress, {{
        onEnter: function(args) {{
            var ebxValue = this.context.ebx;
            var characterDirectionAddress = ebxValue.add(0x55);
            var characterDirection = characterDirectionAddress.readU8();
            send({{directional_address: characterDirectionAddress.toString(), character_direction: characterDirection.toString()}});
        }}
    }});
    """
    script = session.create_script(script_code)
    script.on('message', on_message_directional)
    script.load()

    while xstarted == 1:
        continue

    print("Directional Session Completed.")

def patch_adds_with_nops():
    # attach to the process
    session = frida.attach("Endless.exe")

    # inline the two absolute addresses you want to NOP
    js = """
    [0x005EE862, 0x005EE87C].forEach(function(addr) {
        // make the 7 bytes at addr writeable
        Memory.protect(ptr(addr), 7, 'rwx');
        // overwrite them with NOP (0x90)
        for (var i = 0; i < 7; i++) {
          Memory.writeU8(ptr(addr).add(i), 0x90);
        }
        // restore as RX
        Memory.protect(ptr(addr), 7, 'r-x');
    });
    """

    script = session.create_script(js)
    script.load()
    session.detach()

def start_frida_weight_lock(weight_write_offsets):
    """
    Hooks the instructions that write the weight value and forces the
    written register to 0 (locks weight at zero).

    Params:
        weight_write_offsets: iterable of relative offsets (RVA) from Endless.exe base
                              e.g. [0xFAF26, 0xFA5AF]
    """
    import frida, threading, time

    # Attach once for this feature (kept separate from your other sessions)
    session = frida.attach("Endless.exe")

    # Build the Frida script (module-safe, 32/64-bit friendly)
    js = f"""
    (function() {{
        var mod = null;
        try {{
            mod = Process.getModuleByName("Endless.exe");
        }} catch (e) {{
            var mods = Process.enumerateModules();
            mod = mods.length ? mods[0] : null;
        }}
        if (!mod) {{
            throw new Error("Could not resolve Endless.exe module.");
        }}
        var base = mod.base;

        // Offsets provided by Python
        var OFFS = [{", ".join("ptr(0x%X)" % off for off in weight_write_offsets)}];

        OFFS.forEach(function(rel) {{
            var addr = base.add(rel);
            try {{
                Interceptor.attach(addr, {{
                    onEnter: function (args) {{
                        // Force the destination register/value to zero.
                        // If this instruction writes from EAX/RAX (common pattern),
                        // zeroing it here will clamp the write to 0.
                        if (this.context.eax !== undefined) {{
                            this.context.eax = 0;
                        }} else if (this.context.rax !== undefined) {{
                            this.context.rax = ptr(0);
                        }}
                    }}
                }});
            }} catch (e) {{
                send({{type: "weight-lock-hook-error", address: addr.toString(), error: e.toString()}});
            }}
        }});

        send({{type: "weight-lock-ready", count: OFFS.length}});
    }})();
    """.strip()

    script = session.create_script(js)

    def _on_message(message, data):
        # Bubble up meaningful errors to your console
        if message.get("type") == "send":
            payload = message.get("payload", {})
            if payload.get("type") == "weight-lock-ready":
                print(f"[frida] Weight lock enabled on {payload.get('count')} addresses.")
            elif payload.get("type") == "weight-lock-hook-error":
                print(f"[frida] Hook failed @ {payload.get('address')}: {payload.get('error')}")
        elif message.get("type") == "error":
            print("[frida] Script error:", message)

    script.on("message", _on_message)
    script.load()
    print("[frida] Weight lock hooks installed (listening).")
    # Keep the session alive in this thread
    # (Your program stays alive anyway; no busy loop needed.)

class PlayerDataManager:
    def __init__(self):
        self.data = {
            "x": 0,
            "y": 0,
            "direction": 0
        }

    def update(self, x, y, direction):
        self.data["x"] = x
        self.data["y"] = y
        self.data["direction"] = direction

    def get_data(self):
        return self.data

class AddressManager:
    """
    Tracks known NPC addresses; now includes per-NPC protection windows.
    Pulled/trimmed from your v5 version.
    """
    def __init__(self):
        self.addresses = {}
        self._lock = threading.Lock()
        self._removal_history = []
        self._history_max = 50
        self._protection_default = 8  # seconds
        self.ignore_protection = False
        

    def set_ignore_protection(self, flag: bool):
        self.ignore_protection = bool(flag)

    def is_protected(self, addr_hex: str) -> bool:
        """Respect the global ignore flag; if True, nothing is protected."""
        if self.ignore_protection:
            return False
        st = self.addresses.get(addr_hex)
        if not st:
            return False
        pu = st.get("protected_until")
        now = time.time()
        if pu and now < pu:
            return True
        # If protection just ended, start quarantine and keep filtering briefly
        if pu and now >= pu:
            st["protected_until"] = None
            st["protected_cleared_at"] = now
        # Quarantine window
        pc = st.get("protected_cleared_at")
        if pc and (now - pc) < POST_PROTECT_GRACE_S:
            return True
        return False

    def add_address(self, address):
        address1 = int(address, 16)
        address2 = address1 + 2
        address1_hex = hex(address1).upper()
        address2_hex = hex(address2).upper()
        with self._lock:
            if address1_hex not in self.addresses:
                self.addresses[address1_hex] = {
                    "paired_address": address2_hex,
                    "last_x": None,
                    "last_y": None,
                    "last_moved": time.time(),
                    "is_dead_counter": 0,
                    "last_is_dead_value": None,
                    "last_npc_id": None,
                    "last_unique_id": None,
                    "got_hit": None,
                    "protected_until": None,
                    "read_fail_count": 0,
                    "protected_until": None,
                    "protected_cleared_at": None,
                }
                return True
        return False

    def _log_removal(self, addr_hex: str, reason: str, meta: dict | None, last_state: dict | None):
        entry = {
            "ts": time.time(),
            "address": addr_hex,
            "reason": reason,
            "meta": meta or {},
            "last_state": last_state or {},
        }
        self._removal_history.append(entry)
        if len(self._removal_history) > self._history_max:
            self._removal_history = self._removal_history[-self._history_max:]

        # Skip noisy protection lines unless debugging
        if reason.startswith("protected:") and not DEBUG_PROTECTED:
            return

        ts = time.strftime("%H:%M:%S", time.localtime(entry["ts"]))
        m = entry["meta"] or {}

        def _fmt_float(val, default="?"):
            # Robust: returns a string; uses one decimal when numeric, else raw/default
            try:
                return f"{float(val):.1f}"
            except Exception:
                return str(val) if val is not None else default

        # Build a friendly reason string safely
        if reason == "exp_kill":
            friendly = f"EXP tick suggests kill (+{m.get('delta_exp','?')})."
        elif reason == "stale":
            friendly = f"No movement for {m.get('stale_seconds','?')}s."
        elif reason == "stale_movement":
            friendly = f"Stationary for {_fmt_float(m.get('idle_secs'))}s."
        elif reason == "oob":
            friendly = f"Out of bounds x={m.get('x')} y={m.get('y')}."
        elif reason == "read_error":
            friendly = f"Read error: {m.get('error','?')}."
        elif reason == "read_fail":
            friendly = f"{m.get('consecutive_failures', '?')} consecutive read failures."
        else:
            friendly = "No details."

        print(f"[{ts}] [manager] Removed NPC {addr_hex}  reason={reason}  info={friendly}")

    # ---- New protection API (from v5) ----
    def mark_protected(self, addr_hex: str, seconds: int | None = None, reason: str = "got_hit", meta: dict | None = None):
        secs = seconds if seconds is not None else self._protection_default
        st = self.addresses.get(addr_hex)
        if not st:
            return False
        st["protected_until"] = time.time() + max(1, secs)
        st["protected_cleared_at"] = None
        self._log_removal(addr_hex, f"protected:{reason}", meta or {}, dict(st))
        return True

    def protection_seconds_left(self, addr_hex: str) -> int:
        st = self.addresses.get(addr_hex)
        if not st or not st.get("protected_until"):
            return 0
        return max(0, int(st["protected_until"] - time.time()))

    def remove_address(self, address, reason: str = "unspecified", meta: dict | None = None):
        address1 = int(address, 16)
        address1_hex = hex(address1).upper()
        with self._lock:
            if address1_hex in self.addresses:
                last_state = dict(self.addresses[address1_hex])
                del self.addresses[address1_hex]
                self._log_removal(address1_hex, reason, meta, last_state)
                return True
        return False

    def update_address_movement(self, address, x, y):
        with self._lock:
            state = self.addresses.get(address)
            if state:
                now = time.time()
                if x != state["last_x"] or y != state["last_y"]:
                    state["last_moved"] = now
                    state["last_x"] = x
                    state["last_y"] = y

    def remove_stale_addresses(self, max_stale=None):
        if max_stale is None:
            max_stale = STALE_NPC_SECONDS
        now = time.time()
        to_remove = []
        with self._lock:
            for addr, data in list(self.addresses.items()):
                if data["last_moved"] is not None and now - data["last_moved"] > max_stale:
                    to_remove.append(addr)
            for addr in to_remove:
                last_state = dict(self.addresses[addr])
                del self.addresses[addr]
                self._log_removal(addr, "stale", {"stale_seconds": max_stale}, last_state)

    def list_addresses(self):
        with self._lock:
            return [
                {"address": addr, "paired": data["paired_address"], "got_hit": data["got_hit"]}
                for addr, data in self.addresses.items()
            ]

    def recent_removals(self, n: int = 10):
        return self._removal_history[-n:]
manager = AddressManager()
player_data_manager = PlayerDataManager()
map_data = []
map_data_lock = threading.Lock()

class PlayerDataPopup:
    def __init__(self, player_data_manager):
        self.player_data_manager = player_data_manager
        self.root = tk.Tk()
        self.root.title("Player Data")
        self.labels = {}
        self.protect_var = tk.BooleanVar(value=False)  # <--- NEW: default unchecked (protection enabled)
        self.create_widgets()
        self.create_styles()
        self.update_ui()

    def create_widgets(self):
        self.frame = ttk.Frame(self.root, padding="10")
        self.frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))

        # Existing labels...
        for idx, text in enumerate(["X", "Y", "Direction"], start=2):
            ttk.Label(self.frame, text=text).grid(row=idx, column=0, sticky=tk.W)
            value_label = ttk.Label(self.frame, text="0")
            value_label.grid(row=idx, column=1, sticky=tk.E)
            self.labels[text] = value_label

        # Map canvas
        self.canvas = tk.Canvas(self.frame, width=200, height=200, bg="white")
        self.canvas.grid(row=0, column=2, rowspan=6, padx=10)

        # --- NEW: checkbox row (put it neatly under the stats) ---
        ttk.Checkbutton(
            self.frame,
            text="Disable protected NPCs (boss mode)",
            variable=self.protect_var,
            command=self._on_toggle_protection
        ).grid(row=6, column=0, columnspan=2, sticky=(tk.W), pady=(8, 0))

        # Small status hint (optional)
        self.status_label = ttk.Label(self.frame, text="Protected NPCs: ENABLED")
        self.status_label.grid(row=7, column=0, columnspan=2, sticky=tk.W)


                # --- Hold-at-range (lock) toggle ---
        self.hold_lock_var = tk.BooleanVar(value=HOLD_AT_RANGE_LOCK)
        ttk.Checkbutton(
            self.frame,
            text="Hold at range (no retreat)",
            variable=self.hold_lock_var,
            command=self._on_hold_lock_toggle
        ).grid(row=8, column=0, columnspan=2, sticky=tk.W, pady=(6, 0))

        # --- Flank range control ---
        self.flank_var = tk.IntVar(value=FLANK_RANGE)
        ttk.Label(self.frame, text="Flank Range").grid(row=9, column=0, sticky=tk.W, pady=(10, 0))
        self.flank_spin = tk.Spinbox(
            self.frame, from_=1, to=8, width=5,
            textvariable=self.flank_var,
            command=self._on_flank_change,
            justify="center"
        )
        self.flank_spin.grid(row=9, column=1, sticky=tk.W, pady=(10, 0))
        self.flank_spin.bind("<Return>", lambda e: self._on_flank_change())
        self.flank_spin.bind("<FocusOut>", lambda e: self._on_flank_change())

        
    def _on_toggle_protection(self):
        # When checked, IGNORE protection (i.e., don't filter or postpone targets that got hit)
        manager.set_ignore_protection(self.protect_var.get())
        self.status_label.config(
            text="Protected NPCs: DISABLED (boss mode)" if self.protect_var.get()
                 else "Protected NPCs: ENABLED"
        )

    
    def create_styles(self):
        style = ttk.Style(self.root)
        style.theme_use('default')
        style.configure("red.Horizontal.TProgressbar", troughcolor='white', background='red')
        style.configure("blue.Horizontal.TProgressbar", troughcolor='white', background='blue')

    def update_ui(self):
        data = self.player_data_manager.get_data()
        self.labels["X"].config(text=data["x"])
        self.labels["Y"].config(text=data["y"])
        self.labels["Direction"].config(text=data["direction"])
        self.draw_map()
        self.root.after(100, self.update_ui)

    def draw_map(self):
        # Clear previous drawings.
        self.canvas.delete("all")
        # Set canvas and grid parameters.
        canvas_size = 200
        max_x = 20
        max_y = 20
        cell_width = canvas_size / max_x
        cell_height = canvas_size / max_y
        # Draw a gray background covering the entire canvas.
        self.canvas.create_rectangle(0, 0, canvas_size, canvas_size, fill="gray", outline="")     
        # Draw vertical grid lines.
        for i in range(max_x + 1):
            x = i * cell_width
            self.canvas.create_line(x, 0, x, canvas_size, fill="black")
        # Draw horizontal grid lines.
        for j in range(max_y + 1):
            y = j * cell_height
            self.canvas.create_line(0, y, canvas_size, y, fill="black")
        # Get player data.
        data = self.player_data_manager.get_data()
        player_x = data["x"]
        player_y = data["y"]
        # Define the center of the canvas.
        center_x = canvas_size / 2
        center_y = canvas_size / 2
        player_radius = 5
        # Draw the player at the center of the canvas.
        self.canvas.create_oval(center_x - player_radius, center_y - player_radius,
                                center_x + player_radius, center_y + player_radius,
                                fill="orange", outline="black")
        # Draw NPC markers.
        for item in map_data:
            if item["type"] == "npc":
                npc_x = item["X"]
                npc_y = item["Y"]
                # Map world coordinates to canvas positions relative to the player.
                canvas_x = center_x + (npc_x - player_x) * cell_width
                canvas_y = center_y + (npc_y - player_y) * cell_height
                self.canvas.create_oval(canvas_x - 3, canvas_y - 3,
                                        canvas_x + 3, canvas_y + 3,
                                        fill="red", outline="black")
                
    def _on_flank_change(self):
        """Validate and push GUI value to the global FLANK_RANGE."""
        global FLANK_RANGE
        try:
            val = int(self.flank_var.get())
        except Exception:
            # revert to current global if invalid
            self.flank_var.set(FLANK_RANGE)
            return

        # clamp to a sane range
        if val < 1: val = 1
        if val > 8: val = 8

        # reflect any clamping in the UI
        if val != self.flank_var.get():
            self.flank_var.set(val)

        FLANK_RANGE = val

        # persist (optional)
        cfg = load_config()
        cfg["FLANK_RANGE"] = FLANK_RANGE
        save_config(cfg)

    def _on_hold_lock_toggle(self):
        global HOLD_AT_RANGE_LOCK
        HOLD_AT_RANGE_LOCK = bool(self.hold_lock_var.get())
        cfg = load_config()
        cfg["HOLD_AT_RANGE_LOCK"] = HOLD_AT_RANGE_LOCK
        save_config(cfg)

    def run(self):
        self.root.mainloop()

def check_player_data(x_address, y_address, directional_address):
    global pm
    initialize_pymem()
    prev_dir = 0  # keep last good direction so a bad read doesn't stall map_data
    try:
        while True:
            # --- read X/Y robustly ---
            try:
                x = pm.read_short(x_address)
                y = pm.read_short(y_address)
            except Exception as e:
                print(f"[player] XY read failed: {e}")
                time.sleep(0.05)
                continue  # we can't build a player row without XY

            # --- read direction *best-effort* ---
            try:
                direction = pm.read_bytes(directional_address, 1)[0]
                prev_dir = direction
            except Exception as e:
                direction = prev_dir  # fall back; do NOT skip publishing the player row
                # (optional) print sparingly:
                # print(f"[player] direction read failed (using {prev_dir}): {e}")

            # --- read X/Y robustly ---
            try:
                x = pm.read_short(x_address)
                y = pm.read_short(y_address)
            except Exception as e:
                ...
            # --- read direction best-effort ---
            try:
                direction = pm.read_bytes(directional_address, 1)[0]
                prev_dir = direction
            except Exception:
                direction = prev_dir

            # ✅ add this so the GUI sees live player coords
            player_data_manager.update(x, y, direction)

            # seed the next snapshot with the player, no matter what
            temp_map_data = [{
                "type": "player",
                "X": x,
                "Y": y,
                "direction": direction
            }]

            # --- NPCs are best-effort; errors here shouldn't drop the player row ---
            for addr, data in list(manager.addresses.items()):
                address_x = int(addr, 16)
                address_y = int(data["paired_address"], 16)
                try:
                    value_x = pm.read_short(address_x)
                    value_y = pm.read_short(address_y)

                    manager.update_address_movement(addr, value_x, value_y)

                    # oob cull
                    if value_x < 0 or value_y < 0 or value_x > 100 or value_y > 100:
                        manager.remove_address(addr, reason="out_of_bounds",
                                               meta={"x": value_x, "y": value_y})
                        continue

                    got_hit = pm.read_int(address_x + 0x1D0)

                    st = manager.addresses.get(addr)
                    if st is not None:
                        prev_gh = st.get("got_hit") or 0
                        st["got_hit"] = got_hit

                        if got_hit > prev_gh:
                            my_target = (addr == current_target_npc)

                            # Am I plausibly the hitter on THIS address?
                            self_active = my_target and (
                                is_attacking() or
                                recently_attacking(addr, window=ATTACK_RECENCY_S + PRE_HIT_GRACE_S)
                            )

                            # For our current target, push out an eligibility timestamp whenever we're hitting.
                            now_s = time.time()
                            if my_target and self_active:
                                # stash per-NPC without new globals
                                st["protect_eligible_at"] = now_s + (ATTACK_RECENCY_S + PRE_HIT_GRACE_S)

                            if not my_target:
                                # Non-targets: protect instantly (unchanged)
                                manager.mark_protected(
                                    addr, seconds=8, reason="got_hit",
                                    meta={"prev": prev_gh, "now": got_hit}
                                )
                            else:
                                # Current target: only protect if we're no longer the hitter AND cooldown passed
                                eligible_at = st.get("protect_eligible_at", 0.0)
                                if (not self_active) and (now_s >= eligible_at):
                                    manager.mark_protected(
                                        addr, seconds=8, reason="got_hit",
                                        meta={"prev": prev_gh, "now": got_hit, "elig_at": eligible_at, "now_s": now_s}
                                    )

                    # Keep allowing your own target even if protected, so you can keep fighting it
                    if manager.is_protected(addr) and not (
                        addr == current_target_npc and (
                            is_attacking() or recently_attacking(addr, window=ATTACK_RECENCY_S)
                        )
                    ):
                        continue

                    temp_map_data.append({
                        "type": "npc",
                        "X": value_x,
                        "Y": value_y,
                        "address_x": addr,
                        "address_y": data["paired_address"]
                    })
                except Exception:
                    # Ignore per-NPC failures; keep the rest flowing
                    continue

            # atomic swap for UI + combat thread
            with map_data_lock:
                map_data.clear()
                map_data.extend(temp_map_data)

            time.sleep(0.1)
    except Exception as e:
        print(f"Failed to initialize memory reading: {e}")

def on_message(message, data):
    if message['type'] == 'send':
        payload = message['payload']
        action = payload.get('action')
        address = payload.get('address')
        if action == 'add' and address is not None:
            manager.add_address(address)

def start_frida(npc_address):
    print("Npc Started")
    frida_script = f"""
Interceptor.attach(Module.findBaseAddress("Endless.exe").add({npc_address}), {{
    onEnter: function(args) {{
        var eax = this.context.eax.toInt32();
        var offset = {varOffset};
        var address = eax + offset;
        var addressHex = '0x' + address.toString(16).toUpperCase();
        send({{action: 'add', address: addressHex}});
    }}
}});
"""
    session = frida.attach("Endless.exe")
    script = session.create_script(frida_script)
    script.on('message', on_message)
    script.load()

def check_values():
    global pm, combat_baseline_exp, current_target_npc, pickup_points
    initialize_pymem()

    if combat_baseline_exp is None:
        try:
            combat_baseline_exp = pm.read_int(totalExp)
            print(f"Combat baseline EXP initialized: {combat_baseline_exp}")
        except Exception as e:
            print(f"Error initializing baseline EXP: {e}")

    while True:
        try:
            current_exp = pm.read_int(totalExp)
            if current_exp > combat_baseline_exp:
                delta = current_exp - combat_baseline_exp
                print(f"EXP increased from {combat_baseline_exp} to {current_exp}.")
                if current_target_npc is not None:
                    manager.remove_address(
                        current_target_npc,
                        reason="exp_kill",
                        meta={"from": combat_baseline_exp, "to": current_exp, "delta_exp": delta}
                    )
                combat_baseline_exp = current_exp

            # Build reasons while scanning
            removals = []
            current_time = time.time()

            for x in list(manager.addresses.keys()):
                data = manager.addresses[x]
                address_x = int(x, 16)
                address_y = int(data["paired_address"], 16)
                try:
                    value_x = pm.read_short(address_x)
                    value_y = pm.read_short(address_y)

                    last_x = data.get("last_x")
                    last_y = data.get("last_y")
                    last_moved = data.get("last_moved")

                    if value_x != last_x or value_y != last_y:
                        manager.addresses[x]["last_x"] = value_x
                        manager.addresses[x]["last_y"] = value_y
                        manager.addresses[x]["last_moved"] = current_time
                    else:
                        idle = current_time - last_moved if last_moved else 9999
                        if idle > STALE_NPC_SECONDS:
                            removals.append((x, "stale_movement", {"idle_secs": idle}))

                    # Out-of-bounds guard
                    if value_x == 0 or value_x > 100 or value_y == 0 or value_y > 100:
                        removals.append((x, "oob", {"x": value_x, "y": value_y}))

                except Exception as e:
                    removals.append((x, "read_error", {"error": str(e)[:80]}))

            # Dedup by address; prefer earlier reason
            seen = set()
            for addr, reason, meta in removals:
                if addr in seen:
                    continue
                seen.add(addr)
                manager.remove_address(addr, reason=reason, meta=meta)

        except Exception as e:
            print(f"Error in check_values: {e}")

        time.sleep(0.05)

def load_walkable_tiles(file_path='walkable.json'):
    try:
        with open(file_path, 'r') as f:
            data = json.load(f)
            if 'safe_tiles' in data and data['safe_tiles']:
                return {(tile['X'], tile['Y']) for tile in data['safe_tiles']}
            else:
                print("No valid tiles found in file, using default walkable tiles.")
                return {(x, y) for x in range(101) for y in range(101)}
    except (FileNotFoundError, json.JSONDecodeError) as e:
        print(f"Error loading walkable tiles: {e}. Using default walkable tiles.")
        return {(x, y) for x in range(101) for y in range(101)}

def heuristic(a, b):
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

def astar_pathfinding(start, goal, walkable_tiles):
    open_set = PriorityQueue()
    open_set.put((0, start))
    came_from = {}
    g_score = {start: 0}
    f_score = {start: heuristic(start, goal)}
    while not open_set.empty():
        _, current = open_set.get()
        if current == goal:
            path = []
            while current in came_from:
                path.append(current)
                current = came_from[current]
            path.append(start)
            path.reverse()
            return path
        for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]:
            neighbor = (current[0] + dx, current[1] + dy)
            if neighbor in walkable_tiles:
                tentative_g_score = g_score[current] + 1
                if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
                    came_from[neighbor] = current
                    g_score[neighbor] = tentative_g_score
                    f_score[neighbor] = tentative_g_score + heuristic(neighbor, goal)
                    open_set.put((f_score[neighbor], neighbor))
    return None

def find_closest_npc(player_x, player_y, npcs):
    closest_npc = None
    min_distance = float('inf')
    for npc in npcs:
        distance = abs(player_x - npc['X']) + abs(player_y - npc['Y'])
        if distance < min_distance:
            min_distance = distance
            closest_npc = npc
    return closest_npc

pause_flag = False

def key_listener():
    global pause_flag
    import keyboard
    while True:
        if keyboard.is_pressed(','):
            pause_flag = True
            print("Pausing for 1 minute...")
            time.sleep(60)
            pause_flag = False
            print("Resuming combat...")
        time.sleep(0.1)

last_combat_time = time.time()
sitting = False

def combat_thread():
    global last_combat_time, sitting, pause_flag, current_target_npc, recover_to_range_until, flank_hold_target, HOLD_AT_RANGE_LOCK
    walkable_tiles = set(load_walkable_tiles()) or {(x, y) for x in range(101) for y in range(101)}
    last_direction = None
    wandering_target = None
    ctrl_pressed = False
    blocked_tiles = {}
    BLOCK_TTL_S = 4.0
    stuck = UniversalStuck(step_timeout_s=1.2)
    HOLD_UNTIL_ADJACENT = True

    while True:
        if pause_flag:
            time.sleep(1)
            continue

        current_time = time.time()

        # Cull expired blocked tiles and compute walkable set for this tick
        blocked_tiles = {tile: expire_time for tile, expire_time in blocked_tiles.items() if expire_time > current_time}
        adjusted_walkable_tiles = walkable_tiles.difference(blocked_tiles.keys())

        # ---- Map snapshot (thread-safe) ----
        with map_data_lock:
            snapshot = list(map_data)
        if not snapshot:
            time.sleep(0.01)
            continue

        # Player + NPCs for this tick
        try:
            player = next(item for item in snapshot if item.get("type") == "player")
        except StopIteration:
            time.sleep(0.01)
            continue
        npcs = [item for item in snapshot if item.get("type") == "npc"]

        # ---- Soft reacquire config ----
        REACQUIRE_MAX_DIST = 20.0   # tweak to your melee reach + buffer
        AUTO_RESUME_ATTACK = True   # resume Ctrl after re-aiming

        def _dist(ax, ay, bx, by):
            dx = float(ax) - float(bx)
            dy = float(ay) - float(by)
            return (dx*dx + dy*dy) ** 0.5

        # ---- If current target vanished, clear & soft-reacquire (orientation + optional attack) ----
        if current_target_npc is not None:
            target_in_snapshot = any(n["address_x"] == current_target_npc for n in npcs)
            if not target_in_snapshot:
                print(f"[target] Clearing current target {current_target_npc} — reason=not_in_snapshot")
                current_target_npc = None
                set_attack(False)  # release Ctrl first

                if npcs:
                    px, py = player["X"], player["Y"]
                    cand = min(npcs, key=lambda n: _dist(px, py, n["X"], n["Y"]))
                    cand_dist = _dist(px, py, cand["X"], cand["Y"])
                    if cand_dist <= REACQUIRE_MAX_DIST:
                        current_target_npc = cand["address_x"]
                        print(f"[target] Soft-reacquired {current_target_npc} at dist {cand_dist:.1f} — orient")
                        if AUTO_RESUME_ATTACK:
                            set_attack(True)

        # ---- ALWAYS build valid_npcs (even if no current target) ----
        valid_npcs = []
        for npc in npcs:
            # must be on a walkable tile
            if (npc["X"], npc["Y"]) not in adjusted_walkable_tiles:
                continue
            addr = npc["address_x"]

            # allow our current target even if protected, while we’re attacking/recently attacked
            if manager.is_protected(addr) and not (addr == current_target_npc and (is_attacking() or recently_attacking(addr))):
                continue

            valid_npcs.append(npc)

        # ---- If no valid NPCs, wander (send movement keys) ----
        if not valid_npcs:
            set_attack(False)

            # Pick/refresh a wander goal when needed
            if not wandering_target or (player["X"], player["Y"]) == wandering_target:
                wandering_target = random.choice(list(adjusted_walkable_tiles))

            path_to_wander = astar_pathfinding(
                (player["X"], player["Y"]),
                wandering_target,
                adjusted_walkable_tiles
            )

            if path_to_wander and len(path_to_wander) > 1:
                next_step = path_to_wander[1]
                move_to_x, move_to_y = next_step

                # >>> Universal stuck check
                event = stuck.begin_or_continue(next_step, (player["X"], player["Y"]), current_time)
                if event and event[0] == 'timeout':
                    blocked_tiles[next_step] = current_time + BLOCK_TTL_S
                    print(f"[stuck/universal] Blocking tile {next_step} for {BLOCK_TTL_S:.1f}s (timeout {stuck.step_timeout_s:.1f}s)")
                    wandering_target = None  # force new goal/route next tick
                    continue

                # Move toward the step (no fake XY mutate)
                current_direction = None
                if player["X"] < move_to_x:   current_direction = "right"
                elif player["X"] > move_to_x: current_direction = "left"
                if player["Y"] < move_to_y:   current_direction = "down"
                elif player["Y"] > move_to_y: current_direction = "up"

                if current_direction:
                    if current_direction != last_direction:
                        press_key(current_direction, 2, 0.05)
                    else:
                        press_key(current_direction, 1, 0.05)
                    last_direction = current_direction

            else:
                # No path this tick; try a new wander target next loop
                wandering_target = None

            continue  # back to top of loop


        # ---------------- Combat logic (we have valid NPCs) ----------------
        if not sitting:
            # avoid stepping onto NPC tiles
            npc_positions = {(n["X"], n["Y"]) for n in valid_npcs}
            extended_walkable_tiles = adjusted_walkable_tiles.difference(npc_positions)

            # choose closest target
            closest_npc = find_closest_npc(player["X"], player["Y"], valid_npcs)

            # update global current target (by address key)
            prev_target = current_target_npc
            current_target_npc = closest_npc.get("address_x")
            if prev_target is not None and current_target_npc != prev_target:
                flank_hold_target = None

            npc_x, npc_y = closest_npc["X"], closest_npc["Y"]
            player_x, player_y = player["X"], player["Y"]

            dx = abs(player_x - npc_x)
            dy = abs(player_y - npc_y)
            eff_range = max(1, FLANK_RANGE)  # guard against 0

            # helpers
            def face_target():
                target_direction = None
                if player_y == npc_y:
                    target_direction = 3 if npc_x > player_x else 1  # East/West
                elif player_x == npc_x:
                    target_direction = 0 if npc_y > player_y else 2  # South/North
                if target_direction is not None and player["direction"] != target_direction:
                    time.sleep(0.2)
                    press_key(["down", "left", "up", "right"][target_direction], 1, 0.05)

            def has_los():
                los = list(bresenham.bresenham(player_x, player_y, npc_x, npc_y))
                return all((x, y) in walkable_tiles for x, y in los)

            now = time.time()

            # ---------- Sticky hold-at-range fast-path ----------
            if HOLD_AT_RANGE_LOCK and flank_hold_target == current_target_npc:
                if (player_y == npc_y or player_x == npc_x):
                    los = list(bresenham.bresenham(player_x, player_y, npc_x, npc_y))
                    if all((x, y) in walkable_tiles for x, y in los):
                        target_direction = None
                        if player_y == npc_y:
                            target_direction = 3 if npc_x > player_x else 1
                        else:
                            target_direction = 0 if npc_y > player_y else 2
                        if target_direction is not None and player["direction"] != target_direction:
                            time.sleep(0.2)
                            press_key(["down", "left", "up", "right"][target_direction], 1, 0.05)
                        set_attack(True)
                        continue
                # Lost axis or LOS; drop the lock and fall back to normal logic.
                flank_hold_target = None

            # ============= Phase A: EXACT at desired range (aligned) -> hold & attack
            if ((dx == eff_range and player_y == npc_y) or
                (dy == eff_range and player_x == npc_x)):
                if has_los():
                    face_target()
                    set_attack(True)
                    flank_hold_target = current_target_npc  # enable sticky hold once we hit range
                    continue

            # ============= Phase B: INSIDE range but not adjacent (aligned) -> hold & attack
            if (now >= recover_to_range_until) and (
                ((1 < dx < eff_range) and player_y == npc_y) or
                ((1 < dy < eff_range) and player_x == npc_x)
            ):
                if has_los():
                    face_target()
                    set_attack(True)
                    flank_hold_target = current_target_npc
                    continue

            # ============= Phase C: ADJACENT (distance 1) -> retreat to eff_range, with sidestep fallback
            if ((dx == 1 and player_y == npc_y) or
                (dy == 1 and player_x == npc_x)):

                set_attack(False)  # never swing while we are trying to open space
                recover_to_range_until = now + RECOVER_SECS

                # --- 1) Compute straight-back direction away from NPC (axis-aligned) ---
                step_x = 0 if player_x == npc_x else (1 if player_x > npc_x else -1)
                step_y = 0 if player_y == npc_y else (1 if player_y > npc_y else -1)

                back_target = None
                fallback = None
                exact_target = None
                ge_target = None

                # how many tiles straight back ideally from adjacency to hit eff_range?
                # from dist=1, moving away k tiles => new dist = 1 + k, so k = eff_range - 1
                ideal_k = max(1, eff_range - 1)

                for k in range(1, 9):
                    tx, ty = player_x + step_x * k, player_y + step_y * k
                    if (tx, ty) in adjusted_walkable_tiles:
                        dist_here = abs(tx - npc_x) + abs(ty - npc_y)

                        # remember farthest valid seen so far (in case corridor too short)
                        fallback = (tx, ty)

                        # prefer exact first
                        if dist_here == eff_range:
                            exact_target = (tx, ty)
                            break
                        # otherwise remember first >= eff_range as secondary
                        if dist_here > eff_range and ge_target is None:
                            ge_target = (tx, ty)
                    else:
                        continue

                # pick the best we found
                if exact_target is not None:
                    back_target = exact_target
                elif ge_target is not None:
                    back_target = ge_target
                else:
                    back_target = fallback  # may still be < eff_range if we’re in a tight corridor

                # Helper to move one step along a path with universal stuck guard and keypress
                def _move_along(path):
                    global recover_to_range_until
                    nonlocal last_direction
                    if not path or len(path) < 2:
                        return False

                    next_step = path[1]
                    if next_step in blocked_tiles:
                        return False

                    # universal stuck detection
                    event = stuck.begin_or_continue(next_step, (player_x, player_y), current_time)
                    if event and event[0] == 'timeout':
                        blocked_tiles[next_step] = current_time + BLOCK_TTL_S
                        print(f"[stuck/universal] Blocking tile {next_step} for {BLOCK_TTL_S:.1f}s (timeout {stuck.step_timeout_s:.1f}s)")
                        return False

                    move_to_x, move_to_y = next_step

                    # convert delta -> direction
                    dir_to_press = None
                    if player_x < move_to_x:   dir_to_press = "right"
                    elif player_x > move_to_x: dir_to_press = "left"
                    if player_y < move_to_y:   dir_to_press = "down"
                    elif player_y > move_to_y: dir_to_press = "up"

                    if dir_to_press:
                        # nudge a bit harder on direction changes to overcome inertia
                        if dir_to_press != last_direction:
                            press_key(dir_to_press, 2, 0.05)
                        else:
                            press_key(dir_to_press, 1, 0.05)
                        last_direction = dir_to_press

                    # if this step spaces us out to eff_range or we reached the planned target, add a short recover
                    target_xy = back_target if back_target is not None else side_target
                    if (abs(move_to_x - npc_x) + abs(move_to_y - npc_y) >= eff_range) or (target_xy and (move_to_x, move_to_y) == target_xy):
                        recover_to_range_until = current_time + RECOVER_SECS

                    return True

                # --- 3) Try to route to the straight-back target first ---
                if back_target:
                    path = astar_pathfinding((player_x, player_y), back_target, adjusted_walkable_tiles)
                    if _move_along(path):
                        continue  # successful movement this tick

                # --- 4) Lateral sidestep fallback (break adjacency if straight back is blocked/unroutable) ---
                # Choose orthogonal candidates that INCREASE distance to NPC and are walkable.
                if player_y == npc_y:
                    # horizontally aligned; try up/down
                    lateral_candidates = [(player_x, player_y - 1), (player_x, player_y + 1)]
                else:
                    # vertically aligned; try left/right
                    lateral_candidates = [(player_x - 1, player_y), (player_x + 1, player_y)]

                side_target = next(
                    (t for t in lateral_candidates
                    if t in adjusted_walkable_tiles and
                        (abs(t[0] - npc_x) + abs(t[1] - npc_y) > (dx + dy))),  # strictly increase distance (>1)
                    None
                )

                if side_target:
                    path = astar_pathfinding((player_x, player_y), side_target, adjusted_walkable_tiles)
                    if _move_along(path):
                        continue  # we sidestepped; next tick we'll try straight-back probing again

                # --- 5) Could not move this tick: hold attack OFF and try again next loop ---
                # (stuck logic + blocked_tiles will keep us from hammering into the same tile forever)
                set_attack(False)
                continue

            # ============= Phase D: path to best flank tile at FLANK_RANGE
            set_attack(False)
            flank_candidates = get_flank_candidates(npc_x, npc_y, eff_range)

            flank_valid_primary = [p for p in flank_candidates if p in extended_walkable_tiles]
            flank_valid_fallback = [p for p in flank_candidates if p in adjusted_walkable_tiles]
            search_sets = [flank_valid_primary, flank_valid_fallback]  # (kept for clarity / future logging)

            def best_path_to(cands, tiles):
                options = []
                for tgt in cands:
                    p = astar_pathfinding((player_x, player_y), tgt, tiles)
                    if p:
                        options.append((p, tgt))
                return min(options, key=lambda x: len(x[0])) if options else None

            best = None
            for cand_set, tiles in [(flank_valid_primary, extended_walkable_tiles),
                                    (flank_valid_fallback, adjusted_walkable_tiles)]:
                best = best_path_to(cand_set, tiles)
                if best:
                    break

            if best:
                best_path, best_target = best

                # If path length is 1, we're already at the flank tile.
                if len(best_path) >= 2:
                    next_step = best_path[1]
                    if next_step in blocked_tiles:
                        continue

                    move_to_x, move_to_y = next_step
                    

                    # >>> Universal stuck check
                    event = stuck.begin_or_continue(next_step, (player["X"], player["Y"]), current_time)
                    if event and event[0] == 'timeout':
                        blocked_tiles[next_step] = current_time + BLOCK_TTL_S
                        print(f"[stuck/universal] Blocking tile {next_step} for {BLOCK_TTL_S:.1f}s (timeout {stuck.step_timeout_s:.1f}s)")
                        continue  # pick a new path next tick

                    # Move toward the step (no fake XY mutate)
                    current_direction = None
                    if player_x < move_to_x:   current_direction = "right"
                    elif player_x > move_to_x: current_direction = "left"
                    if player_y < move_to_y:   current_direction = "down"
                    elif player_y > move_to_y: current_direction = "up"

                    if current_direction:
                        if current_direction != last_direction:
                            press_key(current_direction, 2, 0.05)
                        else:
                            press_key(current_direction, 1, 0.05)
                        last_direction = current_direction

                    continue

                else:
                    # Already at flank tile — face and attack
                    face_target()
                    set_attack(True)
                    flank_hold_target = current_target_npc  # enable sticky hold
                    continue


            # Couldn’t find a flank path this tick: don’t attack; try again next frame
            set_attack(False)


def main():

    global totalExp, combat_baseline_exp
    attacknumber = 8

    # Hardcoded memory addresses
    walk_address = walkAddress
    npc_address = npcAddress
    directional_offset = directionalAddress

    print("Using hardcoded offsets:")
    print(f"Walk Address: {walk_address}")
    print(f"NPC Address: {npc_address}")
    print(f"Directional Address: {directional_offset}")

    patch_adds_with_nops()
   
    initialize_pymem()  # sets pm = Pymem("Endless.exe")

    search_value = int(input("Enter your current TOTAL EXP: "))
    totalExp = scan_for_exp_address(pm, search_value)
    combat_baseline_exp = pm.read_int(totalExp)
    print(f"[+] Using discovered totalExp pointer: {hex(totalExp)}")

    # 3) Start Frida hooks
    threading.Thread(target=start_frida, args=(npcAddress,), daemon=True).start()
    start_frida_session_xy(walkAddress)
    start_frida_session_directional(directionalAddress)

    # 4) Spawn background threads
    threading.Thread(target=check_player_data,
                     args=(x_address, y_address, directional_address),
                     daemon=True).start()
    threading.Thread(target=check_values, daemon=True).start()
    threading.Thread(target=combat_thread, daemon=True).start()
    threading.Thread(target=key_listener, daemon=True).start()

    threading.Thread(
        target=start_frida_weight_lock,
        args=(WEIGHT_WRITE_ADDRS,),
        daemon=True
    ).start()

    # 5) Launch your GUI (blocks until closed)
    PlayerDataPopup(player_data_manager).run()


if __name__ == "__main__":
    main()