AI-система процедурной генерации уровней в играх

AI-процедурная генерация уровней для игр

Ваш игровой данжон генерируется с нелогичными переходами, а кривая сложности скачет? Игроки застревают в тупиках, а редкие проходы ведут в пустые комнаты. Мы решаем эти проблемы с помощью AI-процедурной генерации уровней (PCG-levels) — алгоритмического создания игровых пространств: данжонов, платформенных уровней, открытых миров, головоломок. AI-подходы добавляют семантическое понимание: система знает, где должен быть первый контакт с врагом, где спрятан секрет, какова оптимальная кривая сложности. За 5 лет мы реализовали более 15 проектов для инди-студий и крупных издателей.

Одна из типичных ситуаций: заказчик хочет 100 уровней для roguelike, но ручная разработка каждого занимает 2 дня. Без автоматизации бюджет на дизайн вырастает до внушительной суммы. С нашей AI-системой генерация одного уровня занимает 2 секунды, а итоговая экономия времени — 85%. Нейросети для геймдизайна здесь работают как фильтр качества: LLM оценивает каждый сгенерированный уровень по 10 метрикам и отбраковывает 30% неудачных вариантов.

Почему стандартная генерация уровней перестаёт работать?

Ручное проектирование тысяч уровней — дорого и долго. Хаотичная рандомная генерация даёт несбалансированный опыт: игроки либо скучают, либо умирают на каждом шагу. Проблема усугубляется, когда нужно поддерживать интерес на протяжении 50+ часов геймплея. AI-генерация решает это через:

• Контролируемую сложность — параметр difficulty влияет на плотность врагов, ловушек и наград.
• Детерминированность по seed — один seed даёт идентичный уровень, что важно для реплеев и тестирования.
• Семантическую оценку — LLM анализирует карту как геймдизайнер, выявляя проблемы потока и темпа.

Мы комбинируем классические алгоритмы (BSP, WFC) с машинным обучением, чтобы получить лучшее от обоих миров: скорость и предсказуемость BSP + гибкость и адаптивность ML.

Как AI-генерация уровней решает проблему однообразия?

Однообразие — главный враг процедурной генерации. Игроки быстро замечают паттерны, если алгоритм не умеет варьировать структуру и наполнение. Наш подход включает три уровня адаптации:

1. Вариативность структур — BSP-разбиение с разной глубиной и соотношением комнат/коридоров. WFC использует образцы из реальных уровней-образцов.
2. Интерактивное наполнение — на основе difficulty расставляются ловушки, сундуки, боссы. LLM корректирует размещение, чтобы избежать кластеризации.
3. Тематические биомы — набор параметров (текстуры, тайлы, враги) меняется в зависимости от биома: классический данжон, подземелье, руины.

В одном из кейсов мы генерировали уровни для roguelike-игры: после внедрения AI-оценки показатель exploration_score вырос с 4.2 до 8.7, а retention игроков на 15-м часе увеличился на 23%. Это позволило сократить бюджет на левел-дизайн на 40% — отметил главный геймдизайнер студии.

Алгоритмы генерации данжонов

BSP-генератор

from dataclasses import dataclass, field
from enum import Enum
import random
import numpy as np
from collections import deque

class TileType(Enum):
    WALL = 0
    FLOOR = 1
    DOOR = 2
    CHEST = 3
    SPAWN = 4
    EXIT = 5
    TRAP = 6
    BOSS_ROOM = 7

@dataclass
class DungeonConfig:
    width: int = 64
    height: int = 64
    min_rooms: int = 8
    max_rooms: int = 15
    min_room_size: tuple = (4, 4)
    max_room_size: tuple = (12, 10)
    corridor_width: int = 1
    difficulty: float = 0.5    # 0.0 – 1.0, влияет на врагов и ловушки
    dungeon_type: str = "classic"  # classic, cave, maze, ruins

class BSPDungeonGenerator:
    """Binary Space Partitioning — классический алгоритм для данжонов"""

    def __init__(self, config: DungeonConfig):
        self.config = config
        self.grid = np.full((config.height, config.width), TileType.WALL.value)
        self.rooms = []
        self.rng = random.Random()

    def generate(self, seed: int = None) -> np.ndarray:
        if seed:
            self.rng.seed(seed)
            np.random.seed(seed)

        # 1. BSP-разбиение
        root = {"x": 1, "y": 1, "w": self.config.width - 2, "h": self.config.height - 2}
        leaves = self._split_bsp(root, depth=0, max_depth=4)

        # 2. Создание комнат в листьях
        for leaf in leaves:
            room = self._create_room_in_leaf(leaf)
            if room:
                self.rooms.append(room)
                self._carve_room(room)

        # 3. Соединение комнат коридорами
        for i in range(len(self.rooms) - 1):
            self._connect_rooms(self.rooms[i], self.rooms[i + 1])

        # 4. Размещение специальных тайлов
        self._place_spawn_and_exit()
        self._place_interactive_elements()

        return self.grid

    def _split_bsp(self, node: dict, depth: int, max_depth: int) -> list:
        if depth >= max_depth or (node["w"] < 14 and node["h"] < 14):
            return [node]

        split_horizontal = self.rng.random() > 0.5
        if node["w"] > node["h"] * 1.25:
            split_horizontal = False
        elif node["h"] > node["w"] * 1.25:
            split_horizontal = True

        leaves = []
        if split_horizontal:
            split_pos = self.rng.randint(node["y"] + 6, node["y"] + node["h"] - 6)
            child_a = {"x": node["x"], "y": node["y"], "w": node["w"], "h": split_pos - node["y"]}
            child_b = {"x": node["x"], "y": split_pos, "w": node["w"], "h": node["y"] + node["h"] - split_pos}
        else:
            split_pos = self.rng.randint(node["x"] + 6, node["x"] + node["w"] - 6)
            child_a = {"x": node["x"], "y": node["y"], "w": split_pos - node["x"], "h": node["h"]}
            child_b = {"x": split_pos, "y": node["y"], "w": node["x"] + node["w"] - split_pos, "h": node["h"]}

        leaves.extend(self._split_bsp(child_a, depth + 1, max_depth))
        leaves.extend(self._split_bsp(child_b, depth + 1, max_depth))
        return leaves

    def _create_room_in_leaf(self, leaf: dict) -> dict | None:
        max_w = min(self.config.max_room_size[0], leaf["w"] - 2)
        max_h = min(self.config.max_room_size[1], leaf["h"] - 2)
        if max_w < self.config.min_room_size[0] or max_h < self.config.min_room_size[1]:
            return None
        w = self.rng.randint(self.config.min_room_size[0], max_w)
        h = self.rng.randint(self.config.min_room_size[1], max_h)
        x = leaf["x"] + self.rng.randint(1, leaf["w"] - w - 1)
        y = leaf["y"] + self.rng.randint(1, leaf["h"] - h - 1)
        return {"x": x, "y": y, "w": w, "h": h}

    def _carve_room(self, room: dict) -> None:
        for y in range(room["y"], room["y"] + room["h"]):
            for x in range(room["x"], room["x"] + room["w"]):
                self.grid[y][x] = TileType.FLOOR.value

    def _connect_rooms(self, room_a: dict, room_b: dict) -> None:
        """L-образный коридор между центрами комнат"""
        cx_a = room_a["x"] + room_a["w"] // 2
        cy_a = room_a["y"] + room_a["h"] // 2
        cx_b = room_b["x"] + room_b["w"] // 2
        cy_b = room_b["y"] + room_b["h"] // 2

        if self.rng.random() > 0.5:
            self._carve_horizontal(cy_a, min(cx_a, cx_b), max(cx_a, cx_b))
            self._carve_vertical(cx_b, min(cy_a, cy_b), max(cy_a, cy_b))
        else:
            self._carve_vertical(cx_a, min(cy_a, cy_b), max(cy_a, cy_b))
            self._carve_horizontal(cy_b, min(cx_a, cx_b), max(cx_a, cx_b))

    def _carve_horizontal(self, y: int, x1: int, x2: int) -> None:
        for x in range(x1, x2 + 1):
            self.grid[y][x] = TileType.FLOOR.value

    def _carve_vertical(self, x: int, y1: int, y2: int) -> None:
        for y in range(y1, y2 + 1):
            self.grid[y][x] = TileType.FLOOR.value

    def _place_spawn_and_exit(self) -> None:
        if self.rooms:
            spawn_room = self.rooms[0]
            self.grid[spawn_room["y"] + 1][spawn_room["x"] + 1] = TileType.SPAWN.value
            exit_room = self.rooms[-1]
            self.grid[exit_room["y"] + 1][exit_room["x"] + 1] = TileType.EXIT.value
            # Босс-комната — самая большая комната
            boss_room = max(self.rooms, key=lambda r: r["w"] * r["h"])
            mid_y = boss_room["y"] + boss_room["h"] // 2
            mid_x = boss_room["x"] + boss_room["w"] // 2
            self.grid[mid_y][mid_x] = TileType.BOSS_ROOM.value

    def _place_interactive_elements(self) -> None:
        trap_count = int(len(self.rooms) * self.config.difficulty * 0.3)
        chest_count = max(1, int(len(self.rooms) * 0.4))

        for room in self.rng.sample(self.rooms[1:-1], min(trap_count, len(self.rooms) - 2)):
            x = self.rng.randint(room["x"] + 1, room["x"] + room["w"] - 2)
            y = self.rng.randint(room["y"] + 1, room["y"] + room["h"] - 2)
            self.grid[y][x] = TileType.TRAP.value

        for room in self.rng.sample(self.rooms, min(chest_count, len(self.rooms))):
            x = self.rng.randint(room["x"] + 1, room["x"] + room["w"] - 2)
            y = self.rng.randint(room["y"] + 1, room["y"] + room["h"] - 2)
            if self.grid[y][x] == TileType.FLOOR.value:
                self.grid[y][x] = TileType.CHEST.value

Wave Function Collapse для тайловых уровней

class WaveFunctionCollapse:
    """
    WFC генерирует уровни по образцу: анализирует паттерны в примере тайловой карты
    и генерирует новые карты с теми же локальными паттернами.
    Применяется в платформерах, изометрических RPG, puzzle-играх.
    """

    def __init__(self, sample_grid: np.ndarray, pattern_size: int = 3):
        self.pattern_size = pattern_size
        self.patterns, self.weights = self._extract_patterns(sample_grid)
        self.adjacency = self._compute_adjacency()

    def _extract_patterns(self, grid: np.ndarray) -> tuple:
        patterns = {}
        h, w = grid.shape
        p = self.pattern_size

        for y in range(h - p + 1):
            for x in range(w - p + 1):
                pattern = tuple(grid[y:y+p, x:x+p].flatten())
                patterns[pattern] = patterns.get(pattern, 0) + 1

        all_patterns = list(patterns.keys())
        weights = [patterns[p] for p in all_patterns]
        return all_patterns, weights

    def _compute_adjacency(self) -> dict:
        """Для каждого паттерна определяем допустимых соседей по 4 направлениям"""
        adjacency = {i: {d: set() for d in ["up", "down", "left", "right"]}
                     for i in range(len(self.patterns))}
        p = self.pattern_size

        for i, pat_a in enumerate(self.patterns):
            grid_a = np.array(pat_a).reshape(p, p)
            for j, pat_b in enumerate(self.patterns):
                grid_b = np.array(pat_b).reshape(p, p)
                # Проверяем совместимость перекрытий
                if np.array_equal(grid_a[1:, :], grid_b[:-1, :]):
                    adjacency[i]["down"].add(j)
                    adjacency[j]["up"].add(i)
                if np.array_equal(grid_a[:, 1:], grid_b[:, :-1]):
                    adjacency[i]["right"].add(j)
                    adjacency[j]["left"].add(i)

        return adjacency

    def generate(self, output_size: tuple) -> np.ndarray:
        h, w = output_size
        # Каждая клетка содержит набор возможных паттернов
        wave = [[set(range(len(self.patterns))) for _ in range(w)] for _ in range(h)]
        result = np.zeros((h, w), dtype=int)

        while True:
            # Находим клетку с минимальной энтропией (не коллапсировавшую)
            min_entropy = float("inf")
            min_cell = None
            for y in range(h):
                for x in range(w):
                    if len(wave[y][x]) > 1:
                        entropy = len(wave[y][x])
                        if entropy < min_entropy:
                            min_entropy = entropy
                            min_cell = (y, x)

            if min_cell is None:
                break

            # Коллапс клетки с минимальной энтропией
            y, x = min_cell
            possible = list(wave[y][x])
            weights = [self.weights[p] for p in possible]
            total = sum(weights)
            chosen = random.choices(possible, weights=[w/total for w in weights])[0]
            wave[y][x] = {chosen}

            # Пропагация ограничений (BFS)
            queue = deque([(y, x)])
            while queue:
                cy, cx = queue.popleft()
                for dy, dx, direction, opposite in [(-1,0,"up","down"),(1,0,"down","up"),(0,-1,"left","right"),(0,1,"right","left")]:
                    ny, nx = cy + dy, cx + dx
                    if 0 <= ny < h and 0 <= nx < w and len(wave[ny][nx]) > 1:
                        allowed = set()
                        for pat_idx in wave[cy][cx]:
                            allowed |= self.adjacency[pat_idx][direction]
                        new_options = wave[ny][nx] & allowed
                        if new_options != wave[ny][nx]:
                            wave[ny][nx] = new_options
                            queue.append((ny, nx))

        # Собираем результат из первого тайла каждого паттерна
        for y in range(h):
            for x in range(w):
                if wave[y][x]:
                    pat_idx = next(iter(wave[y][x]))
                    result[y][x] = self.patterns[pat_idx][0]
        return result

AI-оценка и улучшение уровней

from openai import AsyncOpenAI

client = AsyncOpenAI()

async def evaluate_level_design(level_grid: np.ndarray, config: DungeonConfig) -> dict:
    """LLM анализирует ASCII-представление уровня и даёт дизайн-оценку"""
    TILE_CHARS = {0: "#", 1: ".", 2: "+", 3: "C", 4: "S", 5: "E", 6: "^", 7: "B"}
    ascii_map = "\n".join(
        "".join(TILE_CHARS.get(int(cell), "?") for cell in row)
        for row in level_grid
    )

    response = await client.chat.completions.create(
        model="gpt-4",
        messages=[{
            "role": "system",
            "content": """Ты — геймдизайнер, специалист по level design.
            Оцени данжон по критериям и предложи улучшения.

            Обозначения: # стена, . пол, + дверь, C сундук, S спавн, E выход, ^ ловушка, B босс

            Верни JSON: {
                flow_score: 1-10,
                pacing_score: 1-10,
                exploration_score: 1-10,
                issues: ["описание проблемы"],
                improvements: ["конкретные правки"],
                estimated_playtime_minutes: int
            }"""
        }, {
            "role": "user",
            "content": f"Сложность: {config.difficulty}\nКарта:\n{ascii_map[:2000]}"
        }],
        response_format={"type": "json_object"}
    )
    import json
    return json.loads(response.choices[0].message.content)

Интеграция с Unity и Unreal Engine

Unity: генерируемый grid сериализуется в JSON и читается MonoBehaviour-скриптом. Tilemap API заполняет TileBase по типам тайлов, NavMesh запекается автоматически через NavMeshSurface.

Unreal Engine 5: PCG-граф в PCG Framework принимает параметры как атрибуты, Procedural Mesh Component строит геометрию из данных генератора, World Partition управляет загрузкой больших данжонов по чанкам.

Сравнение алгоритмов по типу игры

BSP лучше WFC в 2 раза по скорости генерации для данжонов, но WFC даёт более разнообразные тайловые комбинации. Выбор зависит от задачи: для подземелий — BSP, для платформеров — WFC. ML-генерация обеспечивает максимальную вариативность, но требует больше вычислительных ресурсов.

Типичные ошибки и их решения

Что входит в работу и сроки

• Документация — описание архитектуры генератора, API, параметров конфигурации.
• Исходный код — полностью рабочий генератор с примерами использования.
• Интеграция — плагин под Unity или Unreal (по запросу).
• Обучение команды — воркшоп по настройке и кастомизации генератора.
• Поддержка — месяц бесплатного сопровождения после сдачи.

Процесс работы: аналитика (3–5 дней), проектирование (5–7 дней), реализация (10–20 дней), тестирование (5–7 дней), деплой (3–5 дней). Сроки ориентировочные: от 3 до 12 недель в зависимости от сложности. Стоимость рассчитывается индивидуально — оценим ваш проект бесплатно.

Почему стоит доверять нам? Наши инженеры имеют 5+ лет опыта в геймдеве и AI/ML. Сертифицированы в работе с PyTorch, TensorFlow и Unreal Engine. Успешно запустили генерацию уровней для 15+ игр, включая коммерческие релизы. Гарантируем стабильную работу генератора под любой seed и полную документацию.

Свяжитесь для консультации — мы подберём оптимальное решение под ваш проект. Закажите разработку AI-системы процедурной генерации уровней и ускорьте выпуск игры в 2 раза.

Генеративный AI разработка: от промпта к production API

Нам часто приносят задачу «сгенерируй изображение продукта» — на первый взгляд она простая. Но за этим стоит выбор между десятками моделей, настройка пайплайна инференса, ручное решение проблем consistency, интеграция в продуктовый бэкенд и ответ на вопрос, почему модель генерирует руки с шестью пальцами на стейджинге, но не на продакшене. Разберём направления, с которыми мы работаем.

Генерация изображений: от промпта к production API

Актуальный ландшафт — FLUX.1 [dev/schnell/pro] от Black Forest Labs и Stable Diffusion 3.5. FLUX.1 [schnell] делает 4 шага вместо 20–50 у SDXL — в 5–12 раз быстрее — и при этом держит качество выше. На A100 80GB — 1.2–1.8 с на изображение 1024×1024 при batch_size=4.

Типичная проблема при развёртывании: FLUX.1 [dev] требует 24+ GB VRAM в fp16. На A10G 24GB влезает впритык, при batch_size>1 — OOM. Решение: torch_dtype=torch.bfloat16 + enable_model_cpu_offload() из diffusers, либо квантизация через bitsandbytes в NF4 — падение качества минимально, потребление памяти снижается до 12–14 GB.

ControlNet и IP-Adapter — ключевые инструменты для production-задач, где нужна управляемость. ControlNet с Canny/Depth/Pose картой даёт структурный контроль. IP-Adapter (особенно IP-Adapter-FaceID) позволяет переносить identity персонажа на генерации — это основа для персонализированного контента. Подробнее о ControlNet можно прочитать в Wikipedia.

Кейс: e-commerce фотосъёмка. Ритейлер с 8000 SKU нуждался в lifestyle-фото для каждого продукта. Пайплайн: сегментация продукта (Segment Anything Model 2) → удаление фона → inpainting FLUX.1 [dev] с product image как IP-Adapter reference → upscale через RealESRGAN_x4plus. Стоимость генерации — $0.003/изображение на арендованных A100, vs $15–40 за профессиональную съёмку — экономия в 5000–13000 раз. Throughput — 200 изображений/час на 2× A100. Многолетний опыт 30+ проектов гарантирует, что мы выберем оптимальную модель под вашу задачу — оценку можно получить на старте.

Почему выбор модели — только половина успеха?

Fine-tuning под конкретный стиль или персонаж

Dreambooth и LoRA — стандарт для адаптации под конкретный визуальный стиль или объект. LoRA обучается за 2–4 часа на 20–30 референсных изображениях на одном A100. Rank 16–32 обычно достаточно для стиля, rank 64+ нужен для точного воспроизведения лиц.

Частая ошибка: обучать LoRA слишком долго — модель переобучается на референсы, теряет способность к вариативности. Признак: на cfg_scale=7 все изображения похожи на copy-paste референса. Лечится ранней остановкой (обычно 1500–2000 шагов для 20 изображений) и prior_preservation_loss.

Для более глубокой кастомизации — full fine-tuning через diffusers + accelerate с FSDP на нескольких GPU. Но это уже 40–80 часов обучения и нужен действительно большой датасет (1000+ изображений).

Сравнение подходов к генерации изображений

Генерация видео: какие модели лучше?

Open-weight видеомодели пока отстают от коммерческих по стабильности и длине. Wan2.1 — лучший выбор для self-hosted: 14B параметров, работает на 2× A100, даёт приемлемое качество для коротких клипов.

Главная боль видеогенерации — temporal consistency: персонаж меняет цвет одежды на третьей секунде, объект «плывёт». Частичное решение — генерация с motion_bucket_id и noise_aug_strength в Stable Video Diffusion, или использование I2V (image-to-video) вместо чистого text-to-video. Как отмечается в исследовании VideoPoet, consistency достигается за счёт обучения на длинных последовательностях.

AnimateDiff остаётся рабочим инструментом для коротких петель и motion-эффектов поверх SD/FLUX. Не Sora, но деплоится локально и предсказуем.

Генерация музыки и аудио

AudioCraft от Meta (MusicGen + AudioGen) — production-готовый стек для музыкальной генерации. musicgen-large (3.3B) генерирует 30 с музыки за ~8 с на A100. Управление через текстовый промпт и melody conditioning — можно задать мелодию напеванием.

Stable Audio Open от Stability AI — альтернатива с длиной до 47 с, лучшая управляемость структурой (intro/verse/chorus). Деплой аналогичен: diffusers + FastAPI.

Для voice-over и озвучки — ElevenLabs API или self-hosted XTTS v2 (см. услугу Speech AI). Для sound design и foley — AudioGen.

3D-генерация: практическое состояние

3D-генерация всё ещё не добралась до той же зрелости, что 2D. Но для конкретных задач инструменты уже рабочие:

TripoSG и Shap-E — text/image-to-3D. Shap-E от OpenAI генерирует простые 3D-меши за секунды, но геометрия грубовата. TripoSG даёт более детальные результаты, но требует постпроцессинга (ремешинг, UV-развёртка).

Wonder3D и Zero123++ — реконструкция 3D из одного изображения. Работают через генерацию multi-view (6–8 видов) и последующее 3D-восстановление через NeuS или instant-ngp.

Gaussian Splatting (3DGS) — не генерация, а реконструкция из серии фото/видео. Для товарных карточек и недвижимости это уже production: 50–200 фото → 3DGS модель за 15–30 мин на RTX 4090 → интерактивный 3D-вьювер в браузере.

Инфраструктура и деплой

Для генеративных моделей критично:

• Очередь задач — Celery + Redis или Ray Serve. Синхронный HTTP для генерации изображений неприемлем при >5 конкурентных запросов.
• Кэширование — схожие промпты дают похожие результаты. Семантический кэш через эмбеддинги (faiss + sentence-transformers) может снизить нагрузку на GPU на 20–40%.
• Мониторинг качества — CLIP score для text-image alignment, FID для оценки распределения генераций. Интеграция в MLflow или Weights & Biases.
• Хранение — сгенерированные изображения сразу в S3/MinIO, не на диске сервера инференса.

Что входит в работу (deliverables)

Мы берём проект под ключ — от выбора модели до деплоя и мониторинга. В результат входит:

• Модель (или API-интеграция) с бенчмарками производительности (latency p99, throughput).
• Документация пайплайна (prompt engineering guide, model card, версии зависимостей).
• Интеграция с вашим бэкендом (REST/gRPC, очереди).
• Настроенный мониторинг (дашборды, алерты по дрейфу качества).
• Обучающий воркшоп для команды (2–4 часа).
• Гарантийная поддержка 3 месяца после запуска — в рамках сертификата качества на нашу работу.

Исторически мы выполнили 30+ проектов в генеративном AI — это даёт нам право гарантировать результат.

Как строится процесс разработки генеративного AI?

1. Аналитика (1–2 дня): аудит текущей архитектуры, уточнение use case, выбор моделей и метрик успеха. Оцениваем проект бесплатно.
2. Proof of Concept (1–3 недели): быстрый прототип на ваших данных — чтобы видеть реальное качество, а не демо из блога.
3. Проектирование (1–2 недели): архитектура пайплайна, инфраструктура (GPU-кластер/API), план A/B-тестирования.
4. Реализация и fine-tuning (4–12 недель): разработка, обучение LoRA/full fine-tuning, интеграция с очередью и кэшем.
5. Тестирование (1–2 недели): нагрузочные тесты, валидация метрик, проверка на edge-case (негативные сценарии).
6. Деплой и мониторинг (1–2 недели): развёртывание на production, настройка мониторинга, документирование.

Сроки ориентировочно

Интеграция готового API (DALL‑E 3, Midjourney API, Stability API) — 1–2 недели. Self-hosted пайплайн с fine-tuning — 6–12 недель. Полная платформа с UI, очередями и мониторингом — 3–6 месяцев. Конкретная стоимость рассчитывается индивидуально после анализа вашего сценария.

Свяжитесь с нами — закажите консультацию, и мы подберём оптимальную архитектуру для вашего проекта. Получите предварительную оценку стоимости и сроков бесплатно.