Update app.py

app.py

@@ -1,18 +1,12 @@
 """
-AI PLATFORMER + CHATBOT (FIXED & OPTIMIZED)
-Safe spawn, proper rendering, stateful game loop
+AI PLATFORMER + CHATBOT (RICH GRAPHICS + FIXED PHYSICS)
+AABB Collision, Detailed Rendering, Stateful Engine
 """
 
-import os
-import json
-import random
-import threading
-import time
-import logging
+import os, json, random, threading, logging, time
 from collections import deque
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Any
-
+from typing import Dict, List, Optional
 import numpy as np
 import torch
 import torch.nn as nn
@@ -22,245 +16,217 @@ from flask import Flask, jsonify, request, render_template_string
 logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
 logger = logging.getLogger(__name__)
 
-# ============================================================================
-# CONFIGURATION
-# ============================================================================
-
 @dataclass
-class Config:
-    GRID_W: int = 80
-    GRID_H: int = 20
-    GROUND_Y: int = 17
-    CHUNK_SIZE: int = 30
-    SAFE_ZONE: int = 15  # No obstacles in first N units
-    
-    VIEWPORT_SIZE: int = 40  # NN input size (40x40)
-    
-    GRAVITY: float = 0.4
-    JUMP_POWER: float = -7.0
-    MOVE_SPEED: float = 0.4
-    
-    STATE_SIZE: int = VIEWPORT_SIZE * VIEWPORT_SIZE
-    ACTION_SIZE: int = 4
-    MEMORY_SIZE: int = 10000
-    BATCH_SIZE: int = 64
-    GAMMA: float = 0.99
-    LR: float = 5e-4
-    EPSILON_DECAY: float = 0.995
-    
-    PORT: int = 7860
-    MODEL_PATH: str = "dqn_model.pth"
-    CHAT_PATH: str = "chat_data.json"
-
-CFG = Config()
+class Cfg:
+    W: int = 80; H: int = 20; GROUND: int = 17; CHUNK: int = 30
+    SAFE: int = 15; VIEW: int = 40
+    GRAV: float = 0.35; JUMP: float = -6.5; SPEED: float = 0.35
+    STATE: int = 40 * 40; ACTS: int = 4; MEM: int = 10000
+    BATCH: int = 64; GAMMA: float = 0.99; LR: float = 5e-4
+    EPS_DEC: float = 0.995; PORT: int = 7860
+    MODEL: str = "dqn_model.pth"; CHAT: str = "chat_data.json"
+
+C = Cfg()
 
 # ============================================================================
-# GAME ENGINE (Stateful, Safe Spawn, Deterministic)
+# GAME ENGINE: AABB PHYSICS + RICH WORLD
 # ============================================================================
 
-class PlatformerEngine:
-    def __init__(self, seed: Optional[int] = None):
+class Engine:
+    def __init__(self, seed=None):
         self.seed = seed or random.randint(0, 999999)
         self.reset()
-    
-    def reset(self) -> np.ndarray:
-        self.player = [5.0, float(CFG.GROUND_Y)]
-        self.vel_y = 0.0
-        self.on_ground = True
+
+    def reset(self):
+        self.px, self.py = 5.0, float(C.GROUND)
+        self.vx, self.vy = 0.0, 0.0
+        self.grounded = True
         self.alive = True
         self.score = 0
-        self.coins_collected = 0
-        self.step_count = 0
-        
+        self.coins = 0
+        self.step_n = 0
         self.chunks: Dict[int, dict] = {}
-        self.obstacles: List[dict] = []
+        self.obs: List[dict] = []
         self.enemies: List[dict] = []
-        self.coins: List[dict] = []
-        
-        self._update_chunks()
+        self.coin_list: List[dict] = []
+        self._load_chunks()
         return self.get_state()
-    
-    def _generate_chunk(self, chunk_id: int) -> dict:
-        rng = random.Random((chunk_id * 1337 + self.seed) % 999999)
-        base_x = chunk_id * CFG.CHUNK_SIZE
-        
-        obstacles, enemies, coins = [], [], []
-        difficulty = max(1.0, abs(chunk_id) * 0.1)
-        
-        # SAFE ZONE: Skip obstacles for the first chunk near spawn
-        is_safe = (base_x < CFG.SAFE_ZONE)
-        
-        if not is_safe:
-            for _ in range(rng.randint(3, 6) + int(difficulty)):
-                x = base_x + rng.randint(5, 25)
-                h = rng.randint(1, 3 + int(difficulty * 0.5))
+
+    def _gen_chunk(self, cid: int) -> dict:
+        rng = random.Random((cid * 1337 + self.seed) % 999999)
+        bx = cid * C.CHUNK
+        obs, ens, cns = [], [], []
+        diff = max(1.0, abs(cid) * 0.1)
+        safe = bx < C.SAFE
+
+        if not safe:
+            for _ in range(rng.randint(3, 6) + int(diff)):
+                x = bx + rng.randint(5, 25)
+                h = rng.randint(1, 3 + int(diff * 0.5))
                 w = rng.randint(1, 3)
-                obstacles.append({'x': x, 'y': CFG.GROUND_Y - h, 'w': w, 'h': h, 'pit': False})
-            
+                obs.append({'x': x, 'y': C.GROUND - h, 'w': w, 'h': h, 'pit': False})
             for _ in range(rng.randint(1, 2)):
-                x = base_x + rng.randint(10, 20)
-                w = rng.randint(2, 4)
-                obstacles.append({'x': x, 'y': CFG.GROUND_Y + 1, 'w': w, 'h': 1, 'pit': True})
-            
+                x = bx + rng.randint(10, 20)
+                obs.append({'x': x, 'y': C.GROUND + 1, 'w': rng.randint(2, 4), 'h': 1, 'pit': True})
             for _ in range(rng.randint(1, 2)):
-                x = base_x + rng.randint(10, 20)
-                enemies.append({
-                    'x': x, 'y': CFG.GROUND_Y - 1,
+                x = bx + rng.randint(10, 20)
+                ens.append({
+                    'x': x, 'y': C.GROUND - 1,
                     'type': rng.choice(['walker', 'jumper']),
                     'dir': rng.choice([-1, 1]),
-                    'speed': 0.3 + rng.random() * 0.3,
-                    'range': rng.randint(3, 8),
-                    'origin': x
+                    'spd': 0.3 + rng.random() * 0.3,
+                    'rng': rng.randint(3, 8), 'ox': x
                 })
-        
-        for _ in range(rng.randint(5, 10) + int(difficulty)):
-            x = base_x + rng.randint(2, 28)
-            y = rng.randint(5, CFG.GROUND_Y - 2)
-            coins.append({'x': x, 'y': y, 'collected': False})
-        
-        return {'obstacles': obstacles, 'enemies': enemies, 'coins': coins}
-    
-    def _update_chunks(self):
-        current_chunk = int(self.player[0] // CFG.CHUNK_SIZE)
-        for cid in range(current_chunk - 1, current_chunk + 3):
-            if cid not in self.chunks:
-                self.chunks[cid] = self._generate_chunk(cid)
-        
-        # Refresh active entities based on viewport
-        view_l = self.player[0] - CFG.GRID_W / 2
-        view_r = self.player[0] + CFG.GRID_W / 2
-        
-        self.obstacles = []
-        self.enemies = []
-        self.coins = []
-        
-        for cid in range(current_chunk - 1, current_chunk + 3):
-            chunk = self.chunks.get(cid, {})
-            for o in chunk.get('obstacles', []):
-                if view_l <= o['x'] <= view_r:
-                    self.obstacles.append(o)
-            for e in chunk.get('enemies', []):
-                if view_l <= e['x'] <= view_r:
-                    self.enemies.append(e)
-            for c in chunk.get('coins', []):
-                if not c['collected'] and view_l <= c['x'] <= view_r:
-                    self.coins.append(c)
-    
-    def get_state(self) -> np.ndarray:
-        """Returns normalized 40x40 grid centered on player."""
-        size = CFG.VIEWPORT_SIZE
-        state = np.zeros((size, size), dtype=np.float32)
-        half = size // 2
-        px, py = int(round(self.player[0])), int(round(self.player[1]))
-        
-        # Player always at center
-        state[half, half] = 1.0
-        
-        for obs in self.obstacles:
-            dx = int(round(obs['x'])) - px
-            dy = int(round(obs['y'])) - py
-            if abs(dx) < half and abs(dy) < half:
-                val = -1.0 if obs.get('pit') else 0.8
-                for w in range(obs.get('w', 1)):
-                    for h in range(obs.get('h', 1)):
-                        sx, sy = half + dx + w, half + dy + h
-                        if 0 <= sx < size and 0 <= sy < size:
-                            state[sy, sx] = val
-        
-        for enemy in self.enemies:
-            dx = int(round(enemy['x'])) - px
-            dy = int(round(enemy['y'])) - py
-            if 0 <= half + dx < size and 0 <= half + dy < size:
-                state[half + dy, half + dx] = 0.7
-        
-        for coin in self.coins:
-            dx = int(round(coin['x'])) - px
-            dy = int(round(coin['y'])) - py
-            if 0 <= half + dx < size and 0 <= half + dy < size:
-                state[half + dy, half + dx] = 0.3
-        
-        return state.flatten()
-    
-    def step(self, action: int) -> tuple[np.ndarray, float, bool, Optional[str]]:
+
+        for _ in range(rng.randint(5, 10) + int(diff)):
+            cns.append({
+                'x': bx + rng.randint(2, 28),
+                'y': rng.randint(5, C.GROUND - 2),
+                'collected': False
+            })
+        return {'obs': obs, 'ens': ens, 'cns': cns}
+
+    def _load_chunks(self):
+        cc = int(self.px // C.CHUNK)
+        for i in range(cc - 1, cc + 3):
+            if i not in self.chunks:
+                self.chunks[i] = self._gen_chunk(i)
+
+        vl, vr = self.px - C.W / 2, self.px + C.W / 2
+        self.obs, self.enemies, self.coin_list = [], [], []
+        for i in range(cc - 1, cc + 3):
+            ch = self.chunks.get(i, {})
+            self.obs.extend([o for o in ch.get('obs', []) if vl <= o['x'] <= vr])
+            self.enemies.extend([e for e in ch.get('ens', []) if vl <= e['x'] <= vr])
+            self.coin_list.extend([c for c in ch.get('cns', []) if not c['collected'] and vl <= c['x'] <= vr])
+
+    def _aabb(self, ax, ay, aw, ah, bx, by, bw, bh):
+        return ax < bx + bw and ax + aw > bx and ay < by + bh and ay + ah > by
+
+    def get_state(self):
+        s = np.zeros((C.VIEW, C.VIEW), dtype=np.float32)
+        h = C.VIEW // 2
+        px, py = int(round(self.px)), int(round(self.py))
+        s[h, h] = 1.0
+        for o in self.obs:
+            dx, dy = int(round(o['x'])) - px, int(round(o['y'])) - py
+            v = -1.0 if o.get('pit') else 0.8
+            for ww in range(o.get('w', 1)):
+                for hh in range(o.get('h', 1)):
+                    sx, sy = h + dx + ww, h + dy + hh
+                    if 0 <= sx < C.VIEW and 0 <= sy < C.VIEW:
+                        s[sy, sx] = v
+        for e in self.enemies:
+            dx, dy = int(round(e['x'])) - px, int(round(e['y'])) - py
+            if 0 <= h + dx < C.VIEW and 0 <= h + dy < C.VIEW:
+                s[h + dy, h + dx] = 0.7
+        for c in self.coin_list:
+            dx, dy = int(round(c['x'])) - px, int(round(c['y'])) - py
+            if 0 <= h + dx < C.VIEW and 0 <= h + dy < C.VIEW:
+                s[h + dy, h + dx] = 0.3
+        return s.flatten()
+
+    def step(self, action: int):
         sound = None
-        
-        # Movement
-        if action == 1: self.player[0] -= CFG.MOVE_SPEED
-        elif action == 2: self.player[0] += CFG.MOVE_SPEED
-        elif action == 3 and self.on_ground:
-            self.vel_y = CFG.JUMP_POWER
-            self.on_ground = False
+        PW, PH = 0.6, 0.9  # Player hitbox size
+
+        # Input
+        self.vx = 0.0
+        if action == 1: self.vx = -C.SPEED
+        elif action == 2: self.vx = C.SPEED
+        if action == 3 and self.grounded:
+            self.vy = C.JUMP
+            self.grounded = False
             sound = 'jump'
-        
-        # Physics
-        self.vel_y += CFG.GRAVITY
-        self.player[1] += self.vel_y
-        
-        if self.player[1] >= CFG.GROUND_Y:
-            self.player[1] = CFG.GROUND_Y
-            self.vel_y = 0.0
-            self.on_ground = True
-        
-        # Death checks
-        if self.player[1] > CFG.GRID_H:
+
+        # === X AXIS MOVEMENT + COLLISION ===
+        self.px += self.vx
+        for o in self.obs:
+            if o.get('pit'): continue
+            if self._aabb(self.px, self.py, PW, PH, o['x'], o['y'], o['w'], o['h']):
+                if self.vx > 0:
+                    self.px = o['x'] - PW
+                elif self.vx < 0:
+                    self.px = o['x'] + o['w']
+                self.vx = 0
+
+        # === Y AXIS MOVEMENT + COLLISION ===
+        self.vy += C.GRAV
+        self.py += self.vy
+        self.grounded = False
+
+        # Ground collision
+        if self.py >= C.GROUND:
+            self.py = C.GROUND
+            self.vy = 0.0
+            self.grounded = True
+
+        # Platform collision (Y)
+        for o in self.obs:
+            if o.get('pit'): continue
+            if self._aabb(self.px, self.py, PW, PH, o['x'], o['y'], o['w'], o['h']):
+                if self.vy > 0:  # Falling down onto platform
+                    self.py = o['y'] - PH
+                    self.vy = 0.0
+                    self.grounded = True
+                elif self.vy < 0:  # Jumping up into platform
+                    self.py = o['y'] + o['h']
+                    self.vy = 0.0
+
+        # Death: fell off world
+        if self.py > C.H + 2:
             self.alive = False
             return self.get_state(), -50.0, True, 'die'
-        
+
+        # Pit death
+        for o in self.obs:
+            if o.get('pit') and o['x'] <= self.px + PW / 2 <= o['x'] + o['w'] and self.py >= C.GROUND:
+                self.alive = False
+                return self.get_state(), -50.0, True, 'die'
+
         # Enemy collision
         for e in self.enemies:
-            if abs(e['x'] - self.player[0]) < 0.8 and abs(e['y'] - self.player[1]) < 0.8:
+            if self._aabb(self.px, self.py, PW, PH, e['x'] - 0.3, e['y'] - 0.3, 0.6, 0.6):
                 self.alive = False
                 return self.get_state(), -50.0, True, 'die'
-        
-        # Obstacle collision
-        px, py = self.player[0], self.player[1]
-        for obs in self.obstacles:
-            if obs.get('pit'):
-                if obs['x'] <= px <= obs['x'] + obs['w'] and py >= obs['y']:
-                    self.alive = False
-                    return self.get_state(), -50.0, True, 'die'
-            else:
-                if obs['x'] <= px <= obs['x'] + obs['w'] - 0.1:
-                    if obs['y'] <= py <= obs['y'] + obs['h']:
-                        self.alive = False
-                        return self.get_state(), -50.0, True, 'die'
-        
+
         # Coins
-        collected = 0
-        for coin in self.coins:
-            if not coin['collected'] and abs(coin['x'] - px) < 1.0 and abs(coin['y'] - py) < 1.0:
-                coin['collected'] = True
-                collected += 1
-        if collected:
-            self.coins_collected += collected
-            self.score += collected * 10
+        got = 0
+        for c in self.coin_list:
+            if not c['collected'] and self._aabb(self.px, self.py, PW, PH, c['x'] - 0.3, c['y'] - 0.3, 0.6, 0.6):
+                c['collected'] = True
+                got += 1
+        if got:
+            self.coins += got
+            self.score += got * 10
             sound = 'coin'
-        
-        # Update world
-        self.score += 1
-        self.step_count += 1
-        self._update_chunks()
-        
+
         # Update enemies
+        t = time.time()
         for e in self.enemies:
             if e['type'] == 'walker':
-                e['x'] += e['speed'] * e['dir']
-                if abs(e['x'] - e['origin']) > e['range']:
-                    e['dir'] *= -1
-        
-        done = self.step_count > 3000
-        reward = 1.0 + collected * 5.0
+                e['x'] += e['spd'] * e['dir']
+                if abs(e['x'] - e['ox']) > e['rng']: e['dir'] *= -1
+            else:
+                e['y'] = (C.GROUND - 1) + np.sin(t * e['spd'] * 3) * 0.5
+
+        self.score += 1
+        self.step_n += 1
+        self._load_chunks()
+
+        done = self.step_n > 3000
+        reward = 1.0 + got * 5.0
         return self.get_state(), reward, done, sound
-    
-    def get_world_data(self) -> dict:
+
+    def world_data(self):
         return {
-            'player': [round(self.player[0], 2), round(self.player[1], 2)],
-            'obstacles': self.obstacles,
+            'player': [round(self.px, 2), round(self.py, 2)],
+            'obstacles': self.obs,
             'entities': self.enemies,
-            'coins': [c for c in self.coins if not c['collected']],
-            'ground_level': CFG.GROUND_Y,
+            'coins': [c for c in self.coin_list if not c['collected']],
+            'ground': C.GROUND,
             'score': self.score,
-            'coins_collected': self.coins_collected,
+            'coins_collected': self.coins,
             'alive': self.alive
         }
 
@@ -269,164 +235,109 @@ class PlatformerEngine:
 # DQN AGENT
 # ============================================================================
 
-class DQNetwork(nn.Module):
+class Net(nn.Module):
     def __init__(self):
         super().__init__()
         self.net = nn.Sequential(
-            nn.Linear(CFG.STATE_SIZE, 256), nn.ReLU(),
+            nn.Linear(C.STATE, 256), nn.ReLU(),
             nn.Linear(256, 256), nn.ReLU(),
             nn.Linear(256, 128), nn.ReLU(),
-            nn.Linear(128, CFG.ACTION_SIZE)
+            nn.Linear(128, C.ACTS)
         )
-    
-    def forward(self, x):
-        return self.net(x)
+    def forward(self, x): return self.net(x)
 
-class DQNAgent:
+class Agent:
     def __init__(self):
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        self.model = DQNetwork().to(self.device)
-        self.target_model = DQNetwork().to(self.device)
-        self.target_model.load_state_dict(self.model.state_dict())
-        
-        self.optimizer = optim.Adam(self.model.parameters(), lr=CFG.LR)
-        self.criterion = nn.MSELoss()
-        self.memory = deque(maxlen=CFG.MEMORY_SIZE)
-        
-        self.epsilon = 1.0
-        self.epsilon_min = 0.01
-        self.steps = 0
-        self.best_score = 0
-        self.training = False
-        
-        if os.path.exists(CFG.MODEL_PATH):
+        self.dev = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.model = Net().to(self.dev)
+        self.target = Net().to(self.dev)
+        self.target.load_state_dict(self.model.state_dict())
+        self.opt = optim.Adam(self.model.parameters(), lr=C.LR)
+        self.crit = nn.MSELoss()
+        self.mem = deque(maxlen=C.MEM)
+        self.eps = 1.0; self.steps = 0; self.best = 0; self.training = False
+        if os.path.exists(C.MODEL):
             try:
-                self.model.load_state_dict(torch.load(CFG.MODEL_PATH, map_location=self.device))
-                self.target_model.load_state_dict(self.model.state_dict())
+                self.model.load_state_dict(torch.load(C.MODEL, map_location=self.dev))
+                self.target.load_state_dict(self.model.state_dict())
                 logger.info("✅ Model loaded")
-            except Exception as e:
-                logger.warning(f"⚠️ Failed to load model: {e}")
-    
-    def act(self, state: np.ndarray) -> int:
-        if random.random() <= self.epsilon:
-            return random.randrange(CFG.ACTION_SIZE)
+            except Exception as e: logger.warning(f"⚠️ Load failed: {e}")
+
+    def act(self, s):
+        if random.random() <= self.eps: return random.randrange(C.ACTS)
         with torch.no_grad():
-            t = torch.FloatTensor(state).unsqueeze(0).to(self.device)
-            return torch.argmax(self.model(t)).item()
-    
-    def remember(self, s, a, r, ns, d):
-        self.memory.append((s, a, r, ns, d))
-    
+            return torch.argmax(self.model(torch.FloatTensor(s).unsqueeze(0).to(self.dev))).item()
+
+    def remember(self, s, a, r, ns, d): self.mem.append((s, a, r, ns, d))
+
     def replay(self):
-        if len(self.memory) < CFG.BATCH_SIZE:
-            return
-        
-        batch = random.sample(self.memory, CFG.BATCH_SIZE)
-        states = torch.FloatTensor([b[0] for b in batch]).to(self.device)
-        actions = torch.LongTensor([b[1] for b in batch]).to(self.device)
-        rewards = torch.FloatTensor([b[2] for b in batch]).to(self.device)
-        next_states = torch.FloatTensor([b[3] for b in batch]).to(self.device)
-        dones = torch.FloatTensor([b[4] for b in batch]).to(self.device)
-        
-        q = self.model(states).gather(1, actions.unsqueeze(1)).squeeze()
-        next_q = self.target_model(next_states).max(1)[0].detach()
-        target = rewards + CFG.GAMMA * next_q * (1 - dones)
-        
-        loss = self.criterion(q, target)
-        self.optimizer.zero_grad()
-        loss.backward()
-        self.optimizer.step()
-        
-        if self.epsilon > self.epsilon_min:
-            self.epsilon *= CFG.EPSILON_DECAY
-        
+        if len(self.mem) < C.BATCH: return
+        b = random.sample(self.mem, C.BATCH)
+        st = torch.FloatTensor([x[0] for x in b]).to(self.dev)
+        ac = torch.LongTensor([x[1] for x in b]).to(self.dev)
+        rw = torch.FloatTensor([x[2] for x in b]).to(self.dev)
+        ns = torch.FloatTensor([x[3] for x in b]).to(self.dev)
+        dn = torch.FloatTensor([x[4] for x in b]).to(self.dev)
+        q = self.model(st).gather(1, ac.unsqueeze(1)).squeeze()
+        nq = self.target(ns).max(1)[0].detach()
+        tgt = rw + C.GAMMA * nq * (1 - dn)
+        loss = self.crit(q, tgt)
+        self.opt.zero_grad(); loss.backward(); self.opt.step()
+        if self.eps > 0.01: self.eps *= C.EPS_DEC
         self.steps += 1
-        if self.steps % CFG.TARGET_UPDATE_FREQ == 0:
-            self.target_model.load_state_dict(self.model.state_dict())
-    
-    def train_episode(self) -> float:
-        env = PlatformerEngine()
-        state = env.reset()
-        total_reward = 0.0
-        done = False
-        steps = 0
-        
-        while not done and steps < 500:
-            action = self.act(state)
-            next_state, reward, done, _ = env.step(action)
-            self.remember(state, action, reward, next_state, done)
-            self.replay()
-            state = next_state
-            total_reward += reward
-            steps += 1
-        
-        if total_reward > self.best_score:
-            self.best_score = total_reward
-            self.save()
-        
-        return total_reward
-    
-    def save(self):
-        torch.save(self.model.state_dict(), CFG.MODEL_PATH)
+        if self.steps % 100 == 0: self.target.load_state_dict(self.model.state_dict())
+
+    def train_ep(self):
+        env = Engine(); s = env.reset(); tr = 0.0; d = False; n = 0
+        while not d and n < 500:
+            a = self.act(s); ns, r, d, _ = env.step(a)
+            self.remember(s, a, r, ns, d); self.replay()
+            s = ns; tr += r; n += 1
+        if tr > self.best: self.best = tr; self.save()
+        return tr
+
+    def save(self): torch.save(self.model.state_dict(), C.MODEL)
 
 
 # ============================================================================
 # CHAT MEMORY
 # ============================================================================
 
-class ChatMemory:
+class ChatMem:
     def __init__(self):
-        self.data: Dict[str, str] = {}
-        self.load()
-    
-    def load(self):
-        if os.path.exists(CFG.CHAT_PATH):
+        self.data = {}
+        if os.path.exists(C.CHAT):
             try:
-                with open(CFG.CHAT_PATH, 'r', encoding='utf-8') as f:
-                    self.data = json.load(f)
+                with open(C.CHAT, 'r', encoding='utf-8') as f: self.data = json.load(f)
             except: pass
-    
     def save(self):
-        with open(CFG.CHAT_PATH, 'w', encoding='utf-8') as f:
-            json.dump(self.data, f, ensure_ascii=False, indent=2)
-    
-    def add(self, q: str, a: str) -> str:
-        self.data[q.lower()] = a
-        self.save()
-        return f"✅ Добавлено: {q} → {a}"
-    
-    def find(self, q: str) -> Optional[str]:
+        with open(C.CHAT, 'w', encoding='utf-8') as f: json.dump(self.data, f, ensure_ascii=False, indent=2)
+    def add(self, q, a):
+        self.data[q.lower()] = a; self.save(); return f"✅ {q} → {a}"
+    def find(self, q):
         q = q.lower()
-        if q in self.data:
-            return self.data[q]
-        words = q.split()
-        best, best_score = None, 0
-        for key, val in self.data.items():
-            score = sum(1 for w in words if w in key)
-            if score > best_score:
-                best_score = score
-                best = val
-        return best if best_score >= len(words) * 0.4 else None
+        if q in self.data: return self.data[q]
+        words = q.split(); best, bs = None, 0
+        for k, v in self.data.items():
+            sc = sum(1 for w in words if w in k)
+            if sc > bs: bs, best = sc, v
+        return best if bs >= len(words) * 0.4 else None
 
 
 # ============================================================================
 # GLOBAL STATE
 # ============================================================================
 
-agent = DQNAgent()
-chat_memory = ChatMemory()
-current_seed = random.randint(0, 999999)
-
-# Persistent game instances
-ai_env = PlatformerEngine(seed=current_seed)
-player_env = PlatformerEngine(seed=current_seed)
-
+agent = Agent()
+chat = ChatMem()
+seed = random.randint(0, 999999)
+ai_env = Engine(seed)
+pl_env = Engine(seed)
 is_training = False
-training_thread = None
 
 
 # ============================================================================
-# HTML TEMPLATE (Fixed Canvas Rendering)
+# RICH GRAPHICS HTML
 # ============================================================================
 
 HTML = """
@@ -438,217 +349,258 @@ HTML = """
 <title>🧠 AI Platformer</title>
 <style>
 *{margin:0;padding:0;box-sizing:border-box}
-body{background:#0a0a1a;color:#eee;font-family:'Segoe UI',sans-serif;display:flex;justify-content:center;padding:20px;min-height:100vh}
-.container{max-width:1100px;width:100%}
-h1{text-align:center;padding:15px 0;background:linear-gradient(135deg,#e94560,#0f3460);-webkit-background-clip:text;-webkit-text-fill-color:transparent;font-size:2.2em}
-.sub{text-align:center;color:#666;margin-bottom:15px}
-.game-row{display:flex;gap:20px;flex-wrap:wrap}
-.game-box{flex:1;min-width:320px;background:#16213e;border-radius:16px;padding:15px;box-shadow:0 8px 32px rgba(0,0,0,.5)}
-.game-box h3{text-align:center;margin-bottom:10px}
-canvas{width:100%;aspect-ratio:4/1;background:#1a1a2e;border-radius:8px;display:block;image-rendering:pixelated}
-.controls{display:flex;justify-content:center;gap:12px;margin:15px 0;flex-wrap:wrap}
-.controls button{padding:12px 30px;font-size:1.1em;border:none;border-radius:10px;cursor:pointer;font-weight:bold;transition:all .15s;color:#fff}
-.controls button:hover{transform:scale(1.05)}
-.controls button:active{transform:scale(.93)}
-.btn-l,.btn-r{background:#e94560}
-.btn-j{background:#0f3460;padding:12px 45px}
-.btn-reset{background:#533483}
-.stats-bar{background:#16213e;border-radius:12px;padding:12px 20px;margin:10px 0;display:flex;justify-content:space-around;flex-wrap:wrap;gap:10px;font-size:1.1em}
-.stats-bar span{color:#e94560;font-weight:bold}
+body{background:#0d1117;color:#eee;font-family:'Segoe UI',sans-serif;display:flex;justify-content:center;padding:20px;min-height:100vh}
+.wrap{max-width:1100px;width:100%}
+h1{text-align:center;padding:15px 0;background:linear-gradient(135deg,#ff6b6b,#4ecdc4);-webkit-background-clip:text;-webkit-text-fill-color:transparent;font-size:2.2em}
+.sub{text-align:center;color:#888;margin-bottom:15px}
+.row{display:flex;gap:20px;flex-wrap:wrap}
+.box{flex:1;min-width:320px;background:#161b22;border-radius:16px;padding:15px;box-shadow:0 8px 32px rgba(0,0,0,.5);border:1px solid #30363d}
+.box h3{text-align:center;margin-bottom:10px;color:#c9d1d9}
+canvas{width:100%;aspect-ratio:4/1;border-radius:8px;display:block;image-rendering:pixelated;background:#0d1117}
+.ctrl{display:flex;justify-content:center;gap:12px;margin:15px 0;flex-wrap:wrap}
+.ctrl button{padding:12px 30px;font-size:1.1em;border:none;border-radius:10px;cursor:pointer;font-weight:bold;transition:all .15s;color:#fff;text-shadow:0 1px 2px rgba(0,0,0,.5)}
+.ctrl button:hover{transform:scale(1.05);filter:brightness(1.2)}
+.ctrl button:active{transform:scale(.93)}
+.bl,.br{background:linear-gradient(135deg,#ff6b6b,#ee5a24)}
+.bj{background:linear-gradient(135deg,#4ecdc4,#2ecc71);padding:12px 45px}
+.brs{background:linear-gradient(135deg,#a29bfe,#6c5ce7)}
+.stats{background:#161b22;border-radius:12px;padding:12px 20px;margin:10px 0;display:flex;justify-content:space-around;flex-wrap:wrap;gap:10px;font-size:1.1em;border:1px solid #30363d}
+.stats span{color:#ff6b6b;font-weight:bold}
 .tabs{display:flex;gap:10px;margin:15px 0;flex-wrap:wrap}
-.tab{padding:10px 22px;background:#16213e;border-radius:10px;cursor:pointer;border:2px solid transparent;transition:all .3s}
-.tab:hover{border-color:#e94560}
-.tab.active{border-color:#e94560;background:#1a1a3e}
-.tab-content{background:#16213e;border-radius:12px;padding:20px;min-height:200px}
-.chat-area{display:flex;gap:10px;margin-top:10px}
-.chat-area input{flex:1;padding:10px;border-radius:8px;border:1px solid #333;background:#0a0a1a;color:#eee;font-size:1em}
-.chat-area button{padding:10px 25px;background:#e94560;color:#fff;border:none;border-radius:8px;cursor:pointer;font-weight:bold}
-.chat-msgs{max-height:200px;overflow-y:auto;padding:5px}
-.chat-msgs div{padding:6px 12px;margin:3px 0;border-radius:6px;background:#0a0a1a}
-.chat-msgs .user{border-left:3px solid #e94560}
-.chat-msgs .bot{border-left:3px solid #0f3460}
+.tab{padding:10px 22px;background:#161b22;border-radius:10px;cursor:pointer;border:2px solid #30363d;transition:all .3s;color:#c9d1d9}
+.tab:hover{border-color:#ff6b6b}
+.tab.active{border-color:#ff6b6b;background:#1c2333}
+.tc{background:#161b22;border-radius:12px;padding:20px;min-height:200px;border:1px solid #30363d}
+.ca{display:flex;gap:10px;margin-top:10px}
+.ca input{flex:1;padding:10px;border-radius:8px;border:1px solid #30363d;background:#0d1117;color:#eee;font-size:1em}
+.ca button{padding:10px 25px;background:#ff6b6b;color:#fff;border:none;border-radius:8px;cursor:pointer;font-weight:bold}
+.cm{max-height:200px;overflow-y:auto;padding:5px}
+.cm div{padding:6px 12px;margin:3px 0;border-radius:6px;background:#0d1117}
+.cm .u{border-left:3px solid #ff6b6b}
+.cm .b{border-left:3px solid #4ecdc4}
 .hidden{display:none}
 </style>
 </head>
 <body>
-<div class="container">
+<div class="wrap">
 <h1>🧠 AI vs Player Platformer</h1>
 <p class="sub">�� Нейросеть слева 🎮 Ты справа (⬅️ ➡️ ⬆️)</p>
-
-<div class="game-row">
-<div class="game-box"><h3>🤖 Нейросеть</h3><canvas id="aiC"></canvas></div>
-<div class="game-box"><h3>🎮 Ты</h3><canvas id="plC"></canvas></div>
+<div class="row">
+<div class="box"><h3>🤖 Нейросеть</h3><canvas id="ac"></canvas></div>
+<div class="box"><h3>🎮 Ты</h3><canvas id="pc"></canvas></div>
 </div>
-
-<div class="stats-bar">
-<div>🤖 ИИ: <span id="aiS">0</span></div>
-<div>🎮 Ты: <span id="plS">0</span></div>
+<div class="stats">
+<div>🤖 ИИ: <span id="as">0</span></div>
+<div>🎮 Ты: <span id="ps">0</span></div>
 <div>🪙 Монет: <span id="cc">0</span></div>
-<div>🧠 ε: <span id="eps">1.00</span></div>
+<div>🧠 ε: <span id="ep">1.00</span></div>
 <div>🏆 Рекорд: <span id="bs">0</span></div>
 </div>
-
-<div class="controls">
-<button class="btn-l" id="bL">⬅️</button>
-<button class="btn-j" id="bJ">⬆️ ПРЫЖОК</button>
-<button class="btn-r" id="bR">➡️</button>
-<button class="btn-reset" id="bReset">🔄 Новый уровень</button>
+<div class="ctrl">
+<button class="bl" id="bL">⬅️ Влево</button>
+<button class="bj" id="bJ">⬆️ ПРЫЖОК</button>
+<button class="br" id="bR">➡️ Вправо</button>
+<button class="brs" id="bReset">🔄 Новый уровень</button>
 </div>
-
 <div class="tabs">
 <div class="tab active" data-tab="chat">💬 Чат</div>
 <div class="tab" data-tab="train">🧠 Тренировка</div>
 <div class="tab" data-tab="stats">📊 Статистика</div>
 </div>
-
-<div class="tab-content">
+<div class="tc">
 <div id="chatTab">
-<div class="chat-msgs" id="msgs">
-<div class="bot">🤖 Привет! Команды: /ai вопрос, /data вопрос|ответ, /stats, /train</div>
-</div>
-<div class="chat-area">
-<input id="ci" placeholder="Введите команду..." onkeydown="if(event.key==='Enter')sendChat()">
-<button onclick="sendChat()">➤</button>
-</div>
+<div class="cm" id="msgs"><div class="b">🤖 Привет! Команды: /ai вопрос, /data вопрос|ответ, /stats, /train</div></div>
+<div class="ca"><input id="ci" placeholder="Введите команду..." onkeydown="if(event.key==='Enter')sendChat()"><button onclick="sendChat()">➤</button></div>
 </div>
 <div id="trainTab" class="hidden">
-<h3>🧠 Тренировка DQN</h3>
-<p>DQN (256→256→128 нейронов)</p>
-<button onclick="startTrain()" style="padding:12px 35px;background:#e94560;color:#fff;border:none;border-radius:10px;font-size:1.1em;cursor:pointer;margin-top:10px">🚀 Запустить</button>
-<div id="ts" style="margin-top:10px;color:#aaa">⏸ Остановлена</div>
+<h3>🧠 Тренировка DQN</h3><p>DQN (256→256→128 нейронов)</p>
+<button onclick="startTrain()" style="padding:12px 35px;background:linear-gradient(135deg,#ff6b6b,#ee5a24);color:#fff;border:none;border-radius:10px;font-size:1.1em;cursor:pointer;margin-top:10px">🚀 Запустить</button>
+<div id="ts" style="margin-top:10px;color:#888">⏸ Остановлена</div>
 </div>
 <div id="statsTab" class="hidden"><h3>📊 Статистика</h3><div id="sc">Загрузка...</div></div>
 </div>
 </div>
-
 <script>
-// Fixed canvas resolution
-function initCanvas(id){
-    const c=document.getElementById(id);
-    c.width=800;c.height=200;
-    return c.getContext('2d');
-}
-const aiCtx=initCanvas('aiC'), plCtx=initCanvas('plC');
-
-let playerAction=0;
+function initC(id){const c=document.getElementById(id);c.width=800;c.height=200;return c.getContext('2d')}
+const aC=initC('ac'),pC=initC('pc');
+let pA=0;
 
-function draw(ctx,data,showPlayer){
-    const W=ctx.canvas.width,H=ctx.canvas.height;
-    const cellW=W/80,cellH=H/20;
+function draw(ctx,d,show){
+    const W=ctx.canvas.width,H=ctx.canvas.height,cW=W/80,cH=H/20;
     ctx.clearRect(0,0,W,H);
-    
+
     // Sky gradient
-    const g=ctx.createLinearGradient(0,0,0,H);
-    g.addColorStop(0,'#0a0a2e');g.addColorStop(0.7,'#1a1a4e');
-    ctx.fillStyle=g;ctx.fillRect(0,0,W,H);
-    
-    // Camera offset - clamped so we don't see negative space at start
-    const camX=Math.max(0,data.player[0]-40);
-    function toS(wx,wy){return[(wx-camX)*cellW,wy*cellH]}
-    
-    // Ground
-    const gy=data.ground_level*cellH;
-    ctx.fillStyle='#4a3a2a';ctx.fillRect(0,gy,W,cellH*3);
-    ctx.fillStyle='#3a2a1a';ctx.fillRect(0,gy+cellH*.5,W,cellH*.5);
-    
-    // Obstacles
-    for(const o of data.obstacles){
+    const sg=ctx.createLinearGradient(0,0,0,H);
+    sg.addColorStop(0,'#0f0c29');sg.addColorStop(0.5,'#302b63');sg.addColorStop(1,'#24243e');
+    ctx.fillStyle=sg;ctx.fillRect(0,0,W,H);
+
+    // Stars
+    ctx.fillStyle='rgba(255,255,255,0.3)';
+    for(let i=0;i<30;i++){
+        const sx=(i*137+d.player[0]*0.1)%W,sy=(i*97)%((d.ground-2)*cH);
+        ctx.fillRect(sx,sy,2,2);
+    }
+
+    const cam=Math.max(0,d.player[0]-40);
+    function toS(wx,wy){return[(wx-cam)*cW,wy*cH]}
+
+    // Ground layers
+    const gy=d.ground*cH;
+    const gg=ctx.createLinearGradient(0,gy,0,H);
+    gg.addColorStop(0,'#4a7c59');gg.addColorStop(0.15,'#3d6b4e');gg.addColorStop(0.5,'#5c4033');gg.addColorStop(1,'#3e2723');
+    ctx.fillStyle=gg;ctx.fillRect(0,gy,W,H-gy);
+    // Grass top
+    ctx.fillStyle='#6abf69';ctx.fillRect(0,gy,W,cH*0.3);
+    ctx.fillStyle='#81c784';
+    for(let gx=0;gx<W;gx+=8){ctx.fillRect(gx,gy-cH*0.1,4,cH*0.15)}
+
+    // Obstacles with detail
+    for(const o of d.obstacles){
         const[x,y]=toS(o.x,o.y);
-        if(o.pit){ctx.fillStyle='#000';ctx.fillRect(x,y-cellH,o.w*cellW,cellH*2)}
-        else{ctx.fillStyle='#8a7a6a';ctx.fillRect(x,y,o.w*cellW,o.h*cellH)}
+        if(o.pit){
+            const pg=ctx.createLinearGradient(0,y-cH,0,y+cH);
+            pg.addColorStop(0,'#1a1a2e');pg.addColorStop(1,'#000');
+            ctx.fillStyle=pg;ctx.fillRect(x,y-cH,o.w*cW,cH*2);
+            ctx.fillStyle='#ff4444';ctx.fillRect(x,y-cH*0.5,o.w*cW,2);
+        }else{
+            // Brick pattern
+            const bg=ctx.createLinearGradient(x,y,x,y+o.h*cH);
+            bg.addColorStop(0,'#8d6e63');bg.addColorStop(1,'#6d4c41');
+            ctx.fillStyle=bg;ctx.fillRect(x,y,o.w*cW,o.h*cH);
+            // Brick lines
+            ctx.strokeStyle='rgba(0,0,0,0.3)';ctx.lineWidth=1;
+            for(let by=0;by<o.h;by++){
+                const yy=y+by*cH;
+                ctx.beginPath();ctx.moveTo(x,yy);ctx.lineTo(x+o.w*cW,yy);ctx.stroke();
+                const off=(by%2)*cW*0.5;
+                for(let bx=off;bx<o.w*cW;bx+=cW){
+                    ctx.beginPath();ctx.moveTo(x+bx,yy);ctx.lineTo(x+bx,yy+cH);ctx.stroke();
+                }
+            }
+            // Top highlight
+            ctx.fillStyle='rgba(255,255,255,0.15)';ctx.fillRect(x,y,o.w*cW,cH*0.15);
+            // Shadow
+            ctx.fillStyle='rgba(0,0,0,0.3)';ctx.fillRect(x+o.w*cW,y,3,o.h*cH);
+        }
     }
-    
-    // Enemies
-    for(const e of data.entities){
+
+    // Enemies with animation
+    const t=Date.now()/200;
+    for(const e of d.entities){
         const[x,y]=toS(e.x,e.y);
-        ctx.fillStyle='#e94560';ctx.beginPath();
-        ctx.arc(x+cellW/2,y+cellH/2,cellH/2.5,0,Math.PI*2);ctx.fill();
+        const bounce=Math.sin(t+e.x)*2;
+        ctx.save();ctx.translate(x+cW/2,y+cH/2+bounce);
+        // Body
+        const eg=ctx.createRadialGradient(0,0,2,0,0,cH/2);
+        eg.addColorStop(0,'#ff6b6b');eg.addColorStop(1,'#c0392b');
+        ctx.fillStyle=eg;ctx.beginPath();ctx.arc(0,0,cH/2.5,0,Math.PI*2);ctx.fill();
+        // Eyes
+        ctx.fillStyle='#fff';
+        ctx.beginPath();ctx.arc(-4,-3,3,0,Math.PI*2);ctx.arc(4,-3,3,0,Math.PI*2);ctx.fill();
+        ctx.fillStyle='#000';
+        const ex=e.dir*2;
+        ctx.beginPath();ctx.arc(-4+ex,-3,1.5,0,Math.PI*2);ctx.arc(4+ex,-3,1.5,0,Math.PI*2);ctx.fill();
+        // Glow
+        ctx.shadowColor='#ff6b6b';ctx.shadowBlur=10;
+        ctx.strokeStyle='#ff6b6b';ctx.lineWidth=1;ctx.beginPath();ctx.arc(0,0,cH/2.2,0,Math.PI*2);ctx.stroke();
+        ctx.restore();
     }
-    
-    // Coins
-    for(const c of data.coins){
+
+    // Coins with sparkle
+    for(const c of d.coins){
         const[x,y]=toS(c.x,c.y);
-        ctx.fillStyle='#ffd700';ctx.beginPath();
-        ctx.arc(x+cellW/2,y+cellH/2,cellH/3,0,Math.PI*2);ctx.fill();
+        const pulse=1+Math.sin(t*2+c.x)*0.15;
+        ctx.save();ctx.translate(x+cW/2,y+cH/2);ctx.scale(pulse,pulse);
+        const cg=ctx.createRadialGradient(-2,-2,1,0,0,cH/3);
+        cg.addColorStop(0,'#fff9c4');cg.addColorStop(0.5,'#ffd700');cg.addColorStop(1,'#f9a825');
+        ctx.fillStyle=cg;ctx.beginPath();ctx.arc(0,0,cH/3,0,Math.PI*2);ctx.fill();
+        ctx.shadowColor='#ffd700';ctx.shadowBlur=12;
+        ctx.strokeStyle='#ffeb3b';ctx.lineWidth=1.5;ctx.beginPath();ctx.arc(0,0,cH/3,0,Math.PI*2);ctx.stroke();
+        // Shine
+        ctx.fillStyle='rgba(255,255,255,0.8)';ctx.beginPath();ctx.arc(-3,-3,2,0,Math.PI*2);ctx.fill();
+        ctx.restore();
     }
-    
+
     // Player
-    if(showPlayer&&data.alive){
-        const[px,py]=toS(data.player[0],data.player[1]);
-        ctx.fillStyle='#00ff88';ctx.shadowColor='#00ff88';ctx.shadowBlur=15;
-        ctx.fillRect(px+2,py+2,cellW-4,cellH-4);ctx.shadowBlur=0;
+    if(show&&d.alive){
+        const[px,py]=toS(d.player[0],d.player[1]);
+        ctx.save();
+        // Glow
+        ctx.shadowColor='#00ff88';ctx.shadowBlur=20;
+        // Body gradient
+        const pg=ctx.createLinearGradient(px,py,px+cW,py+cH);
+        pg.addColorStop(0,'#00ff88');pg.addColorStop(1,'#00b894');
+        ctx.fillStyle=pg;
+        ctx.fillRect(px+2,py+2,cW-4,cH-4);
+        // Face
+        ctx.shadowBlur=0;
+        ctx.fillStyle='#fff';
+        ctx.fillRect(px+cW*0.2,py+cH*0.25,cW*0.2,cH*0.2);
+        ctx.fillRect(px+cW*0.6,py+cH*0.25,cW*0.2,cH*0.2);
+        ctx.fillStyle='#0d1117';
+        ctx.fillRect(px+cW*0.25,py+cH*0.3,cW*0.1,cH*0.1);
+        ctx.fillRect(px+cW*0.65,py+cH*0.3,cW*0.1,cH*0.1);
+        ctx.restore();
     }
 }
 
 async function update(){
     try{
-        const r=await fetch('/step',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:playerAction})});
+        const r=await fetch('/step',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:pA})});
         const d=await r.json();
-        draw(aiCtx,d.ai,true);
-        draw(plCtx,d.player,d.player.alive);
-        document.getElementById('aiS').textContent=d.ai.score;
-        document.getElementById('plS').textContent=d.player.score;
+        draw(aC,d.ai,true);draw(pC,d.player,d.player.alive);
+        document.getElementById('as').textContent=d.ai.score;
+        document.getElementById('ps').textContent=d.player.score;
         document.getElementById('cc').textContent=d.player.coins_collected;
-        document.getElementById('eps').textContent=d.epsilon.toFixed(3);
+        document.getElementById('ep').textContent=d.epsilon.toFixed(3);
         document.getElementById('bs').textContent=d.best_score;
     }catch(e){}
 }
 
-// Controls
-const setA=(v)=>{playerAction=v};
-document.getElementById('bL').onmousedown=()=>setA(1);document.getElementById('bL').onmouseup=()=>setA(0);
-document.getElementById('bR').onmousedown=()=>setA(2);document.getElementById('bR').onmouseup=()=>setA(0);
-document.getElementById('bJ').onmousedown=()=>setA(3);document.getElementById('bJ').onmouseup=()=>setA(0);
+const sA=v=>{pA=v};
+document.getElementById('bL').onmousedown=()=>sA(1);document.getElementById('bL').onmouseup=()=>sA(0);
+document.getElementById('bR').onmousedown=()=>sA(2);document.getElementById('bR').onmouseup=()=>sA(0);
+document.getElementById('bJ').onmousedown=()=>sA(3);document.getElementById('bJ').onmouseup=()=>sA(0);
 document.addEventListener('keydown',e=>{
-    if(e.key==='ArrowLeft'){e.preventDefault();setA(1)}
-    else if(e.key==='ArrowRight'){e.preventDefault();setA(2)}
-    else if(e.key==='ArrowUp'||e.key===' '){e.preventDefault();setA(3)}
-});
-document.addEventListener('keyup',e=>{
-    if(['ArrowLeft','ArrowRight','ArrowUp',' '].includes(e.key)){e.preventDefault();setA(0)}
+    if(e.key==='ArrowLeft'){e.preventDefault();sA(1)}
+    else if(e.key==='ArrowRight'){e.preventDefault();sA(2)}
+    else if(e.key==='ArrowUp'||e.key===' '){e.preventDefault();sA(3)}
 });
+document.addEventListener('keyup',e=>{if(['ArrowLeft','ArrowRight','ArrowUp',' '].includes(e.key)){e.preventDefault();sA(0)}});
 
 document.getElementById('bReset').onclick=async()=>{
-    const r=await fetch('/reset',{method:'POST'});
-    const d=await r.json();
-    draw(aiCtx,d.ai,true);draw(plCtx,d.player,true);
-    document.getElementById('aiS').textContent=d.ai.score;
-    document.getElementById('plS').textContent=d.player.score;
+    const r=await fetch('/reset',{method:'POST'});const d=await r.json();
+    draw(aC,d.ai,true);draw(pC,d.player,true);
+    document.getElementById('as').textContent=d.ai.score;
+    document.getElementById('ps').textContent=d.player.score;
 };
 
-// Chat
 async function sendChat(){
-    const inp=document.getElementById('ci');
-    const msg=inp.value.trim();if(!msg)return;inp.value='';
+    const inp=document.getElementById('ci');const msg=inp.value.trim();if(!msg)return;inp.value='';
     const m=document.getElementById('msgs');
-    m.innerHTML+=`<div class="user">👤 ${msg}</div>`;m.scrollTop=m.scrollHeight;
+    m.innerHTML+=`<div class="u">👤 ${msg}</div>`;m.scrollTop=m.scrollHeight;
     const r=await fetch('/chat',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({message:msg})});
     const d=await r.json();
-    m.innerHTML+=`<div class="bot">🤖 ${d.response}</div>`;m.scrollTop=m.scrollHeight;
+    m.innerHTML+=`<div class="b">🤖 ${d.response}</div>`;m.scrollTop=m.scrollHeight;
 }
 
-// Training
 async function startTrain(){
     document.getElementById('ts').textContent='⏳ Запуск...';
-    const r=await fetch('/train',{method:'POST'});
-    const d=await r.json();
+    const r=await fetch('/train',{method:'POST'});const d=await r.json();
     document.getElementById('ts').textContent=d.message;
 }
 
-// Tabs
 document.querySelectorAll('.tab').forEach(t=>t.onclick=function(){
     document.querySelectorAll('.tab').forEach(x=>x.classList.remove('active'));
-    this.classList.add('active');
-    const n=this.dataset.tab;
-    document.querySelectorAll('.tab-content>div').forEach(d=>d.classList.add('hidden'));
+    this.classList.add('active');const n=this.dataset.tab;
+    document.querySelectorAll('.tc>div').forEach(d=>d.classList.add('hidden'));
     document.getElementById(n+'Tab').classList.remove('hidden');
     if(n==='stats')fetch('/stats').then(r=>r.json()).then(d=>{
         document.getElementById('sc').innerHTML=`<p>🧠 Память: ${d.memory_size}</p><p>🎮 Шагов: ${d.steps}</p><p>📉 ε: ${d.epsilon}</p><p>🏆 Рекорд: ${d.best_score}</p><p>⚡ Тренируется: ${d.training?'✅':'❌'}</p>`;
     });
 });
 
-setInterval(update,100);
-update();
+setInterval(update,100);update();
 </script>
 </body>
 </html>
@@ -661,109 +613,73 @@ update();
 app = Flask(__name__)
 
 @app.route('/')
-def index():
-    return render_template_string(HTML)
+def index(): return render_template_string(HTML)
 
 @app.route('/step', methods=['POST'])
 def step():
-    global ai_env, player_env
-    
+    global ai_env, pl_env
     action = request.json.get('action', 0)
-    
-    # AI moves autonomously
     if ai_env.alive:
-        ai_action = agent.act(ai_env.get_state())
-        ai_env.step(ai_action)
+        ai_env.step(agent.act(ai_env.get_state()))
     else:
         ai_env.reset()
-    
-    # Player moves based on input
-    if player_env.alive:
-        player_env.step(action)
+    if pl_env.alive:
+        pl_env.step(action)
     else:
-        player_env.reset()
-    
+        pl_env.reset()
     return jsonify({
-        'ai': ai_env.get_world_data(),
-        'player': player_env.get_world_data(),
-        'epsilon': agent.epsilon,
-        'best_score': agent.best_score
+        'ai': ai_env.world_data(), 'player': pl_env.world_data(),
+        'epsilon': agent.eps, 'best_score': agent.best
     })
 
 @app.route('/reset', methods=['POST'])
 def reset():
-    global current_seed, ai_env, player_env
-    current_seed = random.randint(0, 999999)
-    ai_env = PlatformerEngine(seed=current_seed)
-    player_env = PlatformerEngine(seed=current_seed)
-    return jsonify({
-        'ai': ai_env.get_world_data(),
-        'player': player_env.get_world_data()
-    })
+    global seed, ai_env, pl_env
+    seed = random.randint(0, 999999)
+    ai_env = Engine(seed); pl_env = Engine(seed)
+    return jsonify({'ai': ai_env.world_data(), 'player': pl_env.world_data()})
 
 @app.route('/chat', methods=['POST'])
-def chat():
+def chat_route():
     msg = request.json.get('message', '').strip()
-    
     if msg.startswith('/ai '):
-        ans = chat_memory.find(msg[4:])
-        return jsonify({'response': ans or "🤖 Не знаю. Обучи через /data"})
+        a = chat.find(msg[4:])
+        return jsonify({'response': a or "🤖 Не знаю. Обучи через /data"})
     elif msg.startswith('/data '):
-        parts = msg[6:].split('|')
-        if len(parts) != 2:
-            return jsonify({'response': "❌ Формат: /data вопрос|ответ"})
-        return jsonify({'response': chat_memory.add(parts[0].strip(), parts[1].strip())})
+        p = msg[6:].split('|')
+        if len(p) != 2: return jsonify({'response': "❌ Формат: /data вопрос|ответ"})
+        return jsonify({'response': chat.add(p[0].strip(), p[1].strip())})
     elif msg == '/stats':
-        return jsonify({'response': f"📊 Память: {len(chat_memory.data)}, Шагов: {agent.steps}"})
+        return jsonify({'response': f"📊 Память: {len(chat.data)}, Шагов: {agent.steps}"})
     elif msg == '/train':
         return jsonify({'response': start_training()})
-    else:
-        return jsonify({'response': "🤖 Команды: /ai, /data, /stats, /train"})
+    return jsonify({'response': "🤖 Команды: /ai, /data, /stats, /train"})
 
 @app.route('/train', methods=['POST'])
-def train_route():
-    return jsonify({'message': start_training()})
+def train_route(): return jsonify({'message': start_training()})
 
 @app.route('/stats')
 def stats():
     return jsonify({
-        'memory_size': len(chat_memory.data),
-        'steps': agent.steps,
-        'epsilon': round(agent.epsilon, 3),
-        'best_score': agent.best_score,
-        'training': is_training
+        'memory_size': len(chat.data), 'steps': agent.steps,
+        'epsilon': round(agent.eps, 3), 'best_score': agent.best, 'training': is_training
     })
 
-def start_training() -> str:
-    global is_training, training_thread
-    
-    if is_training:
-        return "⏳ Уже тренируется!"
-    
+def start_training():
+    global is_training
+    if is_training: return "⏳ Уже тренируется!"
     is_training = True
-    
-    def _train():
+    def _t():
         global is_training
         try:
             for ep in range(100):
-                if not is_training:
-                    break
-                score = agent.train_episode()
-                if ep % 10 == 0:
-                    logger.info(f"Episode {ep}: score={score:.1f}, ε={agent.epsilon:.3f}")
-        except Exception as e:
-            logger.error(f"Training error: {e}")
-        finally:
-            is_training = False
-    
-    training_thread = threading.Thread(target=_train, daemon=True)
-    training_thread.start()
+                if not is_training: break
+                sc = agent.train_ep()
+                if ep % 10 == 0: logger.info(f"Ep {ep}: score={sc:.1f}, ε={agent.eps:.3f}")
+        except Exception as e: logger.error(f"Train error: {e}")
+        finally: is_training = False
+    threading.Thread(target=_t, daemon=True).start()
     return "🚀 Тренировка запущена!"
 
-
-# ============================================================================
-# ENTRY POINT
-# ============================================================================
-
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=CFG.PORT, debug=False)
+    app.run(host='0.0.0.0', port=C.PORT, debug=False)