Update app.py

app.py

@@ -1,89 +1,68 @@
 # app.py
 import gradio as gr
 import numpy as np
-import torch
-import torch.nn as nn
 import random
-from collections import deque
-import math
 from PIL import Image, ImageDraw
+import math
 
 # ============== НАСТРОЙКИ ==============
-WORLD_SIZE = 40
-CELL_SIZE = 10
-MAX_CREATURES = 40
-MUTATION_RATE = 0.2
-MUTATION_SCALE = 0.25
-RESPAWN_RATE = 5
-
-# ============== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ==============
-def is_grass(color):
-    return color[0] == 100 and color[1] == 200 and color[2] == 100
-
-def is_tree(color):
-    return color[0] == 34 and color[1] == 139 and color[2] == 34
-
-def is_food(color):
-    return color[0] == 0 and color[1] == 150 and color[2] == 0
+WORLD_SIZE = 30
+CELL_SIZE = 12
+MAX_CREATURES = 30
 
-def is_stone(color):
-    return color[0] == 128 and color[1] == 128 and color[2] == 128
-
-def is_metal(color):
-    return color[0] == 192 and color[1] == 192 and color[2] == 192
-
-def is_water(color):
-    return color[0] == 0 and color[1] == 100 and color[2] == 255
-
-# ============== НЕЙРОСЕТЬ ==============
-class CreatureBrain(nn.Module):
-    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)
-        
-    def forward(self, x):
-        x = torch.relu(self.fc1(x))
-        x = torch.relu(self.fc2(x))
-        x = torch.tanh(self.fc3(x))
-        return x
+# ============== ПРОСТАЯ НЕЙРОСЕТЬ (без PyTorch) ==============
+class SimpleBrain:
+    def __init__(self):
+        # Простая матрица весов
+        self.weights = np.random.randn(8, 5) * 0.5
+        self.bias = np.random.randn(5) * 0.5
+    
+    def forward(self, inputs):
+        # Простой перцептрон
+        x = np.array(inputs)
+        output = np.tanh(np.dot(x, self.weights) + self.bias)
+        return output
+    
+    def copy(self):
+        new_brain = SimpleBrain()
+        new_brain.weights = self.weights.copy()
+        new_brain.bias = self.bias.copy()
+        return new_brain
+    
+    def mutate(self, rate=0.2, scale=0.3):
+        if random.random() < rate:
+            self.weights += np.random.randn(*self.weights.shape) * scale
+        if random.random() < rate:
+            self.bias += np.random.randn(*self.bias.shape) * scale
 
 # ============== СУЩЕСТВО ==============
 class Creature:
-    def __init__(self, x, y, color, team, brain=None, generation=0):
+    def __init__(self, x, y, color, team, brain=None):
         self.x = x
         self.y = y
         self.color = color
         self.team = team
-        self.generation = generation
         
-        self.health = 100.0
-        self.energy = 80.0
-        self.food = 50.0
-        self.water = 50.0
+        self.health = 100
+        self.energy = 80
+        self.food = 50
+        self.water = 50
         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.brain = brain if brain else SimpleBrain()
     
-    def get_inputs(self, world, creatures):
-        # Состояние
+    def think(self, world, creatures):
+        # Собираем входные данные
         hunger = 1.0 - self.food / 100.0
         thirst = 1.0 - self.water / 100.0
         health = self.health / 100.0
         energy = self.energy / 100.0
         
-        # Обзор вокруг
+        # Смотрим вокруг
         nearby = []
         for dx in [-1, 0, 1]:
             for dy in [-1, 0, 1]:
@@ -92,83 +71,56 @@ class Creature:
                 nx, ny = self.x + dx, self.y + dy
                 if 0 <= nx < WORLD_SIZE and 0 <= ny < WORLD_SIZE:
                     cell = world[nx, ny]
-                    if is_tree(cell):
+                    if cell[0] == 34 and cell[1] == 139 and cell[2] == 34:
                         nearby.append(1.0)
-                    elif is_food(cell):
+                    elif cell[0] == 0 and cell[1] == 150 and cell[2] == 0:
                         nearby.append(2.0)
-                    elif is_stone(cell):
+                    elif cell[0] == 128 and cell[1] == 128 and cell[2] == 128:
                         nearby.append(0.5)
-                    elif is_metal(cell):
-                        nearby.append(3.0)
-                    elif is_water(cell):
-                        nearby.append(4.0)
                     else:
                         nearby.append(0.0)
                 else:
                     nearby.append(0.0)
         
-        # Ближайшие существа
+        # Ищем врагов и друзей
         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 < 4:
+            dist = abs(self.x - other.x) + abs(self.y - other.y)
+            if dist < 3:
                 if other.team == self.team:
-                    partners = max(partners, 1.0 - dist/4.0)
+                    partners = max(partners, 1.0 - dist/3.0)
                 else:
-                    enemies = max(enemies, 1.0 - dist/4.0)
+                    enemies = max(enemies, 1.0 - dist/3.0)
         
-        # Формируем вход
+        # Входные данные (8 признаков)
         inputs = [hunger, thirst, health, energy, partners, enemies]
-        inputs.extend(nearby[:6])
-        
-        # Добавляем память
-        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])
+        inputs.extend(nearby[:4])  # берем первые 4 направления
         
-        # Обрезаем до нужного размера
-        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)
+        # Прогоняем через нейросеть
+        output = self.brain.forward(inputs)
         
-        with torch.no_grad():
-            output = self.brain(inputs.unsqueeze(0)).squeeze().numpy()
+        # Декодируем действия
+        dx = int(round(output[0] * 2))
+        dy = int(round(output[1] * 2))
+        build = output[2] > 0.3
+        reproduce = output[3] > 0.5
+        attack = output[4] > 0.4
         
-        actions = np.clip(output, -1, 1)
-        self.memory.append(actions.copy())
-        
-        # Движение
-        dx = int(np.round(actions[0] * 2))
-        dy = int(np.round(actions[1] * 2))
+        # Выполняем действия
         self.move(dx, dy)
         
-        # Строительство
-        if actions[2] > 0.3 and self.resources >= 2:
+        if build and self.resources >= 2:
             self.build(world)
         
-        # Размножение
-        if actions[3] > 0.5 and self.food > 50 and self.energy > 60:
+        if reproduce and self.food > 50 and self.energy > 60:
             return self.reproduce(creatures)
         
-        # Атака
-        if actions[4] > 0.4:
+        if attack:
             self.attack(creatures)
         
-        # Добыча металла
-        if actions[5] > 0.5:
-            self.mine_metal(world)
-            
         return None
     
     def move(self, dx, dy):
@@ -184,59 +136,27 @@ class Creature:
         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]):
+                cell = world[nx, ny]
+                if cell[0] == 100 and cell[1] == 200 and cell[2] == 100:
                     world[nx, ny] = [139, 69, 19]
                     self.fitness += 15
                     return True
         return False
     
-    def mine_metal(self, world):
-        if is_metal(world[self.x, self.y]):
-            self.metal += 1
-            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
         
-        # Ищем партнера
-        partner = None
-        for other in creatures:
-            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 < 4 and other.food > 40:
-                    partner = other
-                    break
-        
-        if partner:
-            child_brain = CreatureBrain()
-            for child_param, p1_param, p2_param in zip(
-                child_brain.parameters(),
-                self.brain.parameters(),
-                partner.brain.parameters()
-            ):
-                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():
-                if random.random() < MUTATION_RATE * 1.5:
-                    param.data += torch.randn_like(param) * MUTATION_SCALE * 1.2
+        # Создаем ребенка
+        child_brain = self.brain.copy()
+        child_brain.mutate()
         
         child = Creature(
-            self.x + random.randint(-3, 3),
-            self.y + random.randint(-3, 3),
+            self.x + random.randint(-2, 2),
+            self.y + random.randint(-2, 2),
             self.color,
             self.team,
-            child_brain,
-            self.generation + 1
+            child_brain
         )
         child.food = 30
         child.water = 30
@@ -255,22 +175,22 @@ class Creature:
             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:
-                    other.health -= 10 + self.health / 10
+                    other.health -= 15
                     self.energy -= 5
                     self.food -= 2
                     self.fitness += 8
                     return True
         return False
     
-    def eat_food(self, world):
+    def eat(self, world):
         cell = world[self.x, self.y]
-        if is_food(cell):
+        if cell[0] == 0 and cell[1] == 150 and cell[2] == 0:
             self.food = min(100, self.food + 30)
             self.health = min(100, self.health + 8)
             world[self.x, self.y] = [100, 200, 100]
             self.fitness += 12
             return True
-        elif is_tree(cell):
+        elif cell[0] == 34 and cell[1] == 139 and cell[2] == 34:
             self.food = min(100, self.food + 15)
             self.health = min(100, self.health + 5)
             world[self.x, self.y] = [100, 200, 100]
@@ -278,8 +198,9 @@ class Creature:
             return True
         return False
     
-    def drink_water(self, world):
-        if is_water(world[self.x, self.y]):
+    def drink(self, world):
+        cell = world[self.x, self.y]
+        if cell[0] == 0 and cell[1] == 100 and cell[2] == 255:
             self.water = min(100, self.water + 40)
             self.health = min(100, self.health + 5)
             if random.random() < 0.3:
@@ -289,7 +210,8 @@ class Creature:
         return False
     
     def collect_stone(self, world):
-        if is_stone(world[self.x, self.y]):
+        cell = world[self.x, self.y]
+        if cell[0] == 128 and cell[1] == 128 and cell[2] == 128:
             self.resources += 1
             world[self.x, self.y] = [100, 200, 100]
             self.fitness += 10
@@ -306,82 +228,78 @@ class Creature:
             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:
+        
+        if self.health <= 0 or self.energy <= 0:
             self.alive = False
             return False
-            
-        if self.age > 500:
+        
+        if self.age > 300:
             self.alive = False
             return False
-            
+        
         return True
 
-# ============== СИМУЛЯЦИЯ ==============
+# ============== СОЗДАНИЕ МИРА ==============
 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):
+    for _ in range(15):
+        for _ in range(30):
             x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
-            if is_grass(world[x, y]):
+            if world[x, y][0] == 100 and world[x, y][1] == 200 and world[x, y][2] == 100:
                 world[x, y] = [34, 139, 34]
                 break
     
-    for _ in range(15):
-        for _ in range(50):
+    for _ in range(12):
+        for _ in range(30):
             x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
-            if is_grass(world[x, y]):
+            if world[x, y][0] == 100 and world[x, y][1] == 200 and world[x, y][2] == 100:
                 world[x, y] = [0, 150, 0]
                 break
     
-    for _ in range(10):
-        for _ in range(50):
+    for _ in range(8):
+        for _ in range(30):
             x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
-            if is_grass(world[x, y]):
+            if world[x, y][0] == 100 and world[x, y][1] == 200 and world[x, y][2] == 100:
                 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):
+        for _ in range(30):
             x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
-            if is_grass(world[x, y]):
+            if world[x, y][0] == 100 and world[x, y][1] == 200 and world[x, y][2] == 100:
                 world[x, y] = [0, 100, 255]
                 break
     
     # Существа
     creatures = []
     
-    c1 = Creature(10, 10, [255, 50, 50], "red")
+    # Красный вид
+    c1 = Creature(5, 5, [255, 50, 50], "red")
     creatures.append(c1)
     
-    c2 = Creature(30, 30, [50, 50, 255], "blue")
+    # Синий вид
+    c2 = Creature(25, 25, [50, 50, 255], "blue")
     creatures.append(c2)
     
-    c3 = Creature(20, 20, [255, 215, 0], "gold")
+    # Золотой вид
+    c3 = Creature(15, 15, [255, 215, 0], "gold")
     creatures.append(c3)
     
     return world, creatures
 
-# ============== ОСНОВНАЯ ФУНКЦИЯ ==============
-def simulate_step(world, creatures, step_count):
+# ============== ШАГ СИМУЛЯЦИИ ==============
+def simulate_step(world, creatures, step):
     new_creatures = []
     
     for creature in creatures[:]:
         if not creature.alive:
             continue
         
-        creature.eat_food(world)
-        creature.drink_water(world)
+        creature.eat(world)
+        creature.drink(world)
         creature.collect_stone(world)
         
         child = creature.think(world, creatures)
@@ -396,11 +314,11 @@ def simulate_step(world, creatures, step_count):
     creatures = [c for c in creatures if c.alive]
     
     # Восстановление ресурсов
-    if step_count % RESPAWN_RATE == 0:
+    if step % 5 == 0:
         for _ in range(2):
-            for _ in range(30):
+            for _ in range(20):
                 x, y = random.randint(0, WORLD_SIZE-1), random.randint(0, WORLD_SIZE-1)
-                if is_grass(world[x, y]):
+                if world[x, y][0] == 100 and world[x, y][1] == 200 and world[x, y][2] == 100:
                     world[x, y] = [0, 150, 0]
                     break
     
@@ -413,29 +331,31 @@ def simulate_step(world, creatures, step_count):
     
     return world, creatures
 
-# ============== РЕНДЕРИНГ ==============
-def render_world(world, creatures, step_count):
-    img = Image.new('RGB', (WORLD_SIZE * CELL_SIZE, WORLD_SIZE * CELL_SIZE + 100), (30, 30, 30))
+# ============== ОТРИСОВКА ==============
+def render_world(world, creatures, step):
+    img = Image.new('RGB', (WORLD_SIZE * CELL_SIZE, WORLD_SIZE * CELL_SIZE + 80), (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]))
+            color = tuple(world[i, j].tolist())
+            draw.rectangle([x, y, x + CELL_SIZE, y + CELL_SIZE], fill=color)
     
     # Существа
     for creature in 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=tuple(creature.color), outline=(255,255,255))
+                    fill=color, outline=(255,255,255))
         
         # Индикаторы
-        hw = (creature.health / 100) * CELL_SIZE
-        fw = (creature.food / 100) * CELL_SIZE
-        ww = (creature.water / 100) * CELL_SIZE
+        hw = int((creature.health / 100) * CELL_SIZE)
+        fw = int((creature.food / 100) * CELL_SIZE)
+        ww = int((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))
@@ -448,37 +368,37 @@ def render_world(world, creatures, step_count):
     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]))
+    trees = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) 
+                if world[i, j][0] == 34 and world[i, j][1] == 139 and world[i, j][2] == 34)
+    foods = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) 
+                if world[i, j][0] == 0 and world[i, j][1] == 150 and world[i, j][2] == 0)
+    stones = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) 
+                 if world[i, j][0] == 128 and world[i, j][1] == 128 and world[i, j][2] == 128)
     
     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))
+    draw.text([10, y_offset], f"Шаг: {step} | Существ: {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}", fill=(255,255,255))
+    draw.text([10, y_offset + 60], f"⭐ Лучший фитнес: {best_fitness:.0f}", fill=(255,255,255))
     
     return img
 
-# ============== GRADIO ==============
+# ============== GRADIO ФУНКЦИИ ==============
 world, creatures = create_world()
-step_count = 0
+step_counter = 0
 
 def run_simulation(steps):
-    global world, creatures, step_count
+    global world, creatures, step_counter
     
     images = []
-    stats_text = ""
     
     for i in range(steps):
-        step_count += 1
-        world, creatures = simulate_step(world, creatures, step_count)
+        step_counter += 1
+        world, creatures = simulate_step(world, creatures, step_counter)
         
         if i % 2 == 0:
-            img = render_world(world, creatures, step_count)
+            img = render_world(world, creatures, step_counter)
             images.append(img)
     
     # Статистика
@@ -486,69 +406,69 @@ def run_simulation(steps):
     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]))
+    trees = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) 
+                if world[i, j][0] == 34 and world[i, j][1] == 139 and world[i, j][2] == 34)
+    foods = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) 
+                if world[i, j][0] == 0 and world[i, j][1] == 150 and world[i, j][2] == 0)
+    stones = sum(1 for i in range(WORLD_SIZE) for j in range(WORLD_SIZE) 
+                 if world[i, j][0] == 128 and world[i, j][1] == 128 and world[i, j][2] == 128)
+    
     best_fitness = max([c.fitness for c in creatures if c.alive] + [0])
     
-    stats_text = f"""
-📊 СТАТИСТИКА:
+    stats_text = f"""📊 СТАТИСТИКА
 
-Шаг: {step_count}
+Шаг: {step_counter}
 Существ: {len(creatures)}
+
 🔴 Красных: {red}
 🔵 Синих: {blue}
 🟡 Золотых: {gold}
 
-🌳 Ресурсы:
-  Деревья: {trees}
-  🫐 Еда: {foods}
-  🪨 Камни: {stones}
-  ⚙️ Металл: {metals}
-  💧 Вода: {waters}
+🌳 Деревьев: {trees}
+🫐 Ягод: {foods}
+🪨 Камней: {stones}
 
-⭐ Лучший фитнес: {best_fitness:.1f}
-    """
+⭐ Лучший фитнес: {best_fitness:.0f}"""
     
     return images, stats_text
 
 def reset_simulation():
-    global world, creatures, step_count
+    global world, creatures, step_counter
     world, creatures = create_world()
-    step_count = 0
-    img = render_world(world, creatures, step_count)
-    return [img], "Мир сброшен!"
+    step_counter = 0
+    img = render_world(world, creatures, 0)
+    return [img], "Мир сброшен! Нажмите 'Запустить'"
 
 # ============== ИНТЕРФЕЙС ==============
-with gr.Blocks(title="🧬 Эволюционная симуляция") as demo:
+with gr.Blocks(title="🧬 Эволюция") as demo:
     gr.Markdown("""
-    # 🧬 Эволюционная симуляция с нейросетями
+    # 🧬 Эволюционная симуляция
     
-    🔴 Красные | 🔵 Синие | 🟡 Золотые
+    🔴 Красные  |  🔵 Синие  |  🟡 Золотые
     
-    🍽️ Едят, 💧 пьют, 🏗️ строят, ⚔️ воюют, 👶 размножаются!
+    Существа **едят**, **пьют**, **строят**, **воюют** и **размножаются**!
     """)
     
     with gr.Row():
-        gallery = gr.Gallery(label="Мир", columns=1, rows=1, height=600)
-        stats = gr.Textbox(label="Статистика", lines=18, interactive=False)
+        gallery = gr.Gallery(label="Мир", columns=1, rows=1, height=500)
+        stats = gr.Textbox(label="Статистика", lines=20, interactive=False)
     
     with gr.Row():
-        steps = gr.Slider(label="Шагов", minimum=10, maximum=100, value=30, step=5)
+        steps = gr.Slider(label="Шагов", minimum=5, maximum=50, value=20, 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_simulation,
+        inputs=[steps],
+        outputs=[gallery, stats]
+    )
     
-    run_btn.click(run_action, inputs=[steps], outputs=[gallery, stats])
-    reset_btn.click(reset_action, outputs=[gallery, stats])
+    reset_btn.click(
+        reset_simulation,
+        outputs=[gallery, stats]
+    )
 
 # ============== ЗАПУСК ==============
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(share=False)