Update app.py

app.py

@@ -1,338 +1,764 @@
+"""
+🎮 ДВОЙНОЙ ПЛАТФОРМЕР: ИИ vs ИГРОК + ЗВУКИ + ЧАТ-БОТ
+Hugging Face Space (Gradio)
+"""
 import gradio as gr
-from datasets import Dataset, load_from_disk
+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
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
 import time
-from threading import Thread
+import threading
+import math
+import base64
+from PIL import Image
+import io
 
-# === 1. БАЗА ДИАЛОГОВ ===
+# =====================================================
+# 1. ЗВУКИ (только эффекты, без фона)
+# =====================================================
 
-dialog_templates = [
-    {
-        "dialog": [
-            ("Привет!", "Здравствуйте! Как я могу вам помочь?"),
-            ("Привет!", "Приветствую! Чем могу быть полезен?"),
-            ("Доброе утро!", "Доброе утро! Отличный день, не правда ли?"),
-            ("Добрый день!", "Добрый день! Чем могу помочь?"),
-            ("Здравствуйте!", "Здравствуйте! Рад вас видеть."),
-            ("Привет!", "Привет! Как у тебя дела?"),
-            ("Хай!", "Хай! Что нового?"),
-        ]
-    },
-    {
-        "dialog": [
-            ("Как дела?", "Всё отлично! А у вас?"),
-            ("Что нового?", "Много интересного! А у вас?"),
-            ("Как жизнь?", "Жизнь прекрасна! Спасибо, что спросили."),
-            ("Как настроение?", "Настроение отличное! А у вас?"),
-            ("Как успехи?", "Успехи есть! Работаю над новыми проектами."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Кто ты?", "Я искусственный интеллект, созданный чтобы помогать людям."),
-            ("Что ты умеешь?", "Я умею отвечать на вопросы, писать тексты, помогать с задачами."),
-            ("Где ты живёшь?", "Я живу в облаке! Всегда рядом с вами."),
-            ("Сколько тебе лет?", "Мне несколько лет, но я постоянно учусь."),
-            ("Зачем ты здесь?", "Я здесь, чтобы помогать людям в их повседневных задачах."),
-            ("У тебя есть имя?", "Меня зовут AI-ассистент. А вас?"),
-            ("Ты человек?", "Нет, я компьютерная программа, но стараюсь быть полезной."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Почему небо голубое?", "Небо голубое из-за рассеяния Рэлея."),
-            ("Как работает интернет?", "Интернет работает через сеть серверов и маршрутизаторов."),
-            ("Что такое искусственный интеллект?", "ИИ — это технология, позволяющая машинам имитировать человеческий разум."),
-            ("Что такое нейросети?", "Нейросети — это алгоритмы, вдохновлённые структурой мозга."),
-            ("Почему трава зелёная?", "Трава зелёная из-за хлорофилла."),
-            ("Когда появилась жизнь на Земле?", "Жизнь появилась около 3,5 миллиардов лет назад."),
-            ("Сколько планет в солнечной системе?", "В солнечной системе 8 планет."),
-            ("Что такое чёрная дыра?", "Чёрная дыра — область пространства с огромной гравитацией."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Кто написал Войну и мир?", "Войну и мир написал Лев Толстой."),
-            ("Что такое роман?", "Роман — это литературный жанр с развёрнутым сюжетом."),
-            ("Кто такой Шекспир?", "Шекспир — великий английский драматург и поэт."),
-            ("Что такое живопись?", "Живопись — искусство создания изображений красками."),
-            ("Кто нарисовал Мону Лизу?", "Мону Лизу нарисовал Леонардо да Винчи."),
-            ("Чт�� такое театр?", "Театр — это искусство драматических представлений."),
-            ("Кто такой Пушкин?", "Александр Пушкин — великий русский поэт."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Где можно купить хлеб?", "Хлеб можно купить в ближайшем супермаркете."),
-            ("Как приготовить яичницу?", "Разбейте яйца на сковороду, обжарьте до готовности."),
-            ("Сколько времени?", "Сейчас 12:00, если точнее."),
-            ("Как пройти в библиотеку?", "Пройдите прямо, затем поверните налево."),
-            ("Что посмотреть вечером?", "Рекомендую хороший фильм или книгу."),
-            ("Как выучить язык?", "Нужна регулярная практика и мотивация."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Как выучить Python?", "Начните с основ: переменные, циклы, функции."),
-            ("Что такое API?", "API — это интерфейс для взаимодействия программ."),
-            ("Как создать сайт?", "Нужно знать HTML, CSS, JavaScript и серверный язык."),
-            ("Что такое Git?", "Git — система контроля версий для кода."),
-            ("Как стать разработчиком?", "Много практикуйтесь, изучайте алгоритмы."),
-            ("Что такое Docker?", "Docker — платформа для контейнеризации приложений."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Как справиться со стрессом?", "Помогают медитация, отдых и спорт."),
-            ("Что делать при тревоге?", "Подышите глубоко, сосредоточьтесь на моменте."),
-            ("Как найти смысл жизни?", "Смысл в том, что вы делаете и кого любите."),
-            ("Почему люди счастливы?", "Счастье в простых вещах: любви, здоровье, увлечениях."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Где лучше отдыхать?", "Всё зависит от ваших предпочтений: море, горы, город."),
-            ("Что посмотреть в Европе?", "Рекомендую Париж, Рим, Лондон."),
-            ("Как добраться до Парижа?", "Можно на поезде или самолёте."),
-            ("Где находится Эйфелева башня?", "В Париже, Франция."),
-        ]
-    },
-    {
-        "dialog": [
-            ("Что такое любовь?", "Любовь — глубокое чувство привязанности и заботы."),
-            ("Что такое дружба?", "Дружба — доверительные отношения между людьми."),
-            ("Что такое справедливость?", "Справедливость — принцип равенства и честности."),
-            ("Что такое свобода?", "Свобода — возможность действовать по своей воле."),
-        ]
-    },
-]
+# Генерируем простые звуки в base64 (без внешних файлов)
+def generate_sound(freq=440, duration=0.1, waveform='sine'):
+    """Генерирует простой звук в base64"""
+    import struct
+    import wave
+    
+    sample_rate = 22050
+    samples = int(sample_rate * duration)
+    
+    # Создаём WAV в памяти
+    buffer = io.BytesIO()
+    wav = wave.open(buffer, 'wb')
+    wav.setnchannels(1)
+    wav.setsampwidth(2)
+    wav.setframerate(sample_rate)
+    
+    # Генерируем волну
+    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))
+        elif waveform == 'noise':
+            val = int(32767 * 0.3 * random.random())
+        else:  # sweep (для смерти)
+            f = freq + i * 200 / samples
+            val = int(32767 * 0.5 * math.sin(2 * math.pi * f * t))
+        wav.writeframes(struct.pack('<h', val))
+    
+    wav.close()
+    buffer.seek(0)
+    
+    # Конвертируем в base64
+    audio_data = base64.b64encode(buffer.read()).decode('utf-8')
+    return f'data:audio/wav;base64,{audio_data}'
 
-# === 2. ФУНКЦИИ ГЕНЕРАЦИИ ===
+# Создаём звуки
+SOUNDS = {
+    'jump': generate_sound(600, 0.08, 'sine'),     # Высокий писк
+    'coin': generate_sound(880, 0.05, 'sine'),     # Очень высокий
+    'die': generate_sound(200, 0.3, 'sweep')       # Падающий звук
+}
 
-def generate_dialog():
-    template = random.choice(dialog_templates)
-    q, a = random.choice(template["dialog"])
-    
-    variations = [
-        a,
-        f"{a} А что вы думаете?",
-        f"{a} Это интересный вопрос!",
-        f"{a} Я надеюсь, это поможет.",
-        f"{a} Есть ещё вопросы?",
-    ]
-    answer = random.choice(variations)
-    
-    prefixes = ["Скажите, ", "А можно узнать, ", "Подскажите, ", "Интересно, ", ""]
-    prefix = random.choice(prefixes)
-    
-    dialog = f"Человек: {prefix}{q.lower()}\nАссистент: {answer}"
-    return dialog
+def get_sound_html(sound_type):
+    """Возвращает HTML для воспроизведения звука"""
+    if sound_type in SOUNDS:
+        return f'<audio autoplay><source src="{SOUNDS[sound_type]}" type="audio/wav"></audio>'
+    return ''
 
-def generate_long_dialog():
-    turns = random.randint(5, 12)
-    lines = []
-    
-    topics = ["работа", "учёба", "хобби", "путешествия", "наука", "искусство", "технологии", "здоровье"]
-    topic = random.choice(topics)
-    lines.append(f"Тема: {topic.capitalize()}")
-    
-    for i in range(turns):
-        if i % 2 == 0:
-            template = random.choice(dialog_templates)
-            q, _ = random.choice(template["dialog"])
-            prefixes = ["Скажите, ", "А можно узнать, ", "Подскажите, ", "Интересно, ", ""]
-            prefix = random.choice(prefixes)
-            lines.append(f"Человек: {prefix}{q.lower()}")
-        else:
-            template = random.choice(dialog_templates)
-            _, a = random.choice(template["dialog"])
-            responses = [
-                a,
-                f"О, {a}",
-                f"Хорошо, {a}",
-                f"Да, {a}",
-                f"Верно, {a}",
-                f"Конечно же, {a}",
-                f"Без сомнения, {a}",
-            ]
-            lines.append(f"Ассистент: {random.choice(responses)}")
-    
-    return "\n".join(lines)
+# =====================================================
+# 2. БЕСКОНЕЧНЫЙ ПЛАТФОРМЕР
+# =====================================================
 
-def generate_dialog_batch():
-    count = random.randint(2, 5)
-    dialogs = []
-    for _ in range(count):
-        if random.random() > 0.5:
-            dialogs.append(generate_long_dialog())
-        else:
-            dialogs.append(generate_dialog())
-    return "\n\n---\n\n".join(dialogs)
+class InfinitePlatformer:
+    def __init__(self, seed=None):
+        self.width = 100
+        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.camera_x = 0
+        self.velocity_y = 0
+        self.gravity = 0.5
+        self.jump_power = -8
+        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
+        
+        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):
+            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(num_enemies):
+            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,
+                'range': random.randint(3, 8),
+                'start_x': x
+            })
+        
+        # Монетки
+        for _ in range(num_coins):
+            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
+        
+        for x in range(state_size):
+            state[state_size-3, x] = 0.2
+        
+        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.5
+                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:
+                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.5 and abs(coin['y'] - self.player[1]) < 1.5:
+                    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, is_ai=False):
+        """Выполняет действие. Возвращает (состояние, награда, конец, звук)"""
+        px, py = self.player[0], self.player[1]
+        sound = None
+        
+        # Горизонтальное движение
+        if action == 1:  # влево
+            self.player[0] -= 0.5
+        elif action == 2:  # вправо
+            self.player[0] += 0.5
+        
+        # Прыжок
+        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 > 2000:
+            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):
+        """Визуализация"""
+        grid = np.zeros((self.height, 80, 3), dtype=np.uint8)
+        grid.fill(200)
+        
+        # Земля
+        grid[self.ground_level:self.ground_level+2, :] = [100, 80, 40]
+        
+        # Препятствия
+        for obs in self.obstacles:
+            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]
+        
+        # Враги
+        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]
+                if enemy['type'] == 'jumper':
+                    grid[y-1, x] = [200, 0, 0]
+        
+        # Монетки
+        for coin in self.coins:
+            if not coin['collected']:
+                x = int(coin['x'] - self.player[0] + 40)
+                y = int(coin['y'])
+                if 0 <= x < 80 and 0 <= y < self.height:
+                    grid[y, x] = [255, 215, 0]
+        
+        # Игрок
+        if show_player:
+            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-2, px] = [0, 150, 0]
+        
+        # Информация
+        img = Image.fromarray(grid, 'RGB')
+        return img
+
+# =====================================================
+# 3. DQN АГЕНТ
+# =====================================================
 
-# === 3. ГЕНЕРАТОР ===
+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 DatasetGenerator:
+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.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.total_steps = 0
+        self.update_target_every = 100
+        self.training = False
+        self.episode_score = 0
+        self.best_score = 0
+        self.seed = None
+    
+    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()
+    
+    def remember(self, state, action, reward, next_state, done):
+        self.memory.append((state, action, reward, next_state, done))
+    
+    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])
+        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()
+        
+        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)
+        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, is_ai=True)
+            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. ЧАТ-БОТ
+# =====================================================
+
+class ChatMemory:
     def __init__(self):
-        self.data = {"text": [], "dialog": [], "turns": []}
-        self.target_size = 100 * 1024 * 1024
-        self.current_size = 0
-        self.is_running = False
-        self.count = 0
-        
-        self.load_existing()
-    
-    def load_existing(self):
-        if os.path.exists("/data/dialog_dataset"):
-            try:
-                dataset = load_from_disk("/data/dialog_dataset")
-                self.data["text"] = list(dataset["text"])
-                self.data["dialog"] = list(dataset["dialog"])
-                self.data["turns"] = list(dataset["turns"])
-                self.count = len(self.data["text"])
-                self.current_size = len(json.dumps(self.data, ensure_ascii=False).encode('utf-8'))
-                print(f"✅ Загружено {self.count} диалогов, {self.current_size // 1024 // 1024} МБ")
-            except Exception as e:
-                print(f"❌ Ошибка загрузки: {e}")
-    
-    def generate_batch(self, batch_size=100):
-        new_texts = []
-        new_dialogs = []
-        new_turns = []
-        
-        for _ in range(batch_size):
-            if random.random() < 0.3:
-                dialog = generate_dialog_batch()
-                turns = random.randint(5, 15)
-            elif random.random() < 0.6:
-                dialog = generate_long_dialog()
-                turns = random.randint(5, 12)
-            else:
-                dialog = generate_dialog()
-                turns = random.randint(2, 4)
-            
-            new_texts.append(dialog)
-            new_dialogs.append(dialog)
-            new_turns.append(turns)
-        
-        return new_texts, new_dialogs, new_turns
-    
-    def generate_loop(self):
-        self.is_running = True
-        
-        while self.is_running and self.current_size < self.target_size:
-            texts, dialogs, turns = self.generate_batch(100)
-            
-            self.data["text"].extend(texts)
-            self.data["dialog"].extend(dialogs)
-            self.data["turns"].extend(turns)
-            
-            self.count += len(texts)
-            self.current_size = len(json.dumps(self.data, ensure_ascii=False).encode('utf-8'))
-            
-            if self.count % 1000 == 0:
-                self.save_dataset()
-                print(f"💾 Сохранено {self.count} диалогов, {self.current_size // 1024 // 1024} МБ")
-            
-            time.sleep(0.1)
-        
-        self.is_running = False
-        self.save_dataset()
-        print("✅ Генерация завершена!")
-    
-    def save_dataset(self):
-        os.makedirs("/data", exist_ok=True)
-        dataset = Dataset.from_dict(self.data)
-        dataset.save_to_disk("/data/dialog_dataset")
-        
-        with open("/data/dialog_dataset.jsonl", "w", encoding="utf-8") as f:
-            for i in range(len(self.data["text"])):
-                entry = {
-                    "text": self.data["text"][i],
-                    "dialog": self.data["dialog"][i],
-                    "turns": self.data["turns"][i]
-                }
-                f.write(json.dumps(entry, ensure_ascii=False) + "\n")
-    
-    def get_status(self):
-        percent = (self.current_size / self.target_size) * 100 if self.target_size > 0 else 0
-        return {
-            "count": self.count,
-            "size_mb": self.current_size // 1024 // 1024,
-            "target_mb": self.target_size // 1024 // 1024,
-            "percent": min(percent, 100),
-            "is_running": self.is_running
-        }
+        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:
+            json.dump(self.data, f, ensure_ascii=False, indent=2)
+    
+    def add(self, question, answer):
+        self.data[question.lower()] = answer
+        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
+        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)
+            if score > best_score:
+                best_score = score
+                best_match = a
+        
+        if best_score >= len(words) * 0.5:
+            return best_match
+        return None
 
-# === 4. GRADIO ===
+# =====================================================
+# 5. ИГРОВОЙ ЦИКЛ
+# =====================================================
 
-generator = DatasetGenerator()
+agent = DQNAgent()
+chat_memory = ChatMemory()
+training_thread = None
+is_training = False
 
-def start_generation():
-    if generator.is_running:
-        return "⏳ Генерация уже запущена!"
-    
-    thread = Thread(target=generator.generate_loop)
-    thread.daemon = True
-    thread.start()
-    return "🚀 Генерация Minset запущена!"
+# Синхронизированный seed для обоих игроков
+current_seed = random.randint(0, 999999)
 
-def stop_generation():
-    generator.is_running = False
-    return "⏹️ Генерация остановлена"
+def game_loop(player_action=None):
+    """Основной игровой цикл для двух игроков"""
+    global current_seed, agent
+    
+    # Создаём два экземпляра игры с одинаковым seed
+    ai_env = InfinitePlatformer(seed=current_seed)
+    player_env = InfinitePlatformer(seed=current_seed)
+    
+    ai_state = ai_env.reset()
+    player_state = player_env.reset()
+    
+    frames_ai = []
+    frames_player = []
+    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_action: 0-ничего, 1-влево, 2-вправо, 3-прыжок
+            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:
+            break
+    
+    # Создаём анимацию через HTML
+    from PIL import Image as PILImage
+    import io
+    
+    # Конвертируем кадры в GIF (для демонстрации используем последний кадр)
+    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()
+    
+    return final_img_ai, final_img_player, f"🤖 ИИ: {ai_score} | 🎮 Ты: {player_score}", sound_html
 
-def get_status():
-    status = generator.get_status()
-    progress_bar = "█" * int(status['percent'] // 2) + "░" * (50 - int(status['percent'] // 2))
-    return f"""
-    📊 **Minset - Статус генерации**
-    
-    📝 Диалогов: **{status['count']}**
-    💾 Размер: **{status['size_mb']} МБ / {status['target_mb']} МБ**
-    📈 Прогресс: **{status['percent']:.1f}%**
-    🔄 Состояние: **{'✅ Работает' if status['is_running'] else '⏸️ Остановлен'}**
-    
-    `{progress_bar}`
-    """
+# =====================================================
+# 6. CHAT FUNCTIONS
+# =====================================================
 
-def get_sample():
-    if generator.count == 0:
-        return "Нет сгенерированных диалогов"
+def chat_ai(message):
+    """Обработчик чата"""
+    if message.startswith('/ai '):
+        question = message[4:].strip()
+        if not question:
+            return "❌ Напиши вопрос после /ai"
+        
+        answer = chat_memory.find_best_match(question)
+        if answer:
+            return f"🤖 {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 для обучения"
+    
+    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)
+    
+    elif message == '/stats':
+        return f"""
+📊 **Статистика:**
+- Память: {len(chat_memory.data)} пар
+- Игровой агент: {agent.total_steps} шагов
+- Эпсилон: {agent.epsilon:.3f}
+- Лучший счёт: {agent.best_score:.0f}
+- Тренируется: {is_training}
+"""
+    
+    elif message == '/train':
+        global training_thread, is_training, current_seed
+        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 "⏳ Уже тренируется!"
     
-    idx = random.randint(0, generator.count - 1)
-    return f"**Пример диалога Minset #{idx}**\n\n{generator.data['text'][idx]}"
+    else:
+        return "🤖 Команды:\n/ai <вопрос>\n/data вопрос|ответ\n/stats\n/train"
 
-# === 5. ИНТЕРФЕЙС ===
+def player_move(action):
+    """Обработка действий игрока"""
+    # action: 0-ничего, 1-влево, 2-вправо, 3-прыж��к
+    return game_loop(action)
 
-with gr.Blocks(title="Minset Dataset Generator") as demo:
+# =====================================================
+# 7. GRADIO INTERFACE
+# =====================================================
+
+with gr.Blocks(title="🎮 AI vs Player Platformer", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🤖 Minset - Генератор датасета диалогов
-    
-    **Minset** — это датасет русских диалогов для обучения моделей.
+    # 🎮 Двойной Платформер: ИИ против Тебя!
     
-    ⚠️ **Важно:** Модели **ОБУЧАЮТСЯ НА ЭТОМ ДАТАСЕТЕ**, а не являются им самим.
+    ### 🤖 Слева — нейросеть играет сама, справа — ты на том же уровне!
+    ### 🎵 Звуки: прыжок, монетка, смерть (без фоновой музыки)
     """)
     
     with gr.Row():
-        with gr.Column(scale=1):
-            start_btn = gr.Button("▶️ Запустить генерацию Minset", variant="primary", size="lg")
-            stop_btn = gr.Button("⏹️ Остановить", variant="stop", size="lg")
-            
-            refresh_btn = gr.Button("🔄 Обновить статус", variant="secondary")
-            sample_btn = gr.Button("📝 Показать пример диалога", variant="secondary")
+        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)
     
-    status_output = gr.Markdown(get_status())
-    sample_output = gr.Markdown("")
+    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="Звуки")
     
-    start_btn.click(start_generation, outputs=[status_output])
-    start_btn.click(get_status, outputs=[status_output])
+    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")
     
-    stop_btn.click(stop_generation, outputs=[status_output])
-    stop_btn.click(get_status, outputs=[status_output])
+    # Привязка кнопок
+    def reset_game():
+        global current_seed
+        current_seed = random.randint(0, 999999)
+        return game_loop(0)
     
-    refresh_btn.click(get_status, outputs=[status_output])
-    sample_btn.click(get_sample, outputs=[sample_output])
+    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])
+
+# =====================================================
+# 8. ЗАПУСК
+# =====================================================
 
 if __name__ == "__main__":
     demo.launch(share=True)