Update app.py

app.py

@@ -1,8 +1,8 @@
 """
 🎮 ДВОЙНОЙ ПЛАТФОРМЕР: ИИ vs ИГРОК + ЗВУКИ + ЧАТ-БОТ
-Hugging Face Space (Gradio)
+Flask Web Server (порт 7860)
 """
-import gradio as gr
+from flask import Flask, render_template_string, request, jsonify, send_from_directory
 import numpy as np
 import random
 import json
@@ -11,20 +11,22 @@ import torch
 import torch.nn as nn
 import torch.optim as optim
 from collections import deque
-from transformers import GPT2LMHeadModel, GPT2Tokenizer
 import time
 import threading
 import math
 import base64
 from PIL import Image
 import io
+import sys
+
+app = Flask(__name__)
 
 # =====================================================
-# 1. ЗВУКИ (только эффекты, без фона)
+# 1. ЗВУКИ
 # =====================================================
 
 def generate_sound(freq=440, duration=0.1, waveform='sine'):
-    """Генерирует простой звук в base64"""
+    """Генерирует звук в base64"""
     import struct
     import wave
     
@@ -43,9 +45,7 @@ def generate_sound(freq=440, duration=0.1, 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))
-        elif waveform == 'noise':
-            val = int(32767 * 0.3 * random.random())
-        else:  # sweep
+        else:
             f = freq + i * 200 / samples
             val = int(32767 * 0.5 * math.sin(2 * math.pi * f * t))
         wav.writeframes(struct.pack('<h', val))
@@ -62,13 +62,8 @@ SOUNDS = {
     'die': generate_sound(200, 0.3, 'sweep')
 }
 
-def get_sound_html(sound_type):
-    if sound_type in SOUNDS:
-        return f'<audio autoplay><source src="{SOUNDS[sound_type]}" type="audio/wav"></audio>'
-    return ''
-
 # =====================================================
-# 2. БЕСКОНЕЧНЫЙ ПЛАТФОРМЕР
+# 2. ПЛАТФОРМЕР
 # =====================================================
 
 class InfinitePlatformer:
@@ -91,7 +86,6 @@ class InfinitePlatformer:
         self.entities = []
         self.coins = []
         self.obstacles = []
-        self.camera_x = 0
         self.velocity_y = 0
         self.gravity = 0.5
         self.jump_power = -8
@@ -203,9 +197,6 @@ class InfinitePlatformer:
                     if 0 <= sx < state_size and 0 <= sy < state_size:
                         state[sy, sx] = 0.3
         
-        for x in range(state_size):
-            state[state_size-3, x] = 0.2
-        
         return state.flatten()
     
     def update_entities(self):
@@ -245,8 +236,7 @@ class InfinitePlatformer:
                         return True
         return False
     
-    def step(self, action, is_ai=False):
-        px, py = self.player[0], self.player[1]
+    def step(self, action):
         sound = None
         
         if action == 1:
@@ -349,8 +339,6 @@ class InfinitePlatformer:
             y = int(enemy['y'])
             if 0 <= x < 80 and 0 <= y < self.height:
                 grid[y, x] = [255, 0, 0]
-                if enemy['type'] == 'jumper':
-                    grid[y-1, x] = [200, 0, 0]
         
         for coin in self.coins:
             if not coin['collected']:
@@ -365,115 +353,97 @@ class InfinitePlatformer:
             if 0 <= py < self.height:
                 grid[py, px] = [0, 255, 0]
                 grid[py-1, px] = [0, 200, 0]
-                grid[py-2, px] = [0, 150, 0]
         
         img = Image.fromarray(grid, 'RGB')
         return img
 
 # =====================================================
-# 3. DQN АГЕНТ
+# 3. DQN АГЕНТ (упрощённый, без PyTorch если нет)
 # =====================================================
 
-class DQN(nn.Module):
-    def __init__(self, input_size, output_size):
-        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, output_size)
-        )
-    
-    def forward(self, x):
-        return self.net(x)
-
-class DQNAgent:
+class SimpleDQNAgent:
     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.998
-        self.model = DQN(state_size, action_size)
-        self.target_model = DQN(state_size, action_size)
-        self.target_model.load_state_dict(self.model.state_dict())
-        self.optimizer = optim.Adam(self.model.parameters(), lr=0.0001)
-        self.criterion = nn.MSELoss()
-        self.gamma = 0.99
-        self.batch_size = 64
+        self.epsilon_decay = 0.995
+        self.memory = deque(maxlen=1000)
         self.total_steps = 0
-        self.update_target_every = 100
-        self.training = False
-        self.episode_score = 0
         self.best_score = 0
-        self.seed = None
+        
+        # Простая 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)
-        with torch.no_grad():
-            state_tensor = torch.FloatTensor(state).unsqueeze(0)
-            q_values = self.model(state_tensor)
-            return torch.argmax(q_values).item()
+        
+        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) < self.batch_size:
+        if len(self.memory) < 32:
             return
         
-        batch = random.sample(self.memory, self.batch_size)
-        states = torch.FloatTensor([b[0] for b in batch])
-        actions = torch.LongTensor([b[1] for b in batch])
-        rewards = torch.FloatTensor([b[2] for b in batch])
-        next_states = torch.FloatTensor([b[3] for b in batch])
-        dones = torch.FloatTensor([b[4] for b in batch])
-        
-        current_q = self.model(states).gather(1, actions.unsqueeze(1)).squeeze()
-        next_q = self.target_model(next_states).max(1)[0]
-        target_q = rewards + self.gamma * next_q * (1 - dones)
-        
-        loss = self.criterion(current_q, target_q.detach())
-        self.optimizer.zero_grad()
-        loss.backward()
-        self.optimizer.step()
+        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
-        if self.total_steps % self.update_target_every == 0:
-            self.target_model.load_state_dict(self.model.state_dict())
     
     def train_episode(self):
-        env = InfinitePlatformer(seed=self.seed)
+        env = InfinitePlatformer()
         state = env.reset()
         total_reward = 0
         done = False
         steps = 0
         
-        while not done and steps < 500:
+        while not done and steps < 300:
             action = self.act(state)
-            next_state, reward, done, _ = env.step(action, is_ai=True)
+            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
         
-        self.episode_score = total_reward
         if total_reward > self.best_score:
             self.best_score = total_reward
         
         return total_reward, steps, env.distance
 
 # =====================================================
-# 4. ЧАТ-БОТ
+# 4. ЧАТ-ПАМЯТЬ
 # =====================================================
 
 class ChatMemory:
@@ -511,76 +481,522 @@ class ChatMemory:
                 best_score = score
                 best_match = a
         
-        if best_score >= len(words) * 0.5:
+        if best_score >= len(words) * 0.4:
             return best_match
         return None
 
 # =====================================================
-# 5. ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ (объявлены ДО использования)
+# 5. ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
 # =====================================================
 
-agent = DQNAgent()
+agent = SimpleDQNAgent()
 chat_memory = ChatMemory()
-training_thread = None
 is_training = False
 current_seed = random.randint(0, 999999)
 
 # =====================================================
-# 6. ИГРОВОЙ ЦИКЛ
+# 6. HTML ШАБЛОН
+# =====================================================
+
+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 game_loop(player_action=None):
+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():
     global current_seed, agent
     
+    # Создаём игру для отображения
     ai_env = InfinitePlatformer(seed=current_seed)
     player_env = InfinitePlatformer(seed=current_seed)
     
-    ai_state = ai_env.reset()
-    player_state = player_env.reset()
+    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)
     
-    frames_ai = []
-    frames_player = []
+    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.reset()
+    player_env.reset()
+    
+    # Играем несколько шагов
     ai_score = 0
     player_score = 0
-    ai_alive = True
-    player_alive = True
-    sound_html = ''
-    
-    for step in range(200):
-        if ai_alive:
-            ai_action = agent.act(ai_state)
-            ai_next_state, ai_reward, ai_done, ai_sound = ai_env.step(ai_action, is_ai=True)
-            if ai_sound and ai_alive:
-                sound_html += get_sound_html(ai_sound)
-            ai_state = ai_next_state
-            ai_score = ai_env.score
-            ai_alive = not ai_done
-        
-        if player_alive and player_action is not None:
-            player_next_state, player_reward, player_done, player_sound = player_env.step(player_action, is_ai=False)
-            if player_sound and player_alive:
-                sound_html += get_sound_html(player_sound)
-            player_state = player_next_state
-            player_score = player_env.score
-            player_alive = not player_done
-        
-        frames_ai.append(ai_env.render(show_player=ai_alive))
-        frames_player.append(player_env.render(show_player=player_alive))
-        
-        if not ai_alive and not player_alive:
+    sound = None
+    coins = 0
+    
+    for _ in range(3):  # 3 шага за раз
+        # Ход ИИ
+        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 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 not ai_env.alive and not player_env.alive:
             break
     
-    final_img_ai = frames_ai[-1] if frames_ai else ai_env.render()
-    final_img_player = frames_player[-1] if frames_player else player_env.render()
+    ai_img = ai_env.render(show_player=ai_env.alive)
+    player_img = player_env.render(show_player=player_env.alive)
     
-    return final_img_ai, final_img_player, f"🤖 ИИ: {ai_score} | 🎮 Ты: {player_score} | 🪙 Монет: {player_env.coins_collected}", sound_html
+    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
+    })
 
-# =====================================================
-# 7. CHAT FUNCTIONS
-# =====================================================
+@app.route('/reset', methods=['POST'])
+def reset():
+    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
+    })
 
-def chat_ai(message):
-    global training_thread, is_training, current_seed
+@app.route('/chat', methods=['POST'])
+def chat():
+    data = request.json
+    message = data.get('message', '').strip()
+    
+    response = process_chat(message)
+    
+    return jsonify({'response': response})
+
+def process_chat(message):
+    global is_training, agent
     
     if message.startswith('/ai '):
         question = message[4:].strip()
@@ -589,19 +1005,9 @@ def chat_ai(message):
         
         answer = chat_memory.find_best_match(question)
         if answer:
-            return f"🤖 {answer}"
+            return answer
         
-        try:
-            tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
-            model = GPT2LMHeadModel.from_pretrained('gpt2')
-            inputs = tokenizer.encode(question, return_tensors='pt')
-            outputs = model.generate(inputs, max_length=100, num_return_sequences=1, temperature=0.7)
-            answer = tokenizer.decode(outputs[0], skip_special_tokens=True)
-            if len(answer) > len(question):
-                answer = answer[len(question):].strip()
-            return f"🤖 {answer}"
-        except:
-            return "🤖 Используй /data для обучения"
+        return "🤖 Я не знаю ответа. Обучи меня через /data вопрос|ответ"
     
     elif message.startswith('/data '):
         parts = message[6:].split('|')
@@ -612,112 +1018,75 @@ def chat_ai(message):
         return chat_memory.add(question, answer)
     
     elif message == '/stats':
-        return f"""
-📊 **Статистика:**
+        return f"""📊 Статистика:
 - Память: {len(chat_memory.data)} пар
-- Игровой агент: {agent.total_steps} шагов
+- Шагов ИИ: {agent.total_steps}
 - Эпсилон: {agent.epsilon:.3f}
-- Лучший счёт: {agent.best_score:.0f}
-- Тренируется: {is_training}
-"""
+- Лучший счёт: {agent.best_score}
+- Тренируется: {'✅' if is_training else '❌'}"""
     
     elif message == '/train':
-        if not is_training:
-            is_training = True
-            def train():
-                global is_training, agent
-                for ep in range(100):
-                    if not is_training:
-                        break
-                    agent.train_episode()
-                    if ep % 10 == 0:
-                        print(f"📊 Episode {ep}: Epsilon={agent.epsilon:.3f}")
-                is_training = False
-            training_thread = threading.Thread(target=train)
-            training_thread.start()
-            return "🚀 Тренировка запущена! Смотри консоль."
-        return "⏳ Уже тренируется!"
+        return start_training()
     
     else:
-        return "🤖 Команды:\n/ai <вопрос>\n/data вопрос|ответ\n/stats\n/train"
+        return """🤖 Доступные команды:
+/ai <вопрос> — спросить
+/data вопрос|ответ — обучить
+/stats — статистика
+/train — тренировка ИИ"""
 
-def player_move(action):
-    return game_loop(action)
-
-# =====================================================
-# 8. GRADIO INTERFACE
-# =====================================================
-
-with gr.Blocks(title="🎮 AI vs Player Platformer", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🎮 Двойной Платформер: ИИ против Тебя!
+def start_training():
+    global is_training, agent
     
-    ### 🤖 Слева — нейросеть играет сама, справа — ты на том же уровне!
-    ### 🎵 Звуки: прыжок, монетка, смерть (без фоновой музыки)
-    """)
+    if is_training:
+        return "⏳ Уже тренируется!"
+    
+    is_training = True
     
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 🤖 ИИ играет")
-            ai_output = gr.Image(label="AI Game", height=400)
-        with gr.Column():
-            gr.Markdown("### 🎮 Ты играешь")
-            player_output = gr.Image(label="Player Game", height=400)
-    
-    with gr.Row():
-        stats_output = gr.Textbox(label="Счёт", lines=2)
-    
-    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():
-        sound_output = gr.HTML(label="Звуки")
-    
-    with gr.Tab("💬 Чат"):
-        gr.Markdown("""
-        ### Команды:
-        - `/ai <вопрос>` - задать вопрос
-        - `/data вопрос|ответ` - обучить
-        - `/stats` - статистика
-        - `/train` - тренировка ИИ
-        """)
-        chat_input = gr.Textbox(label="Команда", placeholder="/ai Как дела?")
-        chat_output = gr.Markdown(label="Ответ")
-        chat_btn = gr.Button("Отправить", variant="primary")
-    
-    # Привязка кнопок
-    def reset_game():
-        global current_seed
-        current_seed = random.randint(0, 999999)
-        return game_loop(0)
-    
-    def move_left():
-        return game_loop(1)
-    
-    def move_right():
-        return game_loop(2)
-    
-    def move_jump():
-        return game_loop(3)
-    
-    reset_btn.click(reset_game, outputs=[ai_output, player_output, stats_output, sound_output])
-    left_btn.click(move_left, outputs=[ai_output, player_output, stats_output, sound_output])
-    right_btn.click(move_right, outputs=[ai_output, player_output, stats_output, sound_output])
-    jump_btn.click(move_jump, outputs=[ai_output, player_output, stats_output, sound_output])
-    
-    chat_btn.click(chat_ai, inputs=[chat_input], outputs=[chat_output])
-    chat_input.submit(chat_ai, inputs=[chat_input], outputs=[chat_output])
-    
-    # Автозапуск
-    demo.load(reset_game, outputs=[ai_output, player_output, stats_output, sound_output])
+    def train():
+        global is_training, agent
+        try:
+            for ep in range(50):
+                if not is_training:
+                    break
+                score, steps, dist = agent.train_episode()
+                if ep % 10 == 0:
+                    print(f"📊 Episode {ep}: Score={score:.0f}, Epsilon={agent.epsilon:.3f}")
+        except Exception as e:
+            print(f"Ошибка тренировки: {e}")
+        finally:
+            is_training = False
+    
+    thread = threading.Thread(target=train)
+    thread.start()
+    
+    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
+    })
+
+@app.route('/train', methods=['POST'])
+def train_route():
+    return jsonify({'message': start_training()})
 
 # =====================================================
-# 9. ЗАПУСК
+# 8. ЗАПУСК
 # =====================================================
 
-if __name__ == "__main__":
-    demo.launch(share=True)
+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)