Update app.py

app.py

@@ -1,74 +1,144 @@
 """
-🎮 ДВОЙНОЙ ПЛАТФОРМЕР: ИИ vs ИГРОК + ЗВУКИ + ЧАТ-БОТ
-Flask Web Server (порт 7860)
+🧠 AI PLATFORMER + CHATBOT
+Hugging Face Space с настоящей нейросетью
 """
-from flask import Flask, render_template_string, request, jsonify, send_from_directory
+import gradio as gr
 import numpy as np
 import random
 import json
 import os
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from collections import deque
 import time
 import threading
 import math
-import base64
+from collections import deque
+import torch
+import torch.nn as nn
+import torch.optim as optim
 from PIL import Image
 import io
-import sys
-
-app = Flask(__name__)
 
 # =====================================================
-# 1. ЗВУКИ
+# 1. НЕЙРОСЕТЬ (DQN)
 # =====================================================
 
-def generate_sound(freq=440, duration=0.1, waveform='sine'):
-    """Генерирует звук в base64"""
-    import struct
-    import wave
+class DQNetwork(nn.Module):
+    def __init__(self, input_size=1600, output_size=4):
+        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)
+        )
+    
+    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)
+        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.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()
     
-    sample_rate = 22050
-    samples = int(sample_rate * duration)
+    def act(self, state):
+        if np.random.rand() <= self.epsilon:
+            return random.randrange(self.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()
     
-    buffer = io.BytesIO()
-    wav = wave.open(buffer, 'wb')
-    wav.setnchannels(1)
-    wav.setsampwidth(2)
-    wav.setframerate(sample_rate)
+    def remember(self, state, action, reward, next_state, done):
+        self.memory.append((state, action, reward, next_state, done))
     
-    for i in range(samples):
-        t = i / sample_rate
-        if waveform == 'sine':
-            val = int(32767 * 0.5 * math.sin(2 * math.pi * freq * t))
-        elif waveform == 'square':
-            val = int(32767 * 0.5 * (1 if math.sin(2 * math.pi * freq * t) > 0 else -1))
-        else:
-            f = freq + i * 200 / samples
-            val = int(32767 * 0.5 * math.sin(2 * math.pi * f * t))
-        wav.writeframes(struct.pack('<h', val))
+    def replay(self):
+        if len(self.memory) < self.batch_size:
+            return
+        
+        batch = random.sample(self.memory, self.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()
+        next_q = self.target_model(next_states).max(1)[0].detach()
+        target_q = rewards + self.gamma * next_q * (1 - dones)
+        
+        loss = self.criterion(current_q, target_q)
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+        
+        if self.epsilon > self.epsilon_min:
+            self.epsilon *= self.epsilon_decay
+        
+        self.total_steps += 1
+        if self.total_steps % self.update_target_every == 0:
+            self.target_model.load_state_dict(self.model.state_dict())
     
-    wav.close()
-    buffer.seek(0)
+    def train_episode(self):
+        env = PlatformerLogic()
+        state = env.reset()
+        total_reward = 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
+        
+        return total_reward, steps
     
-    audio_data = base64.b64encode(buffer.read()).decode('utf-8')
-    return f'data:audio/wav;base64,{audio_data}'
-
-SOUNDS = {
-    'jump': generate_sound(600, 0.08, 'sine'),
-    'coin': generate_sound(880, 0.05, 'sine'),
-    'die': generate_sound(200, 0.3, 'sweep')
-}
+    def save_model(self):
+        torch.save(self.model.state_dict(), 'dqn_model.pth')
+    
+    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())
 
 # =====================================================
 # 2. ПЛАТФОРМЕР
 # =====================================================
 
-class InfinitePlatformer:
+class PlatformerLogic:
     def __init__(self, seed=None):
-        self.width = 100
+        self.width = 80
         self.height = 20
         self.seed = seed or random.randint(0, 999999)
         self.reset()
@@ -87,8 +157,8 @@ class InfinitePlatformer:
         self.coins = []
         self.obstacles = []
         self.velocity_y = 0
-        self.gravity = 0.5
-        self.jump_power = -8
+        self.gravity = 0.4
+        self.jump_power = -7
         self.on_ground = False
         self.alive = True
         self.steps = 0
@@ -110,14 +180,9 @@ class InfinitePlatformer:
         obstacles = []
         enemies = []
         coins = []
-        
         base_x = chunk_x * 30
         
-        num_obstacles = random.randint(3, 6) + int(self.difficulty)
-        num_enemies = random.randint(1, 3) + int(self.difficulty * 0.5)
-        num_coins = random.randint(5, 10) + int(self.difficulty)
-        
-        for _ in range(num_obstacles):
+        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)
@@ -134,19 +199,19 @@ class InfinitePlatformer:
                 'width': width, 'height': 1, 'is_pit': True
             })
         
-        for _ in range(num_enemies):
+        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.5 + random.random() * 0.5,
+                'speed': 0.3 + random.random() * 0.3,
                 'range': random.randint(3, 8),
                 'start_x': x
             })
         
-        for _ in range(num_coins):
+        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})
@@ -156,7 +221,6 @@ class InfinitePlatformer:
             'enemies': enemies,
             'coins': coins
         }
-        
         random.seed()
     
     def get_state(self):
@@ -206,12 +270,12 @@ class InfinitePlatformer:
                 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.5
+                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]) < 1.0 and abs(enemy['y'] - self.player[1]) < 1.0:
+            if abs(enemy['x'] - self.player[0]) < 0.8 and abs(enemy['y'] - self.player[1]) < 0.8:
                 return True
         return False
     
@@ -219,7 +283,7 @@ class InfinitePlatformer:
         collected = 0
         for coin in self.coins:
             if not coin['collected']:
-                if abs(coin['x'] - self.player[0]) < 1.5 and abs(coin['y'] - self.player[1]) < 1.5:
+                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
@@ -240,9 +304,9 @@ class InfinitePlatformer:
         sound = None
         
         if action == 1:
-            self.player[0] -= 0.5
+            self.player[0] -= 0.4
         elif action == 2:
-            self.player[0] += 0.5
+            self.player[0] += 0.4
         
         if action == 3 and self.on_ground:
             self.velocity_y = self.jump_power
@@ -307,39 +371,49 @@ class InfinitePlatformer:
         self.coins = [c for c in self.coins if abs(c['x'] - self.player[0]) < self.width]
         
         self.steps += 1
-        if self.steps > 2000:
+        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 render(self, show_player=True):
+    def render(self):
+        """Рисует игровое поле для Gradio"""
         grid = np.zeros((self.height, 80, 3), dtype=np.uint8)
-        grid.fill(200)
+        grid.fill(40)
         
-        grid[self.ground_level:self.ground_level+2, :] = [100, 80, 40]
+        # Небо
+        for y in range(self.ground_level):
+            grid[y, :] = [20, 30, 60]
         
+        # Земля
+        grid[self.ground_level:self.ground_level+2, :] = [80, 60, 30]
+        
+        # Препятствия
         for obs in self.obstacles:
+            x = int(obs['x'] - self.player[0] + 40)
             if obs.get('is_pit', False):
-                x = int(obs['x'] - self.player[0] + 40)
                 for w in range(obs['width']):
                     if 0 <= x+w < 80:
                         grid[obs['y']:obs['y']+2, x+w] = [0, 0, 0]
             else:
-                x = int(obs['x'] - self.player[0] + 40)
                 for w in range(obs['width']):
                     for h in range(obs['height']):
                         sx = x + w
                         sy = obs['y'] + h
                         if 0 <= sx < 80 and 0 <= sy < self.height:
-                            grid[sy, sx] = [150, 120, 80]
+                            grid[sy, sx] = [140, 110, 80]
         
+        # Враги
         for enemy in self.entities:
             x = int(enemy['x'] - self.player[0] + 40)
             y = int(enemy['y'])
             if 0 <= x < 80 and 0 <= y < self.height:
-                grid[y, x] = [255, 0, 0]
+                grid[y, x] = [255, 50, 50]
+                if y > 0:
+                    grid[y-1, x] = [200, 30, 30]
         
+        # Монетки
         for coin in self.coins:
             if not coin['collected']:
                 x = int(coin['x'] - self.player[0] + 40)
@@ -347,103 +421,22 @@ class InfinitePlatformer:
                 if 0 <= x < 80 and 0 <= y < self.height:
                     grid[y, x] = [255, 215, 0]
         
-        if show_player:
+        # Игрок
+        if self.alive:
             px = 40
             py = int(self.player[1])
             if 0 <= py < self.height:
-                grid[py, px] = [0, 255, 0]
-                grid[py-1, px] = [0, 200, 0]
+                grid[py, px] = [0, 255, 100]
+                if py > 0:
+                    grid[py-1, px] = [0, 200, 80]
+                if py > 1:
+                    grid[py-2, px] = [0, 150, 60]
         
         img = Image.fromarray(grid, 'RGB')
         return img
 
 # =====================================================
-# 3. DQN АГЕНТ (упрощённый, без PyTorch если нет)
-# =====================================================
-
-class SimpleDQNAgent:
-    def __init__(self, state_size=1600, action_size=4):
-        self.state_size = state_size
-        self.action_size = action_size
-        self.epsilon = 1.0
-        self.epsilon_min = 0.01
-        self.epsilon_decay = 0.995
-        self.memory = deque(maxlen=1000)
-        self.total_steps = 0
-        self.best_score = 0
-        
-        # Простая Q-таблица (для демо)
-        self.q_table = {}
-    
-    def get_state_key(self, state):
-        # Упрощаем состояние для хранения в Q-таблице
-        flat = state.flatten() if hasattr(state, 'flatten') else state
-        # Берём только первые 100 значений
-        key = tuple(flat[:100].astype(int))
-        return key
-    
-    def act(self, state):
-        if np.random.rand() <= self.epsilon:
-            return random.randrange(self.action_size)
-        
-        key = self.get_state_key(state)
-        if key not in self.q_table:
-            self.q_table[key] = [0] * self.action_size
-        return np.argmax(self.q_table[key])
-    
-    def remember(self, state, action, reward, next_state, done):
-        self.memory.append((state, action, reward, next_state, done))
-        if len(self.memory) > 1000:
-            self.memory.popleft()
-    
-    def replay(self):
-        if len(self.memory) < 32:
-            return
-        
-        batch = random.sample(self.memory, 32)
-        for state, action, reward, next_state, done in batch:
-            key = self.get_state_key(state)
-            next_key = self.get_state_key(next_state)
-            
-            if key not in self.q_table:
-                self.q_table[key] = [0] * self.action_size
-            if next_key not in self.q_table:
-                self.q_table[next_key] = [0] * self.action_size
-            
-            current_q = self.q_table[key][action]
-            max_next_q = max(self.q_table[next_key])
-            target_q = reward + 0.95 * max_next_q * (not done)
-            
-            self.q_table[key][action] += 0.1 * (target_q - current_q)
-        
-        if self.epsilon > self.epsilon_min:
-            self.epsilon *= self.epsilon_decay
-        
-        self.total_steps += 1
-    
-    def train_episode(self):
-        env = InfinitePlatformer()
-        state = env.reset()
-        total_reward = 0
-        done = False
-        steps = 0
-        
-        while not done and steps < 300:
-            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
-        
-        return total_reward, steps, env.distance
-
-# =====================================================
-# 4. ЧАТ-ПАМЯТЬ
+# 3. ЧАТ-ПАМЯТЬ
 # =====================================================
 
 class ChatMemory:
@@ -460,583 +453,154 @@ class ChatMemory:
         with open('chat_data.json', 'w', encoding='utf-8') as f:
             json.dump(self.data, f, ensure_ascii=False, indent=2)
     
-    def add(self, question, answer):
-        self.data[question.lower()] = answer
+    def add(self, q, a):
+        self.data[q.lower()] = a
         self.save_data()
-        return f"✅ Добавлено: {question} -> {answer}"
-    
-    def find_best_match(self, question):
-        question_lower = question.lower()
-        if question_lower in self.data:
-            return self.data[question_lower]
-        
-        words = question_lower.split()
-        best_match = None
+        return f"✅ Добавлено: {q} -> {a}"
+    
+    def find(self, q):
+        q = q.lower()
+        if q in self.data:
+            return self.data[q]
+        words = q.split()
+        best = None
         best_score = 0
-        
-        for q, a in self.data.items():
-            q_words = q.split()
-            score = sum(1 for w in words if w in q_words)
+        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_match = a
-        
+                best = val
         if best_score >= len(words) * 0.4:
-            return best_match
+            return best
         return None
 
 # =====================================================
-# 5. ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
+# 4. ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
 # =====================================================
 
-agent = SimpleDQNAgent()
+agent = DQNAgent()
 chat_memory = ChatMemory()
 is_training = False
 current_seed = random.randint(0, 999999)
+training_thread = None
 
 # =====================================================
-# 6. HTML ШАБЛОН
+# 5. GRADIO ФУНКЦИИ
 # =====================================================
 
-HTML_TEMPLATE = """
-<!DOCTYPE html>
-<html>
-<head>
-    <title>🎮 AI vs Player Platformer</title>
-    <meta charset="UTF-8">
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            background: #1a1a2e;
-            color: #eee;
-            min-height: 100vh;
-            display: flex;
-            justify-content: center;
-            padding: 20px;
-        }
-        .container {
-            max-width: 1200px;
-            width: 100%;
-        }
-        h1 {
-            text-align: center;
-            padding: 20px 0;
-            background: linear-gradient(135deg, #e94560, #0f3460);
-            -webkit-background-clip: text;
-            -webkit-text-fill-color: transparent;
-            font-size: 2.5em;
-        }
-        .subtitle {
-            text-align: center;
-            color: #aaa;
-            margin-bottom: 20px;
-        }
-        .game-row {
-            display: flex;
-            gap: 20px;
-            flex-wrap: wrap;
-        }
-        .game-col {
-            flex: 1;
-            min-width: 300px;
-            background: #16213e;
-            border-radius: 16px;
-            padding: 15px;
-            box-shadow: 0 8px 32px rgba(0,0,0,0.5);
-        }
-        .game-col h3 {
-            text-align: center;
-            margin-bottom: 10px;
-            color: #e94560;
-        }
-        .game-col .label {
-            text-align: center;
-            font-size: 0.9em;
-            color: #888;
-            margin-top: 5px;
-        }
-        .game-canvas {
-            width: 100%;
-            aspect-ratio: 4/1;
-            background: #0a0a1a;
-            border-radius: 8px;
-            image-rendering: pixelated;
-        }
-        .controls {
-            display: flex;
-            justify-content: center;
-            gap: 15px;
-            margin: 20px 0;
-            flex-wrap: wrap;
-        }
-        .controls button {
-            padding: 15px 35px;
-            font-size: 1.2em;
-            border: none;
-            border-radius: 12px;
-            cursor: pointer;
-            transition: all 0.2s;
-            font-weight: bold;
-        }
-        .controls button:hover {
-            transform: scale(1.05);
-        }
-        .controls button:active {
-            transform: scale(0.95);
-        }
-        .btn-left { background: #e94560; color: white; }
-        .btn-right { background: #e94560; color: white; }
-        .btn-jump { background: #0f3460; color: white; padding: 15px 50px; }
-        .btn-reset { background: #533483; color: white; }
-        .stats {
-            background: #16213e;
-            border-radius: 12px;
-            padding: 15px;
-            margin: 10px 0;
-            text-align: center;
-            font-size: 1.2em;
-        }
-        .tabs {
-            display: flex;
-            gap: 10px;
-            margin: 20px 0;
-            flex-wrap: wrap;
-        }
-        .tab {
-            padding: 12px 25px;
-            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-input-area {
-            display: flex;
-            gap: 10px;
-            margin-top: 15px;
-        }
-        .chat-input-area input {
-            flex: 1;
-            padding: 12px;
-            border-radius: 8px;
-            border: 1px solid #333;
-            background: #0a0a1a;
-            color: #eee;
-            font-size: 1em;
-        }
-        .chat-input-area button {
-            padding: 12px 25px;
-            background: #e94560;
-            color: white;
-            border: none;
-            border-radius: 8px;
-            cursor: pointer;
-            font-weight: bold;
-        }
-        .chat-messages {
-            max-height: 300px;
-            overflow-y: auto;
-            padding: 10px;
-        }
-        .chat-msg {
-            padding: 8px 12px;
-            margin: 5px 0;
-            border-radius: 8px;
-            background: #0a0a1a;
-        }
-        .chat-msg.user { border-left: 3px solid #e94560; }
-        .chat-msg.bot { border-left: 3px solid #0f3460; }
-        .commands-hint {
-            color: #666;
-            font-size: 0.9em;
-            padding: 10px;
-            border-top: 1px solid #222;
-            margin-top: 10px;
-        }
-        .commands-hint code {
-            background: #0a0a1a;
-            padding: 2px 8px;
-            border-radius: 4px;
-            color: #e94560;
-        }
-        @media (max-width: 700px) {
-            .game-col { min-width: 100%; }
-            .controls button { padding: 10px 20px; font-size: 1em; }
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>🎮 AI vs Player Platformer</h1>
-        <p class="subtitle">🤖 Нейросеть слева 🆚 Ты справа — одинаковый уровень!</p>
-        
-        <div class="game-row">
-            <div class="game-col">
-                <h3>🤖 ИИ играет</h3>
-                <img id="aiCanvas" class="game-canvas" src="data:image/png;base64,{{ai_image}}" alt="AI Game">
-                <div class="label">ИИ учится играть</div>
-            </div>
-            <div class="game-col">
-                <h3>🎮 Ты играешь</h3>
-                <img id="playerCanvas" class="game-canvas" src="data:image/png;base64,{{player_image}}" alt="Player Game">
-                <div class="label">Ты — зелёный</div>
-            </div>
-        </div>
-        
-        <div class="stats" id="stats">
-            🤖 ИИ: {{ai_score}} &nbsp;|&nbsp; 🎮 Ты: {{player_score}} &nbsp;|&nbsp; 🪙 Монет: {{coins}}
-        </div>
-        
-        <div class="controls">
-            <button class="btn-left" onclick="move(1)">⬅️ Влево</button>
-            <button class="btn-jump" onclick="move(3)">⬆️ Прыжок</button>
-            <button class="btn-right" onclick="move(2)">➡️ Вправо</button>
-            <button class="btn-reset" onclick="resetGame()">🔄 Новый уровень</button>
-        </div>
-        
-        <div class="tabs">
-            <div class="tab active" onclick="switchTab('chat')">💬 Чат</div>
-            <div class="tab" onclick="switchTab('train')">🧠 Тренировка</div>
-            <div class="tab" onclick="switchTab('stats')">📊 Статистика</div>
-        </div>
-        
-        <div class="tab-content" id="tabContent">
-            <div id="chatTab">
-                <div class="chat-messages" id="chatMessages">
-                    <div class="chat-msg bot">🤖 Привет! Я нейросеть-помощник. Используй команды:</div>
-                    <div class="chat-msg bot"><code>/ai вопрос</code> — спросить</div>
-                    <div class="chat-msg bot"><code>/data вопрос|ответ</code> — обучить</div>
-                    <div class="chat-msg bot"><code>/stats</code> — статистика</div>
-                    <div class="chat-msg bot"><code>/train</code> — тренировка ИИ</div>
-                </div>
-                <div class="chat-input-area">
-                    <input type="text" id="chatInput" placeholder="Введите команду..." onkeydown="if(event.key==='Enter') sendChat()">
-                    <button onclick="sendChat()">Отправить</button>
-                </div>
-                <div class="commands-hint">
-                    💡 Пример: <code>/ai Как пройти уровень?</code> или <code>/data привет|Здравствуй!</code>
-                </div>
-            </div>
-            <div id="trainTab" style="display:none;">
-                <h3>🧠 Тренировка нейросети</h3>
-                <p>ИИ учится играть в платформер методом проб и ошибок.</p>
-                <button onclick="startTrain()" style="padding:15px 40px;background:#e94560;color:white;border:none;border-radius:10px;font-size:1.2em;cursor:pointer;">
-                    🚀 Запустить тренировку
-                </button>
-                <div id="trainStatus" style="margin-top:15px;color:#aaa;"></div>
-            </div>
-            <div id="statsTab" style="display:none;">
-                <h3>📊 Статистика</h3>
-                <div id="statsContent">
-                    <p>Загрузка...</p>
-                </div>
-            </div>
-        </div>
-        
-        <div id="soundContainer"></div>
-    </div>
-    
-    <script>
-        let currentAction = 0;
-        let soundEnabled = true;
-        
-        function move(action) {
-            currentAction = action;
-            fetch('/move', {
-                method: 'POST',
-                headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify({action: action})
-            })
-            .then(r => r.json())
-            .then(data => {
-                document.getElementById('aiCanvas').src = 'data:image/png;base64,' + data.ai_image;
-                document.getElementById('playerCanvas').src = 'data:image/png;base64,' + data.player_image;
-                document.getElementById('stats').innerHTML = 
-                    '🤖 ИИ: ' + data.ai_score + 
-                    ' &nbsp;|&nbsp; 🎮 Ты: ' + data.player_score + 
-                    ' &nbsp;|&nbsp; 🪙 Монет: ' + data.coins;
-                if (data.sound) {
-                    playSound(data.sound);
-                }
-            });
-        }
-        
-        function resetGame() {
-            fetch('/reset', {method: 'POST'})
-            .then(r => r.json())
-            .then(data => {
-                document.getElementById('aiCanvas').src = 'data:image/png;base64,' + data.ai_image;
-                document.getElementById('playerCanvas').src = 'data:image/png;base64,' + data.player_image;
-                document.getElementById('stats').innerHTML = 
-                    '🤖 ИИ: ' + data.ai_score + 
-                    ' &nbsp;|&nbsp; 🎮 Ты: ' + data.player_score + 
-                    ' &nbsp;|&nbsp; 🪙 Монет: ' + data.coins;
-            });
-        }
-        
-        function playSound(soundType) {
-            if (!soundEnabled) return;
-            const sounds = {
-                'jump': '{{sounds.jump}}',
-                'coin': '{{sounds.coin}}',
-                'die': '{{sounds.die}}'
-            };
-            if (sounds[soundType]) {
-                const audio = new Audio(sounds[soundType]);
-                audio.play().catch(() => {});
-            }
-        }
-        
-        function sendChat() {
-            const input = document.getElementById('chatInput');
-            const msg = input.value.trim();
-            if (!msg) return;
-            input.value = '';
-            
-            const container = document.getElementById('chatMessages');
-            container.innerHTML += '<div class="chat-msg user">👤 ' + msg + '</div>';
-            container.scrollTop = container.scrollHeight;
-            
-            fetch('/chat', {
-                method: 'POST',
-                headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify({message: msg})
-            })
-            .then(r => r.json())
-            .then(data => {
-                container.innerHTML += '<div class="chat-msg bot">🤖 ' + data.response + '</div>';
-                container.scrollTop = container.scrollHeight;
-            });
-        }
-        
-        function switchTab(tab) {
-            document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
-            document.querySelectorAll('.tab-content > div').forEach(d => d.style.display = 'none');
-            
-            document.querySelector(`.tab:nth-child(${tab === 'chat' ? 1 : tab === 'train' ? 2 : 3})`).classList.add('active');
-            document.getElementById(tab + 'Tab').style.display = 'block';
-            
-            if (tab === '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>';
-                });
-            }
-        }
-        
-        function startTrain() {
-            document.getElementById('trainStatus').innerHTML = '⏳ Тренировка запущена... Смотри консоль!';
-            fetch('/train', {method: 'POST'})
-            .then(r => r.json())
-            .then(data => {
-                document.getElementById('trainStatus').innerHTML = data.message;
-            });
-        }
-        
-        // Авто-обновление
-        setInterval(() => {
-            if (document.hidden) return;
-            fetch('/move', {
-                method: 'POST',
-                headers: {'Content-Type': 'application/json'},
-                body: JSON.stringify({action: 0})
-            })
-            .then(r => r.json())
-            .then(data => {
-                document.getElementById('aiCanvas').src = 'data:image/png;base64,' + data.ai_image;
-                document.getElementById('playerCanvas').src = 'data:image/png;base64,' + data.player_image;
-                document.getElementById('stats').innerHTML = 
-                    '🤖 ИИ: ' + data.ai_score + 
-                    ' &nbsp;|&nbsp; 🎮 Ты: ' + data.player_score + 
-                    ' &nbsp;|&nbsp; 🪙 Монет: ' + data.coins;
-            });
-        }, 300);
-    </script>
-</body>
-</html>
-"""
-
-# =====================================================
-# 7. FLASK ROUTES
-# =====================================================
-
-def image_to_base64(img):
-    buffer = io.BytesIO()
-    img.save(buffer, format='PNG')
-    return base64.b64encode(buffer.getvalue()).decode('utf-8')
-
-@app.route('/')
-def index():
+def game_loop(player_action=0):
+    """Основной игровой цикл"""
     global current_seed, agent
     
-    # Создаём игру для отображения
-    ai_env = InfinitePlatformer(seed=current_seed)
-    player_env = InfinitePlatformer(seed=current_seed)
-    
-    ai_env.reset()
-    player_env.reset()
-    
-    ai_img = ai_env.render(show_player=True)
-    player_img = player_env.render(show_player=True)
-    
-    # ИИ делает ход
-    ai_action = agent.act(ai_env.get_state())
-    ai_env.step(ai_action)
-    
-    return render_template_string(
-        HTML_TEMPLATE,
-        ai_image=image_to_base64(ai_img),
-        player_image=image_to_base64(player_img),
-        ai_score=0,
-        player_score=0,
-        coins=0,
-        sounds={
-            'jump': SOUNDS['jump'],
-            'coin': SOUNDS['coin'],
-            'die': SOUNDS['die']
-        }
-    )
-
-@app.route('/move', methods=['POST'])
-def move():
-    global current_seed, agent
-    
-    data = request.json
-    player_action = data.get('action', 0)
-    
     # Создаём два экземпляра с одинаковым seed
-    ai_env = InfinitePlatformer(seed=current_seed)
-    player_env = InfinitePlatformer(seed=current_seed)
+    ai_env = PlatformerLogic(seed=current_seed)
+    player_env = PlatformerLogic(seed=current_seed)
     
-    ai_env.reset()
+    ai_state = ai_env.reset()
     player_env.reset()
     
-    # Играем несколько шагов
-    ai_score = 0
-    player_score = 0
-    sound = None
-    coins = 0
+    # Делаем несколько шагов
+    ai_alive = True
+    player_alive = True
     
-    for _ in range(3):  # 3 шага за раз
+    for _ in range(5):
         # Ход ИИ
-        ai_state = ai_env.get_state()
-        ai_action = agent.act(ai_state)
-        _, ai_reward, ai_done, ai_sound = ai_env.step(ai_action)
-        if ai_sound and not sound:
-            sound = ai_sound
+        if ai_alive:
+            ai_action = agent.act(ai_state)
+            ai_next_state, _, ai_done, _ = ai_env.step(ai_action)
+            ai_state = ai_next_state
+            ai_alive = not ai_done
         
         # Ход игрока
-        if player_env.alive:
-            _, player_reward, player_done, player_sound = player_env.step(player_action)
-            if player_sound and not sound:
-                sound = player_sound
-        
-        ai_score = ai_env.score
-        player_score = player_env.score
-        coins = player_env.coins_collected
+        if player_alive:
+            _, _, player_done, _ = player_env.step(player_action)
+            player_alive = not player_done
         
-        if not ai_env.alive and not player_env.alive:
+        if not ai_alive and not player_alive:
             break
     
-    ai_img = ai_env.render(show_player=ai_env.alive)
-    player_img = player_env.render(show_player=player_env.alive)
-    
-    return jsonify({
-        'ai_image': image_to_base64(ai_img),
-        'player_image': image_to_base64(player_img),
-        'ai_score': ai_score,
-        'player_score': player_score,
-        'coins': coins,
-        'sound': sound
-    })
+    # Рендерим
+    ai_img = ai_env.render()
+    player_img = player_env.render()
+    
+    return (
+        ai_img,
+        player_img,
+        ai_env.score,
+        player_env.score,
+        player_env.coins_collected,
+        agent.epsilon,
+        agent.best_score
+    )
 
-@app.route('/reset', methods=['POST'])
-def reset():
+def reset_game():
     global current_seed
     current_seed = random.randint(0, 999999)
-    
-    ai_env = InfinitePlatformer(seed=current_seed)
-    player_env = InfinitePlatformer(seed=current_seed)
-    ai_env.reset()
-    player_env.reset()
-    
-    ai_img = ai_env.render(show_player=True)
-    player_img = player_env.render(show_player=True)
-    
-    return jsonify({
-        'ai_image': image_to_base64(ai_img),
-        'player_image': image_to_base64(player_img),
-        'ai_score': 0,
-        'player_score': 0,
-        'coins': 0
-    })
+    return game_loop(0)
 
-@app.route('/chat', methods=['POST'])
-def chat():
-    data = request.json
-    message = data.get('message', '').strip()
-    
-    response = process_chat(message)
-    
-    return jsonify({'response': response})
+def move_left():
+    return game_loop(1)
 
-def process_chat(message):
-    global is_training, agent
-    
+def move_right():
+    return game_loop(2)
+
+def move_jump():
+    return game_loop(3)
+
+def chat_response(message):
+    """Обработчик чата"""
     if message.startswith('/ai '):
         question = message[4:].strip()
         if not question:
             return "❌ Напиши вопрос после /ai"
         
-        answer = chat_memory.find_best_match(question)
+        answer = chat_memory.find(question)
         if answer:
-            return answer
-        
+            return f"🤖 {answer}"
         return "🤖 Я не знаю ответа. Обучи меня через /data вопрос|ответ"
     
     elif message.startswith('/data '):
         parts = message[6:].split('|')
         if len(parts) != 2:
             return "❌ Используй: /data вопрос|ответ"
-        question = parts[0].strip()
-        answer = parts[1].strip()
-        return chat_memory.add(question, answer)
+        q = parts[0].strip()
+        a = parts[1].strip()
+        return chat_memory.add(q, a)
     
     elif message == '/stats':
-        return f"""📊 Статистика:
-- Память: {len(chat_memory.data)} пар
-- Шагов ИИ: {agent.total_steps}
-- Эпсилон: {agent.epsilon:.3f}
-- Лучший счёт: {agent.best_score}
-- Тренируется: {'✅' if is_training else '❌'}"""
+        return f"""
+📊 **Статистика нейросети:**
+- 🧠 Память: {len(chat_memory.data)} пар
+- 🎮 Шагов обучения: {agent.total_steps}
+- 📉 Эпсилон: {agent.epsilon:.3f}
+- 🏆 Лучший счёт: {agent.best_score}
+- ⚡ Тренируется: {'✅' if is_training else '❌'}
+- 🖥️ Устройство: {agent.device}
+"""
     
     elif message == '/train':
         return start_training()
     
+    elif message == '/save':
+        agent.save_model()
+        return "💾 Модель сохранена!"
+    
+    elif message == '/load':
+        agent.load_model()
+        return "📂 Модель загружена!"
+    
     else:
-        return """🤖 Доступные команды:
-/ai <вопрос> — спросить
-/data вопрос|ответ — обучить
-/stats — статистика
-/train — тренировка ИИ"""
+        return """🤖 **Доступные команды:**
+- `/ai вопрос` — задать вопрос
+- `/data вопрос|ответ` — обучить
+- `/stats` — статистика
+- `/train` — тренировка ИИ
+- `/save` — сохранить модель
+- `/load` — загрузить модель"""
 
 def start_training():
-    global is_training, agent
+    """Запускает тренировку в фоновом потоке"""
+    global is_training, training_thread, agent
     
     if is_training:
         return "⏳ Уже тренируется!"
@@ -1046,47 +610,108 @@ def start_training():
     def train():
         global is_training, agent
         try:
-            for ep in range(50):
+            for ep in range(100):
                 if not is_training:
                     break
-                score, steps, dist = agent.train_episode()
+                score, steps = agent.train_episode()
                 if ep % 10 == 0:
                     print(f"📊 Episode {ep}: Score={score:.0f}, Epsilon={agent.epsilon:.3f}")
+                if score > 0 and ep % 20 == 0:
+                    agent.save_model()
         except Exception as e:
-            print(f"Ошибка тренировки: {e}")
+            print(f"❌ Ошибка: {e}")
         finally:
             is_training = False
     
-    thread = threading.Thread(target=train)
-    thread.start()
+    training_thread = threading.Thread(target=train)
+    training_thread.start()
     
-    return "🚀 Тренировка запущена! Смотри консоль."
+    return "🚀 **Тренировка запущена!** Смотри консоль для прогресса."
 
-@app.route('/stats', methods=['GET'])
-def stats():
-    global is_training, agent, chat_memory
-    return jsonify({
-        'memory_size': len(chat_memory.data),
-        'steps': agent.total_steps,
-        'epsilon': round(agent.epsilon, 3),
-        'best_score': agent.best_score,
-        'training': is_training
-    })
+# =====================================================
+# 6. GRADIO INTERFACE
+# =====================================================
 
-@app.route('/train', methods=['POST'])
-def train_route():
-    return jsonify({'message': start_training()})
+with gr.Blocks(title="🧠 AI Platformer", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧠 AI vs Player Platformer
+    
+    ### 🤖 Слева — нейросеть (DQN) играет сама
+    ### 🎮 Справа — ты управляешь зелёным (⬅️ ➡️ ⬆️)
+    ### 💬 Снизу — общий чат с ИИ, который можно обучать!
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 🤖 Нейросеть")
+            ai_output = gr.Image(label="AI Game", height=300)
+        with gr.Column():
+            gr.Markdown("### 🎮 Ты")
+            player_output = gr.Image(label="Player Game", height=300)
+    
+    with gr.Row():
+        ai_score = gr.Number(label="🤖 Счёт ИИ", value=0)
+        player_score = gr.Number(label="🎮 Твой счёт", value=0)
+        coins = gr.Number(label="🪙 Монет", value=0)
+        epsilon = gr.Number(label="🧠 Эпсилон", value=1.0)
+        best_score = gr.Number(label="🏆 Рекорд ИИ", value=0)
+    
+    with gr.Row():
+        gr.Markdown("### 🎮 Управление:")
+        left_btn = gr.Button("⬅️ Влево", size="lg")
+        jump_btn = gr.Button("⬆️ Прыжок", size="lg", variant="primary")
+        right_btn = gr.Button("➡️ Вправо", size="lg")
+        reset_btn = gr.Button("🔄 Новый уровень", size="lg", variant="secondary")
+    
+    with gr.Row():
+        train_btn = gr.Button("🧠 Тренировать ИИ", variant="secondary", size="lg")
+        save_btn = gr.Button("💾 Сохранить модель", size="lg")
+        load_btn = gr.Button("📂 Загрузить модель", size="lg")
+        status = gr.Textbox(label="Статус", lines=1)
+    
+    with gr.Tab("💬 Чат с ИИ"):
+        gr.Markdown("""
+        ### Команды:
+        - `/ai <вопрос>` — спросить ИИ
+        - `/data <вопрос>|<ответ>` — обучить ИИ
+        - `/stats` — статистика
+        - `/train` — тренировка
+        - `/save` / `/load` — сохранить/загрузить модель
+        """)
+        chat_input = gr.Textbox(label="Введите команду", placeholder="/ai Как пройти уровень?")
+        chat_output = gr.Markdown(label="Ответ")
+        chat_btn = gr.Button("Отправить", variant="primary")
+    
+    with gr.Accordion("📊 Расширенная статистика", open=False):
+        gr.Markdown("""
+        **Как работает нейросеть:**
+        - 🧠 Архитектура: 4 слоя (256→256→256→128 нейронов)
+        - 📚 Memory: 10000 опыта
+        - 🎯 Алгоритм: DQN с целевой сетью
+        - 📉 Эпсилон-жадность: исследование vs эксплуатация
+        - 🏆 Цель: максимизировать счёт в платформере
+        """)
+        gr.Markdown("*Модель сохраняется автомат��чески каждые 20 эпизодов*")
+    
+    # Привязка кнопок
+    left_btn.click(move_left, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
+    right_btn.click(move_right, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
+    jump_btn.click(move_jump, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
+    reset_btn.click(reset_game, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
+    
+    train_btn.click(start_training, outputs=[status])
+    save_btn.click(lambda: agent.save_model() or "💾 Модель сохранена!", outputs=[status])
+    load_btn.click(lambda: agent.load_model() or "📂 Модель загружена!", outputs=[status])
+    
+    chat_btn.click(chat_response, inputs=[chat_input], outputs=[chat_output])
+    chat_input.submit(chat_response, inputs=[chat_input], outputs=[chat_output])
+    
+    # Автозапуск при загрузке
+    demo.load(reset_game, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
 
 # =====================================================
-# 8. ЗАПУСК
+# 7. ЗАПУСК
 # =====================================================
 
-if __name__ == '__main__':
-    print("""
-    ╔══════════════════════════════════════════════════╗
-    ║  🎮 AI vs Player Platformer                     ║
-    ║  Сервер запущен на http://0.0.0.0:7860         ║
-    ║  Нажми Ctrl+C для остановки                    ║
-    ╚══════════════════════════════════════════════════╝
-    """)
-    app.run(host='0.0.0.0', port=7860, debug=False, threaded=True)
+if __name__ == "__main__":
+    demo.launch(share=True)