Upload 2 files

ai.py

@@ -0,0 +1,1052 @@
+import os, sys, shutil, time, math, struct, subprocess, socket, warnings, threading, json, logging
+from pathlib import Path
+from collections import deque
+import numpy as np
+import cv2, mss, psutil, pyautogui
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+import ctypes
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.optim as optim
+    from torch.utils.data import TensorDataset, DataLoader
+    from tqdm.auto import tqdm
+    import optuna
+    from sklearn.model_selection import train_test_split
+except ImportError:
+    print("\033[91mKluczowe biblioteki (torch, tqdm, optuna, scikit-learn) nie są zainstalowane.\033[0m")
+    print("\033[93mUżyj: pip install torch tqdm optuna scikit-learn keyboard\033[0m")
+    torch = nn = optim = TensorDataset = DataLoader = tqdm = optuna = train_test_split = None
+
+try:
+    import keyboard
+except ImportError:
+    print("\033[91mBiblioteka 'keyboard' nie jest zainstalowana. Opcja nagrywania będzie niedostępna.\033[0m")
+    print("\033[93mUżyj: pip install keyboard\033[0m")
+    keyboard = None
+
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+class Colors:
+    RESET, RED, GREEN, YELLOW, BLUE, CYAN, MAGENTA, BOLD = (
+        "\033[0m","\033[91m","\033[92m","\033[93m","\033[94m","\033[96m","\033[95m","\033[1m"
+    )
+
+if os.name == 'nt':
+    class _CursorInfo(ctypes.Structure): _fields_ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
+    def hide_cursor():
+        ci = _CursorInfo(); handle = ctypes.windll.kernel32.GetStdHandle(-11)
+        ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci)); ci.visible = False
+        ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci))
+    def show_cursor():
+        handle = ctypes.windll.kernel32.GetStdHandle(-11); ci = _CursorInfo()
+        ctypes.windll.kernel32.GetConsoleCursorInfo(handle, ctypes.byref(ci)); ci.visible = True
+        ctypes.windll.kernel32.SetConsoleCursorInfo(handle, ctypes.byref(ci))
+    def reset_cursor_position():
+        handle = ctypes.windll.kernel32.GetStdHandle(-11); ctypes.windll.kernel32.SetConsoleCursorPosition(handle, 0)
+else:
+    def hide_cursor(): sys.stdout.write("\033[?25l"); sys.stdout.flush()
+    def show_cursor(): sys.stdout.write("\033[?25h"); sys.stdout.flush()
+    def reset_cursor_position(): sys.stdout.write("\x1b[H")
+
+TYPE_ROPE = 0.0
+TYPE_GROUND = 1.0
+
+SCRIPT_DIR = Path(__file__).parent.resolve()
+MODEL_SAVE_PATH = SCRIPT_DIR / "hcr_imitation_model.pth"
+DEMONSTRATIONS_PATH = SCRIPT_DIR / "hcr_demonstrations.npz"
+LOG_FILE_PATH = SCRIPT_DIR / "hcr_ai_log.txt"
+OPTUNA_DB_PATH = SCRIPT_DIR / "hcr_imitation_optuna.db"
+
+OPTUNA_TRIALS = 20
+OPTUNA_EPOCHS_PER_TRIAL = 40
+FINAL_MODEL_EPOCHS = 80
+
+MONITOR_INDEX = 1
+CAPTURE_RESOLUTION_WIDTH, CAPTURE_RESOLUTION_HEIGHT = 1280, 720
+PROCESS_NAME = "HillClimbRacing.exe"
+AUMID = "FINGERSOFT.HILLCLIMBRACING_xt3psb39rghm0!App"
+VELOCITY_SMOOTHING_FACTOR = 0.1
+
+DISTANCE_POINTER_CONFIG = {"base_offset": 0x28CA2C, "offsets": [0x130, 0x10C, 0x19C, 0xA8, 0xA8, 0x184, 0x164]}
+MAP_POINTER_CONFIG      = {"base_offset": 0x28CAB4, "offsets": []}
+FUEL_POINTER_CONFIG     = {"base_offset": 0x28CA2C, "offsets": [0x2A8]}
+
+MAP_IDS_TO_INDEX = {1:0, 3:1, 4:2, 5:3, 7:4, 9:5, 11:6, 14:7, 16:8, 17:9, 18:10, 20:11, 25:12}
+NUM_MAP_FEATURES = 13
+MAP_ID_PROGRESSION = [1, 3, 4, 5, 7, 9, 11, 14, 16, 17, 18, 20, 25]
+
+MAP_SELECT_BUTTON = (444, 513)
+START_RACE_BUTTON = (1050, 511)
+LIFE_CHECK_PIXEL_X, LIFE_CHECK_PIXEL_Y = 32, 31
+LIFE_CHECK_EXACT_RGB = (200, 0, 8)
+
+NUMBER_OF_RAYS, NUM_VERTICAL_SCANS = 37, 15
+MAX_CAR_RAY_DISTANCE, MAX_VERTICAL_RAY_DISTANCE = 700, 700
+NUM_ANGLE_FEATURES, NUM_VELOCITY_FEATURES = 2, 1
+LOWER_TARGET_GROUND, UPPER_TARGET_GROUND = np.array([142,250,250]), np.array([142,255,255])
+LOWER_ROPE,         UPPER_ROPE         = np.array([ 16, 94,188]), np.array([ 16, 94,188])
+LOWER_PINK,         UPPER_PINK         = np.array([147,255,255]), np.array([147,255,255])
+LOWER_YELLOW,       UPPER_YELLOW       = np.array([ 30,255,255]), np.array([ 30,255,255])
+
+INTERRUPT_REQUESTED = threading.Event()
+OBS_SIZE = (NUM_MAP_FEATURES + (NUMBER_OF_RAYS * 2) + (NUM_VERTICAL_SCANS * 2) + NUM_ANGLE_FEATURES + NUM_VELOCITY_FEATURES)
+
+STATE_LOCK = threading.Lock()
+DASH_STATE = {}
+
+def publish_to_dashboard(obs_used: np.ndarray, action:int, probs:list, reward:float, info:dict, step:int):
+    global DASH_STATE
+    if obs_used is None or obs_used.size == 0: return
+    try:
+        i = 0
+        mp = obs_used[i:i+NUM_MAP_FEATURES].tolist(); i += NUM_MAP_FEATURES
+        rays_flat = obs_used[i:i+(NUMBER_OF_RAYS*2)].tolist(); i += (NUMBER_OF_RAYS*2)
+        vscan_flat = obs_used[i:i+(NUM_VERTICAL_SCANS*2)].tolist(); i += (NUM_VERTICAL_SCANS*2)
+        angle = obs_used[i:i+NUM_ANGLE_FEATURES].tolist(); i += NUM_ANGLE_FEATURES
+        vel = obs_used[i:i+NUM_VELOCITY_FEATURES].tolist()
+        
+        with STATE_LOCK:
+            DASH_STATE = {
+                "step": int(step), "action": int(action), "action_probs": [float(p) for p in probs],
+                "reward": float(reward), "distance": int(info.get("distance", 0)),
+                "obs_parts": {
+                    "map": mp,
+                    "rays": [rays_flat[k:k+2] for k in range(0, len(rays_flat), 2)],
+                    "vscan": [vscan_flat[k:k+2] for k in range(0, len(vscan_flat), 2)],
+                    "angle": angle, "velocity": vel, "action_history_idx": []
+                },
+                "flat": obs_used.tolist()
+            }
+    except Exception: pass
+
+_HTML = r"""<!doctype html><html lang="pl"><meta charset="utf-8">
+<title>HCR PPO — Obserwacje i Akcje</title>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+:root{--bg:#0b0f14;--card:#0f1624;--muted:#8aa3c2;--txt:#e5f0ff;--ring:#3b82f6;--green:#22c55e;--orange:#f59e0b;--gray:#64748b;--brown:#a16207;--miss:#475569}
+*{box-sizing:border-box;font-family:ui-sans-serif,system-ui,Segoe UI,Roboto}
+body{margin:0;background:linear-gradient(180deg,var(--bg),#0a1524 60%,#09182b);color:var(--txt);font-size:14px}
+.wrap{max-width:1200px;margin:24px auto;padding:0 18px}
+h1{font-size:26px;margin:0 0 6px;letter-spacing:-.025em}.sub{color:var(--muted);margin:0 0 18px;font-size:14px}
+.grid{display:grid;gap:16px;grid-template-columns:repeat(auto-fit,minmax(400px,1fr))}
+.card{background:linear-gradient(180deg,rgba(255,255,255,.02),rgba(255,255,255,.01));border:1px solid rgba(128,178,255,.16);border-radius:16px;padding:14px}
+.row{display:flex;gap:12px;flex-wrap:wrap}
+.stat{flex:1 1 150px;background:#0f1b2e;border:1px solid rgba(128,178,255,.18);border-radius:12px;padding:10px}
+.k{color:var(--muted);font-size:12px;margin-bottom:4px}.v{font-size:18px;font-weight:700}
+.bars{display:flex;gap:8px}.bar{flex:1;background:#0f1b2e;border:1px solid rgba(128,178,255,.18);border-radius:12px;padding:10px}
+.bar .lab{font-size:12px;color:var(--muted);margin-bottom:6px}.bar .w{height:14px;border-radius:10px;background:#173055;overflow:hidden}
+.bar .f{height:100%;width:0%;transition:width .08s linear}.p0{background:var(--brown)}.p1{background:var(--green)}.p2{background:var(--gray)}
+canvas{width:100%;height:260px;background:#0f1b2e;border:1px solid rgba(128,178,255,.18);border-radius:12px;display:block}
+.hist{display:grid;grid-template-columns:repeat(5,1fr);gap:6px;margin-top:8px}
+.cell{height:16px;border-radius:4px;opacity:.9}.a0{background:var(--green)}.a1{background:var(--orange)}.a2{background:var(--gray)}
+.map{display:flex;flex-wrap:wrap;gap:6px;margin-top:6px}
+.map .m{font-size:11px;padding:4px 6px;border-radius:8px;border:1px solid rgba(128,178,255,.18);background:#0f1b2e}
+.map .on{outline:2px solid var(--ring);background:rgba(59,130,246,.2)}
+details{margin-top:10px}
+.mono{font-family:ui-monospace,Consolas,Menlo,monospace;font-size:12px;white-space:pre-wrap;overflow:auto;max-height:480px;background:#0f1b2e;border:1px solid rgba(128,178,255,.18);padding:10px;border-radius:10px}
+.foot{margin-top:10px;color:var(--muted);font-size:12px}
+.vscan-legend{display:flex;gap:12px;margin-top:4px;font-size:12px;align-items:center}
+.vscan-legend .dot{width:12px;height:12px;border-radius:3px}
+</style>
+<div class="wrap">
+  <h1>HCR — Obserwacje i Akcje</h1>
+  <p class="sub">Promienie/skany zwracają parę: <b>[długość, typ]</b>.</p>
+  <div class="grid">
+    <div class="card">
+      <div class="row">
+        <div class="stat"><div class="k">Kroki</div><div id="steps" class="v">0</div></div>
+        <div class="stat"><div class="k">Akcja</div><div id="cur" class="v">—</div></div>
+        <div class="stat"><div class="k">Nagroda</div><div id="rew" class="v">0.00</div></div>
+        <div class="stat"><div class="k">Dystans</div><div id="dst" class="v">0</div></div>
+      </div>
+      <div class="bars" style="margin-top:10px">
+        <div class="bar"><div class="lab">P(HAMULEC=0)</div><div class="w"><div id="p0" class="f p0"></div></div></div>
+        <div class="bar"><div class="lab">P(GAZ=1)</div><div class="w"><div id="p1" class="f p1"></div></div></div>
+        <div class="bar"><div class="lab">P(NIC=2)</div><div class="w"><div id="p2" class="f p2"></div></div></div>
+      </div>
+      <div style="margin-top:10px">
+        <div class="k">Historia akcji (ostatnie 5)</div>
+        <div id="hist" class="hist"></div>
+      </div>
+      <div style="margin-top:10px">
+        <div class="k">Mapy (one-hot)</div>
+        <div id="maps" class="map"></div>
+      </div>
+      <details open>
+        <summary>🔎 Surowe dane</summary>
+        <div class="mono" id="raw"></div>
+      </details>
+    </div>
+    <div class="card">
+      <div class="k">Skany pionowe — 1 = daleko, 0 = blisko</div>
+      <canvas id="vscan"></canvas>
+      <div class="vscan-legend">
+          <span style="display:flex;align-items:center;gap:4px"><div class="dot" style="background:var(--brown)"></div>Lina (Typ 0)</span>
+          <span style="display:flex;align-items:center;gap:4px"><div class="dot" style="background:var(--green)"></div>Ziemia (Typ 1)</span>
+      </div>
+      <div class="k" style="margin-top:10px">Lasery okrężne</div>
+      <canvas id="rays"></canvas>
+    </div>
+  </div>
+  <div class="foot">Typy trafień: 0 = <span style="color:var(--brown)">Lina (Brąz)</span>, 1 = <span style="color:var(--green)">Ziemia (Zielony)</span>. Brak trafienia: [1.0, 0.0]</div>
+</div>
+<script>
+const $ = s => document.querySelector(s);
+const steps=$('#steps'),cur=$('#cur'),rew=$('#rew'),dst=$('#dst');
+const p0=$('#p0'),p1=$('#p1'),p2=$('#p2');
+const hist=$('#hist'),maps=$('#maps'),raw=$('#raw');
+const vscan=document.getElementById('vscan'), rays=document.getElementById('rays');
+let mLabels = ['M1','M3','M4','M5','M7','M9','M11','M14','M16','M17','M18','M20','M25'];
+function initHist(){ hist.innerHTML=''; for(let i=0;i<5;i++){ const d=document.createElement('div'); d.className='cell a2'; hist.appendChild(d);} }
+function setHistIdx(arr){ const cells=hist.children; for(let i=0;i<Math.min(cells.length,arr.length);i++){ cells[i].className='cell a'+arr[i]; } }
+function initMaps(){ maps.innerHTML=''; for(let i=0;i<mLabels.length;i++){ const s=document.createElement('span'); s.className='m'; s.textContent=mLabels[i]; maps.appendChild(s);} }
+function setMaps(onehot){ const els=maps.children; for(let i=0;i<els.length;i++){ els[i].classList.toggle('on', (onehot[i]||0)>0.5); } }
+function fitCanvas(c){ const dpr=window.devicePixelRatio||1; const rect=c.getBoundingClientRect(); c.width=Math.max(10,rect.width*dpr); c.height=Math.max(10,rect.height*dpr); const ctx=c.getContext('2d'); ctx.setTransform(dpr,0,0,dpr,0,0); return ctx; }
+let vctx=null, rctx=null; function resize(){ vctx=fitCanvas(vscan); rctx=fitCanvas(rays); } window.addEventListener('resize', resize);
+function setProb(el, p){ el.style.width = Math.round(100*(p||0))+'%'; }
+function drawVScanBars(ctx, values){
+    const W=ctx.canvas.width, H=ctx.canvas.height; const n=values.length;
+    const pad=4; const bw=(W - pad*(n+1))/n; ctx.clearRect(0,0,W,H);
+    for(let i=0;i<n;i++){
+        const [dist, type] = values[i] || [1.0, 0.0];
+        const h = Math.max(1, (1.0 - dist) * H);
+        const x = pad + i * (bw + pad);
+        if (type === 0.0) ctx.fillStyle = '#a16207';
+        else if (type === 1.0) ctx.fillStyle = '#22c55e';
+        else continue;
+        ctx.fillRect(x, H - h, bw, h);
+    }
+}
+function drawRays(ctx, values){
+    const W=ctx.canvas.width, H=ctx.canvas.height; const cx=W/2, cy=H/2; const r=Math.min(W,H)*0.45;
+    ctx.clearRect(0,0,W,H); ctx.strokeStyle='#173055'; ctx.lineWidth=1; ctx.beginPath(); ctx.arc(cx,cy,r,0,Math.PI*2); ctx.stroke();
+    const n=values.length;
+    for(let i=0;i<n;i++){
+        const [dist, type] = values[i] || [1.0, 0.0];
+        if (dist >= 1.0) { ctx.strokeStyle = '#475569'; }
+        else if (type === 0.0) { ctx.strokeStyle = '#a16207'; }
+        else { ctx.strokeStyle = '#22c55e'; }
+        const ang=i/n*Math.PI*2; const rr=r*dist;
+        const x=cx+Math.cos(ang)*rr; const y=cy+Math.sin(ang)*rr;
+        ctx.beginPath(); ctx.moveTo(cx,cy); ctx.lineTo(x,y); ctx.stroke();
+    }
+}
+function spanNum(n) {
+    const num = Number(n);
+    if (!Number.isFinite(num)) return String(n);
+    if (num >= 0 && num <= 1) {
+        const hue = 120 * (1 - num);
+        return `<span style="color:hsl(${hue}, 85%, 65%)">${num.toFixed(3)}</span>`;
+    }
+    return num.toFixed(3);
+}
+function coloredArray(arr){
+    if (!Array.isArray(arr)) return String(arr); let out='[';
+    for (let i=0;i<arr.length;i++){
+        if (Array.isArray(arr[i])) { out += '[' + spanNum(arr[i][0]) + ', ' + spanNum(arr[i][1]) + ']'; }
+        else { out += spanNum(arr[i]); }
+        if (i!==arr.length-1) out+=', ';
+    } out+=']'; return out;
+}
+function renderRaw(d){
+  const o=d.obs_parts||{};
+  raw.innerHTML =
+    'map             = ' + coloredArray(o.map||[]) + '<br>' +
+    'rays[d,t]       = ' + coloredArray(o.rays||[]) + '<br>' +
+    'vscan[d,t]      = ' + coloredArray(o.vscan||[]) + '<br>' +
+    'angle/vel       = ' + coloredArray(o.angle||[]) + ' ' + coloredArray(o.velocity||[]) + '<br>' +
+    'action_hist     = ' + coloredArray(o.action_history_idx||[]) + '<br>' +
+    'action_probs    = ' + coloredArray(d.action_probs||[]) + '<br>' +
+    'flat(len='+(d.flat||[]).length+') = ' + coloredArray(d.flat||[]);
+}
+initHist(); initMaps(); resize();
+async function tick(){
+  try{
+    const r = await fetch('/state', {cache:'no-store'});
+    const s = await r.json();
+    if (!s.obs_parts) return;
+    steps.textContent = s.step||0;
+    cur.textContent = ['HAMULEC','GAZ','NIC'][s.action] || s.action;
+    rew.textContent = (s.reward||0).toFixed(2);
+    dst.textContent = (s.distance||0);
+    const ap = s.action_probs || [0.33,0.33,0.34];
+    setProb(p0, ap[0]); setProb(p1, ap[1]); setProb(p2, ap[2]);
+    const op = s.obs_parts;
+    if (op.action_history_idx) setHistIdx(op.action_history_idx);
+    if (op.map) setMaps(op.map);
+    if (vctx && op.vscan) drawVScanBars(vctx, op.vscan);
+    if (rctx && op.rays)  drawRays(rctx, op.rays);
+    renderRaw(s);
+  }catch(e){}
+  setTimeout(tick, 150);
+}
+tick();
+</script>
+</html>"""
+
+class _Handler(BaseHTTPRequestHandler):
+    def _send(self, code=200, ctype="text/html; charset=utf-8"):
+        self.send_response(code); self.send_header("Content-Type", ctype); self.send_header("Cache-Control","no-store"); self.end_headers()
+    def log_message(self, *args, **kwargs): return
+    def do_GET(self):
+        if self.path in ("/", "/index.html"):
+            self._send(); self.wfile.write(_HTML.encode("utf-8")); return
+        if self.path == "/state":
+            with STATE_LOCK: payload = DASH_STATE
+            self._send(200, "application/json; charset=utf-8")
+            self.wfile.write(json.dumps(payload).encode("utf-8")); return
+        self._send(404, "text/plain; charset=utf-8"); self.wfile.write(b"404")
+
+def start_dashboard(host="127.0.0.1", port=8088):
+    try:
+        srv = HTTPServer((host, port), _Handler)
+        t = threading.Thread(target=srv.serve_forever, daemon=True); t.start()
+        print(f"{Colors.GREEN}{Colors.BOLD}==> Podgląd: http://{host}:{srv.server_port}{Colors.RESET}")
+    except Exception as e:
+        print(f"{Colors.RED}Nie udało się uruchomić dashboardu: {e}{Colors.RESET}")
+
+class StreamToLogger:
+    def __init__(self, logger, level): self.logger, self.level = logger, level
+    def write(self, buf):
+        for line in buf.rstrip().splitlines(): self.logger.log(self.level, line.rstrip())
+    def flush(self): pass
+
+def setup_logging():
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s.%(msecs)03d [%(levelname)s] %(message)s',
+                        datefmt='%Y-%m-%d %H:%M:%S', handlers=[
+                            logging.FileHandler(LOG_FILE_PATH, mode='a', encoding='utf-8'),
+                            logging.StreamHandler(sys.__stdout__)])
+    sys.stdout = StreamToLogger(logging.getLogger('STDOUT'), logging.INFO)
+    sys.stderr = StreamToLogger(logging.getLogger('STDERR'), logging.ERROR)
+    logging.info("=" * 60 + "\nNOWA SESJA LOGOWANIA\n" + "=" * 60)
+
+class MemoryReader:
+    def __init__(self, process_name):
+        self.process_name=process_name.lower(); self.pid=self._get_pid()
+        if not self.pid: raise RuntimeError(f"Nie znaleziono procesu: {self.process_name}")
+        self.handle=ctypes.windll.kernel32.OpenProcess(0x0010|0x0400|0x0020|0x0008, False, self.pid)
+        if not self.handle: raise RuntimeError(f"Nie można otworzyć procesu (PID: {self.pid}).")
+        self.module_base=self._get_module_base_address()
+    def _get_pid(self):
+        for p in psutil.process_iter(['pid','name']):
+            if p.info.get('name', '').lower()==self.process_name: return p.info['pid']
+        return None
+    def _get_module_base_address(self):
+        try:
+            for m in psutil.Process(self.pid).memory_maps(grouped=False):
+                if m.path and self.process_name in os.path.basename(m.path).lower(): return int(m.addr,16)
+        except psutil.Error: pass
+        raise RuntimeError(f"Nie można znaleźć adresu bazowego dla {self.process_name}")
+    def read_int(self, address):
+        buffer=(ctypes.c_byte*4)(); br=ctypes.c_size_t()
+        if address and ctypes.windll.kernel32.ReadProcessMemory(self.handle, ctypes.c_void_p(address), buffer, 4, ctypes.byref(br)):
+            if br.value==4: return struct.unpack('<I',bytes(buffer))[0]
+        return None
+    def write_int(self, address, value):
+        if address: ctypes.windll.kernel32.WriteProcessMemory(self.handle, address, ctypes.byref(ctypes.c_int(value)), 4, None)
+    def write_float(self, address, value):
+        if address: ctypes.windll.kernel32.WriteProcessMemory(self.handle, address, ctypes.byref(ctypes.c_float(value)), 4, None)
+    def get_final_address(self, base_offset, offsets):
+        try:
+            addr = self.module_base + base_offset
+            for off in offsets:
+                addr_val = self.read_int(addr)
+                if addr_val is None: return None
+                addr = addr_val + off
+            return addr
+        except: return None
+    def close(self):
+        if getattr(self,"handle",None): ctypes.windll.kernel32.CloseHandle(self.handle); self.handle=None
+
+def ensure_game_is_running(process_name, aumid):
+    try: return MemoryReader(process_name)
+    except RuntimeError:
+        logging.warning(f"Nie znaleziono procesu gry. Próba uruchomienia...")
+        try:
+            subprocess.run(f'explorer.exe shell:appsFolder\\{aumid}', shell=True, timeout=15, check=False)
+            logging.info("Oczekiwanie 10 sekund na uruchomienie gry...")
+            time.sleep(10)
+        except Exception as e: logging.error(f"Błąd podczas uruchamiania gry: {e}")
+        for attempt in range(10):
+            try: return MemoryReader(process_name)
+            except RuntimeError: time.sleep(3)
+    raise RuntimeError("Nie udało się uruchomić i połączyć z grą po wielu próbach.")
+
+def force_close_game(process_name):
+    try:
+        pyautogui.keyDown('alt'); pyautogui.press('f4'); pyautogui.keyUp('alt'); time.sleep(0.5)
+    except Exception: pass
+    for p in [p for p in psutil.process_iter(['name']) if p.info.get('name', '').lower()==process_name]:
+        try: p.terminate()
+        except: pass
+    time.sleep(1.0)
+    if any(p.info.get('name', '').lower()==process_name for p in psutil.process_iter(['name'])):
+        try: subprocess.run(f'taskkill /F /IM {process_name}', shell=True, check=False, timeout=5, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except: pass
+    time.sleep(1.0)
+
+def hard_restart_game(env, target_map_id=1):
+    logging.info("Wykonywanie twardego restartu gry...")
+    pyautogui.keyUp('left'); pyautogui.keyUp('right')
+    for attempt in range(1, 4):
+        logging.info(f"Próba restartu #{attempt}/3...")
+        if getattr(env, 'memory_reader', None): env.memory_reader.close()
+        force_close_game(PROCESS_NAME)
+        env.memory_reader = ensure_game_is_running(PROCESS_NAME, AUMID)
+        time.sleep(2.0)
+        if soft_start_race(env, target_map_id):
+            logging.info(f"Restart udany, wyścig rozpoczęty.")
+            return True
+        else:
+            logging.warning(f"Próba restartu #{attempt} nie powiodła się. Czekam 5 sekund przed kolejną próbą.")
+            time.sleep(5)
+    raise RuntimeError("Nie udało się poprawnie zrestartować gry i rozpocząć wyścigu po 3 próbach. Zatrzymuję skrypt.")
+
+def soft_start_race(env, target_map_id=None) -> bool:
+    try:
+        if target_map_id is not None:
+            addr = env.memory_reader.get_final_address(MAP_POINTER_CONFIG["base_offset"], MAP_POINTER_CONFIG["offsets"])
+            if addr: env.memory_reader.write_int(addr, target_map_id)
+        try:
+            center_x = env.monitor['left'] + env.monitor['width'] // 2
+            center_y = env.monitor['top'] + env.monitor['height'] // 2
+            pyautogui.click(center_x, center_y)
+            time.sleep(0.2)
+        except Exception:
+            pass
+        pyautogui.click(MAP_SELECT_BUTTON); time.sleep(0.5)
+        pyautogui.click(START_RACE_BUTTON); time.sleep(1.0)
+        logging.info("Weryfikacja rozpoczęcia wyścigu...")
+        pixel_check_area = {'top': env.monitor['top'] + LIFE_CHECK_PIXEL_Y, 'left': env.monitor['left'] + LIFE_CHECK_PIXEL_X, 'width': 1, 'height': 1}
+        for i in range(30):
+            img = env.sct.grab(pixel_check_area)
+            if tuple(img.rgb) == LIFE_CHECK_EXACT_RGB:
+                logging.info("Weryfikacja pomyślna. Agent jest w grze.")
+                time.sleep(1.0)
+                return True
+            if i % 5 == 4:
+                pyautogui.click(START_RACE_BUTTON)
+            time.sleep(0.5)
+        logging.warning("Nie udało się zweryfikować startu wyścigu w ciągu 15 sekund.")
+        return False
+    except Exception as e:
+        logging.error(f"Wystąpił nieoczekiwany błąd podczas próby startu wyścigu: {e}", exc_info=True)
+        return False
+
+def cast_ray(start_pos, angle_deg, max_dist, color_masks, shape):
+    rad = math.radians(angle_deg)
+    for i in range(1, max_dist):
+        x, y = int(start_pos[0] + i*math.cos(rad)), int(start_pos[1] + i*math.sin(rad))
+        if not (0 <= y < shape[0] and 0 <= x < shape[1]): return max_dist, TYPE_GROUND
+        if color_masks['rope'][y, x] > 0: return i, TYPE_ROPE
+        if color_masks['ground'][y, x] > 0: return i, TYPE_GROUND
+    return max_dist, TYPE_GROUND
+
+def get_observation(masks, memory_reader, velocity_for_ai):
+    obs = []; map_features = [0.0]*NUM_MAP_FEATURES
+    if memory_reader:
+        addr=memory_reader.get_final_address(MAP_POINTER_CONFIG["base_offset"],MAP_POINTER_CONFIG["offsets"])
+        map_id=memory_reader.read_int(addr)
+        if map_id in MAP_IDS_TO_INDEX: map_features[MAP_IDS_TO_INDEX[map_id]]=1.0
+    obs.extend(map_features); vehicle_pos, vehicle_angle_deg = None, 0.0
+    cp,_=cv2.findContours(masks['pink'],cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+    cy,_=cv2.findContours(masks['yellow'],cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
+    if cp and cy:
+        fc,bc=max(cp,key=cv2.contourArea),max(cy,key=cv2.contourArea); Mf,Mb=cv2.moments(fc),cv2.moments(bc)
+        if Mf["m00"]>0 and Mb["m00"]>0:
+            pf=(int(Mf["m10"]/Mf["m00"]),int(Mf["m01"]/Mf["m00"])); pb=(int(Mb["m10"]/Mb["m00"]),int(Mb["m01"]/Mb["m00"]))
+            vehicle_pos=((pb[0]+pf[0])//2,(pb[1]+pf[1])//2); vehicle_angle_deg=math.degrees(math.atan2(pf[1]-pb[1],pf[0]-pb[0]))
+    if vehicle_pos:
+        for angle in np.linspace(0,360,NUMBER_OF_RAYS,endpoint=False): dist,hit_type=cast_ray(vehicle_pos,angle,MAX_CAR_RAY_DISTANCE,masks,masks['pink'].shape); obs.extend([dist/MAX_CAR_RAY_DISTANCE,hit_type])
+    else:
+        for _ in range(NUMBER_OF_RAYS): obs.extend([1.0,TYPE_GROUND])
+    sp=masks['pink'].shape[1]/(NUM_VERTICAL_SCANS-1) if NUM_VERTICAL_SCANS > 1 else 0
+    for i in range(NUM_VERTICAL_SCANS):
+        sx=min(int(i*sp),masks['pink'].shape[1]-1); rope_hits,ground_hits=np.where(masks['rope'][:,sx]>0)[0],np.where(masks['ground'][:,sx]>0)[0]
+        first_rope_y=MAX_VERTICAL_RAY_DISTANCE if len(rope_hits)==0 else rope_hits[0]; first_ground_y=MAX_VERTICAL_RAY_DISTANCE if len(ground_hits)==0 else ground_hits[0]
+        dist,hit_type=(first_rope_y,TYPE_ROPE) if first_rope_y<=first_ground_y else (first_ground_y,TYPE_GROUND); obs.extend([dist/MAX_VERTICAL_RAY_DISTANCE,hit_type])
+    angle_rad=math.radians(vehicle_angle_deg)
+    obs.extend([0.5*(math.sin(angle_rad)+1.0),0.5*(math.cos(angle_rad)+1.0)])
+    obs.append(abs(math.tanh(velocity_for_ai / 30.0)))
+    return np.array(obs,dtype=np.float32), vehicle_pos
+
+def determine_next_map(env):
+    try:
+        addr = env.memory_reader.get_final_address(MAP_POINTER_CONFIG["base_offset"], [])
+        current = env.memory_reader.read_int(addr) if addr else env.current_map_id
+        idx = MAP_ID_PROGRESSION.index(current) if current in MAP_ID_PROGRESSION else -1
+        next_map = MAP_ID_PROGRESSION[0] if idx == -1 or current == MAP_ID_PROGRESSION[-1] else MAP_ID_PROGRESSION[idx+1]
+        logging.info(f"Zmiana mapy z {current} na {next_map}")
+        return next_map
+    except: return 1
+
+class HillClimbImitationEnv:
+    def __init__(self):
+        self.memory_reader = None
+        self.sct = mss.mss()
+        self.monitor = self.sct.monitors[MONITOR_INDEX]
+        self.capture_region = {"top": self.monitor["top"], "left": self.monitor["left"], "width": CAPTURE_RESOLUTION_WIDTH, "height": CAPTURE_RESOLUTION_HEIGHT}
+        pyautogui.FAILSAFE = False; pyautogui.PAUSE = 0.0
+        self.current_map_id = 1
+        self.last_distance = 0
+        self.last_step_time = time.time(); self.smoothed_velocity = 0.0
+        self.dist_address = None
+        self.fuel_address = None
+
+    def reacquire_pointers(self):
+        if not self.memory_reader: return False
+        logging.info("Ponowne wyszukiwanie wskaźników pamięci...")
+        self.dist_address = self.memory_reader.get_final_address(DISTANCE_POINTER_CONFIG["base_offset"], DISTANCE_POINTER_CONFIG["offsets"])
+        self.fuel_address = self.memory_reader.get_final_address(FUEL_POINTER_CONFIG["base_offset"], FUEL_POINTER_CONFIG["offsets"])
+        if self.dist_address and self.fuel_address:
+            logging.info("Wskaźniki znalezione pomyślnie.")
+            return True
+        logging.warning("Nie udało się ponownie znaleźć wskaźników.")
+        return False
+
+    def start(self):
+        pyautogui.keyUp('left'); pyautogui.keyUp('right')
+        try:
+            if not hard_restart_game(self, self.current_map_id):
+                return False
+            self.reacquire_pointers()
+            return True
+        except RuntimeError as e:
+            logging.critical(f"Krytyczny błąd startu: {e}", exc_info=True)
+            return False
+
+    def attach(self):
+        print(f"{Colors.YELLOW}Oczekiwanie na proces gry '{PROCESS_NAME}'...{Colors.RESET}")
+        while not INTERRUPT_REQUESTED.is_set():
+            try:
+                self.memory_reader = MemoryReader(PROCESS_NAME)
+                print(f"{Colors.GREEN}Gra znaleziona. Podłączono do procesu.{Colors.RESET}")
+                if self.reacquire_pointers():
+                    return True
+                else:
+                    print(f"{Colors.YELLOW}Nie znaleziono wskaźników. Prawdopodobnie jesteś w menu. Dalsze akcje wymagają rozpoczęcia gry.{Colors.RESET}")
+                    return True
+            except RuntimeError:
+                time.sleep(2)
+        return False
+
+    def get_obs(self):
+        img = np.array(self.sct.grab(self.capture_region))
+        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+        masks = {'pink': cv2.inRange(hsv, LOWER_PINK, UPPER_PINK), 'yellow': cv2.inRange(hsv, LOWER_YELLOW, UPPER_YELLOW),
+                 'ground': cv2.inRange(hsv, LOWER_TARGET_GROUND, UPPER_TARGET_GROUND), 'rope': cv2.inRange(hsv, LOWER_ROPE, UPPER_ROPE)}
+        
+        current_distance = self.memory_reader.read_int(self.dist_address) if self.dist_address else self.last_distance
+        time_delta = time.time() - self.last_step_time; self.last_step_time = time.time()
+        raw_velocity = (current_distance - self.last_distance) / time_delta if time_delta > 0.001 else 0.0
+        self.smoothed_velocity = VELOCITY_SMOOTHING_FACTOR * raw_velocity + (1 - VELOCITY_SMOOTHING_FACTOR) * self.smoothed_velocity
+        self.last_distance = current_distance
+        
+        obs, _ = get_observation(masks, self.memory_reader, self.smoothed_velocity)
+        return obs
+    
+    def get_state_for_ai(self):
+        img = np.array(self.sct.grab(self.capture_region))
+        img_bgr = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+        hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)
+        masks = {'pink': cv2.inRange(hsv, LOWER_PINK, UPPER_PINK), 'yellow': cv2.inRange(hsv, LOWER_YELLOW, UPPER_YELLOW),
+                 'ground': cv2.inRange(hsv, LOWER_TARGET_GROUND, UPPER_TARGET_GROUND), 'rope': cv2.inRange(hsv, LOWER_ROPE, UPPER_ROPE)}
+
+        current_distance = self.memory_reader.read_int(self.dist_address) if self.dist_address else None
+        if current_distance is None:
+            if self.reacquire_pointers():
+                current_distance = self.memory_reader.read_int(self.dist_address)
+            if current_distance is None:
+                current_distance = self.last_distance
+        
+        time_delta = time.time() - self.last_step_time; self.last_step_time = time.time()
+        raw_velocity = (current_distance - self.last_distance) / time_delta if time_delta > 0.001 else 0.0
+        self.smoothed_velocity = VELOCITY_SMOOTHING_FACTOR * raw_velocity + (1 - VELOCITY_SMOOTHING_FACTOR) * self.smoothed_velocity
+        self.last_distance = current_distance
+        
+        obs, vehicle_pos = get_observation(masks, self.memory_reader, self.smoothed_velocity)
+        return obs, img_bgr, current_distance, vehicle_pos
+
+    def perform_action(self, action):
+        if self.fuel_address: self.memory_reader.write_float(self.fuel_address, 100.0)
+        pyautogui.keyUp('left'); pyautogui.keyUp('right')
+        if action == 1: pyautogui.keyDown('right')
+        elif action == 0: pyautogui.keyDown('left')
+
+    def is_alive(self):
+        px_area = {'top': self.monitor['top'] + LIFE_CHECK_PIXEL_Y, 'left': self.monitor['left'] + LIFE_CHECK_PIXEL_X, 'width': 1, 'height': 1}
+        return tuple(self.sct.grab(px_area).rgb) == LIFE_CHECK_EXACT_RGB
+
+    def close(self):
+        if self.memory_reader: self.memory_reader.close()
+        self.sct.close(); pyautogui.keyUp('left'); pyautogui.keyUp('right')
+
+class MLP(nn.Module):
+    def __init__(self, input_size, output_size, layer_sizes, dropout_rate):
+        super(MLP, self).__init__()
+        layers = []
+        in_size = input_size
+        for out_size in layer_sizes:
+            layers.append(nn.Linear(in_size, out_size))
+            layers.append(nn.ReLU())
+            layers.append(nn.Dropout(p=dropout_rate))
+            in_size = out_size
+        layers.append(nn.Linear(in_size, output_size))
+        self.network = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.network(x)
+
+def draw_ai_pov(image, obs, action, distance, vehicle_pos):
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale_small = 0.4
+    text_color = (50, 255, 255)
+
+    if vehicle_pos:
+        map_features_offset = NUM_MAP_FEATURES
+        rays_data = obs[map_features_offset : map_features_offset + (NUMBER_OF_RAYS * 2)]
+        
+        for i in range(NUMBER_OF_RAYS):
+            norm_dist, hit_type = rays_data[i*2], rays_data[i*2+1]
+            dist = norm_dist * MAX_CAR_RAY_DISTANCE
+            angle_deg = np.linspace(0, 360, NUMBER_OF_RAYS, endpoint=False)[i]
+            angle_rad = math.radians(angle_deg)
+            
+            end_x = int(vehicle_pos[0] + dist * math.cos(angle_rad))
+            end_y = int(vehicle_pos[1] + dist * math.sin(angle_rad))
+            
+            color = (0, 255, 0) if hit_type == TYPE_GROUND else (255, 100, 100)
+            cv2.line(image, vehicle_pos, (end_x, end_y), color, 2)
+            
+            cv2.circle(image, (end_x, end_y), 4, color, -1)
+            
+            cv2.putText(image, f"{norm_dist:.2f}", (end_x + 6, end_y + 4), font, font_scale_small, text_color, 1, cv2.LINE_AA)
+
+    vscans_offset = NUM_MAP_FEATURES + (NUMBER_OF_RAYS * 2)
+    vscans_data = obs[vscans_offset : vscans_offset + (NUM_VERTICAL_SCANS * 2)]
+    
+    img_height, img_width, _ = image.shape
+    
+    for i in range(NUM_VERTICAL_SCANS):
+        norm_dist, hit_type = vscans_data[i*2], vscans_data[i*2+1]
+        dist = norm_dist * MAX_VERTICAL_RAY_DISTANCE
+        
+        start_x = int(i * (img_width - 1) / (NUM_VERTICAL_SCANS - 1)) if NUM_VERTICAL_SCANS > 1 else img_width // 2
+        end_y = int(dist)
+        
+        if end_y < img_height:
+            color = (0, 200, 0) if hit_type == TYPE_GROUND else (200, 50, 50)
+            cv2.line(image, (start_x, 0), (start_x, end_y), color, 1)
+            cv2.circle(image, (start_x, end_y), 4, color, -1)
+            cv2.putText(image, f"{norm_dist:.2f}", (start_x + 6, end_y - 6), font, font_scale_small, text_color, 1, cv2.LINE_AA)
+
+    if vehicle_pos:
+        angle_offset = vscans_offset + (NUM_VERTICAL_SCANS * 2)
+        angle_data = obs[angle_offset : angle_offset + NUM_ANGLE_FEATURES]
+        
+        sin_norm, cos_norm = angle_data[0], angle_data[1]
+        sin_val = (sin_norm * 2) - 1
+        cos_val = (cos_norm * 2) - 1
+        
+        dir_end_x = int(vehicle_pos[0] + 120 * cos_val)
+        dir_end_y = int(vehicle_pos[1] + 120 * sin_val)
+        cv2.arrowedLine(image, vehicle_pos, (dir_end_x, dir_end_y), (0, 255, 255), 3, tipLength=0.2)
+        
+        cos_len, sin_len = 80 * cos_val, 80 * sin_val
+        cv2.line(image, vehicle_pos, (int(vehicle_pos[0] + cos_len), vehicle_pos[1]), (255, 0, 255), 2)
+        cv2.line(image, (int(vehicle_pos[0] + cos_len), vehicle_pos[1]), (int(vehicle_pos[0] + cos_len), int(vehicle_pos[1] + sin_len)), (0, 165, 255), 2)
+        
+    cv2.rectangle(image, (5, 5), (450, 85), (0, 0, 0), -1)
+    
+    dist_text = f"Dystans: {distance or 0} m"
+    cv2.putText(image, dist_text, (10, 35), font, 1, (255, 255, 255), 2, cv2.LINE_AA)
+    
+    action_map_text = {0: "HAMULEC / LEWO", 1: "GAZ / PRAWO", 2: "NIC"}
+    action_text = f"Akcja: {action_map_text.get(action, 'N/A')}"
+    cv2.putText(image, action_text, (10, 70), font, 1, (255, 255, 255), 2, cv2.LINE_AA)
+    
+    return image
+
+
+def display_dashboard_for_recording(obs, current_action, sample_count):
+    reset_cursor_position()
+    
+    action_map_text = {0: "HAMULEC", 1: "GAZ", 2: "NIC"}
+    action_text = action_map_text[current_action]
+    
+    def get_color(value, is_dist=True):
+        if not is_dist:
+            if value > 0.6: return Colors.GREEN
+            if value > 0.4: return Colors.YELLOW
+            return Colors.CYAN
+        if value > 0.9: return Colors.GREEN
+        if value > 0.5: return Colors.YELLOW
+        if value > 0.1: return Colors.CYAN
+        return Colors.RED
+
+    sys.__stdout__.write(f"{Colors.BOLD}{Colors.CYAN}{'--- NAGRYWANIE DEMONSTRACJI ---':^80}{Colors.RESET}\n")
+    sys.__stdout__.write(f" {Colors.BOLD}Zapisanych obserwacji: {Colors.GREEN}{sample_count: >5}{Colors.RESET} | {Colors.BOLD}Twoja akcja: {Colors.GREEN}{action_text: >7}{Colors.RESET}\n\n")
+    
+    sys.__stdout__.write(f"{Colors.BOLD}{Colors.YELLOW}[ PRZESTRZEŃ OBSERWACJI (to co widzi AI) ]{Colors.RESET}\n")
+
+    i=0
+    map_vec = obs[i:i+NUM_MAP_FEATURES]
+    map_idx = np.argmax(map_vec) if np.sum(map_vec) > 0 else -1
+    map_str = "".join([f"{Colors.GREEN}{Colors.BOLD}1{Colors.RESET}" if j==map_idx else "0" for j in range(NUM_MAP_FEATURES)])
+    sys.__stdout__.write(f" - {Colors.BOLD}Mapa ({map_idx if map_idx != -1 else '??'}): [{map_str}]\n")
+    i += NUM_MAP_FEATURES
+    
+    i_rays_end = i + (NUMBER_OF_RAYS * 2)
+    i_vscan_end = i_rays_end + (NUM_VERTICAL_SCANS * 2)
+    angle_vec = obs[i_vscan_end : i_vscan_end + NUM_ANGLE_FEATURES]
+    vel_vec = obs[i_vscan_end + NUM_ANGLE_FEATURES : i_vscan_end + NUM_ANGLE_FEATURES + NUM_VELOCITY_FEATURES]
+    
+    sin_val = (angle_vec[0] * 2) - 1
+    cos_val = (angle_vec[1] * 2) - 1
+    angle_deg = math.degrees(math.atan2(sin_val, cos_val))
+    sys.__stdout__.write(f" - {Colors.BOLD}Kąt: {angle_deg: >6.1f}°{Colors.RESET} (sin: {get_color(angle_vec[0],0)}{angle_vec[0]:.3f}{Colors.RESET}, cos: {get_color(angle_vec[1],0)}{angle_vec[1]:.3f}{Colors.RESET})\n")
+    sys.__stdout__.write(f" - {Colors.BOLD}Prędkość (norm): {get_color(vel_vec[0],0)}{vel_vec[0]:.3f}{Colors.RESET}\n\n")
+
+    sys.__stdout__.write(f" - {Colors.BOLD}Promienie ({NUMBER_OF_RAYS}):{Colors.RESET}\n")
+    for k in range(NUMBER_OF_RAYS):
+        dist, type = obs[i+k*2], obs[i+k*2+1]
+        color = get_color(dist)
+        type_char = "L" if type == TYPE_ROPE else "Z"
+        sys.__stdout__.write(f" {color}{dist:.2f}{Colors.RESET}{type_char} ")
+        if (k + 1) % 13 == 0: sys.__stdout__.write("\n")
+    sys.__stdout__.write("\n\n")
+    i = i_rays_end
+
+    sys.__stdout__.write(f" - {Colors.BOLD}Skany pionowe ({NUM_VERTICAL_SCANS}):{Colors.RESET}\n")
+    for k in range(NUM_VERTICAL_SCANS):
+        dist, type = obs[i+k*2], obs[i+k*2+1]
+        color = get_color(dist)
+        type_char = "L" if type == TYPE_ROPE else "Z"
+        sys.__stdout__.write(f" {color}{dist:.2f}{Colors.RESET}{type_char} ")
+    sys.__stdout__.write("\n")
+    
+    sys.__stdout__.flush()
+    
+def record_demonstrations():
+    if not keyboard:
+        print(f"{Colors.RED}Biblioteka 'keyboard' nie jest zainstalowana. Nagrywanie niemożliwe.{Colors.RESET}")
+        return
+
+    print(f"\n{Colors.CYAN}--- Tryb nagrywania demonstracji ---{Colors.RESET}")
+    print(f"{Colors.YELLOW}1. Uruchom grę Hill Climb Racing.{Colors.RESET}")
+    print(f"{Colors.YELLOW}2. Rozpocznij dowolny wyścig.{Colors.RESET}")
+    print(f"{Colors.YELLOW}Program automatycznie rozpocznie nagrywanie, gdy wykryje, że jesteś w grze.{Colors.RESET}")
+    print(f"Naciśnij 'Q', aby w dowolnym momencie zakończyć nagrywanie i zapisać dane.")
+
+    env = HillClimbImitationEnv()
+    if not env.attach():
+        print(f"{Colors.RED}Nie udało się podłączyć do gry. Zamykanie trybu nagrywania.{Colors.RESET}"); env.close(); return
+
+    print(f"\n{Colors.YELLOW}Oczekiwanie na rozpoczęcie wyścigu...{Colors.RESET}")
+    while not env.is_alive():
+        if keyboard.is_pressed('q'): print("Anulowano."); env.close(); return
+        time.sleep(0.5)
+    
+    print(f"{Colors.GREEN}Wykryto aktywny wyścig. Rozpoczynam nagrywanie!{Colors.RESET}"); time.sleep(1)
+    
+    demonstration_buffer = []; alive = True
+    hide_cursor()
+    try:
+        while not keyboard.is_pressed('q'):
+            if not alive:
+                reset_cursor_position(); print(f"{Colors.RED}{Colors.BOLD}ITO! Usuwam ostatnie 10 sekund nagrania...{Colors.RESET}\n")
+                current_time = time.time()
+                initial_count = len(demonstration_buffer)
+                demonstration_buffer = [d for d in demonstration_buffer if current_time - d[2] > 10]
+                removed_count = initial_count - len(demonstration_buffer)
+                print(f"Usunięto {removed_count} obserwacji. Pozostało: {len(demonstration_buffer)}.\n")
+                print(f"{Colors.YELLOW}Nagrywanie wstrzymane. Rozpocznij nowy wyścig, aby kontynuować...{Colors.RESET} (Naciśnij Q, aby zakończyć)")
+                
+                while not env.is_alive():
+                    if keyboard.is_pressed('q'): break
+                    time.sleep(0.5)
+                if keyboard.is_pressed('q'): break
+                
+                print(f"{Colors.GREEN}Wznowiono nagrywanie! Ponowne wyszukiwanie wskaźników...{Colors.RESET}")
+                while not env.reacquire_pointers():
+                    if keyboard.is_pressed('q'): break
+                    print(f"{Colors.YELLOW}Próba ponownego znalezienia wskaźników...{Colors.RESET}")
+                    time.sleep(1)
+                if keyboard.is_pressed('q'): break
+
+                alive = True; pyautogui.keyUp('left'); pyautogui.keyUp('right'); continue
+
+            if env.fuel_address: env.memory_reader.write_float(env.fuel_address, 100.0)
+
+            obs = env.get_obs()
+            current_action = 2
+            if keyboard.is_pressed('right arrow'): current_action = 1
+            elif keyboard.is_pressed('left arrow'): current_action = 0
+            
+            display_dashboard_for_recording(obs, current_action, len(demonstration_buffer))
+            demonstration_buffer.append((obs, current_action, time.time()))
+            
+            alive = env.is_alive()
+            time.sleep(0.05)
+
+    except Exception as e:
+        logging.error(f"Wystąpił błąd podczas nagrywania: {e}", exc_info=True)
+    finally:
+        show_cursor()
+        env.close()
+
+    if demonstration_buffer:
+        print(f"\n{Colors.GREEN}Zapisywanie {len(demonstration_buffer)} obserwacji...{Colors.RESET}")
+        observations, actions, _ = zip(*demonstration_buffer)
+        
+        if DEMONSTRATIONS_PATH.exists():
+            print("Znaleziono istniejący plik. Łączenie danych...")
+            with np.load(DEMONSTRATIONS_PATH) as data:
+                old_obs, old_actions = data['observations'], data['actions']
+            observations = np.concatenate((old_obs, np.array(observations)))
+            actions = np.concatenate((old_actions, np.array(actions)))
+            print(f"Połączono. Łączna liczba obserwacji: {len(observations)}.")
+
+        np.savez_compressed(DEMONSTRATIONS_PATH, observations=np.array(observations), actions=np.array(actions))
+        print(f"Dane zapisano pomyślnie w '{DEMONSTRATIONS_PATH.name}'.")
+    else:
+        print(f"{Colors.YELLOW}Nie zebrano żadnych nowych danych do zapisu.{Colors.RESET}")
+
+def objective(trial: optuna.Trial, observations, actions):
+    n_layers = trial.suggest_int("n_layers", 1, 4)
+    layer_sizes = [trial.suggest_categorical(f"n_units_l{i}", [64, 128, 256, 512]) for i in range(n_layers)]
+    dropout_rate = trial.suggest_float("dropout", 0.1, 0.5)
+    learning_rate = trial.suggest_float("lr", 1e-5, 1e-2, log=True)
+    optimizer_name = trial.suggest_categorical("optimizer", ["Adam", "AdamW", "RMSprop", "SGD"])
+    batch_size = trial.suggest_categorical("batch_size", [32, 64, 128, 256])
+    epochs = OPTUNA_EPOCHS_PER_TRIAL
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    X_train, X_val, y_train, y_val = train_test_split(observations, actions, test_size=0.2, random_state=42, stratify=actions)
+    train_dataset = TensorDataset(torch.from_numpy(X_train).float(), torch.from_numpy(y_train).long())
+    val_dataset = TensorDataset(torch.from_numpy(X_val).float(), torch.from_numpy(y_val).long())
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    val_loader = DataLoader(val_dataset, batch_size=batch_size)
+    
+    model = MLP(OBS_SIZE, 3, layer_sizes, dropout_rate).to(device)
+    optimizer = getattr(optim, optimizer_name)(model.parameters(), lr=learning_rate)
+    criterion = nn.CrossEntropyLoss()
+
+    for epoch in range(epochs):
+        model.train()
+        for batch_X, batch_y in train_loader:
+            batch_X, batch_y = batch_X.to(device), batch_y.to(device)
+            optimizer.zero_grad(); outputs = model(batch_X); loss = criterion(outputs, batch_y)
+            loss.backward(); optimizer.step()
+
+        model.eval()
+        correct, total = 0, 0
+        with torch.no_grad():
+            for batch_X, batch_y in val_loader:
+                batch_X, batch_y = batch_X.to(device), batch_y.to(device)
+                outputs = model(batch_X); _, predicted = torch.max(outputs.data, 1)
+                total += batch_y.size(0); correct += (predicted == batch_y).sum().item()
+        
+        accuracy = correct / total
+        trial.report(accuracy, epoch)
+        if trial.should_prune(): raise optuna.exceptions.TrialPruned()
+    return accuracy
+
+def run_optuna_optimization():
+    if not DEMONSTRATIONS_PATH.exists():
+        print(f"{Colors.RED}Nie znaleziono pliku z danymi '{DEMONSTRATIONS_PATH.name}'. Najpierw nagraj demonstracje.{Colors.RESET}"); return
+
+    with np.load(DEMONSTRATIONS_PATH) as data:
+        observations, actions = data['observations'], data['actions']
+    print(f"Załadowano {len(observations)} obserwacji do optymalizacji.")
+
+    study = optuna.create_study(study_name="hcr-imitation-study", storage=f"sqlite:///{OPTUNA_DB_PATH}", load_if_exists=True, direction="maximize")
+    
+    try:
+        study.optimize(lambda trial: objective(trial, observations, actions), n_trials=OPTUNA_TRIALS)
+    except KeyboardInterrupt:
+        print(f"\n{Colors.YELLOW}Optymalizacja przerwana przez użytkownika.{Colors.RESET}")
+
+    complete_trials = study.get_trials(deepcopy=False, states=[optuna.trial.TrialState.COMPLETE])
+    print(f"\n--- Podsumowanie Optymalizacji ---")
+    print(f"Liczba prób: {len(study.trials)}")
+
+    if complete_trials:
+        print(f"\n{Colors.GREEN}Najlepsza próba:{Colors.RESET}")
+        best_trial = study.best_trial
+        print(f"  Wartość (celność): {best_trial.value:.4f}")
+        print("  Parametry:")
+        for key, value in best_trial.params.items(): print(f"    - {key}: {value}")
+
+        print(f"\n{Colors.CYAN}Trenowanie finalnego modelu z najlepszymi parametrami...{Colors.RESET}")
+        device = "cuda" if torch.cuda.is_available() else "cpu"; params = best_trial.params
+        n_layers = params["n_layers"]; layer_sizes = [params[f"n_units_l{i}"] for i in range(n_layers)]
+        final_model = MLP(OBS_SIZE, 3, layer_sizes, params["dropout"]).to(device)
+        optimizer = getattr(optim, params["optimizer"])(final_model.parameters(), lr=params["lr"])
+        criterion = nn.CrossEntropyLoss()
+        full_dataset = TensorDataset(torch.from_numpy(observations).float(), torch.from_numpy(actions).long())
+        train_loader = DataLoader(full_dataset, batch_size=params["batch_size"], shuffle=True)
+        
+        final_model.train()
+        for epoch in tqdm(range(FINAL_MODEL_EPOCHS), desc="Finalny trening"):
+            for batch_X, batch_y in train_loader:
+                batch_X, batch_y = batch_X.to(device), batch_y.to(device)
+                optimizer.zero_grad(); outputs = final_model(batch_X); loss = criterion(outputs, batch_y)
+                loss.backward(); optimizer.step()
+        
+        torch.save(final_model.state_dict(), MODEL_SAVE_PATH)
+        print(f"{Colors.GREEN}Finalny model został wytrenowany i zapisany w '{MODEL_SAVE_PATH.name}'.{Colors.RESET}")
+    else:
+        print(f"{Colors.YELLOW}Nie ukończono żadnej próby. Nie można wyłonić najlepszego modelu.{Colors.RESET}")
+
+def play_with_model():
+    if not MODEL_SAVE_PATH.exists():
+        print(f"{Colors.RED}Nie znaleziono pliku modelu '{MODEL_SAVE_PATH.name}'. Najpierw go wytrenuj.{Colors.RESET}"); return
+    
+    start_dashboard()
+    print("\nTrwa ładowanie modelu i przygotowywanie środowiska...")
+    try:
+        study = optuna.load_study(study_name="hcr-imitation-study", storage=f"sqlite:///{OPTUNA_DB_PATH}")
+        params = study.best_trial.params
+        n_layers = params["n_layers"]; layer_sizes = [params[f"n_units_l{i}"] for i in range(n_layers)]
+        dropout = params["dropout"]
+        print(f"{Colors.GREEN}Załadowano architekturę z najlepszej próby Optuny.{Colors.RESET}")
+    except Exception:
+        print(f"{Colors.YELLOW}Nie udało się wczytać architektury z bazy Optuny. Używam domyślnej architektury.[256, 128]{Colors.RESET}")
+        layer_sizes = [256, 128]; dropout = 0.3
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model = MLP(OBS_SIZE, 3, layer_sizes, dropout).to(device)
+    model.load_state_dict(torch.load(MODEL_SAVE_PATH)); model.eval()
+    print(f"Model załadowany i uruchomiony na: {device.upper()}")
+
+    env = HillClimbImitationEnv()
+    
+    print(f"\n{Colors.CYAN}AI przejmuje kontrolę za:{Colors.RESET}")
+    for i in range(3, 0, -1):
+        sys.__stdout__.write(f"\r{Colors.BOLD}{Colors.YELLOW}... {i}{Colors.RESET}")
+        time.sleep(1)
+    sys.__stdout__.write(f"\r{Colors.BOLD}{Colors.GREEN}AI AKTYWNA!{Colors.RESET} Naciśnij Ctrl+C, aby zakończyć.\n")
+    
+    hide_cursor()
+    total_steps = 0
+    try:
+        if not env.attach():
+            raise RuntimeError("Nie udało się podłączyć do procesu gry na starcie.")
+        
+        cv2.namedWindow('Podglad AI', cv2.WINDOW_NORMAL)
+        cv2.resizeWindow('Podglad AI', 960, 540)
+        
+        while not INTERRUPT_REQUESTED.is_set():
+            if not env.is_alive():
+                print(f"{Colors.YELLOW}AI nie jest w grze. Uruchamianie procedury startowej...{Colors.RESET}")
+                if not env.start():
+                    print(f"{Colors.RED}Nie udało się uruchomić/zrestartować gry. Zatrzymuję.{Colors.RESET}")
+                    break
+            else:
+                print(f"{Colors.GREEN}Wykryto aktywną grę. AI przejmuje kontrolę.{Colors.RESET}")
+
+            alive = True
+            do_hard_restart = False
+            max_distance_in_episode = -1.0
+            last_max_dist_time = time.time()
+            STAGNATION_SECONDS = 60.0
+            
+            while alive:
+                obs, img, distance, vehicle_pos = env.get_state_for_ai()
+                
+                if max_distance_in_episode < 0:
+                    max_distance_in_episode = distance if distance is not None else 0.0
+
+                current_dist = distance if distance is not None else max_distance_in_episode
+                if current_dist > max_distance_in_episode:
+                    max_distance_in_episode = current_dist
+                    last_max_dist_time = time.time()
+                elif (time.time() - last_max_dist_time) > STAGNATION_SECONDS:
+                    print(f"{Colors.RED}Wykryto stagnację! Dystans ({int(current_dist)}m) nie zwiększył się od {int(STAGNATION_SECONDS)}s. Wymuszam twardy restart gry...{Colors.RESET}")
+                    do_hard_restart = True
+                    break
+
+                with torch.no_grad():
+                    obs_tensor = torch.from_numpy(obs).float().unsqueeze(0).to(device)
+                    outputs = model(obs_tensor)
+                    probs = torch.softmax(outputs, dim=1).squeeze().tolist()
+                    action = torch.argmax(outputs, dim=1).item()
+                
+                total_steps += 1
+                publish_to_dashboard(obs, action, probs, 0.0, {'distance': distance}, total_steps)
+                
+                display_img = draw_ai_pov(img.copy(), obs, action, distance, vehicle_pos)
+                cv2.imshow('Podglad AI', display_img)
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    INTERRUPT_REQUESTED.set()
+                    break
+                
+                env.perform_action(action)
+                alive = env.is_alive()
+                time.sleep(0.02)
+            
+            if INTERRUPT_REQUESTED.is_set(): break
+
+            print(f"{Colors.YELLOW}AI zginęła. Przechodzenie do następnej mapy...{Colors.RESET}")
+            next_map_id = determine_next_map(env)
+            env.current_map_id = next_map_id
+            if do_hard_restart:
+                try:
+                    hard_restart_game(env, next_map_id)
+                except Exception as e:
+                    logging.error(f"Twardy restart po stagnacji zawiódł: {e}")
+                    break
+            else:
+                if not soft_start_race(env, next_map_id):
+                    logging.warning("Miękki start nie powiódł się. Próba twardego restartu...")
+                    try:
+                        hard_restart_game(env, next_map_id)
+                    except Exception as e:
+                        logging.error(f"Twardy restart zawiódł: {e}")
+                        break
+            env.reacquire_pointers()
+            env.last_distance = 0
+            env.smoothed_velocity = 0.0
+            env.last_step_time = time.time()
+            time.sleep(1.0)
+
+    except (KeyboardInterrupt, RuntimeError) as e: 
+        if isinstance(e, RuntimeError):
+            print(f"{Colors.RED}Wystąpił błąd krytyczny: {e}{Colors.RESET}")
+        print("\nZakończono grę.")
+    finally: 
+        show_cursor()
+        cv2.destroyAllWindows()
+        env.close()
+
+def main_menu():
+    if not all([torch, keyboard, optuna, tqdm, train_test_split]):
+        print(f"\n{Colors.RED}Brak wymaganych bibliotek. Zainstaluj je i uruchom program ponownie.{Colors.RESET}"); return
+
+    while True:
+        sys.__stdout__.write(f"\n{Colors.CYAN}{Colors.BOLD}{'--- MENU GŁÓWNE - UCZENIE PRZEZ IMITACJĘ ---':^60}{Colors.RESET}\n"
+                             f" {Colors.YELLOW}1.{Colors.RESET} Graj na wszystkich mapach (Tryb AI z podglądem)\n"
+                             f" {Colors.RED}2.{Colors.RESET} Wyjdź\n")
+        choice = input(f"{Colors.BOLD}Wybierz opcję (1-2): {Colors.RESET}").strip()
+        if choice == '1':
+            play_with_model()
+        elif choice == '2':
+            print(f"{Colors.CYAN}Do zobaczenia!{Colors.RESET}")
+            break
+        else:
+            print(f"{Colors.RED}Nieprawidłowy wybór.{Colors.RESET}")
+
+if __name__ == "__main__":
+    if sys.platform == "win32": ctypes.windll.kernel32.SetConsoleTitleW("HCR AI Control - Imitation Learning")
+    setup_logging()
+    try:
+        main_menu()
+    except Exception:
+        logging.critical("KRYTYCZNY, NIEZŁAPANY BŁĄD NA NAJWYŻSZYM POZIOMIE!", exc_info=True)
+        sys.__stderr__.write(f"{Colors.RED}Wystąpił krytyczny błąd. Sprawdź plik logu.{Colors.RESET}\n")
+    finally:
+        show_cursor()
+        logging.info("Zakończono działanie programu.")

hcr_imitation_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5817bd299cbcb019b5b42c7d2a11fb6f00fcbccfda09c58676657c7048dcb164
+size 1434549