42 KiB

Raw Blame History Unescape Escape

Создание космической игры. Часть 1: Введение

journey
    title Your Game Development Journey
    section Foundation
      Learn game architecture: 3: Student
      Understand inheritance: 4: Student
      Explore composition: 4: Student
    section Communication
      Build pub/sub system: 4: Student
      Design event flow: 5: Student
      Connect components: 5: Student
    section Application
      Create game objects: 5: Student
      Implement patterns: 5: Student
      Plan game structure: 5: Student

Как и центр управления полетами NASA координирует работу множества систем во время запуска космического корабля, мы создадим космическую игру, которая покажет, как различные части программы могут работать вместе безупречно. Создавая что-то, во что можно действительно играть, вы изучите основные концепции программирования, которые применимы к любому программному проекту.

Мы рассмотрим два фундаментальных подхода к организации кода: наследование и композицию. Это не просто академические концепции – это те же самые шаблоны, которые используются в создании видеоигр, банковских систем и многого другого. Мы также реализуем систему коммуникации, называемую pub/sub, которая работает как сети связи, используемые в космических аппаратах, позволяя различным компонентам обмениваться информацией без создания зависимостей.

К концу этой серии уроков вы поймете, как создавать приложения, которые могут масштабироваться и развиваться – будь то игры, веб-приложения или любые другие программные системы.

mindmap
  root((Game Architecture))
    Object Organization
      Inheritance
      Composition
      Class Hierarchies
      Behavior Mixing
    Communication Patterns
      Pub/Sub System
      Event Emitters
      Message Passing
      Loose Coupling
    Game Objects
      Properties (x, y)
      Behaviors (move, collide)
      Lifecycle Management
      State Management
    Design Patterns
      Factory Functions
      Observer Pattern
      Component System
      Event-Driven Architecture
    Scalability
      Modular Design
      Maintainable Code
      Testing Strategies
      Performance Optimization

Тест перед лекцией

Наследование и композиция в разработке игр

По мере усложнения проектов организация кода становится критически важной. То, что начинается как простой скрипт, может стать трудным для поддержки без правильной структуры – так же, как миссии "Аполлон" требовали тщательной координации между тысячами компонентов.

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

✅ Одна из самых известных книг о программировании посвящена шаблонам проектирования.

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

Несмотря на визуальные различия, эти объекты часто имеют общие базовые поведения:

Они существуют где-то – У каждого объекта есть координаты x и y, чтобы игра знала, где его нарисовать
Многие могут двигаться – Герои бегают, враги преследуют, пули летят по экрану
У них есть срок жизни – Некоторые остаются навсегда, другие (например, взрывы) появляются на короткое время и исчезают
Они реагируют на события – При столкновениях бонусы собираются, полоски здоровья обновляются

✅ Подумайте о такой игре, как Pac-Man. Можете ли вы определить четыре типа объектов, перечисленных выше, в этой игре?

classDiagram
    class GameObject {
        +x: number
        +y: number
        +type: string
        +exists_somewhere()
    }
    
    class MovableObject {
        +moveTo(x, y)
        +can_move_around()
    }
    
    class TemporaryObject {
        +lifespan: number
        +has_lifespan()
    }
    
    class InteractiveObject {
        +onCollision()
        +reacts_to_stuff()
    }
    
    GameObject <|-- MovableObject
    GameObject <|-- TemporaryObject
    GameObject <|-- InteractiveObject
    
    MovableObject <|-- Hero
    MovableObject <|-- Enemy
    MovableObject <|-- Bullet
    
    TemporaryObject <|-- PowerUp
    TemporaryObject <|-- Explosion
    
    InteractiveObject <|-- Collectible
    InteractiveObject <|-- Obstacle

Выражение поведения через код

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

Подход на основе классов

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

✅ Наследование – важная концепция для понимания. Узнайте больше в статье MDN о наследовании.

Вот как можно реализовать игровые объекты с использованием классов и наследования:

// Step 1: Create the base GameObject class
class GameObject {
  constructor(x, y, type) {
    this.x = x;
    this.y = y;
    this.type = type;
  }
}

Разберем это шаг за шагом:

Мы создаем базовый шаблон, который может использовать каждый игровой объект
Конструктор сохраняет, где находится объект (x, y) и что это за объект
Это становится основой, на которой будут строиться все ваши игровые объекты

// Step 2: Add movement capability through inheritance
class Movable extends GameObject {
  constructor(x, y, type) {
    super(x, y, type); // Call parent constructor
  }

  // Add the ability to move to a new position
  moveTo(x, y) {
    this.x = x;
    this.y = y;
  }
}

В приведенном выше примере мы:

Расширили класс GameObject, добавив функциональность движения
Вызвали родительский конструктор с помощью super(), чтобы инициализировать унаследованные свойства
Добавили метод moveTo(), который обновляет позицию объекта

// Step 3: Create specific game object types
class Hero extends Movable {
  constructor(x, y) {
    super(x, y, 'Hero'); // Set type automatically
  }
}

class Tree extends GameObject {
  constructor(x, y) {
    super(x, y, 'Tree'); // Trees don't need movement
  }
}

// Step 4: Use your game objects
const hero = new Hero(0, 0);
hero.moveTo(5, 5); // Hero can move!

const tree = new Tree(10, 15);
// tree.moveTo() would cause an error - trees can't move

Понимание этих концепций:

Создает специализированные типы объектов, которые наследуют соответствующие поведения
Демонстрирует, как наследование позволяет выборочно включать функции
Показывает, что герои могут двигаться, а деревья остаются неподвижными
Иллюстрирует, как иерархия классов предотвращает неподходящие действия

✅ Потратьте несколько минут, чтобы представить героя Pac-Man (например, Инки, Пинки или Блинки) и как он мог бы быть написан на JavaScript.

Подход на основе композиции

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

// Step 1: Create base behavior objects
const gameObject = {
  x: 0,
  y: 0,
  type: ''
};

const movable = {
  moveTo(x, y) {
    this.x = x;
    this.y = y;
  }
};

Что делает этот код:

Определяет базовый gameObject с координатами и свойствами типа
Создает отдельный объект поведения movable с функциональностью движения
Разделяет задачи, сохраняя данные о позиции и логику движения независимыми

// Step 2: Compose objects by combining behaviors
const movableObject = { ...gameObject, ...movable };

// Step 3: Create factory functions for different object types
function createHero(x, y) {
  return {
    ...movableObject,
    x,
    y,
    type: 'Hero'
  };
}

function createStatic(x, y, type) {
  return {
    ...gameObject,
    x,
    y,
    type
  };
}

В приведенном выше примере мы:

Объединили свойства базового объекта с поведением движения, используя синтаксис spread
Создали фабричные функции, возвращающие настроенные объекты
Обеспечили гибкое создание объектов без жестких иерархий классов
Позволили объектам иметь только те поведения, которые им нужны

// Step 4: Create and use your composed objects
const hero = createHero(10, 10);
hero.moveTo(5, 5); // Works perfectly!

const tree = createStatic(0, 0, 'Tree');
// tree.moveTo() is undefined - no movement behavior was composed

Основные моменты, которые нужно запомнить:

Комбинирует объекты, смешивая поведения, а не наследуя их
Предоставляет больше гибкости, чем жесткие иерархии наследования
Позволяет объектам иметь только те функции, которые им нужны
Использует современный синтаксис spread в JavaScript для чистого объединения объектов


**Which Pattern Should You Choose?**

**Which Pattern Should You Choose?**

```mermaid
quadrantChart
    title Code Organization Patterns
    x-axis Simple --> Complex
    y-axis Rigid --> Flexible
    quadrant-1 Advanced Composition
    quadrant-2 Hybrid Approaches
    quadrant-3 Basic Inheritance
    quadrant-4 Modern Composition
    
    Class Inheritance: [0.3, 0.2]
    Interface Implementation: [0.6, 0.4]
    Mixin Patterns: [0.7, 0.7]
    Pure Composition: [0.8, 0.9]
    Factory Functions: [0.5, 0.8]
    Prototype Chain: [0.4, 0.3]

💡 Полезный совет: Оба подхода имеют свое место в современной разработке на JavaScript. Классы хорошо подходят для четко определенных иерархий, а композиция – для максимальной гибкости.

Когда использовать каждый подход:

Выбирайте наследование, если у вас есть четкие отношения "является" (Герой является движущимся объектом)
Выбирайте композицию, если вам нужны отношения "имеет" (Герой имеет способности к движению)
Учитывайте предпочтения вашей команды и требования проекта
Помните, что вы можете смешивать оба подхода в одном приложении

🔄 Педагогическая проверка

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

✅ Объяснить разницу между наследованием и композицией
✅ Определить, когда использовать классы и фабричные функции
✅ Понять, как работает ключевое слово super() в наследовании
✅ Осознать преимущества каждого подхода для разработки игр

Быстрый тест: Как бы вы создали Летающего Врага, который может и двигаться, и летать?

Подход наследования: class FlyingEnemy extends Movable
Подход композиции: { ...movable, ...flyable, ...gameObject }

Связь с реальным миром: Эти паттерны встречаются повсюду:

React-компоненты: Props (композиция) против наследования классов
Игровые движки: Системы сущностей-компонентов используют композицию
Мобильные приложения: UI-фреймворки часто используют иерархии наследования

Паттерны коммуникации: система Pub/Sub

По мере усложнения приложений управление коммуникацией между компонентами становится сложной задачей. Паттерн публикации-подписки (pub/sub) решает эту проблему, используя принципы, схожие с радиовещанием – один передатчик может достигать множества приемников, не зная, кто слушает.

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

✅ Pub/Sub расшифровывается как 'публикация-подписка'

flowchart TD
    A[Hero Takes Damage] --> B[Publish: HERO_DAMAGED]
    B --> C[Event System]
    
    C --> D[Health Bar Subscriber]
    C --> E[Sound System Subscriber]
    C --> F[Visual Effects Subscriber]
    C --> G[Achievement System Subscriber]
    
    D --> H[Update Health Display]
    E --> I[Play Damage Sound]
    F --> J[Show Red Flash]
    G --> K[Check Survival Achievements]
    
    style A fill:#ffebee
    style B fill:#e1f5fe
    style C fill:#e8f5e8
    style H fill:#fff3e0
    style I fill:#fff3e0
    style J fill:#fff3e0
    style K fill:#fff3e0

Понимание архитектуры Pub/Sub

Паттерн pub/sub позволяет различным частям вашего приложения быть слабо связанными, что означает, что они могут работать вместе, не будучи напрямую зависимыми друг от друга. Такое разделение делает ваш код более поддерживаемым, тестируемым и гибким к изменениям.

Основные элементы pub/sub:

Сообщения – Простые текстовые метки, такие как 'PLAYER_SCORED', которые описывают произошедшее (плюс любая дополнительная информация)
Издатели – Объекты, которые "кричат" о том, что что-то произошло, всем, кто слушает
Подписчики – Объекты, которые говорят "Мне важно это событие" и реагируют, когда оно происходит
Система событий – Посредник, который обеспечивает доставку сообщений нужным слушателям

Создание системы событий

Давайте создадим простую, но мощную систему событий, которая демонстрирует эти концепции:

// Step 1: Create the EventEmitter class
class EventEmitter {
  constructor() {
    this.listeners = {}; // Store all event listeners
  }
  
  // Register a listener for a specific message type
  on(message, listener) {
    if (!this.listeners[message]) {
      this.listeners[message] = [];
    }
    this.listeners[message].push(listener);
  }
  
  // Send a message to all registered listeners
  emit(message, payload = null) {
    if (this.listeners[message]) {
      this.listeners[message].forEach(listener => {
        listener(message, payload);
      });
    }
  }
}

Разберем, что здесь происходит:

Создается центральная система управления событиями с использованием простого класса
Сохраняются слушатели в объекте, организованном по типу сообщений
Регистрируются новые слушатели с помощью метода on()
Передаются сообщения всем заинтересованным слушателям с помощью emit()
Поддерживаются необязательные данные для передачи соответствующей информации

Объединение всего: практический пример

Давайте посмотрим, как это работает на практике! Мы создадим простую систему движения, которая показывает, насколько чистым и гибким может быть pub/sub:

// Step 1: Define your message types
const Messages = {
  HERO_MOVE_LEFT: 'HERO_MOVE_LEFT',
  HERO_MOVE_RIGHT: 'HERO_MOVE_RIGHT',
  ENEMY_SPOTTED: 'ENEMY_SPOTTED'
};

// Step 2: Create your event system and game objects
const eventEmitter = new EventEmitter();
const hero = createHero(0, 0);

Что делает этот код:

Определяет объект констант, чтобы избежать опечаток в названиях сообщений
Создает экземпляр эмиттера событий для управления всей коммуникацией
Инициализирует объект героя в начальной позиции

// Step 3: Set up event listeners (subscribers)
eventEmitter.on(Messages.HERO_MOVE_LEFT, () => {
  hero.moveTo(hero.x - 5, hero.y);
  console.log(`Hero moved to position: ${hero.x}, ${hero.y}`);
});

eventEmitter.on(Messages.HERO_MOVE_RIGHT, () => {
  hero.moveTo(hero.x + 5, hero.y);
  console.log(`Hero moved to position: ${hero.x}, ${hero.y}`);
});

В приведенном выше примере мы:

Зарегистрировали слушателей событий, которые реагируют на сообщения о движении
Обновили позицию героя на основе направления движения
Добавили вывод в консоль для отслеживания изменений позиции героя
Разделили логику движения и обработку ввода

// Step 4: Connect keyboard input to events (publishers)
window.addEventListener('keydown', (event) => {
  switch(event.key) {
    case 'ArrowLeft':
      eventEmitter.emit(Messages.HERO_MOVE_LEFT);
      break;
    case 'ArrowRight':
      eventEmitter.emit(Messages.HERO_MOVE_RIGHT);
      break;
  }
});

Понимание этих концепций:

Соединяет ввод с игровыми событиями без жесткой связи
Позволяет системе ввода общаться с игровыми объектами косвенно
Обеспечивает, чтобы несколько систем реагировали на одни и те же события ввода
Упрощает изменение привязки клавиш или добавление новых методов ввода

sequenceDiagram
    participant User
    participant Keyboard
    participant EventEmitter
    participant Hero
    participant SoundSystem
    participant Camera
    
    User->>Keyboard: Presses ArrowLeft
    Keyboard->>EventEmitter: emit('HERO_MOVE_LEFT')
    EventEmitter->>Hero: Move left 5 pixels
    EventEmitter->>SoundSystem: Play footstep sound
    EventEmitter->>Camera: Follow hero
    
    Hero->>Hero: Update position
    SoundSystem->>SoundSystem: Play audio
    Camera->>Camera: Adjust viewport

💡 Полезный совет: Прелесть этого паттерна – в его гибкости! Вы можете легко добавить звуковые эффекты, тряску экрана или эффекты частиц, просто добавив больше слушателей событий – не нужно изменять существующий код ввода или движения.

Почему вам понравится этот подход:

Добавление новых функций становится очень простым – просто слушайте нужные события
Несколько систем могут реагировать на одно событие, не мешая друг другу
Тестирование становится намного проще, так как каждая часть работает независимо
Когда что-то ломается, вы точно знаете, где искать проблему

Почему Pub/Sub эффективно масштабируется

Паттерн pub/sub сохраняет простоту, даже когда приложения становятся сложными. Независимо от того, управляете ли вы десятками врагов, динамическими обновлениями интерфейса или звуковыми системами, этот паттерн справляется с увеличением масштаба без изменений архитектуры. Новые функции интегрируются в существующую систему событий, не затрагивая уже установленную функциональность.

⚠️ Распространенная ошибка: Не создавайте слишком много специфичных типов сообщений на ранних этапах. Начните с широких категорий и уточняйте их по мере того, как потребности вашей игры становятся яснее.

Лучшие практики:

Группируйте связанные сообщения в логические категории
Используйте описательные названия, которые четко указывают на произошедшее
Делайте данные сообщений простыми и целенаправленными
Документируйте типы сообщений для командной работы

🔄 Педагогическая проверка

Понимание архитектуры, основанной на событиях: Убедитесь, что вы понимаете всю систему:

✅ Как паттерн pub/sub предотвращает жесткую связь между компонентами?
✅ Почему легче добавлять новые функции с архитектурой, основанной на событиях?
✅ Какую роль играет EventEmitter в процессе коммуникации?
✅ Как константы сообщений предотвращают ошибки и улучшают поддерживаемость?

Дизайнерский вызов: Как бы вы справились с этими игровыми сценариями, используя pub/sub?

Враг умирает: Обновить счет, воспроизвести звук, создать бонус, удалить с экрана
Уровень завершен: Остановить музыку, показать интерфейс, сохранить прогресс, загрузить следующий уровень
Собран бонус: Улучшить способности, обновить интерфейс, воспроизвести эффект, запустить таймер

Профессиональная связь: Этот паттерн используется в:

Фреймворках фронтенда: Системы событий React/Vue
Сервисах бэкенда: Коммуникация микросервисов
Игровых движках: Система событий Unity
Мобильной разработке: Системы уведомлений iOS/Android

Вызов GitHub Copilot Agent 🚀

Используйте режим Agent, чтобы выполнить следующий вызов:

Описание: Создайте простую систему игровых объектов, используя как наследование, так и паттерн pub/sub. Вы реализуете базовую игру, где различные объекты могут общаться через события, не зная друг о друге напрямую.

Задание: Создайте систему игры на JavaScript с следующими требованиями: 1) Создайте базовый класс GameObject с координатами x, y и свойством типа. 2) Создайте класс Hero, который расширяет GameObject и может двигаться. 3) Создайте класс Enemy, который расширяет GameObject и может преследовать героя. 4) Реализуйте класс EventEmitter для паттерна pub/sub. 5) Настройте слушателей событий так, чтобы при движении героя ближайшие враги получали событие 'HERO_MOVED' и обновляли свою позицию, чтобы двигаться к герою. Включите вывод в консоль, чтобы показать коммуникацию между объектами.

Узнайте больше о режиме агент здесь.

🚀 Вызов

Рассмотрите, как паттерн pub-sub может улучшить архитектуру игры. Определите, какие компоненты должны генерировать события и как система должна на них реагировать. Разработайте концепцию игры и спланируйте коммуникационные паттерны между её компонентами.

Тест после лекции

Обзор и самостоятельное изучение

Узнайте больше о Pub/Sub, прочитав об этом.

⚡ Что можно сделать за следующие 5 минут

Откройте любую HTML5-игру онлайн и изучите её код с помощью DevTools
Создайте простой элемент HTML5 Canvas и нарисуйте базовую фигуру
Попробуйте использовать setInterval для создания простого цикла анимации
Ознакомьтесь с документацией API Canvas и попробуйте метод рисования

🎯 Что можно достичь за час

Пройдите тест после урока и разберитесь в концепциях разработки игр
Настройте структуру проекта игры с файлами HTML, CSS и JavaScript
Создайте базовый игровой цикл, который обновляется и рендерится непрерывно
Нарисуйте свои первые игровые спрайты на Canvas
Реализуйте базовую загрузку ресурсов для изображений и звуков

📅 Создание игры за неделю

Завершите полную космическую игру со всеми запланированными функциями
Добавьте качественную графику, звуковые эффекты и плавные анимации
Реализуйте игровые состояния (экран начала, игровой процесс, конец игры)
Создайте систему подсчёта очков и отслеживания прогресса игрока
Сделайте игру адаптивной и доступной на разных устройствах
Поделитесь своей игрой онлайн и соберите отзывы от игроков

🌟 Разработка игр за месяц

Создайте несколько игр, исследуя разные жанры и механики
Изучите фреймворк для разработки игр, например Phaser или Three.js
Внесите вклад в проекты разработки игр с открытым исходным кодом
Освойте продвинутые паттерны программирования игр и оптимизацию
Создайте портфолио, демонстрирующее ваши навыки разработки игр
Станьте наставником для тех, кто интересуется разработкой игр и интерактивными медиа

🎯 Таймлайн вашего мастерства в разработке игр

timeline
    title Game Architecture Learning Progression
    
    section Object Patterns (20 minutes)
        Code Organization: Class inheritance
                         : Composition patterns
                         : Factory functions
                         : Behavior mixing
        
    section Communication Systems (25 minutes)
        Event Architecture: Pub/Sub implementation
                          : Message design
                          : Event emitters
                          : Loose coupling
        
    section Game Object Design (30 minutes)
        Entity Systems: Property management
                      : Behavior composition
                      : State handling
                      : Lifecycle management
        
    section Architecture Patterns (35 minutes)
        System Design: Component systems
                     : Observer pattern
                     : Command pattern
                     : State machines
        
    section Advanced Concepts (45 minutes)
        Scalable Architecture: Performance optimization
                             : Memory management
                             : Modular design
                             : Testing strategies
        
    section Game Engine Concepts (1 week)
        Professional Development: Scene graphs
                                 : Asset management
                                 : Rendering pipelines
                                 : Physics integration
        
    section Framework Mastery (2 weeks)
        Modern Game Development: React game patterns
                               : Canvas optimization
                               : WebGL basics
                               : PWA games
        
    section Industry Practices (1 month)
        Professional Skills: Team collaboration
                           : Code reviews
                           : Game design patterns
                           : Performance profiling

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

После завершения этого урока вы освоили:

Мастерство паттернов проектирования: Понимание компромиссов между наследованием и композицией
Архитектура, основанная на событиях: Реализация pub/sub для масштабируемой коммуникации
Объектно-ориентированное проектирование: Иерархии классов и композиция поведения
Современный JavaScript: Фабричные функции, синтаксис spread и паттерны ES6+
Масштабируемая архитектура: Принципы слабой связанности и модульного дизайна
Основы разработки игр: Системы сущностей и паттерны компонентов
Профессиональные паттерны: Стандарты индустрии для организации кода

Применение в реальном мире: Эти паттерны напрямую применимы к:

Фреймворкам фронтенда: Архитектура компонентов React/Vue и управление состоянием
Бэкенд-сервисам: Коммуникация микросервисов и системы, основанные на событиях
Мобильной разработке: Архитектура приложений для iOS/Android и системы уведомлений
Игровым движкам: Unity, Unreal и разработка игр для веба
Корпоративному ПО: Проектирование событийных и распределённых систем
Дизайну API: RESTful-сервисы и системы реального времени

Приобретённые профессиональные навыки: Теперь вы можете:

Проектировать масштабируемые архитектуры программного обеспечения, используя проверенные паттерны
Реализовывать системы, основанные на событиях, для сложных взаимодействий
Выбирать подходящие стратегии организации кода для различных сценариев
Отлаживать и эффективно поддерживать системы с слабой связанностью
Объяснять технические решения, используя терминологию индустриального стандарта

Следующий уровень: Вы готовы реализовать эти паттерны в реальной игре, изучить продвинутые темы разработки игр или применить эти архитектурные концепции к веб-приложениям!

🌟 Достижение разблокировано: Вы освоили фундаментальные паттерны архитектуры программного обеспечения, которые лежат в основе всего — от простых игр до сложных корпоративных систем!

Задание

Создайте макет игры

Отказ от ответственности:
Этот документ был переведен с использованием сервиса автоматического перевода Co-op Translator. Хотя мы стремимся к точности, пожалуйста, учитывайте, что автоматические переводы могут содержать ошибки или неточности. Оригинальный документ на его родном языке следует считать авторитетным источником. Для получения критически важной информации рекомендуется профессиональный перевод человеком. Мы не несем ответственности за любые недоразумения или неправильные интерпретации, возникающие в результате использования данного перевода.

42 KiB Raw Blame History Unescape Escape

Создание космической игры. Часть 1: Введение

Тест перед лекцией

Наследование и композиция в разработке игр

Выражение поведения через код

🔄 Педагогическая проверка

Паттерны коммуникации: система Pub/Sub

Понимание архитектуры Pub/Sub

Создание системы событий

Объединение всего: практический пример

Почему Pub/Sub эффективно масштабируется

🔄 Педагогическая проверка

Вызов GitHub Copilot Agent 🚀

🚀 Вызов

Тест после лекции

Обзор и самостоятельное изучение

⚡ Что можно сделать за следующие 5 минут

🎯 Что можно достичь за час

📅 Создание игры за неделю

🌟 Разработка игр за месяц

🎯 Таймлайн вашего мастерства в разработке игр

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

Задание

42 KiB

Raw Blame History Unescape Escape