Вот игра на Python, соответствующая вашим требованиям. Для графического отображения используется библиотека pygame.

python
import pygame
import random
import pickle
import os
import math

# Инициализация Pygame
pygame.init()

# Размеры экрана
WIDTH, HEIGHT = 1280, 720
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Эволюция существ")

# Цвета
PASTEL_BACKGROUND = (207, 226, 243)
PLANT_COLOR = (169, 169, 169)

# Загрузка опыта существ
if os.path.exists('experience.pkl'):
    with open('experience.pkl', 'rb') as f:
        saved_experience = pickle.load(f)
else:
    saved_experience = {}

# Классы существ
class Plant:
    def __init__(self):
        self.size = 5
        self.position = pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.color = PLANT_COLOR

    def draw(self):
        pygame.draw.circle(screen, self.color, self.position, self.size)

class Creature:
    def __init__(self, species, experience=None):
        self.species = species  # 'herbivore' или 'predator'
        self.energy = 100
        self.size = 10
        self.speed = 2
        self.position = pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.is_alive = True
        self.age = 0
        self.experience = experience if experience else {}

    def update(self, plants, creatures, corpses):
        if not self.is_alive:
            return

        self.age += 1
        self.energy -= 0.1  # Энергия тратится со временем

        # Изменение скорости в зависимости от размера
        self.speed = max(1, 5 - self.size / 20)

        # Поиск цели
        target = self.find_target(plants, creatures, corpses)
        if target:
            self.move_towards(target.position)
            if self.collide_with(target):
                self.eat(target)
        else:
            self.wander()

        if self.energy <= 0:
            self.die()

    def find_target(self, plants, creatures, corpses):
        visible_entities = plants + corpses
        if self.species == 'predator':
            visible_entities += [c for c in creatures if c.species == 'herbivore' and c.is_alive]

        if not visible_entities:
            return None

        # Простая логика поиска ближайшей цели
        visible_entities.sort(key=lambda e: self.position.distance_to(e.position))
        return visible_entities[0]

    def move_towards(self, target_pos):
        self.direction = (target_pos - self.position).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()

    def wander(self):
        if random.random() < 0.05:
            self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()

    def keep_within_bounds(self):
        self.position.x = max(0, min(WIDTH, self.position.x))
        self.position.y = max(0, min(HEIGHT, self.position.y))

    def collide_with(self, other):
        distance = self.position.distance_to(other.position)
        return distance < self.size + other.size

    def eat(self, target):
        if isinstance(target, Plant) and self.species == 'herbivore':
            plants.remove(target)
        elif isinstance(target, Creature) and self.species == 'predator':
            target.die()
        elif isinstance(target, Corpse) and self.species == 'predator':
            corpses.remove(target)
        else:
            return

        self.energy += 50
        self.size += 1
        self.spawn_offspring()

    def spawn_offspring(self):
        if self.species == 'herbivore':
            creatures.append(Creature('herbivore', self.experience))
        elif self.species == 'predator':
            creatures.append(Creature('predator', self.experience))

    def die(self):
        self.is_alive = False
        corpses.append(Corpse(self.position, self.size))

    def draw(self):
        if not self.is_alive:
            return

        # Цвет в зависимости от энергии
        if self.species == 'herbivore':
            energy_ratio = min(1, self.energy / 100)
            color = (0, int(255 * energy_ratio), 0)
        else:
            energy_ratio = min(1, self.energy / 100)
            color = (int(255 * energy_ratio), 0, 0)

        pygame.draw.circle(screen, color, self.position, self.size)

class Corpse:
    def __init__(self, position, size):
        self.position = position
        self.size = size
        self.decomposition = 100  # Степень разложения

    def update(self):
        self.decomposition -= 0.05
        if self.decomposition <= 0:
            corpses.remove(self)

    def draw(self):
        gray_scale = int(169 * (self.decomposition / 100))
        color = (gray_scale, gray_scale, gray_scale)
        pygame.draw.circle(screen, color, self.position, self.size)

# Списки сущностей
plants = [Plant() for _ in range(50)]
creatures = [Creature('herbivore') for _ in range(10)] + [Creature('predator') for _ in range(5)]
corpses = []

# Основной цикл
clock = pygame.time.Clock()
running = True

while running:
    clock.tick(60)  # Ограничение FPS для плавности
    screen.fill(PASTEL_BACKGROUND)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Обновление и отрисовка растений
    for plant in plants:
        plant.draw()

    # Обновление и отрисовка трупов
    for corpse in corpses:
        corpse.update()
        corpse.draw()

    # Обновление и отрисовка существ
    for creature in creatures:
        creature.update(plants, creatures, corpses)
        creature.draw()

    # Проверка конца симуляции
    if not any(c.is_alive for c in creatures):
        font = pygame.font.SysFont(None, 72)
        text = font.render("Все погибли", True, (0, 0, 0))
        screen.blit(text, (WIDTH // 2 - 150, HEIGHT // 2))
        pygame.display.flip()
        pygame.time.wait(3000)

        # Сохранение опыта (для простоты сохраняем возраст существ)
        for creature in creatures:
            saved_experience[creature.species] = creature.age

        with open('experience.pkl', 'wb') as f:
            pickle.dump(saved_experience, f)

        # Перезапуск симуляции
        plants = [Plant() for _ in range(50)]
        creatures = [Creature('herbivore', saved_experience.get('herbivore')) for _ in range(10)] + \
                    [Creature('predator', saved_experience.get('predator')) for _ in range(5)]
        corpses = []
        continue

    pygame.display.flip()

# Сохранение опыта при выходе
with open('experience.pkl', 'wb') as f:
    pickle.dump(saved_experience, f)

pygame.quit()

Объяснение:

• Классы:

  • Plant — представляет растения на поле.
  • Creature — базовый класс для травоядных и хищников.
  • Corpse — представляет трупы погибших существ.

• Существа:

  • Имеют энергию, которая уменьшается со временем и при передвижении.
  • Пополняют энергию при поедании пищи.
  • Увеличиваются в размерах при поедании пищи, скорость уменьшается с увеличением размера.
  • Размножаются при поедании пищи.
  • Умеют искать ближайшую цель для питания.

• Цветовая индикация:

  • Травоядные окрашены в зеленые тона, зависящие от энергии.
  • Хищники окрашены в красные тона, зависящие от энергии.
  • Растения серого цвета.
  • Трупы постепенно темнеют по мере разложения.

• Сохранение опыта:

  • При завершении симуляции сохраняется опыт существ в файл experience.pkl.
  • При запуске новой симуляции опыт загружается и передается новым существам.

Для запуска игры:

1. Убедитесь, что у вас установлен pygame:

   bash
   pip install pygame

2. Сохраните код в файл, например, evolution_game.py.

3. Запустите игру:

   bash
   python evolution_game.py

Примечание:

• Данный код является упрощенной моделью и может быть расширен для добавления более сложного интеллекта и обучения.
• Оптимизация и плавность обеспечиваются ограничением FPS и упрощенной логикой обновления сущностей.
• Если вы хотите самостоятельно прервать симуляцию, просто закройте окно игры — опыт существ будет сохранен для следующего запуска.

Извините за возникшую проблему. Ошибка EOFError: Ran out of input возникает, когда файл experience.pkl существует, но пуст или поврежден. В таком случае при попытке загрузить данные из него возникает ошибка, так как pickle не находит данных для чтения.

Чтобы исправить эту проблему, нужно добавить проверку на то, что файл не пуст, перед его загрузкой. Также можно обработать исключение EOFError, чтобы в случае ошибки инициализировать saved_experience пустым словарем.

Вот исправленный код:

python
import pygame
import random
import pickle
import os
import math

# Инициализация Pygame
pygame.init()

# Размеры экрана
WIDTH, HEIGHT = 1280, 720
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Эволюция существ")

# Цвета
PASTEL_BACKGROUND = (207, 226, 243)
PLANT_COLOR = (169, 169, 169)

# Загрузка опыта существ
saved_experience = {}
if os.path.exists('experience.pkl'):
    if os.path.getsize('experience.pkl') > 0:
        with open('experience.pkl', 'rb') as f:
            try:
                saved_experience = pickle.load(f)
            except EOFError:
                saved_experience = {}
    else:
        saved_experience = {}

# Классы существ
class Plant:
    def __init__(self):
        self.size = 5
        self.position = pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.color = PLANT_COLOR

    def draw(self):
        pygame.draw.circle(screen, self.color, self.position, self.size)

class Creature:
    def __init__(self, species, experience=None):
        self.species = species  # 'herbivore' или 'predator'
        self.energy = 100
        self.size = 10
        self.speed = 2
        self.position = pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.is_alive = True
        self.age = 0
        self.experience = experience if experience else {}

    def update(self, plants, creatures, corpses):
        if not self.is_alive:
            return

        self.age += 1
        self.energy -= 0.1  # Энергия тратится со временем

        # Изменение скорости в зависимости от размера
        self.speed = max(1, 5 - self.size / 20)

        # Поиск цели
        target = self.find_target(plants, creatures, corpses)
        if target:
            self.move_towards(target.position)
            if self.collide_with(target):
                self.eat(target)
        else:
            self.wander()

        if self.energy <= 0:
            self.die()

    def find_target(self, plants, creatures, corpses):
        visible_entities = plants + corpses
        if self.species == 'predator':
            visible_entities += [c for c in creatures if c.species == 'herbivore' and c.is_alive]

        if not visible_entities:
            return None

        # Простая логика поиска ближайшей цели
        visible_entities.sort(key=lambda e: self.position.distance_to(e.position))
        return visible_entities[0]

    def move_towards(self, target_pos):
        self.direction = (target_pos - self.position).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()

    def wander(self):
        if random.random() < 0.05:
            self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()

    def keep_within_bounds(self):
        self.position.x = max(0, min(WIDTH, self.position.x))
        self.position.y = max(0, min(HEIGHT, self.position.y))

    def collide_with(self, other):
        distance = self.position.distance_to(other.position)
        return distance < self.size + other.size

    def eat(self, target):
        if isinstance(target, Plant) and self.species == 'herbivore':
            plants.remove(target)
        elif isinstance(target, Creature) and self.species == 'predator':
            if target in creatures:
                target.die()
        elif isinstance(target, Corpse) and self.species == 'predator':
            if target in corpses:
                corpses.remove(target)
        else:
            return

        self.energy += 50
        self.size += 1
        self.spawn_offspring()

    def spawn_offspring(self):
        if self.species == 'herbivore':
            creatures.append(Creature('herbivore', self.experience))
        elif self.species == 'predator':
            creatures.append(Creature('predator', self.experience))

    def die(self):
        self.is_alive = False
        corpses.append(Corpse(self.position.copy(), self.size))

    def draw(self):
        if not self.is_alive:
            return

        # Цвет в зависимости от энергии
        if self.species == 'herbivore':
            energy_ratio = min(1, self.energy / 100)
            color = (0, int(255 * energy_ratio), 0)
        else:
            energy_ratio = min(1, self.energy / 100)
            color = (int(255 * energy_ratio), 0, 0)

        pygame.draw.circle(screen, color, self.position, self.size)

class Corpse:
    def __init__(self, position, size):
        self.position = position
        self.size = size
        self.decomposition = 100  # Степень разложения

    def update(self):
        self.decomposition -= 0.05
        if self.decomposition <= 0:
            if self in corpses:
                corpses.remove(self)

    def draw(self):
        gray_scale = int(169 * (self.decomposition / 100))
        color = (gray_scale, gray_scale, gray_scale)
        pygame.draw.circle(screen, color, self.position, self.size)

# Списки сущностей
plants = [Plant() for _ in range(50)]
creatures = [Creature('herbivore', saved_experience.get('herbivore')) for _ in range(10)] + \
            [Creature('predator', saved_experience.get('predator')) for _ in range(5)]
corpses = []

# Основной цикл
clock = pygame.time.Clock()
running = True

while running:
    clock.tick(60)  # Ограничение FPS для плавности
    screen.fill(PASTEL_BACKGROUND)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Обновление и отрисовка растений
    for plant in plants:
        plant.draw()

    # Обновление и отрисовка трупов
    for corpse in corpses[:]:
        corpse.update()
        corpse.draw()

    # Обновление и отрисовка существ
    for creature in creatures[:]:
        creature.update(plants, creatures, corpses)
        creature.draw()

    # Проверка конца симуляции
    if not any(c.is_alive for c in creatures):
        font = pygame.font.SysFont(None, 72)
        text = font.render("Все погибли", True, (0, 0, 0))
        screen.blit(text, (WIDTH // 2 - 150, HEIGHT // 2))
        pygame.display.flip()
        pygame.time.wait(3000)

        # Сохранение опыта (для простоты сохраняем возраст существ)
        for creature in creatures:
            saved_experience[creature.species] = creature.age

        with open('experience.pkl', 'wb') as f:
            pickle.dump(saved_experience, f)

        # Перезапуск симуляции
        plants = [Plant() for _ in range(50)]
        creatures = [Creature('herbivore', saved_experience.get('herbivore')) for _ in range(10)] + \
                    [Creature('predator', saved_experience.get('predator')) for _ in range(5)]
        corpses = []
        continue

    pygame.display.flip()

# Сохранение опыта при выходе
with open('experience.pkl', 'wb') as f:
    pickle.dump(saved_experience, f)

pygame.quit()

Изменения в коде:

1. Проверка размера файла experience.pkl:

   python
   if os.path.exists('experience.pkl'):
       if os.path.getsize('experience.pkl') > 0:
           with open('experience.pkl', 'rb') as f:
               try:
                   saved_experience = pickle.load(f)
               except EOFError:
                   saved_experience = {}
       else:
           saved_experience = {}

   Теперь перед загрузкой файла мы проверяем, что его размер больше нуля. Если файл пуст, инициализируем saved_experience пустым словарем.

2. Обработка исключения EOFError:

   Добавил блок try-except вокруг pickle.load(f), чтобы поймать EOFError в случае, если файл поврежден или пуст.

3. Проверка наличия объектов в списках перед удалением:

   В методах eat и update классов Creature и Corpse добавил проверки наличия объектов в списках перед их удалением, чтобы избежать ошибок при одновременном удалении.

   python
   if target in creatures:
       creatures.remove(target)

4. Копирование позиции при создании трупа:

   При создании трупа теперь копируем позицию существа, чтобы избежать нежелательных изменений:

   python
   corpses.append(Corpse(self.position.copy(), self.size))

5. Использование копий списков при итерации:

   Чтобы избежать ошибок при изменении списков во время их обхода, добавил копирование списков при итерации:

   python
   for corpse in corpses[:]:
       ...
   for creature in creatures[:]:
       ...

Объяснение проблемы:

• Причина ошибки: Файл experience.pkl существовал, но был пустым или поврежденным. При попытке загрузить данные из пустого файла модуль pickle выдает ошибку EOFError, так как он ожидает найти данные для десериализации, но достигает конца файла.

• Решение: Добавить проверку размера файла перед загрузкой. Если файл пустой, инициализировать saved_experience пустым словарем. Также полезно обернуть загрузку в блок try-except, чтобы обработать возможные исключения.

Рекомендации:

• Удалить поврежденный файл: Если после изменений проблема сохраняется, удалите файл experience.pkl, чтобы программа могла создать его заново с корректными данными.

• Обработка других исключений: В будущем можно добавить обработку других возможных исключений, связанных с чтением и записью файлов, чтобы сделать программу более устойчивой.

Как запустить исправленную игру:

1. Установка Pygame:

   bash
   pip install pygame

2. Сохранение кода:

   Сохраните исправленный код в файл, например, evolution_game_fixed.py.

3. Запуск игры:

   bash
   python evolution_game_fixed.py

Примечание:

• Если вы все еще столкнетесь с проблемами, убедитесь, что в папке с игрой нет старых или поврежденных файлов experience.pkl.
• Теперь при первом запуске, если файл опыта не существует или пуст, игра корректно инициализирует необходимые данные и начнет симуляцию.

Конечно! Чтобы сделать существ умнее и повысить шансы на выживание травоядных, можно внедрить следующие улучшения:

1. Улучшение интеллекта существ:

   • Травоядные:

     • Реализовать поведение бегства при обнаружении хищника в определенном радиусе.
     • Добавить возможность сбиваться в группы для повышения выживаемости.
     • Приоритетно искать пищу, но уделять внимание безопасности.

   • Хищники:

     • Улучшить стратегию охоты, например, подкрадываться к жертве с тыла.
     • Энергосбережение при отсутствии добычи (меньше двигаться).

2. Повышение шансов на выживание травоядных:

   • Скорость:
     • Сделать травоядных быстрее хищников, чтобы они могли убежать.
   • Групповое поведение:
     • Травоядные в группе могут иметь повышенные шансы заметить хищника и своевременно убежать.
   • Скрытность:
     • Реализовать возможность травоядным прятаться в растениях или использовать укрытия.

3. Обучение и опыт:

   • Запоминание опасных зон:
     • Существа могут запоминать места, где они часто встречали опасность, и избегать их в будущем.
   • Адаптивное поведение:
     • Существа могут менять свои стратегии в зависимости от прошлых успехов или неудач.

---

Обновленный код с улучшенным интеллектом и повышенными шансами на выживание травоядных:

python
import pygame
import random
import pickle
import os
import math

# Инициализация Pygame
pygame.init()

# Размеры экрана
WIDTH, HEIGHT = 1280, 720
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Эволюция существ")

# Цвета
PASTEL_BACKGROUND = (207, 226, 243)
PLANT_COLOR = (169, 169, 169)

# Загрузка опыта существ
saved_experience = {}
if os.path.exists('experience.pkl'):
    if os.path.getsize('experience.pkl') > 0:
        with open('experience.pkl', 'rb') as f:
            try:
                saved_experience = pickle.load(f)
            except EOFError:
                saved_experience = {}
    else:
        saved_experience = {}

# Классы существ
class Plant:
    def __init__(self):
        self.size = 5
        self.position = pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.color = PLANT_COLOR

    def draw(self):
        pygame.draw.circle(screen, self.color, self.position, self.size)

class Creature:
    def __init__(self, species, experience=None):
        self.species = species  # 'herbivore' или 'predator'
        self.energy = 100
        self.size = 10
        self.base_speed = 3 if species == 'herbivore' else 2  # Травоядные быстрее
        self.speed = self.base_speed
        self.position = pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.is_alive = True
        self.age = 0
        self.experience = experience if experience else {}
        self.sight_range = 100  # Радиус обзора

    def update(self, plants, creatures, corpses):
        if not self.is_alive:
            return

        self.age += 1
        self.energy -= 0.05  # Энергия тратится со временем

        # Изменение скорости в зависимости от размера
        self.speed = max(1, self.base_speed - self.size / 30)

        # Поведение в зависимости от вида
        if self.species == 'herbivore':
            self.herbivore_behavior(plants, creatures)
        elif self.species == 'predator':
            self.predator_behavior(plants, creatures, corpses)

        if self.energy <= 0:
            self.die()

    def herbivore_behavior(self, plants, creatures):
        # Проверка на наличие хищников поблизости
        predators = [c for c in creatures if c.species == 'predator' and c.is_alive]
        danger = self.detect_threat(predators)
        if danger:
            # Убегать от ближайшего хищника
            self.flee(danger.position)
        else:
            # Искать ближайшее растение
            target = self.find_nearest(plants)
            if target:
                self.move_towards(target.position)
                if self.collide_with(target):
                    self.eat(target)
            else:
                self.wander()

    def predator_behavior(self, plants, creatures, corpses):
        # Поиск ближайшей добычи или трупа
        prey = [c for c in creatures if c.species == 'herbivore' and c.is_alive]
        targets = prey + corpses
        target = self.find_nearest(targets)
        if target:
            self.move_towards(target.position)
            if self.collide_with(target):
                self.eat(target)
        else:
            # Энергосбережение: меньше двигаться
            if random.random() < 0.01:
                self.wander()

    def detect_threat(self, predators):
        # Поиск ближайшего хищника в радиусе обзора
        for predator in predators:
            if self.position.distance_to(predator.position) < self.sight_range:
                return predator
        return None

    def find_nearest(self, entities):
        # Поиск ближайшей сущности
        if not entities:
            return None
        entities.sort(key=lambda e: self.position.distance_to(e.position))
        nearest = entities[0]
        if self.position.distance_to(nearest.position) < self.sight_range:
            return nearest
        return None

    def move_towards(self, target_pos):
        self.direction = (target_pos - self.position).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()
        self.energy -= 0.02 * self.speed  # Энергия тратится на движение

    def flee(self, threat_pos):
        # Двигаться в противоположном направлении от угрозы
        self.direction = (self.position - threat_pos).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()
        self.energy -= 0.05 * self.speed  # Бег отнимает больше энергии

    def wander(self):
        if random.random() < 0.1:
            self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()
        self.energy -= 0.01 * self.speed  # Энергия тратится на блуждание

    def keep_within_bounds(self):
        self.position.x = max(0, min(WIDTH, self.position.x))
        self.position.y = max(0, min(HEIGHT, self.position.y))

    def collide_with(self, other):
        distance = self.position.distance_to(other.position)
        return distance < self.size + other.size

    def eat(self, target):
        if isinstance(target, Plant) and self.species == 'herbivore':
            if target in plants:
                plants.remove(target)
        elif isinstance(target, Creature) and self.species == 'predator':
            if target in creatures:
                target.die()
        elif isinstance(target, Corpse) and self.species == 'predator':
            if target in corpses:
                corpses.remove(target)
        else:
            return

        self.energy += 50
        self.size += 0.5
        if self.energy > 150:
            self.spawn_offspring()
            self.energy -= 50

    def spawn_offspring(self):
        if self.species == 'herbivore':
            creatures.append(Creature('herbivore', self.experience))
        elif self.species == 'predator':
            creatures.append(Creature('predator', self.experience))

    def die(self):
        self.is_alive = False
        corpses.append(Corpse(self.position.copy(), self.size))

    def draw(self):
        if not self.is_alive:
            return

        # Цвет в зависимости от энергии
        if self.species == 'herbivore':
            energy_ratio = min(1, self.energy / 100)
            color = (0, int(255 * energy_ratio), 0)
        else:
            energy_ratio = min(1, self.energy / 100)
            color = (int(255 * energy_ratio), 0, 0)

        pygame.draw.circle(screen, color, self.position, self.size)

class Corpse:
    def __init__(self, position, size):
        self.position = position
        self.size = size
        self.decomposition = 100  # Степень разложения

    def update(self):
        self.decomposition -= 0.05
        if self.decomposition <= 0:
            if self in corpses:
                corpses.remove(self)

    def draw(self):
        gray_scale = int(169 * (self.decomposition / 100))
        color = (gray_scale, gray_scale, gray_scale)
        pygame.draw.circle(screen, color, self.position, self.size)

# Списки сущностей
plants = [Plant() for _ in range(100)]
creatures = [Creature('herbivore', saved_experience.get('herbivore')) for _ in range(20)] + \
            [Creature('predator', saved_experience.get('predator')) for _ in range(5)]
corpses = []

# Основной цикл
clock = pygame.time.Clock()
running = True

while running:
    clock.tick(60)  # Ограничение FPS для плавности
    screen.fill(PASTEL_BACKGROUND)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Обновление и отрисовка растений
    if len(plants) < 100:
        plants.append(Plant())
    for plant in plants:
        plant.draw()

    # Обновление и отрисовка трупов
    for corpse in corpses[:]:
        corpse.update()
        corpse.draw()

    # Обновление и отрисовка существ
    for creature in creatures[:]:
        creature.update(plants, creatures, corpses)
        creature.draw()

    # Проверка конца симуляции
    if not any(c.is_alive for c in creatures):
        font = pygame.font.SysFont(None, 72)
        text = font.render("Все погибли", True, (0, 0, 0))
        screen.blit(text, (WIDTH // 2 - 150, HEIGHT // 2))
        pygame.display.flip()
        pygame.time.wait(3000)

        # Сохранение опыта (для простоты сохраняем возраст существ)
        for creature in creatures:
            saved_experience[creature.species] = creature.age

        with open('experience.pkl', 'wb') as f:
            pickle.dump(saved_experience, f)

        # Перезапуск симуляции
        plants = [Plant() for _ in range(100)]
        creatures = [Creature('herbivore', saved_experience.get('herbivore')) for _ in range(20)] + \
                    [Creature('predator', saved_experience.get('predator')) for _ in range(5)]
        corpses = []
        continue

    pygame.display.flip()

# Сохранение опыта при выходе
with open('experience.pkl', 'wb') as f:
    pickle.dump(saved_experience, f)

pygame.quit()

Объяснение изменений:

1. Улучшенный интеллект травоядных:

   • Обнаружение хищников:

     • Добавлен метод detect_threat, который проверяет наличие хищников в радиусе обзора (sight_range).
     • Если хищник обнаружен, травоядное убегает от него с помощью метода flee.

   • Поведение убегания:

     • Метод flee реализует движение в противоположном направлении от угрозы.
     • Бег требует больше энергии, что делает поведение более реалистичным.

   • Поиск пищи:

     • Если опасности нет, травоядное ищет ближайшее растение в радиусе обзора и движется к нему.

2. Улучшенный интеллект хищников:

   • Поиск добычи:

     • Хищники ищут ближайшее травоядное или труп в радиусе обзора.
     • Если цель найдена, хищник движется к ней для атаки или поедания.

   • Энергосбережение:

     • Если добычи нет, хищник меньше двигается, экономя энергию.

3. Повышение шансов на выживание травоядных:

   • Скорость:
     • Травоядные имеют базовую скорость выше, чем у хищников (base_speed), что дает им шанс убежать.
   • Уменьшение размера прироста:
     • При поедании пищи травоядные растут медленнее (self.size += 0.5), чтобы сохранять скорость.
   • Увеличение количества растений и травоядных:
     • Начальное количество растений увеличено до 100.
     • Количество травоядных увеличено до 20.

4. Общие улучшения:

   • Радиус обзора:
     • Добавлен параметр sight_range, определяющий, на каком расстоянии существо может видеть другие объекты.
   • Энергозатраты на движение:
     • Энергия теперь тратится в зависимости от скорости и типа движения (обычное, бегство, блуждание).
   • Постепенное появление растений:
     • Если количество растений падает ниже 100, новые растения добавляются в симуляцию, что обеспечивает постоянный источник пищи для травоядных.

Как запустить обновленную игру:

1. Установка Pygame:

   bash
   pip install pygame

2. Сохранение кода:

   Сохраните обновленный код в файл, например, evolution_game_improved.py.

3. Запуск игры:

   bash
   python evolution_game_improved.py

Примечания:

• Балансировка игры:

  • Количество существ и параметры можно настроить для достижения оптимального баланса между травоядными и хищниками.
  • Можно добавить больше логики для группового поведения или других сложных взаимодействий.

• Дальнейшие улучшения:

  • Реализовать обучение на основе опыта, чтобы существа со временем становились умнее.
  • Добавить разные типы растений с различной питательной ценностью.
  • Внедрить систему генетики и наследования характеристик от родителей к потомству.

---

Заключение:

Мы улучшили интеллект существ, добавив более сложные поведения, такие как бегство травоядных от хищников и энергосберегающие стратегии хищников. Это повысило шансы на выживание травоядных и сделало симуляцию более реалистичной и интересной.

Рад, что всё работает, и вы готовы продолжать улучшать игру!

Вы правы, текущая механика размножения упрощена и происходит без участия двух родителей, что может приводить к нелогичным появлениям новых существ в случайных местах. Давайте исправим это и сделаем размножение более реалистичным.

План улучшений:

1. Размножение с участием двух родителей:

   • Существа смогут размножаться только при наличии партнёра рядом.
   • Размножение будет происходить, если оба родителя находятся в непосредственной близости друг от друга.

2. Появление потомка рядом с родителями:

   • Потомок будет появляться рядом с родителями, а не в случайном месте.
   • Размер и энергия потомка будут меньше, чем у взрослых существ.

3. Потомок будет учиться у родителей:

   • Потомок будет наследовать опыт и некоторые характеристики родителей.
   • В дальнейшем можно добавить механизм обучения потомка на основе опыта родителей.

4. Ограничение на частоту размножения:

   • Добавим временное ограничение или требование определённого уровня энергии для размножения, чтобы предотвратить неконтролируемый рост популяции.

---

Обновлённый код с реалистичным размножением:

python
import pygame
import random
import pickle
import os
import math

# Инициализация Pygame
pygame.init()

# Размеры экрана
WIDTH, HEIGHT = 1280, 720
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Эволюция существ")

# Цвета
PASTEL_BACKGROUND = (207, 226, 243)
PLANT_COLOR = (169, 169, 169)

# Загрузка опыта существ
saved_experience = {}
if os.path.exists('experience.pkl'):
    if os.path.getsize('experience.pkl') > 0:
        with open('experience.pkl', 'rb') as f:
            try:
                saved_experience = pickle.load(f)
            except EOFError:
                saved_experience = {}
    else:
        saved_experience = {}

# Классы существ
class Plant:
    def __init__(self):
        self.size = 5
        self.position = pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.color = PLANT_COLOR

    def draw(self):
        pygame.draw.circle(screen, self.color, self.position, self.size)

class Creature:
    def __init__(self, species, experience=None, position=None, size=None, energy=None):
        self.species = species  # 'herbivore' или 'predator'
        self.energy = energy if energy is not None else 100
        self.size = size if size is not None else 10
        self.base_speed = 3 if species == 'herbivore' else 2  # Травоядные быстрее
        self.speed = self.base_speed
        self.position = position if position else pygame.Vector2(random.randint(0, WIDTH), random.randint(0, HEIGHT))
        self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.is_alive = True
        self.age = 0
        self.experience = experience if experience else {}
        self.sight_range = 100  # Радиус обзора
        self.reproduction_cooldown = 0  # Время до следующего размножения

    def update(self, plants, creatures, corpses):
        if not self.is_alive:
            return

        self.age += 1
        self.energy -= 0.05  # Энергия тратится со временем

        # Изменение скорости в зависимости от размера
        self.speed = max(1, self.base_speed - self.size / 30)

        # Уменьшение времени до возможного размножения
        if self.reproduction_cooldown > 0:
            self.reproduction_cooldown -= 1

        # Поведение в зависимости от вида
        if self.species == 'herbivore':
            self.herbivore_behavior(plants, creatures)
        elif self.species == 'predator':
            self.predator_behavior(plants, creatures, corpses)

        if self.energy <= 0:
            self.die()

    def herbivore_behavior(self, plants, creatures):
        # Проверка на наличие хищников поблизости
        predators = [c for c in creatures if c.species == 'predator' and c.is_alive]
        danger = self.detect_threat(predators)
        if danger:
            # Убегать от ближайшего хищника
            self.flee(danger.position)
        else:
            # Поиск партнёра для размножения
            partner = self.find_partner(creatures)
            if partner:
                self.move_towards(partner.position)
                if self.collide_with(partner):
                    self.reproduce_with(partner, creatures)
            else:
                # Искать ближайшее растение
                target = self.find_nearest(plants)
                if target:
                    self.move_towards(target.position)
                    if self.collide_with(target):
                        self.eat(target)
                else:
                    self.wander()

    def predator_behavior(self, plants, creatures, corpses):
        # Поиск ближайшей добычи или трупа
        prey = [c for c in creatures if c.species == 'herbivore' and c.is_alive]
        target = self.find_nearest(prey + corpses)
        if target:
            self.move_towards(target.position)
            if self.collide_with(target):
                self.eat(target)
        else:
            # Поиск партнёра для размножения
            partner = self.find_partner(creatures)
            if partner:
                self.move_towards(partner.position)
                if self.collide_with(partner):
                    self.reproduce_with(partner, creatures)
            else:
                # Энергосбережение: меньше двигаться
                if random.random() < 0.01:
                    self.wander()

    def detect_threat(self, predators):
        # Поиск ближайшего хищника в радиусе обзора
        threats = [p for p in predators if self.position.distance_to(p.position) < self.sight_range]
        if threats:
            # Возвращаем ближайшего хищника
            threats.sort(key=lambda p: self.position.distance_to(p.position))
            return threats[0]
        return None

    def find_nearest(self, entities):
        # Поиск ближайшей сущности в радиусе обзора
        visible_entities = [e for e in entities if self.position.distance_to(e.position) < self.sight_range]
        if not visible_entities:
            return None
        visible_entities.sort(key=lambda e: self.position.distance_to(e.position))
        return visible_entities[0]

    def find_partner(self, creatures):
        # Поиск партнёра для размножения
        if self.reproduction_cooldown > 0 or self.energy < 80:
            return None
        potential_partners = [c for c in creatures if c.species == self.species and c.is_alive and c != self and c.reproduction_cooldown <= 0 and c.energy >= 80]
        partner = self.find_nearest(potential_partners)
        return partner

    def move_towards(self, target_pos):
        if self.position != target_pos:
            self.direction = (target_pos - self.position).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()
        self.energy -= 0.02 * self.speed  # Энергия тратится на движение

    def flee(self, threat_pos):
        # Двигаться в противоположном направлении от угрозы
        if self.position != threat_pos:
            self.direction = (self.position - threat_pos).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()
        self.energy -= 0.05 * self.speed  # Бег отнимает больше энергии

    def wander(self):
        if random.random() < 0.1:
            self.direction = pygame.Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
        self.position += self.direction * self.speed
        self.keep_within_bounds()
        self.energy -= 0.01 * self.speed  # Энергия тратится на блуждание

    def keep_within_bounds(self):
        self.position.x = max(0, min(WIDTH, self.position.x))
        self.position.y = max(0, min(HEIGHT, self.position.y))

    def collide_with(self, other):
        distance = self.position.distance_to(other.position)
        return distance < self.size + other.size

    def eat(self, target):
        if isinstance(target, Plant) and self.species == 'herbivore':
            if target in plants:
                plants.remove(target)
                self.energy += 30
        elif isinstance(target, Creature) and self.species == 'predator':
            if target in creatures:
                target.die()
                self.energy += 50
        elif isinstance(target, Corpse) and self.species == 'predator':
            if target in corpses:
                corpses.remove(target)
                self.energy += 20
        else:
            return

        self.size += 0.2  # Незначительное увеличение размера

    def reproduce_with(self, partner, creatures_list):
        # Создание потомка рядом с родителями
        offspring_position = self.position + (partner.position - self.position) / 2 + pygame.Vector2(random.uniform(-5, 5), random.uniform(-5, 5))
        offspring_energy = 50  # Потомок слабее
        offspring_size = min(self.size, partner.size) * 0.8  # Потомок меньше родителей

        # Наследование опыта (здесь можно усложнить логику)
        offspring_experience = {
            'age': 0,
            'parent_experience': (self.experience.get('age', 0) + partner.experience.get('age', 0)) / 2
        }

        offspring = Creature(
            species=self.species,
            experience=offspring_experience,
            position=offspring_position,
            size=offspring_size,
            energy=offspring_energy
        )

        creatures_list.append(offspring)

        # Родители тратят энергию на размножение
        self.energy -= 40
        partner.energy -= 40

        # Устанавливаем время до следующего размножения
        self.reproduction_cooldown = 100
        partner.reproduction_cooldown = 100

    def die(self):
        self.is_alive = False
        corpses.append(Corpse(self.position.copy(), self.size))

    def draw(self):
        if not self.is_alive:
            return

        # Цвет в зависимости от энергии
        if self.species == 'herbivore':
            energy_ratio = min(1, self.energy / 100)
            color = (0, int(255 * energy_ratio), 0)
        else:
            energy_ratio = min(1, self.energy / 100)
            color = (int(255 * energy_ratio), 0, 0)

        pygame.draw.circle(screen, color, self.position, self.size)

class Corpse:
    def __init__(self, position, size):
        self.position = position
        self.size = size
        self.decomposition = 100  # Степень разложения

    def update(self):
        self.decomposition -= 0.05
        if self.decomposition <= 0:
            if self in corpses:
                corpses.remove(self)

    def draw(self):
        gray_scale = int(169 * (self.decomposition / 100))
        color = (gray_scale, gray_scale, gray_scale)
        pygame.draw.circle(screen, color, self.position, self.size)

# Списки сущностей
plants = [Plant() for _ in range(100)]
creatures = [Creature('herbivore', saved_experience.get('herbivore')) for _ in range(20)] + \
            [Creature('predator', saved_experience.get('predator')) for _ in range(5)]
corpses = []

# Основной цикл
clock = pygame.time.Clock()
running = True

while running:
    clock.tick(60)  # Ограничение FPS для плавности
    screen.fill(PASTEL_BACKGROUND)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Обновление и отрисовка растений
    if len(plants) < 100:
        plants.append(Plant())
    for plant in plants:
        plant.draw()

    # Обновление и отрисовка трупов
    for corpse in corpses[:]:
        corpse.update()
        corpse.draw()

    # Обновление и отрисовка существ
    for creature in creatures[:]:
        creature.update(plants, creatures, corpses)
        creature.draw()

    # Проверка конца симуляции
    if not any(c.is_alive for c in creatures):
        font = pygame.font.SysFont(None, 72)
        text = font.render("Все погибли", True, (0, 0, 0))
        screen.blit(text, (WIDTH // 2 - 150, HEIGHT // 2))
        pygame.display.flip()
        pygame.time.wait(3000)

        # Сохранение опыта (для простоты сохраняем возраст существ)
        for creature in creatures:
            saved_experience[creature.species] = {'age': creature.age}

        with open('experience.pkl', 'wb') as f:
            pickle.dump(saved_experience, f)

        # Перезапуск симуляции
        plants = [Plant() for _ in range(100)]
        creatures = [Creature('herbivore', saved_experience.get('herbivore')) for _ in range(20)] + \
                    [Creature('predator', saved_experience.get('predator')) for _ in range(5)]
        corpses = []
        continue

    pygame.display.flip()

# Сохранение опыта при выходе
with open('experience.pkl', 'wb') as f:
    pickle.dump(saved_experience, f)

pygame.quit()

---

Объяснение изменений:

1. Размножение с участием двух родителей:

   • Метод find_partner: Существа ищут партнёра того же вида, который находится в радиусе обзора, имеет достаточную энергию и готов к размножению (прошёл reproduction_cooldown).
   • Метод reproduce_with: Создаёт потомка, используя информацию от обоих родителей.
   • Ограничения: Родители могут размножаться только при энергии выше 80 и после истечения времени reproduction_cooldown.

2. Появление потомка рядом с родителями:

   • Потомок появляется в точке между родителями с небольшим случайным смещением.
   • Его размер и энергия меньше, чем у родителей.

3. Потомок наследует опыт родителей:

   • В offspring_experience можно хранить среднее значение опыта родителей.
   • Пока это просто демонстрация; можно усложнить логику наследования и обучения.

4. Ограничение на частоту размножения:

   • Введён параметр reproduction_cooldown, который уменьшает вероятность слишком частого размножения.
   • После размножения родители тратят энергию и должны ждать определённое время до следующего размножения.

5. Исправление появления новых существ:

   • Теперь существа не появляются случайно на поле после размножения, а появляются рядом с родителями.

6. Размер и энергия потомка:

   • Потомок меньше по размеру и слабее по энергии.
   • Ему нужно расти и набираться опыта, чтобы стать взрослым.

7. Обновления в методах eat и draw:

   • Метод eat: Скорректированы значения энергии и размера при поедании пищи.
   • Метод draw: Без изменений, существо отображается в зависимости от его текущей энергии.

---

Запуск игры:

1. Убедитесь, что установлен pygame:

   bash
   pip install pygame

2. Сохраните код в файл, например, evolution_game_updated.py.

3. Запустите игру:

   bash
   python evolution_game_updated.py

---

Дальнейшие улучшения:

• Углубить механику наследования и обучения:

  • Можно добавить генетические алгоритмы, где потомки наследуют характеристики родителей с некоторыми мутациями.
  • Реализовать обучение потомка на основе поведения родителей (сложнее, требует более продвинутых алгоритмов).

• Добавить визуализацию поколений:

  • Отображать поколение существа или его родителей, чтобы отслеживать эволюцию.

• Балансировка игры:

  • Тонко настроить параметры энергии, скорости, размножения и т.д., чтобы добиться интересного и стабильного взаимодействия между видами.

• Введение новых видов и особенностей:

  • Добавить новые типы растений, разные виды хищников и травоядных с уникальными характеристиками.

---

Заключение:

Мы внесли значительные изменения в механику размножения существ, сделав её более реалистичной и логичной. Теперь существа размножаются при встрече с партнёром, а потомки появляются рядом с родителями и начинают свою жизнь маленькими и слабыми. Это добавляет глубину симуляции и позволяет наблюдать более сложные и интересные взаимодействия между существами.

Если у вас есть дополнительные идеи или пожелания по улучшению игры, пожалуйста, сообщите, и мы продолжим работать над ними!