Update app.py

app.py

@@ -6,104 +6,84 @@ import torch.nn as nn
 import random
 from collections import deque
 import math
-from datetime import datetime
-import os
 from PIL import Image, ImageDraw
 
 # ============== НАСТРОЙКИ ==============
-WORLD_SIZE = 50
-CELL_SIZE = 8
-MAX_CREATURES = 60
+WORLD_SIZE = 40
+CELL_SIZE = 10
+MAX_CREATURES = 40
 MUTATION_RATE = 0.2
 MUTATION_SCALE = 0.25
 RESPAWN_RATE = 5
-SAVE_DIR = "saved_models"
-
-os.makedirs(SAVE_DIR, exist_ok=True)
 
 # ============== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ==============
 def is_grass(color):
-    """Проверка, является ли клетка травой"""
-    return int(color[0]) == 100 and int(color[1]) == 200 and int(color[2]) == 100
+    return color[0] == 100 and color[1] == 200 and color[2] == 100
 
 def is_tree(color):
-    return int(color[0]) == 34 and int(color[1]) == 139 and int(color[2]) == 34
+    return color[0] == 34 and color[1] == 139 and color[2] == 34
 
 def is_food(color):
-    return int(color[0]) == 0 and int(color[1]) == 150 and int(color[2]) == 0
+    return color[0] == 0 and color[1] == 150 and color[2] == 0
 
 def is_stone(color):
-    return int(color[0]) == 128 and int(color[1]) == 128 and int(color[2]) == 128
+    return color[0] == 128 and color[1] == 128 and color[2] == 128
 
 def is_metal(color):
-    return int(color[0]) == 192 and int(color[1]) == 192 and int(color[2]) == 192
+    return color[0] == 192 and color[1] == 192 and 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
+    return color[0] == 0 and color[1] == 100 and color[2] == 255
 
 # ============== НЕЙРОСЕТЬ ==============
 class CreatureBrain(nn.Module):
-    def __init__(self, input_size=14, hidden_size=20, output_size=6):
+    def __init__(self, input_size=12, hidden_size=16, output_size=6):
         super().__init__()
         self.fc1 = nn.Linear(input_size, 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 = torch.tanh(self.fc3(x))
         return x
 
 # ============== СУЩЕСТВО ==============
 class Creature:
-    def __init__(self, x, y, color, brain=None, generation=0, team="neutral"):
+    def __init__(self, x, y, color, team, brain=None, generation=0):
         self.x = x
         self.y = y
         self.color = color
         self.team = team
         self.generation = generation
-        self.genome_id = f"{datetime.now().timestamp()}{random.randint(1000,9999)}"
         
-        # Ресурсы
         self.health = 100.0
         self.energy = 80.0
         self.food = 50.0
         self.water = 50.0
-        self.resources = 0  # камни
+        self.resources = 0
         self.metal = 0
         self.age = 0
         self.alive = True
         self.fitness = 0
         self.children = 0
         
-        # Память
         self.memory = deque(maxlen=5)
         
-        # Нейросеть
         if brain is None:
             self.brain = CreatureBrain()
         else:
             self.brain = brain
-            
-        self.ancestors = []
-        
+    
     def get_inputs(self, world, creatures):
-        """Сбор входных данных для нейросети"""
-        # 1. Состояние существа
-        hunger = 1.0 - (self.food / 100.0)
-        thirst = 1.0 - (self.water / 100.0)
+        # Состояние
+        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. Обзор вокруг (8 направлений)
+        # Обзор вокруг
         nearby = []
         for dx in [-1, 0, 1]:
             for dy in [-1, 0, 1]:
@@ -111,46 +91,38 @@ class Creature:
                     continue
                 nx, ny = self.x + dx, self.y + dy
                 if 0 <= nx < WORLD_SIZE and 0 <= ny < WORLD_SIZE:
-                    cell_color = world.grid[nx, ny]
-                    if is_tree(cell_color):
+                    cell = world[nx, ny]
+                    if is_tree(cell):
                         nearby.append(1.0)
-                    elif is_food(cell_color):
+                    elif is_food(cell):
                         nearby.append(2.0)
-                    elif is_stone(cell_color):
+                    elif is_stone(cell):
                         nearby.append(0.5)
-                    elif is_metal(cell_color):
+                    elif is_metal(cell):
                         nearby.append(3.0)
-                    elif is_water(cell_color):
+                    elif is_water(cell):
                         nearby.append(4.0)
                     else:
                         nearby.append(0.0)
                 else:
                     nearby.append(0.0)
         
-        # 3. Ближайшие существа
-        partners = []
-        enemies = []
+        # Ближайшие существа
+        partners = 0
+        enemies = 0
         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 < 5:
+            if dist < 4:
                 if other.team == self.team:
-                    partners.append(1.0 - dist/5.0)
+                    partners = max(partners, 1.0 - dist/4.0)
                 else:
-                    enemies.append(1.0 - dist/5.0)
+                    enemies = max(enemies, 1.0 - dist/4.0)
         
-        # Формируем входной вектор
-        inputs = [
-            hunger, thirst, health, energy, resources, metal,
-            max(partners) if partners else 0.0,
-            max(enemies) if enemies else 0.0,
-            self.children / 10.0,
-            self.generation / 50.0
-        ]
-        
-        # Добавляем обзор (берем первые 4 направления для экономии)
-        inputs.extend(nearby[:4])
+        # Формируем вход
+        inputs = [hunger, thirst, health, energy, partners, enemies]
+        inputs.extend(nearby[:6])
         
         # Добавляем память
         memory_flat = []
@@ -161,14 +133,13 @@ class Creature:
         inputs.extend(memory_flat[:4])
         
         # Обрезаем до нужного размера
-        inputs = inputs[:14]
-        while len(inputs) < 14:
+        inputs = inputs[:12]
+        while len(inputs) < 12:
             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():
@@ -183,7 +154,7 @@ class Creature:
         self.move(dx, dy)
         
         # Строительство
-        if actions[2] > 0.3:
+        if actions[2] > 0.3 and self.resources >= 2:
             self.build(world)
         
         # Размножение
@@ -201,39 +172,34 @@ class Creature:
         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.x = max(0, min(WORLD_SIZE-1, self.x + dx))
+        self.y = max(0, min(WORLD_SIZE-1, self.y + dy))
         self.energy -= 0.3
         self.food -= 0.2
         self.water -= 0.1
         self.age += 1
-        
+    
     def build(self, world):
-        """Строительство стены"""
-        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 is_grass(world.grid[nx, ny]):
-                        world.grid[nx, ny] = [139, 69, 19]  # стена
-                        self.fitness += 15
-                        return True
+        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 is_grass(world[nx, ny]):
+                    world[nx, ny] = [139, 69, 19]
+                    self.fitness += 15
+                    return True
         return False
     
     def mine_metal(self, world):
-        """Добыча металла"""
-        if is_metal(world.grid[self.x, self.y]):
+        if is_metal(world[self.x, self.y]):
             self.metal += 1
-            world.grid[self.x, self.y] = [100, 200, 100]
+            world[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
         
@@ -247,21 +213,17 @@ class Creature:
                     break
         
         if partner:
-            # Половое размножение
             child_brain = CreatureBrain()
-            # Смешиваем веса
-            for child_param, parent1_param, parent2_param in zip(
+            for child_param, p1_param, p2_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)
-                # Мутация
+                mask = torch.rand_like(p1_param) > 0.5
+                child_param.data = torch.where(mask, p1_param.data, p2_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():
@@ -272,9 +234,9 @@ class 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
+            self.team,
+            child_brain,
+            self.generation + 1
         )
         child.food = 30
         child.water = 30
@@ -289,13 +251,11 @@ class Creature:
         return child
     
     def attack(self, creatures):
-        """Атака врага"""
         for other in creatures:
             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:
-                    damage = 10 + (self.health / 10)
-                    other.health -= damage
+                    other.health -= 10 + self.health / 10
                     self.energy -= 5
                     self.food -= 2
                     self.fitness += 8
@@ -303,44 +263,40 @@ class Creature:
         return False
     
     def eat_food(self, world):
-        """Поедание еды"""
-        cell = world.grid[self.x, self.y]
+        cell = world[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[self.x, self.y] = [100, 200, 100]
             self.fitness += 12
             return True
         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]
+            world[self.x, self.y] = [100, 200, 100]
             self.fitness += 8
             return True
         return False
     
     def drink_water(self, world):
-        """Питье воды"""
-        if is_water(world.grid[self.x, self.y]):
+        if is_water(world[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]
+                world[self.x, self.y] = [100, 200, 100]
             self.fitness += 5
             return True
         return False
     
     def collect_stone(self, world):
-        """Сбор камней"""
-        if is_stone(world.grid[self.x, self.y]):
+        if is_stone(world[self.x, self.y]):
             self.resources += 1
-            world.grid[self.x, self.y] = [100, 200, 100]
+            world[self.x, self.y] = [100, 200, 100]
             self.fitness += 10
             return True
         return False
     
     def update(self):
-        """Обновление состояния"""
         self.food -= 0.3
         self.water -= 0.2
         self.health -= 0.1
@@ -361,303 +317,238 @@ class Creature:
             
         return True
 
-# ============== МИР ==============
-class World:
-    def __init__(self):
-        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.step_count = 0
-        self.scores = {'red': 0, 'blue': 0, 'gold': 0}
-        self.genealogy = []
-        
-        self._generate_resources()
-        self._spawn_creatures()
-        
-    def _generate_resources(self):
-        """Генерация ресурсов"""
-        for _ in range(25):
-            x, y = self._random_free_cell()
-            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()
-            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()
-            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()
-            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):
-        """Поиск свободной клетки"""
+# ============== СИМУЛЯЦИЯ ==============
+def create_world():
+    world = np.zeros((WORLD_SIZE, WORLD_SIZE, 3), dtype=np.uint8)
+    world[:, :] = [100, 200, 100]
+    
+    # Ресурсы
+    for _ in range(20):
         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 None, None
-    
-    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
-        
-        # Действия существ
-        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)
-            
-            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({
-                    'team': creature.team,
-                    'generation': creature.generation,
-                    'fitness': creature.fitness,
-                    'children': creature.children
-                })
-        
-        self.creatures.extend(new_creatures)
-        self.creatures = [c for c in self.creatures if c.alive]
-        
-        # Восстановление ресурсов
-        if self.step_count % RESPAWN_RATE == 0:
-            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)
-            self.creatures = self.creatures[:int(MAX_CREATURES * 0.7)]
-        
-        # Обновление очков
-        if self.step_count % 20 == 0:
-            for creature in self.creatures:
-                if creature.alive:
-                    self.scores[creature.team] += creature.fitness / 100
-    
-    def render(self):
-        """Отрисовка мира"""
-        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
-                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
-            
-            draw.rectangle([x, y-6, x + health_w, y-4], fill=(255, 0, 0))
-            draw.rectangle([x, y-4, x + food_w, y-2], fill=(255, 165, 0))
-            draw.rectangle([x, y-2, x + water_w, y], fill=(0, 200, 255))
-        
-        # Статистика
-        y_offset = WORLD_SIZE * CELL_SIZE + 10
-        
-        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')
+            x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+            if is_grass(world[x, y]):
+                world[x, y] = [34, 139, 34]
+                break
+    
+    for _ in range(15):
+        for _ in range(50):
+            x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+            if is_grass(world[x, y]):
+                world[x, y] = [0, 150, 0]
+                break
+    
+    for _ in range(10):
+        for _ in range(50):
+            x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+            if is_grass(world[x, y]):
+                world[x, y] = [128, 128, 128]
+                break
+    
+    for _ in range(5):
+        for _ in range(50):
+            x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+            if is_grass(world[x, y]):
+                world[x, y] = [192, 192, 192]
+                break
+    
+    for _ in range(4):
+        for _ in range(50):
+            x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+            if is_grass(world[x, y]):
+                world[x, y] = [0, 100, 255]
+                break
+    
+    # Существа
+    creatures = []
+    
+    c1 = Creature(10, 10, [255, 50, 50], "red")
+    creatures.append(c1)
+    
+    c2 = Creature(30, 30, [50, 50, 255], "blue")
+    creatures.append(c2)
+    
+    c3 = Creature(20, 20, [255, 215, 0], "gold")
+    creatures.append(c3)
+    
+    return world, creatures
+
+# ============== ОСНОВНАЯ ФУНКЦИЯ ==============
+def simulate_step(world, creatures, step_count):
+    new_creatures = []
+    
+    for creature in creatures[:]:
+        if not creature.alive:
+            continue
         
-        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))
+        creature.eat_food(world)
+        creature.drink_water(world)
+        creature.collect_stone(world)
         
-        best_fitness = max([c.fitness for c in self.creatures if c.alive] + [0])
-        draw.text([10, y_offset + 80], f"⭐ Лучший фитнес: {best_fitness:.1f}", fill=(255,255,255))
+        child = creature.think(world, creatures)
+        if child:
+            new_creatures.append(child)
         
-        return img
+        if not creature.update():
+            creature.alive = False
+            world[creature.x, creature.y] = [200, 100, 100]
+    
+    creatures.extend(new_creatures)
+    creatures = [c for c in creatures if c.alive]
+    
+    # Восстановление ресурсов
+    if step_count % RESPAWN_RATE == 0:
+        for _ in range(2):
+            for _ in range(30):
+                x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
+                if is_grass(world[x, y]):
+                    world[x, y] = [0, 150, 0]
+                    break
+    
+    # Естественный отбор
+    if len(creatures) > MAX_CREATURES:
+        creatures.sort(key=lambda c: c.fitness, reverse=True)
+        for c in creatures[MAX_CREATURES:]:
+            c.alive = False
+        creatures = [c for c in creatures if c.alive]
+    
+    return world, creatures
 
-# ============== GRADIO ИНТЕРФЕЙС ==============
-world = World()
-simulation_running = False
+# ============== РЕНДЕРИНГ ==============
+def render_world(world, creatures, step_count):
+    img = Image.new('RGB', (WORLD_SIZE * CELL_SIZE, WORLD_SIZE * CELL_SIZE + 100), (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
+            draw.rectangle([x, y, x + CELL_SIZE, y + CELL_SIZE], fill=tuple(world[i, j]))
+    
+    # Существа
+    for creature in creatures:
+        if not creature.alive:
+            continue
+        x, y = creature.x * CELL_SIZE, creature.y * CELL_SIZE
+        draw.ellipse([x+1, y+1, x+CELL_SIZE-1, y+CELL_SIZE-1], 
+                    fill=tuple(creature.color), outline=(255,255,255))
+        
+        # Индикаторы
+        hw = (creature.health / 100) * CELL_SIZE
+        fw = (creature.food / 100) * CELL_SIZE
+        ww = (creature.water / 100) * CELL_SIZE
+        
+        draw.rectangle([x, y-6, x + hw, y-4], fill=(255, 0, 0))
+        draw.rectangle([x, y-4, x + fw, y-2], fill=(255, 165, 0))
+        draw.rectangle([x, y-2, x + ww, y], fill=(0, 200, 255))
+    
+    # Статистика
+    y_offset = WORLD_SIZE * CELL_SIZE + 10
+    
+    red = sum(1 for c in creatures if c.alive and c.team == "red")
+    blue = sum(1 for c in creatures if c.alive and c.team == "blue")
+    gold = sum(1 for c in creatures if c.alive and c.team == "gold")
+    
+    trees = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_tree(world[i, j]))
+    foods = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_food(world[i, j]))
+    stones = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_stone(world[i, j]))
+    metals = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_metal(world[i, j]))
+    waters = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_water(world[i, j]))
+    
+    best_fitness = max([c.fitness for c in creatures if c.alive] + [0])
+    
+    draw.text([10, y_offset], f"Шаг: {step_count} | Существ: {len(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"🌳: {trees} | 🫐: {foods} | 🪨: {stones} | ⚙️: {metals} | 💧: {waters}", fill=(255,255,255))
+    draw.text([10, y_offset + 60], f"⭐ Лучший фитнес: {best_fitness:.1f}", fill=(255,255,255))
+    
+    return img
+
+# ============== GRADIO ==============
+world, creatures = create_world()
+step_count = 0
 
 def run_simulation(steps):
-    global world, simulation_running
-    
-    if not simulation_running:
-        world = World()
-        simulation_running = True
+    global world, creatures, step_count
     
     images = []
-    stats = []
+    stats_text = ""
     
     for i in range(steps):
-        world.step()
-        
-        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,
-            '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])
-        })
+        step_count += 1
+        world, creatures = simulate_step(world, creatures, step_count)
         
         if i % 2 == 0:
-            images.append(world.render())
+            img = render_world(world, creatures, step_count)
+            images.append(img)
     
-    return images, stats
-
-def reset_world():
-    global world, simulation_running
-    world = World()
-    simulation_running = False
-    return [world.render()], []
-
-def update_stats(stats):
-    if not stats:
-        return "Нет данных"
+    # Статистика
+    red = sum(1 for c in creatures if c.alive and c.team == "red")
+    blue = sum(1 for c in creatures if c.alive and c.team == "blue")
+    gold = sum(1 for c in creatures if c.alive and c.team == "gold")
     
-    last = stats[-1]
-    text = f"""
+    trees = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_tree(world[i, j]))
+    foods = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_food(world[i, j]))
+    stones = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_stone(world[i, j]))
+    metals = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_metal(world[i, j]))
+    waters = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) if is_water(world[i, j]))
+    best_fitness = max([c.fitness for c in creatures if c.alive] + [0])
+    
+    stats_text = f"""
 📊 СТАТИСТИКА:
 
-Шаг: {last['step']}
-Всего: {last['total']}
-🔴 Красных: {last['red']}
-🔵 Синих: {last['blue']}
-🟡 Золотых: {last['gold']}
+Шаг: {step_count}
+Существ: {len(creatures)}
+🔴 Красных: {red}
+🔵 Синих: {blue}
+🟡 Золотых: {gold}
 
 🌳 Ресурсы:
-  Деревья: {last['trees']}
-  🫐 Еда: {last['food']}
-  🪨 Камни: {last['stones']}
-  ⚙️ Металл: {last['metal']}
-  💧 Вода: {last['water']}
+  Деревья: {trees}
+  🫐 Еда: {foods}
+  🪨 Камни: {stones}
+  ⚙️ Металл: {metals}
+  💧 Вода: {waters}
 
-⭐ Лучший фитнес: {last['best_fitness']:.1f}
+⭐ Лучший фитнес: {best_fitness:.1f}
     """
-    return text
+    
+    return images, stats_text
+
+def reset_simulation():
+    global world, creatures, step_count
+    world, creatures = create_world()
+    step_count = 0
+    img = render_world(world, creatures, step_count)
+    return [img], "Мир сброшен!"
 
 # ============== ИНТЕРФЕЙС ==============
-with gr.Blocks(title="🧬 Эволюционная симуляция", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="🧬 Эволюционная симуляция") as demo:
     gr.Markdown("""
     # 🧬 Эволюционная симуляция с нейросетями
     
-    **3 вида:** 🔴 Красные | 🔵 Синие | 🟡 Золотые
+    🔴 Красные | 🔵 Синие | 🟡 Золотые
     
-    **Ресурсы:** 🌳 Деревья | 🫐 Ягоды | 🪨 Камни | ⚙️ Металл | 💧 Вода
+    🍽️ Едят, 💧 пьют, 🏗️ строят, ⚔️ воюют, 👶 размножаются!
     """)
     
     with gr.Row():
-        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=15, interactive=False)
-            
-            with gr.Row():
-                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")
-    
-    state = gr.State({"images": [], "stats": []})
-    
-    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):
-        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, state],
-        outputs=[gallery, stats_output, state]
-    )
-    
-    reset_btn.click(
-        reset_action,
-        inputs=[state],
-        outputs=[gallery, stats_output, state]
-    )
+        gallery = gr.Gallery(label="Мир", columns=1, rows=1, height=600)
+        stats = gr.Textbox(label="Статистика", lines=18, interactive=False)
+    
+    with gr.Row():
+        steps = gr.Slider(label="Шагов", minimum=10, maximum=100, value=30, step=5)
+        run_btn = gr.Button("▶️ Запустить", variant="primary")
+        reset_btn = gr.Button("🔄 Сбросить", variant="secondary")
+    
+    def run_action(steps_val):
+        return run_simulation(steps_val)
+    
+    def reset_action():
+        return reset_simulation()
+    
+    run_btn.click(run_action, inputs=[steps], outputs=[gallery, stats])
+    reset_btn.click(reset_action, outputs=[gallery, stats])
 
-# ============== ЗАПУСК С share=False ==============
+# ============== ЗАПУСК ==============
 if __name__ == "__main__":
-    demo.launch(share=False)
+    demo.launch(share=True)