Введение: От простой идеи к сложной архитектуре
Знакома ситуация, когда рядовая задача по добавлению кнопки превращается в раскопки древних пластов спагетти-кода? В геймдеве эта боль проявляется острее всего: логика персонажей, интерфейс и физика норовят слиться в один неразрывный ком (примерно как модули в 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) для выбора алгоритма валидации — например, для «строгих» клиентов (точный порядок слоев) и «лояльных» (главное, чтобы все нужные компоненты присутствовали внутри).
Когда логика заказов и проверки выстроена, остается последний рубеж — сделать так, чтобы вся эта красота плавно отрисовывалась в браузере.
Оптимизация рендеринга и Производительность интерфейса
Даже если наша игровая логика написана идеально, плохой пользовательский интерфейс может полностью разрушить впечатление от игры. В симуляторе сэндвича визуализация каждого слоя играет ключевую роль.
- Виртуализация слоев: кеширование статических слоев для сэндвичей из более чем 20 ингредиентов.
- Паттерн «Наблюдатель» (Observer): подписка интерфейса на изменения в
SandwichContextвместо постоянного опроса. - Пул объектов (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.