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 персонажа на генерації — це основа для персоналізованого контенту.

Кейс: e-commerce фото-зйомка. Рітейлер з 8000 SKU потребував lifestyle-фото для кожного продукту. Пайплайн: сегментація продукту (Segment Anything Model 2) → видалення фону → inpainting FLUX.1 [dev] з product image як IP-Adapter reference → upscale через RealESRGAN_x4plus. Вартість генерації на орендованих A100 значно нижча порівняно з професійною зйомкою, економія багатократна. 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 місяців. Конкретна вартість розраховується індивідуально після аналізу вашого сценарію.

Зв'яжіться з нами — замовте консультацію, і ми підберемо оптимальну архітектуру для вашого проекту. Отримайте попередню оцінку термінів безкоштовно.