Введение: От простой идеи к сложной архитектуре

Знакома ситуация, когда рядовая задача по добавлению кнопки превращается в раскопки древних пластов спагетти-кода? В геймдеве эта боль проявляется острее всего: логика персонажей, интерфейс и физика норовят слиться в один неразрывный ком (примерно как модули в node_modules весом в гигабайт). Представьте, что вам нужно запустить вечерний релиз фичи в «Sandwich Simulator» — игре про сборку идеального бургера, где неожиданно ломается вся последовательность слоев. Как спроектировать систему так, чтобы добавление нового соуса не роняло весь движок? Сегодня мы разберем это на практике.

В этой статье мы разберем, как спроектировать и реализовать масштабируемый симулятор сборки сэндвичей с использованием TypeScript и объектно-ориентированных принципов. Мы не будем писать графический движок с нуля, но создадим надежное «сердце» приложения: доменную логику, систему событий, управление состоянием ингредиентов и валидацию рецептов. Такой подход позволяет отделить игровую логику от интерфейса, что критически важно для современных веб-приложений.

Почему именно TypeScript? Строгая типизация помогает избежать множества ошибок на этапе компиляции, особенно когда речь идет о сложных структурах данных, таких как слоистые объекты (хлеб, соус, сыр, котлета, снова хлеб). Давайте погрузимся в код и построим наш симулятор сэндвича шаг за шагом.

Проектирование доменной модели: Ингредиенты и Слои

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

Давайте определим базовые типы в TypeScript. Ингредиент должен иметь уникальный идентификатор, название, тип (хлеб, начинка, соус), пищевую ценность и визуальное представление или физические свойства.

Рассмотрим базовую структуру данных для наших ингредиентов:

type IngredientType = 'bread' | 'protein' | 'vegetable' | 'cheese' | 'sauce';

interface IIngredient {
    readonly id: string;
    readonly name: string;
    readonly type: IngredientType;
    readonly calories: number;
    readonly thickness: number; // в миллиметрах для симуляции физики
}

class Ingredient implements IIngredient {
    constructor(
        public readonly id: string,
        public readonly name: string,
        public readonly type: IngredientType,
        public readonly calories: number,
        public readonly thickness: number
    ) {}
}

Теперь нам нужна структура, которая будет удерживать эти ингредиенты вместе — сам сэндвич. Сэндвич — это упорядоченный стек ингредиентов, ограниченный сверху и снизу кусками хлеба. Для реализации такой структуры отлично подходит паттерн «Стек» (Stack) или специализированный массив с методами валидации.

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

Управление состоянием и Паттерн «Состояние» (State Pattern)

В «Sandwich Simulator» пользователь выполняет различные действия: выбирает ингредиент, кладет его на стол, перемещает, удаляет или отправляет сэндвич на дегустацию. Если описывать это с помощью разрозненных флагов (isDragging, isCooking, isService), код быстро превратится в нечитаемый «спагетти-код».

Здесь на помощь приходит паттерн «Состояние» (State Pattern). Мы можем выделить несколько ключевых фаз жизненного цикла сэндвича:

  • IdleState — ожидание выбора ингредиента.
  • BuildingState — процесс активной укладки слоев.
  • ValidatedState — проверка сэндвича на соответствие заказу.
  • CompletedState — сэндвич готов и подан клиенту.

Давайте реализуем интерфейс состояния и один из конкретных классов состояний на TypeScript:

interface ISandwichState {
    addIngredient(sandwich: SandwichContext, ingredient: IIngredient): void;
    removeTopIngredient(sandwich: SandwichContext): void;
    submit(sandwich: SandwichContext): void;
}

class BuildingState implements ISandwichState {
    addIngredient(sandwich: SandwichContext, ingredient: IIngredient): void {
        sandwich.ingredients.push(ingredient);
        console.log(`Добавлен ингредиент: ${ingredient.name}`);
        
        if (sandwich.getTotalHeight() > 150) {
            console.warn('Внимание: Сэндвич стал слишком высоким и может упасть!');
        }
    }

    removeTopIngredient(sandwich: SandwichContext): void {
        const removed = sandwich.ingredients.pop();
        if (removed) {
            console.log(`Удален верхний ингредиент: ${removed.name}`);
        }
    }

    submit(sandwich: SandwichContext): void {
        console.log('Сэндвич отправлен на проверку.');
        sandwich.setState(new ValidatedState());
    }
}

Использование такого подхода позволяет изолировать логику поведения. Если игрок попытается добавить ингредиент в состоянии CompletedState, система просто выдаст предупреждение или проигнорирует действие.

Управлять слоями научились, но игра не имеет смысла, если виртуальные гости не оценивают кулинарные шедевры игрока по достоинству.

Система валидации рецептов и Заказы клиентов

Какой симулятор без системы заказов? Наш «Sandwich Simulator» должен проверять, насколько творение игрока соответствует ожиданиям виртуального клиента. Для этого мы создадим систему рецептов и механизм сопоставления (pattern matching).

Клиент приходит с определенными требованиями: «Хочу классический чизбургер». Наша задача — программно проверить, совпадает ли последовательность слоев в созданном SandwichContext с целевым рецептом.

interface IRecipe {
    readonly name: string;
    readonly requiredLayers: string[]; // Массив ID или типов ингредиентов
}

class RecipeValidator {
    static validate(sandwich: SandwichContext, recipe: IRecipe): boolean {
        const currentLayers = sandwich.ingredients.map(ing => ing.id);
        
        if (currentLayers.length !== recipe.requiredLayers.length) {
            return false;
        }

        return currentLayers.every((id, index) => id === recipe.requiredLayers[index]);
    }
}

Мы также можем применить паттерн «Стратегия» (Strategy Pattern) для выбора алгоритма валидации — например, для «строгих» клиентов (точный порядок слоев) и «лояльных» (главное, чтобы все нужные компоненты присутствовали внутри).

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

Оптимизация рендеринга и Производительность интерфейса

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

  1. Виртуализация слоев: кеширование статических слоев для сэндвичей из более чем 20 ингредиентов.
  2. Паттерн «Наблюдатель» (Observer): подписка интерфейса на изменения в SandwichContext вместо постоянного опроса.
  3. Пул объектов (Object Pooling): снижение нагрузки на сборщик мусора при создании сотен крошек или капель соуса (чтобы GC не устраивал фризы в самый ответственный момент сборки бургера).

Пример простой реализации издателя-подписчика для визуального обновления:

type Listener<T> = (data: T) => void;

class EventBus<T> {
    private listeners: Listener<T>[] = [];

    subscribe(listener: Listener<T>): void {
        this.listeners.push(listener);
    }

    unsubscribe(listener: Listener<T>): void {
        this.listeners = this.listeners.filter(l => l !== listener);
    }

    notify(data: T): void {
        this.listeners.forEach(listener => listener(data));
    }
}

Заключение

Создание даже такого простого приложения, как «Sandwich Simulator», наглядно демонстрирует важность правильного архитектурного проектирования. Использование строгой типизации TypeScript, разделения доменной логики с помощью паттернов «Состояние» и «Стратегия», а также эффективного управления событиями позволяет превратить хаотичный скрипт в чистое, расширяемое и тестируемое приложение.

Такой подход оставляет огромный простор для масштабирования: вы легко можете добавить новые типы клиентов, физику падения сэндвичей, мультиплеер на WebSockets или интеграцию с современными фреймворками. Создавайте архитектуру с умом, пишите чистый код и приятного аппетита вашему симулятору!

Что делать дальше? Откройте свой текущий пет-проект (который вы «обязательно допишете на выходных»), найдите в нем самый раздутый компонент и попробуйте применить к нему паттерн «Состояние», вынеся логику в чистый TypeScript-класс без примеси UI.