Update app.py

app.py

@@ -1,112 +1,353 @@
 """
-🧠 AI PLATFORMER + CHATBOT
-Hugging Face Space (Flask + HTML)
+AI PLATFORMER + CHATBOT (FIXED & OPTIMIZED)
+Safe spawn, proper rendering, stateful game loop
 """
-from flask import Flask, render_template_string, request, jsonify
-import numpy as np
-import random
-import json
+
 import os
-import time
+import json
+import random
 import threading
-import math
+import time
+import logging
 from collections import deque
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Any
+
+import numpy as np
 import torch
 import torch.nn as nn
 import torch.optim as optim
+from flask import Flask, jsonify, request, render_template_string
 
-app = Flask(__name__)
+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()
+
+# ============================================================================
+# GAME ENGINE (Stateful, Safe Spawn, Deterministic)
+# ============================================================================
+
+class PlatformerEngine:
+    def __init__(self, seed: Optional[int] = 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
+        self.alive = True
+        self.score = 0
+        self.coins_collected = 0
+        self.step_count = 0
+        
+        self.chunks: Dict[int, dict] = {}
+        self.obstacles: List[dict] = []
+        self.enemies: List[dict] = []
+        self.coins: List[dict] = []
+        
+        self._update_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))
+                w = rng.randint(1, 3)
+                obstacles.append({'x': x, 'y': CFG.GROUND_Y - 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})
+            
+            for _ in range(rng.randint(1, 2)):
+                x = base_x + rng.randint(10, 20)
+                enemies.append({
+                    'x': x, 'y': CFG.GROUND_Y - 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
+                })
+        
+        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]]:
+        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
+            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:
+            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:
+                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
+            sound = 'coin'
+        
+        # Update world
+        self.score += 1
+        self.step_count += 1
+        self._update_chunks()
+        
+        # Update enemies
+        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
+        return self.get_state(), reward, done, sound
+    
+    def get_world_data(self) -> dict:
+        return {
+            'player': [round(self.player[0], 2), round(self.player[1], 2)],
+            'obstacles': self.obstacles,
+            'entities': self.enemies,
+            'coins': [c for c in self.coins if not c['collected']],
+            'ground_level': CFG.GROUND_Y,
+            'score': self.score,
+            'coins_collected': self.coins_collected,
+            'alive': self.alive
+        }
 
-# =====================================================
-# 1. НЕЙРОСЕТЬ (DQN)
-# =====================================================
+
+# ============================================================================
+# DQN AGENT
+# ============================================================================
 
 class DQNetwork(nn.Module):
-    def __init__(self, input_size=1600, output_size=4):
+    def __init__(self):
         super().__init__()
         self.net = nn.Sequential(
-            nn.Linear(input_size, 256),
-            nn.ReLU(),
-            nn.Linear(256, 256),
-            nn.ReLU(),
-            nn.Linear(256, 256),
-            nn.ReLU(),
-            nn.Linear(256, 128),
-            nn.ReLU(),
-            nn.Linear(128, output_size)
+            nn.Linear(CFG.STATE_SIZE, 256), nn.ReLU(),
+            nn.Linear(256, 256), nn.ReLU(),
+            nn.Linear(256, 128), nn.ReLU(),
+            nn.Linear(128, CFG.ACTION_SIZE)
         )
     
     def forward(self, x):
         return self.net(x)
 
 class DQNAgent:
-    def __init__(self, state_size=1600, action_size=4):
-        self.state_size = state_size
-        self.action_size = action_size
-        self.memory = deque(maxlen=10000)
+    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.epsilon_decay = 0.995
-        self.learning_rate = 0.0005
-        self.gamma = 0.99
-        self.batch_size = 64
-        self.total_steps = 0
+        self.steps = 0
         self.best_score = 0
         self.training = False
-        self.update_target_every = 100
         
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        self.model = DQNetwork(state_size, action_size).to(self.device)
-        self.target_model = DQNetwork(state_size, action_size).to(self.device)
-        self.target_model.load_state_dict(self.model.state_dict())
-        self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)
-        self.criterion = nn.MSELoss()
-        
-        if os.path.exists('dqn_model.pth'):
-            self.load_model()
-    
-    def act(self, state):
-        if np.random.rand() <= self.epsilon:
-            return random.randrange(self.action_size)
+        if os.path.exists(CFG.MODEL_PATH):
+            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())
+                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)
         with torch.no_grad():
-            state_tensor = torch.FloatTensor(state).unsqueeze(0).to(self.device)
-            q_values = self.model(state_tensor)
-            return torch.argmax(q_values).item()
+            t = torch.FloatTensor(state).unsqueeze(0).to(self.device)
+            return torch.argmax(self.model(t)).item()
     
-    def remember(self, state, action, reward, next_state, done):
-        self.memory.append((state, action, reward, next_state, done))
+    def remember(self, s, a, r, ns, d):
+        self.memory.append((s, a, r, ns, d))
     
     def replay(self):
-        if len(self.memory) < self.batch_size:
+        if len(self.memory) < CFG.BATCH_SIZE:
             return
         
-        batch = random.sample(self.memory, self.batch_size)
+        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)
         
-        current_q = self.model(states).gather(1, actions.unsqueeze(1)).squeeze()
+        q = self.model(states).gather(1, actions.unsqueeze(1)).squeeze()
         next_q = self.target_model(next_states).max(1)[0].detach()
-        target_q = rewards + self.gamma * next_q * (1 - dones)
+        target = rewards + CFG.GAMMA * next_q * (1 - dones)
         
-        loss = self.criterion(current_q, target_q)
+        loss = self.criterion(q, target)
         self.optimizer.zero_grad()
         loss.backward()
         self.optimizer.step()
         
         if self.epsilon > self.epsilon_min:
-            self.epsilon *= self.epsilon_decay
+            self.epsilon *= CFG.EPSILON_DECAY
         
-        self.total_steps += 1
-        if self.total_steps % self.update_target_every == 0:
+        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):
-        env = PlatformerLogic()
+    def train_episode(self) -> float:
+        env = PlatformerEngine()
         state = env.reset()
-        total_reward = 0
+        total_reward = 0.0
         done = False
         steps = 0
         
@@ -121,691 +362,303 @@ class DQNAgent:
         
         if total_reward > self.best_score:
             self.best_score = total_reward
+            self.save()
         
-        return total_reward, steps
-    
-    def save_model(self):
-        torch.save(self.model.state_dict(), 'dqn_model.pth')
+        return total_reward
     
-    def load_model(self):
-        self.model.load_state_dict(torch.load('dqn_model.pth', map_location=self.device))
-        self.target_model.load_state_dict(self.model.state_dict())
+    def save(self):
+        torch.save(self.model.state_dict(), CFG.MODEL_PATH)
 
-# =====================================================
-# 2. ПЛАТФОРМЕР
-# =====================================================
 
-class PlatformerLogic:
-    def __init__(self, seed=None):
-        self.width = 80
-        self.height = 20
-        self.seed = seed or random.randint(0, 999999)
-        self.reset()
-    
-    def reset(self):
-        random.seed(self.seed)
-        
-        self.player = [5, 15]
-        self.score = 0
-        self.distance = 0
-        self.speed = 1.0
-        self.difficulty = 1.0
-        self.ground_level = 17
-        self.chunks = {}
-        self.entities = []
-        self.coins = []
-        self.obstacles = []
-        self.velocity_y = 0
-        self.gravity = 0.4
-        self.jump_power = -7
-        self.on_ground = False
-        self.alive = True
-        self.steps = 0
-        self.coins_collected = 0
-        
-        self.generate_chunk(0)
-        self.generate_chunk(1)
-        
-        random.seed()
-        return self.get_state()
-    
-    def generate_chunk(self, chunk_x):
-        if chunk_x in self.chunks:
-            return
-        
-        seed = (chunk_x * 1337 + self.seed) % 999999
-        random.seed(seed)
-        
-        obstacles = []
-        enemies = []
-        coins = []
-        base_x = chunk_x * 30
-        
-        for _ in range(random.randint(3, 6) + int(self.difficulty)):
-            x = base_x + random.randint(5, 25)
-            height = random.randint(1, 3 + int(self.difficulty * 0.5))
-            width = random.randint(1, 3)
-            obstacles.append({
-                'x': x, 'y': self.ground_level - height,
-                'width': width, 'height': height
-            })
-        
-        for _ in range(random.randint(1, 2)):
-            x = base_x + random.randint(10, 20)
-            width = random.randint(2, 4)
-            obstacles.append({
-                'x': x, 'y': self.ground_level + 1,
-                'width': width, 'height': 1, 'is_pit': True
-            })
-        
-        for _ in range(random.randint(1, 3) + int(self.difficulty * 0.5)):
-            x = base_x + random.randint(5, 25)
-            y = self.ground_level - 1
-            enemy_type = random.choice(['walker', 'jumper'])
-            enemies.append({
-                'x': x, 'y': y, 'type': enemy_type,
-                'direction': 1 if random.random() > 0.5 else -1,
-                'speed': 0.3 + random.random() * 0.3,
-                'range': random.randint(3, 8),
-                'start_x': x
-            })
-        
-        for _ in range(random.randint(5, 10) + int(self.difficulty)):
-            x = base_x + random.randint(2, 28)
-            y = random.randint(5, self.ground_level - 2)
-            coins.append({'x': x, 'y': y, 'collected': False})
-        
-        self.chunks[chunk_x] = {
-            'obstacles': obstacles,
-            'enemies': enemies,
-            'coins': coins
-        }
-        random.seed()
-    
-    def get_state(self):
-        state_size = 40
-        state = np.zeros((state_size, state_size), dtype=np.float32)
-        half = state_size // 2
-        px, py = int(self.player[0]), int(self.player[1])
-        
-        state[half, half] = 1.0
-        
-        for obs in self.obstacles:
-            dx = obs['x'] - px
-            dy = obs['y'] - py
-            if abs(dx) < half and abs(dy) < half:
-                for w in range(obs['width']):
-                    for h in range(obs['height']):
-                        sx = half + dx + w
-                        sy = half + dy + h
-                        if 0 <= sx < state_size and 0 <= sy < state_size:
-                            state[sy, sx] = -1.0
-        
-        for enemy in self.entities:
-            dx = enemy['x'] - px
-            dy = enemy['y'] - py
-            if abs(dx) < half and abs(dy) < half:
-                sx = half + dx
-                sy = half + dy
-                if 0 <= sx < state_size and 0 <= sy < state_size:
-                    state[sy, sx] = 0.7
-        
-        for coin in self.coins:
-            if not coin['collected']:
-                dx = coin['x'] - px
-                dy = coin['y'] - py
-                if abs(dx) < half and abs(dy) < half:
-                    sx = half + dx
-                    sy = half + dy
-                    if 0 <= sx < state_size and 0 <= sy < state_size:
-                        state[sy, sx] = 0.3
-        
-        return state.flatten()
-    
-    def update_entities(self):
-        for enemy in self.entities[:]:
-            if enemy['type'] == 'walker':
-                enemy['x'] += enemy['speed'] * enemy['direction']
-                if abs(enemy['x'] - enemy['start_x']) > enemy['range']:
-                    enemy['direction'] *= -1
-            elif enemy['type'] == 'jumper':
-                enemy['y'] += math.sin(time.time() * enemy['speed'] * 2) * 0.3
-                if enemy['y'] > self.ground_level - 1:
-                    enemy['y'] = self.ground_level - 1
-        
-        for enemy in self.entities:
-            if abs(enemy['x'] - self.player[0]) < 0.8 and abs(enemy['y'] - self.player[1]) < 0.8:
-                return True
-        return False
-    
-    def collect_coins(self):
-        collected = 0
-        for coin in self.coins:
-            if not coin['collected']:
-                if abs(coin['x'] - self.player[0]) < 1.0 and abs(coin['y'] - self.player[1]) < 1.0:
-                    coin['collected'] = True
-                    collected += 1
-        return collected
-    
-    def check_obstacles(self):
-        px, py = self.player[0], self.player[1]
-        for obs in self.obstacles:
-            if obs.get('is_pit', False):
-                if obs['x'] <= px <= obs['x'] + obs['width'] and py >= obs['y']:
-                    return True
-            else:
-                if obs['x'] <= px <= obs['x'] + obs['width'] - 1:
-                    if obs['y'] <= py <= obs['y'] + obs['height']:
-                        return True
-        return False
-    
-    def step(self, action):
-        sound = None
-        
-        if action == 1:
-            self.player[0] -= 0.4
-        elif action == 2:
-            self.player[0] += 0.4
-        
-        if action == 3 and self.on_ground:
-            self.velocity_y = self.jump_power
-            self.on_ground = False
-            sound = 'jump'
-        
-        self.velocity_y += self.gravity
-        self.player[1] += self.velocity_y
-        
-        if self.player[1] >= self.ground_level:
-            self.player[1] = self.ground_level
-            self.velocity_y = 0
-            self.on_ground = True
-        
-        if self.player[1] > self.height:
-            self.alive = False
-            sound = 'die'
-            return self.get_state(), -50, True, sound
-        
-        died = self.update_entities()
-        if died:
-            self.alive = False
-            sound = 'die'
-            return self.get_state(), -50, True, sound
-        
-        coins_collected = self.collect_coins()
-        if coins_collected > 0:
-            self.coins_collected += coins_collected
-            sound = 'coin'
-        
-        if self.check_obstacles():
-            self.alive = False
-            sound = 'die'
-            return self.get_state(), -50, True, sound
-        
-        self.distance += 0.1 * self.speed
-        self.score += coins_collected * 10 + 1
-        
-        self.difficulty = 1 + self.distance / 1000
-        self.speed = 1 + self.difficulty * 0.1
-        
-        current_chunk = int(self.player[0] // 30)
-        for i in range(current_chunk, current_chunk + 3):
-            self.generate_chunk(i)
-            if i in self.chunks:
-                chunk = self.chunks[i]
-                for obs in chunk['obstacles']:
-                    if abs(obs['x'] - self.player[0]) < self.width:
-                        if obs not in self.obstacles:
-                            self.obstacles.append(obs)
-                for enemy in chunk['enemies']:
-                    if abs(enemy['x'] - self.player[0]) < self.width:
-                        if enemy not in self.entities:
-                            self.entities.append(enemy)
-                for coin in chunk['coins']:
-                    if abs(coin['x'] - self.player[0]) < self.width:
-                        if coin not in self.coins:
-                            self.coins.append(coin)
-        
-        self.obstacles = [o for o in self.obstacles if abs(o['x'] - self.player[0]) < self.width]
-        self.entities = [e for e in self.entities if abs(e['x'] - self.player[0]) < self.width]
-        self.coins = [c for c in self.coins if abs(c['x'] - self.player[0]) < self.width]
-        
-        self.steps += 1
-        if self.steps > 3000:
-            return self.get_state(), self.score, True, sound
-        
-        reward = 1 + coins_collected * 5
-        return self.get_state(), reward, False, sound
-    
-    def get_world_data(self):
-        return {
-            'player': self.player,
-            'obstacles': self.obstacles,
-            'entities': self.entities,
-            'coins': [c for c in self.coins if not c['collected']],
-            'ground_level': self.ground_level,
-            'score': self.score,
-            'coins_collected': self.coins_collected,
-            'alive': self.alive
-        }
-
-# =====================================================
-# 3. ЧАТ-ПАМЯТЬ
-# =====================================================
+# ============================================================================
+# CHAT MEMORY
+# ============================================================================
 
 class ChatMemory:
     def __init__(self):
-        self.data = {}
-        self.load_data()
-    
-    def load_data(self):
-        if os.path.exists('chat_data.json'):
-            with open('chat_data.json', 'r', encoding='utf-8') as f:
-                self.data = json.load(f)
-    
-    def save_data(self):
-        with open('chat_data.json', 'w', encoding='utf-8') as f:
+        self.data: Dict[str, str] = {}
+        self.load()
+    
+    def load(self):
+        if os.path.exists(CFG.CHAT_PATH):
+            try:
+                with open(CFG.CHAT_PATH, '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, a):
+    def add(self, q: str, a: str) -> str:
         self.data[q.lower()] = a
-        self.save_data()
-        return f"✅ Добавлено: {q} -> {a}"
+        self.save()
+        return f"✅ Добавлено: {q} → {a}"
     
-    def find(self, q):
+    def find(self, q: str) -> Optional[str]:
         q = q.lower()
         if q in self.data:
             return self.data[q]
         words = q.split()
-        best = None
-        best_score = 0
+        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
-        if best_score >= len(words) * 0.4:
-            return best
-        return None
+        return best if best_score >= len(words) * 0.4 else None
+
 
-# =====================================================
-# 4. ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
-# =====================================================
+# ============================================================================
+# GLOBAL STATE
+# ============================================================================
 
 agent = DQNAgent()
 chat_memory = ChatMemory()
-is_training = False
 current_seed = random.randint(0, 999999)
+
+# Persistent game instances
+ai_env = PlatformerEngine(seed=current_seed)
+player_env = PlatformerEngine(seed=current_seed)
+
+is_training = False
 training_thread = None
 
-# =====================================================
-# 5. HTML
-# =====================================================
+
+# ============================================================================
+# HTML TEMPLATE (Fixed Canvas Rendering)
+# ============================================================================
 
 HTML = """
 <!DOCTYPE html>
-<html>
+<html lang="ru">
 <head>
-    <meta charset="UTF-8">
-    <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: 300px;
-            background: #16213e;
-            border-radius: 16px;
-            padding: 15px;
-            box-shadow: 0 8px 32px rgba(0,0,0,0.5);
-        }
-        .game-box h3 { text-align: center; margin-bottom: 10px; }
-        canvas {
-            width: 100%; aspect-ratio: 80/20;
-            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 0.15s; color: white;
-        }
-        .controls button:hover { transform: scale(1.05); }
-        .controls button:active { transform: scale(0.93); }
-        .btn-left { background: #e94560; }
-        .btn-right { background: #e94560; }
-        .btn-jump { 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; }
-        .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 0.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: white;
-            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; }
-        .hidden { display: none; }
-    </style>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<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}
+.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}
+.hidden{display:none}
+</style>
 </head>
 <body>
 <div class="container">
-    <h1>🧠 AI vs Player Platformer</h1>
-    <p class="sub">🤖 Нейросеть слева 🎮 Ты справа (⬅️ ➡️ ⬆️)</p>
-    
-    <div class="game-row">
-        <div class="game-box">
-            <h3>🤖 Нейросеть</h3>
-            <canvas id="aiCanvas" width="800" height="200"></canvas>
-        </div>
-        <div class="game-box">
-            <h3>🎮 Ты</h3>
-            <canvas id="playerCanvas" width="800" height="200"></canvas>
-        </div>
-    </div>
-    
-    <div class="stats-bar">
-        <div>🤖 ИИ: <span id="aiScore">0</span></div>
-        <div>🎮 Ты: <span id="playerScore">0</span></div>
-        <div>🪙 Монет: <span id="coinsCount">0</span></div>
-        <div>🧠 Эпсилон: <span id="epsilon">1.00</span></div>
-        <div>🏆 Рекорд: <span id="bestScore">0</span></div>
-    </div>
-    
-    <div class="controls">
-        <button class="btn-left" id="btnLeft">⬅️ Влево</button>
-        <button class="btn-jump" id="btnJump">⬆️ Прыжок</button>
-        <button class="btn-right" id="btnRight">➡️ Вправо</button>
-        <button class="btn-reset" id="btnReset">🔄 Новый уровень</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 id="chatTab">
-            <div class="chat-msgs" id="chatMsgs">
-                <div class="bot">🤖 Привет! Команды:</div>
-                <div class="bot"><code>/ai вопрос</code> — спросить</div>
-                <div class="bot"><code>/data вопрос|ответ</code> — обучить</div>
-                <div class="bot"><code>/stats</code> — статистика</div>
-                <div class="bot"><code>/train</code> — тренировка</div>
-            </div>
-            <div class="chat-area">
-                <input id="chatInput" placeholder="Введите команду..." onkeydown="if(event.key==='Enter') sendChat()">
-                <button onclick="sendChat()">➤</button>
-            </div>
-        </div>
-        <div id="trainTab" class="hidden">
-            <h3>🧠 Тренировка нейросети</h3>
-            <p>DQN с 4 слоями (256→256→256→128 нейронов)</p>
-            <button onclick="startTrain()" style="padding:12px 35px;background:#e94560;color:white;border:none;border-radius:10px;font-size:1.1em;cursor:pointer;">
-                🚀 Запустить
-            </button>
-            <div id="trainStatus" style="margin-top:10px;color:#aaa;">⏸ Остановлена</div>
-        </div>
-        <div id="statsTab" class="hidden">
-            <h3>📊 Статистика</h3>
-            <div id="statsContent">Загрузка...</div>
-        </div>
-    </div>
+<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>
+
+<div class="stats-bar">
+<div>🤖 ИИ: <span id="aiS">0</span></div>
+<div>🎮 Ты: <span id="plS">0</span></div>
+<div>🪙 Монет: <span id="cc">0</span></div>
+<div>🧠 ε: <span id="eps">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>
+
+<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 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>
+<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>
+</div>
+<div id="statsTab" class="hidden"><h3>📊 Статистика</h3><div id="sc">Загрузка...</div></div>
+</div>
 </div>
 
 <script>
-let playerAction = 0;
-
-function drawGame(ctx, data, showPlayer) {
-    const W = ctx.canvas.width, H = ctx.canvas.height;
-    const cellW = W / 80, cellH = H / 20;
-    ctx.clearRect(0, 0, W, H);
-    
-    const grad = ctx.createLinearGradient(0, 0, 0, H);
-    grad.addColorStop(0, '#0a0a2e');
-    grad.addColorStop(0.7, '#1a1a4e');
-    ctx.fillStyle = grad;
-    ctx.fillRect(0, 0, W, H);
-    
-    const cx = data.player[0] - 40;
-    function toScreen(wx, wy) {
-        return [(wx - cx) * cellW, wy * cellH];
-    }
-    
-    const gy = data.ground_level * cellH;
-    ctx.fillStyle = '#4a3a2a';
-    ctx.fillRect(0, gy, W, cellH * 2);
-    ctx.fillStyle = '#3a2a1a';
-    ctx.fillRect(0, gy + cellH * 0.5, W, cellH * 0.5);
-    
-    for (const obs of data.obstacles) {
-        const [x, y] = toScreen(obs.x, obs.y);
-        if (obs.is_pit) {
-            ctx.fillStyle = '#000';
-            ctx.fillRect(x, y - cellH, obs.width * cellW, cellH * 2);
-        } else {
-            ctx.fillStyle = '#8a7a6a';
-            ctx.fillRect(x, y, obs.width * cellW, obs.height * cellH);
-        }
+// 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 draw(ctx,data,showPlayer){
+    const W=ctx.canvas.width,H=ctx.canvas.height;
+    const cellW=W/80,cellH=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[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)}
     }
     
-    for (const enemy of data.entities) {
-        const [x, y] = toScreen(enemy.x, enemy.y);
-        ctx.fillStyle = '#e94560';
-        ctx.beginPath();
-        ctx.arc(x + cellW/2, y + cellH/2, cellH/2.5, 0, Math.PI*2);
-        ctx.fill();
+    // Enemies
+    for(const e of data.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();
     }
     
-    for (const coin of data.coins) {
-        const [x, y] = toScreen(coin.x, coin.y);
-        ctx.fillStyle = '#ffd700';
-        ctx.beginPath();
-        ctx.arc(x + cellW/2, y + cellH/2, cellH/3, 0, Math.PI*2);
-        ctx.fill();
+    // Coins
+    for(const c of data.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();
     }
     
-    if (showPlayer && data.alive) {
-        const [px, py] = toScreen(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;
+    // 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;
     }
 }
 
-async function updateGame() {
-    try {
-        const res = await fetch('/step', {
-            method: 'POST',
-            headers: {'Content-Type': 'application/json'},
-            body: JSON.stringify({action: playerAction})
-        });
-        const data = await res.json();
-        
-        const aiCanvas = document.getElementById('aiCanvas');
-        const playerCanvas = document.getElementById('playerCanvas');
-        drawGame(aiCanvas.getContext('2d'), data.ai, true);
-        drawGame(playerCanvas.getContext('2d'), data.player, data.player.alive);
-        
-        document.getElementById('aiScore').textContent = data.ai.score;
-        document.getElementById('playerScore').textContent = data.player.score;
-        document.getElementById('coinsCount').textContent = data.player.coins_collected;
-        document.getElementById('epsilon').textContent = data.epsilon.toFixed(3);
-        document.getElementById('bestScore').textContent = data.best_score;
-    } catch(e) {}
+async function update(){
+    try{
+        const r=await fetch('/step',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:playerAction})});
+        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;
+        document.getElementById('cc').textContent=d.player.coins_collected;
+        document.getElementById('eps').textContent=d.epsilon.toFixed(3);
+        document.getElementById('bs').textContent=d.best_score;
+    }catch(e){}
 }
 
-// Управление
-document.getElementById('btnLeft').addEventListener('mousedown', () => { playerAction = 1; });
-document.getElementById('btnLeft').addEventListener('mouseup', () => { playerAction = 0; });
-document.getElementById('btnRight').addEventListener('mousedown', () => { playerAction = 2; });
-document.getElementById('btnRight').addEventListener('mouseup', () => { playerAction = 0; });
-document.getElementById('btnJump').addEventListener('mousedown', () => { playerAction = 3; });
-document.getElementById('btnJump').addEventListener('mouseup', () => { playerAction = 0; });
-
-document.addEventListener('keydown', (e) => {
-    if (e.key === 'ArrowLeft') { e.preventDefault(); playerAction = 1; }
-    else if (e.key === 'ArrowRight') { e.preventDefault(); playerAction = 2; }
-    else if (e.key === 'ArrowUp' || e.key === ' ') { e.preventDefault(); playerAction = 3; }
-});
-document.addEventListener('keyup', (e) => {
-    if (['ArrowLeft', 'ArrowRight', 'ArrowUp', ' '].includes(e.key)) {
-        e.preventDefault(); playerAction = 0;
-    }
+// 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);
+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.getElementById('btnReset').addEventListener('click', async () => {
-    const res = await fetch('/reset', {method: 'POST'});
-    const data = await res.json();
-    document.getElementById('aiScore').textContent = data.ai.score;
-    document.getElementById('playerScore').textContent = data.player.score;
-    document.getElementById('coinsCount').textContent = data.player.coins_collected;
+document.addEventListener('keyup',e=>{
+    if(['ArrowLeft','ArrowRight','ArrowUp',' '].includes(e.key)){e.preventDefault();setA(0)}
 });
 
-// Чат
-async function sendChat() {
-    const input = document.getElementById('chatInput');
-    const msg = input.value.trim();
-    if (!msg) return;
-    input.value = '';
-    
-    const container = document.getElementById('chatMsgs');
-    container.innerHTML += '<div class="user">👤 ' + msg + '</div>';
-    container.scrollTop = container.scrollHeight;
-    
-    const res = await fetch('/chat', {
-        method: 'POST',
-        headers: {'Content-Type': 'application/json'},
-        body: JSON.stringify({message: msg})
-    });
-    const data = await res.json();
-    container.innerHTML += '<div class="bot">🤖 ' + data.response + '</div>';
-    container.scrollTop = container.scrollHeight;
+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;
+};
+
+// Chat
+async function sendChat(){
+    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;
+    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;
 }
 
-// Тренировка
-async function startTrain() {
-    document.getElementById('trainStatus').textContent = '⏳ Запуск...';
-    const res = await fetch('/train', {method: 'POST'});
-    const data = await res.json();
-    document.getElementById('trainStatus').textContent = data.message;
+// Training
+async function startTrain(){
+    document.getElementById('ts').textContent='⏳ Запуск...';
+    const r=await fetch('/train',{method:'POST'});
+    const d=await r.json();
+    document.getElementById('ts').textContent=d.message;
 }
 
-// Табы
-document.querySelectorAll('.tab').forEach(tab => {
-    tab.addEventListener('click', function() {
-        document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
-        this.classList.add('active');
-        const tabName = this.dataset.tab;
-        document.querySelectorAll('.tab-content > div').forEach(d => d.classList.add('hidden'));
-        document.getElementById(tabName + 'Tab').classList.remove('hidden');
-        if (tabName === 'stats') {
-            fetch('/stats').then(r => r.json()).then(data => {
-                document.getElementById('statsContent').innerHTML = `
-                    <p>🧠 Память: ${data.memory_size} пар</p>
-                    <p>🎮 ��агов: ${data.steps}</p>
-                    <p>📉 Эпсилон: ${data.epsilon}</p>
-                    <p>🏆 Рекорд: ${data.best_score}</p>
-                    <p>⚡ Тренируется: ${data.training ? '✅' : '❌'}</p>
-                `;
-            });
-        }
+// 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'));
+    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(updateGame, 200);
-updateGame();
+setInterval(update,100);
+update();
 </script>
 </body>
 </html>
 """
 
-# =====================================================
-# 6. FLASK ROUTES
-# =====================================================
+# ============================================================================
+# FLASK ROUTES
+# ============================================================================
+
+app = Flask(__name__)
 
 @app.route('/')
 def index():
@@ -813,27 +666,22 @@ def index():
 
 @app.route('/step', methods=['POST'])
 def step():
-    global current_seed, agent
-    
-    data = request.json
-    player_action = data.get('action', 0)
+    global ai_env, player_env
     
-    ai_env = PlatformerLogic(seed=current_seed)
-    player_env = PlatformerLogic(seed=current_seed)
+    action = request.json.get('action', 0)
     
-    ai_env.reset()
-    player_env.reset()
+    # AI moves autonomously
+    if ai_env.alive:
+        ai_action = agent.act(ai_env.get_state())
+        ai_env.step(ai_action)
+    else:
+        ai_env.reset()
     
-    for _ in range(5):
-        if ai_env.alive:
-            ai_action = agent.act(ai_env.get_state())
-            ai_env.step(ai_action)
-        
-        if player_env.alive:
-            player_env.step(player_action)
-        
-        if not ai_env.alive and not player_env.alive:
-            break
+    # Player moves based on input
+    if player_env.alive:
+        player_env.step(action)
+    else:
+        player_env.reset()
     
     return jsonify({
         'ai': ai_env.get_world_data(),
@@ -844,14 +692,10 @@ def step():
 
 @app.route('/reset', methods=['POST'])
 def reset():
-    global current_seed
+    global current_seed, ai_env, player_env
     current_seed = random.randint(0, 999999)
-    
-    ai_env = PlatformerLogic(seed=current_seed)
-    player_env = PlatformerLogic(seed=current_seed)
-    ai_env.reset()
-    player_env.reset()
-    
+    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()
@@ -859,26 +703,20 @@ def reset():
 
 @app.route('/chat', methods=['POST'])
 def chat():
-    data = request.json
-    message = data.get('message', '').strip()
-    
-    if message.startswith('/ai '):
-        q = message[4:].strip()
-        answer = chat_memory.find(q)
-        return jsonify({'response': answer or "🤖 Не знаю. Обучи через /data"})
+    msg = request.json.get('message', '').strip()
     
-    elif message.startswith('/data '):
-        parts = message[6:].split('|')
+    if msg.startswith('/ai '):
+        ans = chat_memory.find(msg[4:])
+        return jsonify({'response': ans or "🤖 Не знаю. Обучи через /data"})
+    elif msg.startswith('/data '):
+        parts = msg[6:].split('|')
         if len(parts) != 2:
-            return jsonify({'response': "❌ Используй: /data вопрос|ответ"})
+            return jsonify({'response': "❌ Формат: /data вопрос|ответ"})
         return jsonify({'response': chat_memory.add(parts[0].strip(), parts[1].strip())})
-    
-    elif message == '/stats':
-        return jsonify({'response': f"📊 Память: {len(chat_memory.data)} пар, Шагов: {agent.total_steps}"})
-    
-    elif message == '/train':
+    elif msg == '/stats':
+        return jsonify({'response': f"📊 Память: {len(chat_memory.data)}, Шагов: {agent.steps}"})
+    elif msg == '/train':
         return jsonify({'response': start_training()})
-    
     else:
         return jsonify({'response': "🤖 Команды: /ai, /data, /stats, /train"})
 
@@ -886,48 +724,46 @@ def chat():
 def train_route():
     return jsonify({'message': start_training()})
 
-@app.route('/stats', methods=['GET'])
-def stats_route():
-    global is_training, agent, chat_memory
+@app.route('/stats')
+def stats():
     return jsonify({
         'memory_size': len(chat_memory.data),
-        'steps': agent.total_steps,
+        'steps': agent.steps,
         'epsilon': round(agent.epsilon, 3),
         'best_score': agent.best_score,
         'training': is_training
     })
 
-def start_training():
-    global is_training, training_thread, agent
+def start_training() -> str:
+    global is_training, training_thread
     
     if is_training:
         return "⏳ Уже тренируется!"
     
     is_training = True
     
-    def train():
-        global is_training, agent
+    def _train():
+        global is_training
         try:
             for ep in range(100):
                 if not is_training:
                     break
-                agent.train_episode()
+                score = agent.train_episode()
                 if ep % 10 == 0:
-                    print(f"📊 Episode {ep}: Epsilon={agent.epsilon:.3f}")
-                if ep % 20 == 0:
-                    agent.save_model()
+                    logger.info(f"Episode {ep}: score={score:.1f}, ε={agent.epsilon:.3f}")
         except Exception as e:
-            print(f"❌ Ошибка: {e}")
+            logger.error(f"Training error: {e}")
         finally:
             is_training = False
     
-    training_thread = threading.Thread(target=train)
+    training_thread = threading.Thread(target=_train, daemon=True)
     training_thread.start()
     return "🚀 Тренировка запущена!"
 
-# =====================================================
-# 7. ЗАПУСК
-# =====================================================
+
+# ============================================================================
+# ENTRY POINT
+# ============================================================================
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)
+    app.run(host='0.0.0.0', port=CFG.PORT, debug=False)