Update app.py

app.py

@@ -1,106 +1,931 @@
-
-
-# Шаг 2. Импорт
-import torch
-from diffusers import StableDiffusionPipeline
-from PIL import Image, ImageFilter, ImageEnhance
-import numpy as np
+# app.py
 import gradio as gr
+import numpy as np
+import torch
+import torch.nn as nn
+import json
+import os
+from PIL import Image, ImageDraw
+import random
+from collections import deque, defaultdict
+import math
+from datetime import datetime
+import base64
+import io
 
-# Шаг 3. Проверка GPU
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"Используется: {device}")
+# ============== НАСТРОЙКИ ==============
+WORLD_SIZE = 80
+CELL_SIZE = 6
+MAX_CREATURES = 80
+MUTATION_RATE = 0.2
+MUTATION_SCALE = 0.25
+RESPAWN_RATE = 3
+SAVE_DIR = "saved_models"
 
-# Шаг 4. Загрузка модели (без float16 для CPU)
-print("Загрузка модели...")
-model_id = "runwayml/stable-diffusion-v1-5"
+os.makedirs(SAVE_DIR, exist_ok=True)
 
-if device == "cuda":
-    pipe = StableDiffusionPipeline.from_pretrained(
-        model_id,
-        torch_dtype=torch.float16,
-        safety_checker=None,
-        requires_safety_checker=False
-    )
-else:
-    pipe = StableDiffusionPipeline.from_pretrained(
-        model_id,
-        safety_checker=None,
-        requires_safety_checker=False
-    )
+# ============== РАСШИРЕННАЯ НЕЙРОСЕТЬ ==============
+class AdvancedBrain(nn.Module):
+    def __init__(self, input_size=16, hidden_size=32, output_size=6):
+        super().__init__()
+        self.fc1 = nn.Linear(input_size, hidden_size)
+        self.fc2 = nn.Linear(hidden_size, hidden_size * 2)
+        self.fc3 = nn.Linear(hidden_size * 2, hidden_size)
+        self.fc4 = nn.Linear(hidden_size, output_size)
+        self.dropout = nn.Dropout(0.15)
+        self.batch_norm = nn.BatchNorm1d(hidden_size)
+        
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = self.dropout(x)
+        x = torch.relu(self.fc2(x))
+        x = self.batch_norm(x.unsqueeze(0)).squeeze(0) if len(x.shape) == 1 else x
+        x = torch.relu(self.fc3(x))
+        x = torch.tanh(self.fc4(x))  # -1..1
+        return x
 
-pipe = pipe.to(device)
+# ============== ГЕНЕТИЧЕСКИЙ АЛГОРИТМ ==============
+class GeneticAlgorithm:
+    @staticmethod
+    def crossover(parent1, parent2):
+        """Скрещивание двух нейросетей"""
+        child = AdvancedBrain()
+        state_dict1 = parent1.state_dict()
+        state_dict2 = parent2.state_dict()
+        child_dict = {}
+        
+        for key in state_dict1.keys():
+            mask = torch.rand_like(state_dict1[key]) > 0.5
+            child_dict[key] = torch.where(mask, state_dict1[key], state_dict2[key])
+        
+        child.load_state_dict(child_dict)
+        return child
+    
+    @staticmethod
+    def mutate(brain, rate=MUTATION_RATE, scale=MUTATION_SCALE):
+        """Мутация весов"""
+        for param in brain.parameters():
+            if random.random() < rate:
+                param.data += torch.randn_like(param) * scale
+                # Ограничиваем значения
+                param.data = torch.clamp(param.data, -3, 3)
+        return brain
 
-# Экономия памяти
-try:
-    pipe.enable_attention_slicing()
-except:
-    pass
+# ============== СУЩЕСТВО С ГЕНАМИ ==============
+class Creature:
+    def __init__(self, x, y, color, brain=None, generation=0, genome_id=None):
+        self.x = x
+        self.y = y
+        self.color = color
+        self.generation = generation
+        self.genome_id = genome_id or f"{datetime.now().timestamp()}{random.randint(1000,9999)}"
+        self.parent_id = None
+        
+        # Основные ресурсы
+        self.health = 100.0
+        self.energy = 80.0
+        self.food = 50.0  # НОВЫЙ ресурс - ЕДА в желудке
+        self.resources = 0  # камни
+        self.metal = 0  # НОВЫЙ ресурс - металл
+        self.water = 50.0  # НОВЫЙ ресурс - вода
+        
+        self.age = 0
+        self.alive = True
+        self.fitness = 0
+        self.children = 0
+        
+        # Память
+        self.memory = deque(maxlen=10)
+        self.last_action = np.zeros(6)
+        
+        # Нейросеть
+        if brain is None:
+            self.brain = AdvancedBrain()
+        else:
+            self.brain = brain
+            
+        # Генеалогическое древо
+        self.ancestors = []
+        self.achievements = []
+        
+    def get_inputs(self, world, creatures):
+        """Расширенный вход для нейросети"""
+        # 1. Состояние существа
+        hunger = 1.0 - (self.food / 100.0)
+        thirst = 1.0 - (self.water / 100.0)
+        health = self.health / 100.0
+        energy = self.energy / 100.0
+        resources = self.resources / 10.0
+        metal = self.metal / 5.0
+        
+        # 2. Обзор (12 направлений с разными дистанциями)
+        view_radius = 3
+        nearby = []
+        for dx in range(-view_radius, view_radius + 1):
+            for dy in range(-view_radius, view_radius + 1):
+                if dx == 0 and dy == 0:
+                    continue
+                nx, ny = self.x + dx, self.y + dy
+                if 0 <= nx < WORLD_SIZE and 0 <= ny < WORLD_SIZE:
+                    cell = world.grid[nx, ny]
+                    # Кодируем тип ресурса
+                    if np.array_equal(cell, [34, 139, 34]):  # дерево
+                        nearby.append(1.0)
+                    elif np.array_equal(cell, [0, 150, 0]):  # еда (ягоды)
+                        nearby.append(2.0)
+                    elif np.array_equal(cell, [128, 128, 128]):  # камень
+                        nearby.append(0.5)
+                    elif np.array_equal(cell, [192, 192, 192]):  # металл
+                        nearby.append(3.0)
+                    elif np.array_equal(cell, [0, 100, 255]):  # вода
+                        nearby.append(4.0)
+                    else:
+                        nearby.append(0.0)
+                else:
+                    nearby.append(0.0)
+        
+        # 3. Ближайшие существа (сородичи и враги)
+        partners = []
+        enemies = []
+        for other in creatures:
+            if other is self or not other.alive:
+                continue
+            dist = math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
+            if dist < 8:
+                if np.array_equal(other.color, self.color):
+                    partners.append(1.0 - dist/8.0)
+                else:
+                    enemies.append(1.0 - dist/8.0)
+        
+        # 4. Память
+        memory_flat = []
+        for mem in self.memory:
+            memory_flat.extend(mem[:3])  # берем только важные действия
+        while len(memory_flat) < 15:
+            memory_flat.append(0.0)
+        
+        # Собираем вход
+        inputs = np.array([
+            hunger, thirst, health, energy, resources, metal,
+            *nearby[:8],  # 8 ближайших направлений
+            max(partners) if partners else 0.0,
+            max(enemies) if enemies else 0.0,
+            self.children / 10.0,
+            self.generation / 100.0,
+            *memory_flat[:10]
+        ], dtype=np.float32)
+        
+        # Обрезаем до нужного размера
+        if len(inputs) > 16:
+            inputs = inputs[:16]
+        elif len(inputs) < 16:
+            inputs = np.pad(inputs, (0, 16 - len(inputs)))
+            
+        return torch.tensor(inputs, dtype=torch.float32)
+    
+    def think(self, world, creatures):
+        """Принимает решения с расширенными действиями"""
+        inputs = self.get_inputs(world, creatures)
+        
+        with torch.no_grad():
+            output = self.brain(inputs.unsqueeze(0)).squeeze().numpy()
+        
+        # [движение_x, движение_y, строительство, размножение, атака, добыча_металла]
+        actions = np.clip(output, -1, 1)
+        
+        self.memory.append(actions.copy())
+        
+        # 1. Движение
+        dx = int(np.round(actions[0] * 2.5))
+        dy = int(np.round(actions[1] * 2.5))
+        self.move(dx, dy)
+        
+        # 2. Строительство (камни + металл для улучшенных стен)
+        if actions[2] > 0.3:
+            self.build(world)
+        
+        # 3. Размножение
+        if actions[3] > 0.5 and self.food > 50 and self.energy > 60:
+            return self.reproduce(creatures)
+        
+        # 4. Атака
+        if actions[4] > 0.4:
+            self.attack(creatures)
+        
+        # 5. Добыча металла
+        if actions[5] > 0.5:
+            self.mine_metal(world)
+            
+        return None
+    
+    def move(self, dx, dy):
+        new_x = max(0, min(WORLD_SIZE-1, self.x + dx))
+        new_y = max(0, min(WORLD_SIZE-1, self.y + dy))
+        self.x, self.y = new_x, new_y
+        
+        # Тратим ресурсы на движение
+        self.energy -= 0.3
+        self.food -= 0.2
+        self.water -= 0.1
+        self.age += 1
+        
+    def build(self, world):
+        """Строительство с улучшенными материалами"""
+        cost = 2 if self.metal < 2 else 3
+        required_resources = self.resources >= 2 or self.metal >= 1
+        
+        if required_resources:
+            # Выбираем материал
+            if self.metal >= 1 and random.random() > 0.5:
+                # Металлическая стена (крепче)
+                wall_color = [160, 160, 180]
+                self.metal -= 1
+            else:
+                # Каменная стена
+                wall_color = [139, 69, 19]
+                self.resources -= 2
+            
+            # Строим вокруг себя
+            for dx, dy in [(1,0), (-1,0), (0,1), (0,-1)]:
+                nx, ny = self.x + dx, self.y + dy
+                if 0 <= nx < WORLD_SIZE and 0 <= ny < WORLD_SIZE:
+                    if np.array_equal(world.grid[nx, ny], [100, 200, 100]):  # трава
+                        world.grid[nx, ny] = wall_color
+                        self.fitness += 15
+                        self.achievements.append(f"built_wall_{datetime.now()}")
+                        return True
+        return False
+    
+    def mine_metal(self, world):
+        """Добыча металла"""
+        if np.array_equal(world.grid[self.x, self.y], [192, 192, 192]):
+            self.metal += 1
+            world.grid[self.x, self.y] = [100, 200, 100]  # трава
+            self.fitness += 15
+            self.energy -= 3
+            return True
+        return False
+    
+    def reproduce(self, creatures):
+        """Размножение с генетическим алгоритмом"""
+        if len(creatures) >= MAX_CREATURES:
+            return None
+        
+        # Ищем партнера
+        partner = None
+        for other in creatures:
+            if other is not self and other.alive and np.array_equal(other.color, self.color):
+                dist = math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
+                if dist < 5 and other.food > 40:
+                    partner = other
+                    break
+        
+        if not partner:
+            # Может размножаться бесполым путем (с большей мутацией)
+            child_brain = GeneticAlgorithm.mutate(
+                self.brain, 
+                rate=MUTATION_RATE * 1.5,
+                scale=MUTATION_SCALE * 1.2
+            )
+            child = Creature(
+                self.x + random.randint(-4, 4),
+                self.y + random.randint(-4, 4),
+                self.color,
+                brain=child_brain,
+                generation=self.generation + 1
+            )
+        else:
+            # Половое размножение
+            child_brain = GeneticAlgorithm.crossover(self.brain, partner.brain)
+            child_brain = GeneticAlgorithm.mutate(child_brain)
+            child = Creature(
+                self.x + random.randint(-4, 4),
+                self.y + random.randint(-4, 4),
+                [min(255, (self.color[0] + partner.color[0]) // 2),
+                 min(255, (self.color[1] + partner.color[1]) // 2),
+                 min(255, (self.color[2] + partner.color[2]) // 2)],
+                brain=child_brain,
+                generation=max(self.generation, partner.generation) + 1
+            )
+            child.parent_id = f"{self.genome_id}_{partner.genome_id}"
+            child.ancestors = self.ancestors + [self.genome_id, partner.genome_id]
+        
+        child.food = 30
+        child.water = 30
+        child.energy = 40
+        
+        self.food -= 30
+        self.energy -= 20
+        self.children += 1
+        self.fitness += 25
+        
+        creatures.append(child)
+        return child
+    
+    def attack(self, creatures):
+        """Атака с учетом силы"""
+        for other in creatures:
+            if other is not self and other.alive:
+                dist = abs(self.x - other.x) + abs(self.y - other.y)
+                if dist <= 1 and not np.array_equal(other.color, self.color):
+                    # Урон зависит от здоровья, еды и металла
+                    damage = 10 + (self.health / 20) + (self.metal * 5)
+                    other.health -= damage
+                    self.energy -= 5
+                    self.food -= 3
+                    self.fitness += 8
+                    self.achievements.append(f"attacked_{datetime.now()}")
+                    return True
+        return False
+    
+    def eat_food(self, world):
+        """Потребление еды"""
+        if np.array_equal(world.grid[self.x, self.y], [0, 150, 0]):  # ягоды
+            self.food = min(100, self.food + 30)
+            self.health = min(100, self.health + 8)
+            world.grid[self.x, self.y] = [100, 200, 100]  # трава
+            self.fitness += 12
+            return True
+        
+        # Деревья дают меньше еды, но больше ресурсов
+        if np.array_equal(world.grid[self.x, self.y], [34, 139, 34]):  # дерево
+            self.food = min(100, self.food + 15)
+            self.health = min(100, self.health + 5)
+            world.grid[self.x, self.y] = [100, 200, 100]
+            self.fitness += 8
+            return True
+        return False
+    
+    def drink_water(self, world):
+        """Питье воды"""
+        if np.array_equal(world.grid[self.x, self.y], [0, 100, 255]):  # вода
+            self.water = min(100, self.water + 40)
+            self.health = min(100, self.health + 5)
+            # Вода не исчезает, но может "загрязниться"
+            if random.random() < 0.3:
+                world.grid[self.x, self.y] = [100, 200, 100]
+            self.fitness += 5
+            return True
+        return False
+    
+    def collect_stone(self, world):
+        if np.array_equal(world.grid[self.x, self.y], [128, 128, 128]):
+            self.resources += 1
+            world.grid[self.x, self.y] = [100, 200, 100]
+            self.fitness += 10
+            return True
+        return False
+    
+    def update(self):
+        """Обновление состояния с новыми ресурсами"""
+        # Естественные потери
+        self.food -= 0.5
+        self.water -= 0.3
+        self.health -= 0.1
+        self.energy -= 0.2
+        
+        # Если нет еды или воды - быстро умираем
+        if self.food <= 0:
+            self.health -= 2
+        if self.water <= 0:
+            self.health -= 1.5
+            
+        # Смерть
+        if self.health <= 0 or self.energy <= 0 or self.food < -10 or self.water < -10:
+            self.alive = False
+            return False
+            
+        # Старение
+        if self.age > 800:
+            self.alive = False
+            return False
+            
+        return True
+    
+    def save(self, filename):
+        """Сохранение генома"""
+        data = {
+            'genome_id': self.genome_id,
+            'generation': self.generation,
+            'fitness': self.fitness,
+            'children': self.children,
+            'ancestors': self.ancestors[-10:],
+            'brain_state': self.brain.state_dict(),
+            'achievements': self.achievements[-20:]
+        }
+        torch.save(data, filename)
+        
+    @staticmethod
+    def load(filename, x=None, y=None, color=None):
+        """Загрузка генома"""
+        data = torch.load(filename, map_location='cpu')
+        brain = AdvancedBrain()
+        brain.load_state_dict(data['brain_state'])
+        
+        creature = Creature(
+            x or random.randint(0, WORLD_SIZE-1),
+            y or random.randint(0, WORLD_SIZE-1),
+            color or [255, 255, 255],
+            brain=brain,
+            generation=data['generation'],
+            genome_id=data['genome_id']
+        )
+        creature.fitness = data['fitness']
+        creature.children = data['children']
+        return creature
 
-try:
-    pipe.vae.enable_slicing()
-except:
-    pass
+# ============== МИР С НОВЫМИ РЕСУРСАМИ ==============
+class World:
+    def __init__(self):
+        self.grid = None
+        self.creatures = []
+        self.resources = {'trees': [], 'food': [], 'stones': [], 'metal': [], 'water': []}
+        self.genealogy = []
+        self.scores = {'red': 0, 'blue': 0}
+        self.step_count = 0
+        self.best_fitness_history = []
+        self.population_history = []
+        
+        # 3D данные (изометрия)
+        self.iso_height = np.zeros((WORLD_SIZE, WORLD_SIZE))
+        
+        self.reset()
+    
+    def reset(self):
+        self.grid = np.zeros((WORLD_SIZE, WORLD_SIZE, 3), dtype=np.uint8)
+        self.grid[:, :] = [100, 200, 100]  # трава
+        self.iso_height = np.random.rand(WORLD_SIZE, WORLD_SIZE) * 0.3
+        
+        # Генерация ресурсов
+        self._generate_resources()
+        
+        # Создание существ
+        self.creatures = []
+        self._spawn_creature(20, 20, [255, 50, 50], "red")  # Красный
+        self._spawn_creature(60, 60, [50, 50, 255], "blue")  # Синий
+        self._spawn_creature(40, 40, [255, 215, 0], "gold")  # Золотой (нейтральный)
+        
+        self.step_count = 0
+        self.genealogy = []
+        self.scores = {'red': 0, 'blue': 0, 'gold': 0}
+        
+    def _generate_resources(self):
+        """Генерация всех типов ресурсов"""
+        # Деревья (дают древесину и немного еды)
+        for _ in range(35):
+            x, y = self._random_free_cell()
+            self.grid[x, y] = [34, 139, 34]
+            self.resources['trees'].append((x, y))
+            
+        # Ягоды/еда (дают много еды)
+        for _ in range(25):
+            x, y = self._random_free_cell()
+            self.grid[x, y] = [0, 150, 0]
+            self.resources['food'].append((x, y))
+            
+        # Камни (стройматериалы)
+        for _ in range(20):
+            x, y = self._random_free_cell()
+            self.grid[x, y] = [128, 128, 128]
+            self.resources['stones'].append((x, y))
+            
+        # Металл (улучшенные материалы)
+        for _ in range(10):
+            x, y = self._random_free_cell()
+            self.grid[x, y] = [192, 192, 192]
+            self.resources['metal'].append((x, y))
+            
+        # Вода (источник жизни)
+        for _ in range(8):
+            x, y = self._random_free_cell()
+            self.grid[x, y] = [0, 100, 255]
+            self.resources['water'].append((x, y))
+    
+    def _random_free_cell(self):
+        attempts = 100
+        for _ in range(attempts):
+            x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+            if np.array_equal(self.grid[x, y], [100, 200, 100]):
+                return x, y
+        return random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+    
+    def _spawn_creature(self, x, y, color, team):
+        brain = AdvancedBrain()
+        creature = Creature(x, y, color, brain)
+        creature.team = team
+        self.creatures.append(creature)
+        return creature
+    
+    def step(self):
+        self.step_count += 1
+        
+        # 1. Существа действуют
+        new_creatures = []
+        for creature in self.creatures[:]:
+            if not creature.alive:
+                continue
+            
+            # Взаимодействия с миром
+            creature.eat_food(self.grid)
+            creature.drink_water(self.grid)
+            creature.collect_stone(self.grid)
+            creature.mine_metal(self.grid)
+            
+            # Мышление
+            child = creature.think(self.grid, self.creatures)
+            if child:
+                new_creatures.append(child)
+            
+            # Обновление
+            if not creature.update():
+                creature.alive = False
+                self.grid[creature.x, creature.y] = [200, 100, 100]
+                # Добавляем в генеалогию
+                self.genealogy.append({
+                    'id': creature.genome_id,
+                    'generation': creature.generation,
+                    'fitness': creature.fitness,
+                    'children': creature.children,
+                    'team': getattr(creature, 'team', 'unknown'),
+                    'ancestors': creature.ancestors[-5:]
+                })
+        
+        self.creatures.extend(new_creatures)
+        self.creatures = [c for c in self.creatures if c.alive]
+        
+        # 2. Обновление ресурсов
+        if self.step_count % RESPAWN_RATE == 0:
+            self._respawn_resources()
+        
+        # 3. Естественный отбор
+        if len(self.creatures) > MAX_CREATURES * 0.8:
+            self.creatures.sort(key=lambda c: c.fitness, reverse=True)
+            survivors = int(len(self.creatures) * 0.6)
+            for creature in self.creatures[survivors:]:
+                creature.alive = False
+            self.creatures = [c for c in self.creatures if c.alive]
+        
+        # 4. Соревновательный режим
+        if self.step_count % 50 == 0:
+            self._update_scores()
+        
+        # 5. Сохраняем статистику
+        self.best_fitness_history.append(
+            max([c.fitness for c in self.creatures if c.alive] + [0])
+        )
+        self.population_history.append(len(self.creatures))
+    
+    def _respawn_resources(self):
+        """Восстановление ресурсов"""
+        # Восстанавливаем еду
+        if len(self.resources['food']) < 20:
+            x, y = self._random_free_cell()
+            if x is not None:
+                self.grid[x, y] = [0, 150, 0]
+                self.resources['food'].append((x, y))
+        
+        # Восстанавливаем деревья
+        if len(self.resources['trees']) < 30:
+            x, y = self._random_free_cell()
+            if x is not None:
+                self.grid[x, y] = [34, 139, 34]
+                self.resources['trees'].append((x, y))
+    
+    def _update_scores(self):
+        """Обновление соревновательных очков"""
+        for creature in self.creatures:
+            if not creature.alive:
+                continue
+            team = getattr(creature, 'team', 'unknown')
+            if team in self.scores:
+                self.scores[team] += creature.fitness / 100
+    
+    def render(self):
+        """2D рендеринг с расширенной информацией"""
+        img = Image.new('RGB', (WORLD_SIZE * CELL_SIZE, WORLD_SIZE * CELL_SIZE + 200), (50, 50, 50))
+        draw = ImageDraw.Draw(img)
+        
+        # Рендерим мир
+        for i in range(WORLD_SIZE):
+            for j in range(WORLD_SIZE):
+                x, y = i * CELL_SIZE, j * CELL_SIZE
+                color = tuple(self.grid[i, j].tolist())
+                draw.rectangle([x, y, x + CELL_SIZE, y + CELL_SIZE], fill=color)
+        
+        # Рисуем существ
+        for creature in self.creatures:
+            if not creature.alive:
+                continue
+            x, y = creature.x * CELL_SIZE, creature.y * CELL_SIZE
+            color = tuple(creature.color)
+            
+            # Тело с градиентом
+            draw.ellipse([x+1, y+1, x+CELL_SIZE-1, y+CELL_SIZE-1], 
+                        fill=color, outline=(255,255,255))
+            
+            # Показатели здоровья, еды, воды
+            health_w = (creature.health / 100) * CELL_SIZE
+            food_w = (creature.food / 100) * CELL_SIZE
+            water_w = (creature.water / 100) * CELL_SIZE
+            
+            # HP (красный)
+            draw.rectangle([x, y-6, x + health_w, y-4], fill=(255, 0, 0))
+            # Food (оранжевый)
+            draw.rectangle([x, y-4, x + food_w, y-2], fill=(255, 165, 0))
+            # Water (голубой)
+            draw.rectangle([x, y-2, x + water_w, y], fill=(0, 200, 255))
+            
+            # Ресурсы
+            info = ""
+            if creature.resources > 0:
+                info += f"🪨{creature.resources}"
+            if creature.metal > 0:
+                info += f"⚙️{creature.metal}"
+            if creature.children > 0:
+                info += f"👶{creature.children}"
+            
+            if info:
+                draw.text([x, y-CELL_SIZE-5], info, fill=(255,255,255), font_size=5)
+        
+        # Статистика внизу
+        y_offset = WORLD_SIZE * CELL_SIZE + 10
+        
+        # Общая статистика
+        red = sum(1 for c in self.creatures if c.alive and getattr(c, 'team', '') == 'red')
+        blue = sum(1 for c in self.creatures if c.alive and getattr(c, 'team', '') == 'blue')
+        gold = sum(1 for c in self.creatures if c.alive and getattr(c, 'team', '') == 'gold')
+        
+        draw.text([10, y_offset], f"Шаг: {self.step_count} | 👥: {len(self.creatures)}", fill=(255,255,255))
+        draw.text([10, y_offset + 20], f"🔴 Красные: {red} | 🔵 Синие: {blue} | 🟡 Золотые: {gold}", fill=(255,255,255))
+        draw.text([10, y_offset + 40], f"🌳 Деревья: {len(self.resources['trees'])} | 🫐 Еда: {len(self.resources['food'])}", fill=(255,255,255))
+        draw.text([10, y_offset + 60], f"🪨 Камни: {len(self.resources['stones'])} | ⚙️ Металл: {len(self.resources['metal'])} | 💧 Вода: {len(self.resources['water'])}", fill=(255,255,255))
+        
+        # Соревновательные очки
+        draw.text([10, y_offset + 80], f"🏆 Очки: Красные: {int(self.scores['red'])} | Синие: {int(self.scores['blue'])} | Золотые: {int(self.scores['gold'])}", fill=(255,255,255))
+        
+        # Лучший фитнес
+        best_fitness = max([c.fitness for c in self.creatures if c.alive] + [0])
+        draw.text([10, y_offset + 100], f"⭐ Лучший фитнес: {best_fitness:.1f}", fill=(255,255,255))
+        
+        return img
+    
+    def render_3d(self):
+        """Изометрический 3D вид (псевдо-3D)"""
+        # Создаем более крупное изображение для 3D
+        img = Image.new('RGB', (800, 600), (50, 50, 80))
+        draw = ImageDraw.Draw(img)
+        
+        # Изометрическая проекция
+        scale = 4
+        offset_x, offset_y = 400, 100
+        
+        for i in range(WORLD_SIZE):
+            for j in range(WORLD_SIZE):
+                # Изометрические координаты
+                x_iso = (i - j) * scale + offset_x
+                y_iso = (i + j) * scale / 2 + offset_y - self.iso_height[i, j] * 20
+                
+                color = tuple(self.grid[i, j].tolist())
+                # Тень в зависимости от высоты
+                brightness = 1.0 - self.iso_height[i, j] * 0.3
+                color = tuple(int(c * brightness) for c in color)
+                
+                # Рисуем ромб
+                points = [
+                    (x_iso, y_iso - 10),
+                    (x_iso + 10, y_iso + 5),
+                    (x_iso, y_iso + 20),
+                    (x_iso - 10, y_iso + 5)
+                ]
+                draw.polygon(points, fill=color, outline=(100,100,100))
+        
+        # Рисуем существ в 3D
+        for creature in self.creatures:
+            if not creature.alive:
+                continue
+            x_iso = (creature.x - creature.y) * scale + offset_x
+            y_iso = (creature.x + creature.y) * scale / 2 + offset_y - self.iso_height[creature.x, creature.y] * 20 - 15
+            
+            color = tuple(creature.color)
+            draw.ellipse([x_iso-8, y_iso-8, x_iso+8, y_iso+8], fill=color, outline=(255,255,255))
+            
+            # Показатели
+            draw.text([x_iso-10, y_iso-25], f"❤️{int(creature.health)}", fill=(255,255,255), font_size=8)
+        
+        # Легенда
+        draw.text([10, 10], "3D ВИД (изометрический)", fill=(255,255,255))
+        draw.text([10, 30], f"Существ: {len(self.creatures)}", fill=(255,255,255))
+        
+        return img
+    
+    def get_genealogy(self, limit=20):
+        """Возвращает древо эволюции"""
+        if not self.genealogy:
+            return "Нет данных о предках"
+        
+        recent = self.genealogy[-limit:]
+        text = "🧬 ДРЕВО ЭВОЛЮЦИИ (последние):\n\n"
+        
+        for i, genome in enumerate(recent):
+            text += f"#{i+1} Поколение {genome['generation']} | Команда: {genome['team']}\n"
+            text += f"   Фитнес: {genome['fitness']:.1f} | Детей: {genome['children']}\n"
+            if genome['ancestors']:
+                text += f"   Предки: {', '.join(genome['ancestors'][:3])}\n"
+            text += "\n"
+        
+        return text
+    
+    def get_best_model(self):
+        """Возвращает лучшую модель для сохранения"""
+        best = max([c for c in self.creatures if c.alive], key=lambda c: c.fitness, default=None)
+        if best:
+            filename = f"{SAVE_DIR}/best_model_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pth"
+            best.save(filename)
+            return filename
+        return None
 
-print("Модель загружена!")
+# ============== GRADIO ИНТЕРФЕЙС ==============
+world = World()
+simulation_running = False
 
-# Шаг 5. Функция генерации
-def generate_image(prompt, negative_prompt):
-    generator = torch.Generator(device=device).manual_seed(2021)
-    
-    with torch.no_grad():
-        image = pipe(
-            prompt=prompt,
-            negative_prompt=negative_prompt if negative_prompt else "",
-            width=512,
-            height=768,
-            num_inference_steps=10,
-            guidance_scale=11.0,
-            generator=generator,
-            eta=0.8
-        ).images[0]
+def run_simulation(steps, view_mode):
+    global world, simulation_running
     
-    # Постобработка
-    img_array = np.array(image)
-    noise = np.random.randint(-25, 25, img_array.shape, dtype=np.int16)
-    img_noisy = np.clip(img_array.astype(np.int16) + noise, 0, 255).astype(np.uint8)
+    if not simulation_running:
+        world = World()
+        simulation_running = True
     
-    img_final = Image.fromarray(img_noisy).filter(ImageFilter.GaussianBlur(radius=0.6))
+    images = []
+    stats = []
     
-    enhancer = ImageEnhance.Contrast(img_final)
-    img_final = enhancer.enhance(1.3)
+    for i in range(steps):
+        world.step()
+        
+        # Сбор статистики
+        red = sum(1 for c in world.creatures if c.alive and getattr(c, 'team', '') == 'red')
+        blue = sum(1 for c in world.creatures if c.alive and getattr(c, 'team', '') == 'blue')
+        gold = sum(1 for c in world.creatures if c.alive and getattr(c, 'team', '') == 'gold')
+        
+        stats.append({
+            'step': world.step_count,
+            'red': red,
+            'blue': blue,
+            'gold': gold,
+            'total': len(world.creatures),
+            'trees': len(world.resources['trees']),
+            'food': len(world.resources['food']),
+            'stones': len(world.resources['stones']),
+            'metal': len(world.resources['metal']),
+            'water': len(world.resources['water']),
+            'best_fitness': max([c.fitness for c in world.creatures if c.alive] + [0])
+        })
+        
+        # Рендеринг
+        if view_mode == "2D":
+            images.append(world.render())
+        else:
+            images.append(world.render_3d())
     
-    enhancer = ImageEnhance.Color(img_final)
-    img_final = enhancer.enhance(1.3)
+    return images, stats
+
+def save_best_model():
+    """Сохранить лучшую модель"""
+    filename = world.get_best_model()
+    if filename:
+        return f"✅ Модель сохранена: {filename}"
+    return "❌ Нет живых существ для сохранения"
+
+def load_model(model_file):
+    """Загрузить модель"""
+    try:
+        creature = Creature.load(model_file.name, 
+                                random.randint(0, WORLD_SIZE-1),
+                                random.randint(0, WORLD_SIZE-1))
+        world.creatures.append(creature)
+        return f"✅ Модель загружена: {creature.genome_id}"
+    except Exception as e:
+        return f"❌ Ошибка загрузки: {str(e)}"
+
+def update_stats(stats):
+    if not stats:
+        return "Нет данных"
     
-    return img_final
+    last = stats[-1]
+    text = f"""
+📊 СТАТИСТИКА СИМУЛЯЦИИ:
 
-# Шаг 6. Интерфейс
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("#")
+Шаг: {last['step']}
+Всего существ: {last['total']}
+🔴 Красных: {last['red']}
+🔵 Синих: {last['blue']}
+🟡 Золотых: {last['gold']}
+
+🌳 Ресурсы:
+  Деревья: {last['trees']}
+  🫐 Еда: {last['food']}
+  🪨 Камни: {last['stones']}
+  ⚙️ Металл: {last['metal']}
+  💧 Вода: {last['water']}
+
+🏆 Лучший фитнес: {last['best_fitness']:.1f}
+
+📈 Популяция: {last['total']}
+    """
+    return text
+
+# Создаем интерфейс
+with gr.Blocks(title="🌍 Эволюционная симуляция 2.0", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🧬 ЭВОЛЮЦИОННАЯ СИМУЛЯЦИЯ 2.0
+    
+    ### С нейросетями, генетическим алгоритмом, 3D видом и расширенными ресурсами!
+    
+    **3 вида существ:** 🔴 Красные | 🔵 Синие | 🟡 Золотые (нейтральные)
+    
+    **Ресурсы:** 🌳 Деревья (еда+древесина) | 🫐 Ягоды (много еды) | 🪨 Камни (стройматериалы) | ⚙️ Металл (улучшения) | 💧 Вода (жизненно важна)
+    
+    **Что умеют существа:**
+    - 🍽️ Есть и пить
+    - 🏗️ Строить стены (каменные и металлические)
+    - 👶 Размножаться (половое и бесполое)
+    - ⚔️ Атаковать врагов
+    - ⛏️ Добывать ресурсы
+    - 🧬 Эволюционировать через генетический алгоритм
+    """)
     
     with gr.Row():
+        with gr.Column(scale=3):
+            gallery = gr.Gallery(label="Симуляция", columns=1, rows=1, height=800)
+            
         with gr.Column(scale=1):
-            prompt_input = gr.Textbox(
-                label="",
-                placeholder="Ваш промпт...",
-                lines=10
-            )
-            negative_input = gr.Textbox(
-                label="",
-                placeholder="Ваш негативный промпт...",
-                lines=5
-            )
-            generate_btn = gr.Button("Создать", variant="primary")
-        
-        with gr.Column(scale=2):
-            output = gr.Image(label="", type="pil", height=600)
+            stats_output = gr.Textbox(label="📊 Статистика", lines=20, interactive=False)
+            genealogy_output = gr.Textbox(label="🧬 Древо эволюции", lines=10, interactive=False)
+            
+            with gr.Row():
+                view_mode = gr.Radio(choices=["2D", "3D"], value="2D", label="Вид")
+            
+            with gr.Row():
+                steps_input = gr.Slider(label="Шагов", minimum=10, maximum=300, value=50, step=10)
+            
+            with gr.Row():
+                run_btn = gr.Button("▶️ Запустить", variant="primary")
+                reset_btn = gr.Button("🔄 Сбросить", variant="secondary")
+            
+            with gr.Row():
+                save_btn = gr.Button("💾 Сохранить лучшую")
+                load_btn = gr.UploadButton("📂 Загрузить модель", file_types=[".pth"])
+            
+            with gr.Row():
+                genealogy_btn = gr.Button("🧬 Показать древо")
+    
+    # Состояние
+    state = gr.State({"images": [], "stats": [], "genealogy": []})
+    
+    def run_action(steps, view_mode, state_data):
+        images, stats = run_simulation(steps, view_mode)
+        state_data["images"] = images
+        state_data["stats"] = stats
+        return images, update_stats(stats), state_data
+    
+    def reset_action(state_data):
+        global world
+        world = World()
+        state_data["images"] = []
+        state_data["stats"] = []
+        img = world.render()
+        return [img], update_stats([]), state_data
+    
+    def show_genealogy():
+        return world.get_genealogy()
+    
+    run_btn.click(
+        run_action,
+        inputs=[steps_input, view_mode, state],
+        outputs=[gallery, stats_output, state]
+    )
+    
+    reset_btn.click(
+        reset_action,
+        inputs=[state],
+        outputs=[gallery, stats_output, state]
+    )
+    
+    genealogy_btn.click(
+        show_genealogy,
+        outputs=[genealogy_output]
+    )
+    
+    save_btn.click(
+        save_best_model,
+        outputs=[gr.Textbox(label="Статус сохранения")]
+    )
     
-    generate_btn.click(
-        fn=generate_image,
-        inputs=[prompt_input, negative_input],
-        outputs=output
+    load_btn.upload(
+        load_model,
+        inputs=[load_btn],
+        outputs=[gr.Textbox(label="Статус загрузки")]
     )
 
-# Шаг 7. Запуск
-demo.launch(share=True, debug=False)
+# ============== ЗАПУСК ==============
+if __name__ == "__main__":
+    demo.launch()