Update app.py

app.py

@@ -3,113 +3,98 @@ 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
+from collections import deque
 import math
 from datetime import datetime
-import base64
-import io
+import os
+from PIL import Image, ImageDraw
 
 # ============== НАСТРОЙКИ ==============
-WORLD_SIZE = 80
-CELL_SIZE = 6
-MAX_CREATURES = 80
+WORLD_SIZE = 50
+CELL_SIZE = 8
+MAX_CREATURES = 60
 MUTATION_RATE = 0.2
 MUTATION_SCALE = 0.25
-RESPAWN_RATE = 3
+RESPAWN_RATE = 5
 SAVE_DIR = "saved_models"
 
 os.makedirs(SAVE_DIR, exist_ok=True)
 
-# ============== РАСШИРЕННАЯ НЕЙРОСЕТЬ ==============
-class AdvancedBrain(nn.Module):
-    def __init__(self, input_size=16, hidden_size=32, output_size=6):
+# ============== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ==============
+def is_grass(color):
+    """Проверка, является ли клетка травой"""
+    return int(color[0]) == 100 and int(color[1]) == 200 and int(color[2]) == 100
+
+def is_tree(color):
+    return int(color[0]) == 34 and int(color[1]) == 139 and int(color[2]) == 34
+
+def is_food(color):
+    return int(color[0]) == 0 and int(color[1]) == 150 and int(color[2]) == 0
+
+def is_stone(color):
+    return int(color[0]) == 128 and int(color[1]) == 128 and int(color[2]) == 128
+
+def is_metal(color):
+    return int(color[0]) == 192 and int(color[1]) == 192 and int(color[2]) == 192
+
+def is_water(color):
+    return int(color[0]) == 0 and int(color[1]) == 100 and int(color[2]) == 255
+
+def is_wall(color):
+    return int(color[0]) == 139 and int(color[1]) == 69 and int(color[2]) == 19
+
+# ============== НЕЙРОСЕТЬ ==============
+class CreatureBrain(nn.Module):
+    def __init__(self, input_size=14, hidden_size=20, 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)
+        self.fc2 = nn.Linear(hidden_size, hidden_size)
+        self.fc3 = nn.Linear(hidden_size, output_size)
+        self.dropout = nn.Dropout(0.1)
         
     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
+        x = torch.tanh(self.fc3(x))
         return x
 
-# ============== ГЕНЕТИЧЕСКИЙ АЛГОРИТМ ==============
-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
-
-# ============== СУЩЕСТВО С ГЕНАМИ ==============
+# ============== СУЩЕСТВО ==============
 class Creature:
-    def __init__(self, x, y, color, brain=None, generation=0, genome_id=None):
+    def __init__(self, x, y, color, brain=None, generation=0, team="neutral"):
         self.x = x
         self.y = y
         self.color = color
+        self.team = team
         self.generation = generation
-        self.genome_id = genome_id or f"{datetime.now().timestamp()}{random.randint(1000,9999)}"
-        self.parent_id = None
+        self.genome_id = f"{datetime.now().timestamp()}{random.randint(1000,9999)}"
         
-        # Основные ресурсы
+        # Ресурсы
         self.health = 100.0
         self.energy = 80.0
-        self.food = 50.0  # НОВЫЙ ресурс - ЕДА в желудке
+        self.food = 50.0
+        self.water = 50.0
         self.resources = 0  # камни
-        self.metal = 0  # НОВЫЙ ресурс - металл
-        self.water = 50.0  # НОВЫЙ ресурс - вода
-        
+        self.metal = 0
         self.age = 0
         self.alive = True
         self.fitness = 0
         self.children = 0
         
         # Память
-        self.memory = deque(maxlen=10)
-        self.last_action = np.zeros(6)
+        self.memory = deque(maxlen=5)
         
         # Нейросеть
         if brain is None:
-            self.brain = AdvancedBrain()
+            self.brain = CreatureBrain()
         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)
@@ -118,101 +103,98 @@ class Creature:
         resources = self.resources / 10.0
         metal = self.metal / 5.0
         
-        # 2. Обзор (12 направлений с разными дистанциями)
-        view_radius = 3
+        # 2. Обзор вокруг (8 направлений)
         nearby = []
-        for dx in range(-view_radius, view_radius + 1):
-            for dy in range(-view_radius, view_radius + 1):
+        for dx in [-1, 0, 1]:
+            for dy in [-1, 0, 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]):  # дерево
+                    cell_color = world.grid[nx, ny]
+                    if is_tree(cell_color):
                         nearby.append(1.0)
-                    elif np.array_equal(cell, [0, 150, 0]):  # еда (ягоды)
+                    elif is_food(cell_color):
                         nearby.append(2.0)
-                    elif np.array_equal(cell, [128, 128, 128]):  # камень
+                    elif is_stone(cell_color):
                         nearby.append(0.5)
-                    elif np.array_equal(cell, [192, 192, 192]):  # металл
+                    elif is_metal(cell_color):
                         nearby.append(3.0)
-                    elif np.array_equal(cell, [0, 100, 255]):  # вода
+                    elif is_water(cell_color):
                         nearby.append(4.0)
                     else:
                         nearby.append(0.0)
                 else:
                     nearby.append(0.0)
         
-        # 3. Ближайшие существа (сородичи и враги)
+        # 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)
+            if dist < 5:
+                if other.team == self.team:
+                    partners.append(1.0 - dist/5.0)
                 else:
-                    enemies.append(1.0 - dist/8.0)
+                    enemies.append(1.0 - dist/5.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([
+        # Формируем входной вектор
+        inputs = [
             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)
+            self.generation / 50.0
+        ]
+        
+        # Добавляем обзор (берем первые 4 направления для экономии)
+        inputs.extend(nearby[:4])
+        
+        # Добавляем память
+        memory_flat = []
+        for mem in self.memory:
+            memory_flat.extend(mem[:2])
+        while len(memory_flat) < 4:
+            memory_flat.append(0.0)
+        inputs.extend(memory_flat[:4])
         
         # Обрезаем до нужного размера
-        if len(inputs) > 16:
-            inputs = inputs[:16]
-        elif len(inputs) < 16:
-            inputs = np.pad(inputs, (0, 16 - len(inputs)))
+        inputs = inputs[:14]
+        while len(inputs) < 14:
+            inputs.append(0.0)
             
         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))
+        # Движение
+        dx = int(np.round(actions[0] * 2))
+        dy = int(np.round(actions[1] * 2))
         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)
             
@@ -222,94 +204,78 @@ class Creature:
         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
-            
-            # Строим вокруг себя
+        """Строительство стены"""
+        if self.resources >= 2:
+            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
+                    if is_grass(world.grid[nx, ny]):
+                        world.grid[nx, ny] = [139, 69, 19]  # стена
                         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]):
+        if is_metal(world.grid[self.x, self.y]):
             self.metal += 1
-            world.grid[self.x, self.y] = [100, 200, 100]  # трава
+            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):
+            if other is not self and other.alive and other.team == self.team:
                 dist = math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
-                if dist < 5 and other.food > 40:
+                if dist < 4 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:
+        if partner:
             # Половое размножение
-            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_brain = CreatureBrain()
+            # Смешиваем веса
+            for child_param, parent1_param, parent2_param in zip(
+                child_brain.parameters(),
+                self.brain.parameters(),
+                partner.brain.parameters()
+            ):
+                mask = torch.rand_like(parent1_param) > 0.5
+                child_param.data = torch.where(mask, parent1_param.data, parent2_param.data)
+                # Мутация
+                if random.random() < MUTATION_RATE:
+                    child_param.data += torch.randn_like(child_param) * MUTATION_SCALE
+        else:
+            # Бесполое размножение (клон с мутацией)
+            child_brain = CreatureBrain()
+            child_brain.load_state_dict(self.brain.state_dict())
+            for param in child_brain.parameters():
+                if random.random() < MUTATION_RATE * 1.5:
+                    param.data += torch.randn_like(param) * MUTATION_SCALE * 1.2
+        
+        child = Creature(
+            self.x + random.randint(-3, 3),
+            self.y + random.randint(-3, 3),
+            self.color,
+            brain=child_brain,
+            generation=self.generation + 1,
+            team=self.team
+        )
         child.food = 30
         child.water = 30
         child.energy = 40
@@ -323,32 +289,29 @@ class Creature:
         return child
     
     def attack(self, creatures):
-        """Атака с учетом силы"""
+        """Атака врага"""
         for other in creatures:
-            if other is not self and other.alive:
+            if other is not self and other.alive and other.team != self.team:
                 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)
+                if dist <= 1:
+                    damage = 10 + (self.health / 10)
                     other.health -= damage
                     self.energy -= 5
-                    self.food -= 3
+                    self.food -= 2
                     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]):  # ягоды
+        """Поедание еды"""
+        cell = world.grid[self.x, self.y]
+        if is_food(cell):
             self.food = min(100, self.food + 30)
             self.health = min(100, self.health + 8)
-            world.grid[self.x, self.y] = [100, 200, 100]  # трава
+            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]):  # дерево
+        elif is_tree(cell):
             self.food = min(100, self.food + 15)
             self.health = min(100, self.health + 5)
             world.grid[self.x, self.y] = [100, 200, 100]
@@ -358,10 +321,9 @@ class Creature:
     
     def drink_water(self, world):
         """Питье воды"""
-        if np.array_equal(world.grid[self.x, self.y], [0, 100, 255]):  # вода
+        if is_water(world.grid[self.x, self.y]):
             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
@@ -369,7 +331,8 @@ class Creature:
         return False
     
     def collect_stone(self, world):
-        if np.array_equal(world.grid[self.x, self.y], [128, 128, 128]):
+        """Сбор камней"""
+        if is_stone(world.grid[self.x, self.y]):
             self.resources += 1
             world.grid[self.x, self.y] = [100, 200, 100]
             self.fitness += 10
@@ -377,235 +340,161 @@ class Creature:
         return False
     
     def update(self):
-        """Обновление состояния с новыми ресурсами"""
-        # Естественные потери
-        self.food -= 0.5
-        self.water -= 0.3
+        """Обновление состояния"""
+        self.food -= 0.3
+        self.water -= 0.2
         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:
+        if self.age > 500:
             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
 
-# ============== МИР С НОВЫМИ РЕСУРСАМИ ==============
+# ============== МИР ==============
 class World:
     def __init__(self):
-        self.grid = None
+        self.grid = np.zeros((WORLD_SIZE, WORLD_SIZE, 3), dtype=np.uint8)
+        self.grid[:, :] = [100, 200, 100]
         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.scores = {'red': 0, 'blue': 0, 'gold': 0}
+        self.genealogy = []
         
-        # Генерация ресурсов
         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}
+        self._spawn_creatures()
         
     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))
-            
-        # Камни (стройматериалы)
+            if x is not None:
+                self.grid[x, y] = [34, 139, 34]
+                self.resources['trees'].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):
+            if x is not None:
+                self.grid[x, y] = [0, 150, 0]
+                self.resources['food'].append((x, y))
+                
+        for _ in range(15):
             x, y = self._random_free_cell()
-            self.grid[x, y] = [192, 192, 192]
-            self.resources['metal'].append((x, y))
-            
-        # Вода (источник жизни)
+            if x is not None:
+                self.grid[x, y] = [128, 128, 128]
+                self.resources['stones'].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))
+            if x is not None:
+                self.grid[x, y] = [192, 192, 192]
+                self.resources['metal'].append((x, y))
+                
+        for _ in range(6):
+            x, y = self._random_free_cell()
+            if x is not None:
+                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]):
+        """Поиск свободной клетки"""
+        for _ in range(50):
+            x = random.randint(0, WORLD_SIZE-1)
+            y = random.randint(0, WORLD_SIZE-1)
+            if is_grass(self.grid[x, y]):
                 return x, y
-        return random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+        return None, None
     
-    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 _spawn_creatures(self):
+        """Создание существ"""
+        # Красный вид
+        brain1 = CreatureBrain()
+        c1 = Creature(10, 10, [255, 50, 50], brain1, team="red")
+        self.creatures.append(c1)
+        
+        # Синий вид
+        brain2 = CreatureBrain()
+        c2 = Creature(40, 40, [50, 50, 255], brain2, team="blue")
+        self.creatures.append(c2)
+        
+        # Золотой вид (нейтральный)
+        brain3 = CreatureBrain()
+        c3 = Creature(25, 25, [255, 215, 0], brain3, team="gold")
+        self.creatures.append(c3)
     
     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,
+                    'team': creature.team,
                     'generation': creature.generation,
                     'fitness': creature.fitness,
-                    'children': creature.children,
-                    'team': getattr(creature, 'team', 'unknown'),
-                    'ancestors': creature.ancestors[-5:]
+                    'children': creature.children
                 })
         
         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:
+            if len(self.resources['food']) < 15:
+                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']) < 20:
+                x, y = self._random_free_cell()
+                if x is not None:
+                    self.grid[x, y] = [34, 139, 34]
+                    self.resources['trees'].append((x, y))
+        
+        # Естес��венный отбор
+        if len(self.creatures) > MAX_CREATURES:
             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))
+            self.creatures = self.creatures[:int(MAX_CREATURES * 0.7)]
         
-        # Восстанавливаем деревья
-        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
+        # Обновление очков
+        if self.step_count % 20 == 0:
+            for creature in self.creatures:
+                if creature.alive:
+                    self.scores[creature.team] += creature.fitness / 100
     
     def render(self):
-        """2D рендеринг с расширенной информацией"""
-        img = Image.new('RGB', (WORLD_SIZE * CELL_SIZE, WORLD_SIZE * CELL_SIZE + 200), (50, 50, 50))
+        """Отрисовка мира"""
+        img = Image.new('RGB', (WORLD_SIZE * CELL_SIZE, WORLD_SIZE * CELL_SIZE + 120), (30, 30, 30))
         draw = ImageDraw.Draw(img)
         
-        # Рендерим мир
+        # Рисуем мир
         for i in range(WORLD_SIZE):
             for j in range(WORLD_SIZE):
                 x, y = i * CELL_SIZE, j * CELL_SIZE
@@ -619,136 +508,40 @@ class World:
             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')
+        red = sum(1 for c in self.creatures if c.alive and c.team == 'red')
+        blue = sum(1 for c in self.creatures if c.alive and c.team == 'blue')
+        gold = sum(1 for c in self.creatures if c.alive and 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))
+        draw.text([10, y_offset + 80], 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
 
 # ============== GRADIO ИНТЕРФЕЙС ==============
 world = World()
 simulation_running = False
 
-def run_simulation(steps, view_mode):
+def run_simulation(steps):
     global world, simulation_running
     
     if not simulation_running:
@@ -761,10 +554,9 @@ def run_simulation(steps, view_mode):
     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')
+        red = sum(1 for c in world.creatures if c.alive and c.team == 'red')
+        blue = sum(1 for c in world.creatures if c.alive and c.team == 'blue')
+        gold = sum(1 for c in world.creatures if c.alive and c.team == 'gold')
         
         stats.append({
             'step': world.step_count,
@@ -780,31 +572,16 @@ def run_simulation(steps, view_mode):
             'best_fitness': max([c.fitness for c in world.creatures if c.alive] + [0])
         })
         
-        # Рендеринг
-        if view_mode == "2D":
+        if i % 2 == 0:
             images.append(world.render())
-        else:
-            images.append(world.render_3d())
     
     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 reset_world():
+    global world, simulation_running
+    world = World()
+    simulation_running = False
+    return [world.render()], []
 
 def update_stats(stats):
     if not stats:
@@ -812,10 +589,10 @@ def update_stats(stats):
     
     last = stats[-1]
     text = f"""
-📊 СТАТИСТИКА СИМУЛЯЦИИ:
+📊 СТАТИСТИКА:
 
 Шаг: {last['step']}
-Всего существ: {last['total']}
+Всего: {last['total']}
 🔴 Красных: {last['red']}
 🔵 Синих: {last['blue']}
 🟡 Золотых: {last['gold']}
@@ -827,80 +604,51 @@ def update_stats(stats):
   ⚙️ Металл: {last['metal']}
   💧 Вода: {last['water']}
 
-🏆 Лучший фитнес: {last['best_fitness']:.1f}
-
-📈 Популяция: {last['total']}
+⭐ Лучший фитнес: {last['best_fitness']:.1f}
     """
     return text
 
-# Создаем интерфейс
-with gr.Blocks(title="🌍 Эволюционная симуляция 2.0", theme=gr.themes.Soft()) as demo:
+# ============== ИНТЕРФЕЙС ==============
+with gr.Blocks(title="🧬 Эволюционная симуляция", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🧬 ЭВОЛЮЦИОННАЯ СИМУЛЯЦИЯ 2.0
+    # 🧬 Эволюционная симуляция с нейросетями
     
-    ### С нейросетями, генетическим алгоритмом, 3D видом и расширенными ресурсами!
+    **3 вида:** 🔴 Красные | 🔵 Синие | 🟡 Золотые
     
-    **3 вида существ:** 🔴 Красные | 🔵 Синие | 🟡 Золотые (нейтральные)
-    
-    **Ресурсы:** 🌳 Деревья (еда+древесина) | 🫐 Ягоды (много еды) | 🪨 Камни (стройматериалы) | ⚙️ Металл (улучшения) | 💧 Вода (жизненно важна)
-    
-    **Что умеют существа:**
-    - 🍽️ Есть и пить
-    - 🏗️ Строить стены (каменные и металлические)
-    - 👶 Размножаться (половое и бесполое)
-    - ⚔️ Атаковать врагов
-    - ⛏️ Добывать ресурсы
-    - 🧬 Эволюционировать через генетический алгоритм
+    **Ресурсы:** 🌳 Деревья | 🫐 Ягоды | 🪨 Камни | ⚙️ Металл | 💧 Вода
     """)
     
     with gr.Row():
-        with gr.Column(scale=3):
-            gallery = gr.Gallery(label="Симуляция", columns=1, rows=1, height=800)
-            
+        with gr.Column(scale=2):
+            gallery = gr.Gallery(label="Мир", columns=1, rows=1, height=700)
+        
         with gr.Column(scale=1):
-            stats_output = gr.Textbox(label="📊 Статистика", lines=20, interactive=False)
-            genealogy_output = gr.Textbox(label="🧬 Древо эволюции", lines=10, interactive=False)
+            stats_output = gr.Textbox(label="Статистика", lines=15, 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)
+                steps_input = gr.Slider(label="Шагов", minimum=10, maximum=200, 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": []})
+    state = gr.State({"images": [], "stats": []})
     
-    def run_action(steps, view_mode, state_data):
-        images, stats = run_simulation(steps, view_mode)
+    def run_action(steps, state_data):
+        images, stats = run_simulation(steps)
         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()
+        images, stats = reset_world()
+        state_data["images"] = images
+        state_data["stats"] = stats
+        return images, update_stats(stats), state_data
     
     run_btn.click(
         run_action,
-        inputs=[steps_input, view_mode, state],
+        inputs=[steps_input, state],
         outputs=[gallery, stats_output, state]
     )
     
@@ -909,23 +657,7 @@ with gr.Blocks(title="🌍 Эволюционная симуляция 2.0", the
         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="Статус сохранения")]
-    )
-    
-    load_btn.upload(
-        load_model,
-        inputs=[load_btn],
-        outputs=[gr.Textbox(label="Статус загрузки")]
-    )
 
-# ============== ЗАПУСК ==============
+# ============== ЗАПУСК С share=False ==============
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(share=False)