Video Game Development Course

Lesson 1 • Core Game Design Vocabulary

Defines mechanics, dynamics, aesthetics, and player experience terminology. Gives students a shared language for design discussions and documentation.

Lesson 2 • Choosing a Game Engine

Compares leading real-time engines on performance, licensing, and tooling. Students select an appropriate engine for their target platform and project scope.

Lesson 3 • The Game Industry Landscape

Covers studio types, market segments, and career paths in game development. Establishes context for all technical and creative decisions made throughout the course.

Lesson 4 • Game Development Pipeline Overview

Traces a game from concept to ship across pre-production, production, and post-launch phases. Provides the workflow context students will apply in every subsequent chapter.

Lesson 1 • Mechanics, Rules, and Systems Design

Breaks down complex game systems into discrete rules and interactions. Students model emergent behavior from simple mechanic combinations.

Lesson 2 • Core Gameplay Loop Design

Defines the primary action-reward cycle that keeps players engaged. Students diagram and validate their loop before committing to full production.

Lesson 3 • Rapid Prototyping and Playtesting

Builds low-fidelity prototypes to validate design assumptions quickly. Introduces structured playtesting methods to gather actionable feedback.

Lesson 4 • Player Psychology and Motivation

Applies motivation theory to design decisions around progression, mastery, and social play. Connects psychological principles directly to mechanic choices.

Lesson 1 • Data Structures for Game Logic

Introduces arrays, lists, dictionaries, and queues applied to game state management. Students choose appropriate structures for inventory, AI, and level data.

Lesson 2 • Scripting Language Essentials

Covers variables, data types, control flow, and functions in the engine's primary scripting language. Forms the syntax foundation for all game logic written later.

Lesson 3 • Design Patterns in Game Code

Covers singleton, observer, state machine, and object pool patterns common in game codebases. Students apply patterns to reduce coupling and improve scalability.

Lesson 4 • Object-Oriented Programming in Games

Applies classes, inheritance, and encapsulation to game entity design. Students refactor procedural scripts into maintainable OOP structures.

Lesson 1 • 2D Physics and Collision

Configures rigidbodies, colliders, and physics materials for realistic 2D interaction. Students implement platformer movement and projectile physics.

Lesson 2 • Sprites, Atlases, and Animation

Covers sprite import settings, texture atlases, and frame-based animation workflows. Students create animated characters ready for gameplay integration.

Lesson 3 • Tilemap and Level Design Tools

Uses engine tilemap editors to build scrolling levels with collision and layering. Connects level design theory from Chapter 2 to practical engine tooling.

Lesson 4 • 2D UI and HUD Implementation

Builds health bars, score displays, and menus using the engine's UI canvas system. Students wire UI elements to game state through scripted data binding.

Lesson 1 • 3D Coordinate Systems and Transforms

Explains world, local, and screen space alongside position, rotation, and scale transforms. Provides the spatial reasoning required for all 3D object manipulation.

Lesson 2 • Lighting and Shadow Systems

Configures real-time and baked lighting, shadow maps, and ambient occlusion. Students balance visual quality against runtime performance budgets.

Lesson 3 • 3D Physics and Raycasting

Applies 3D colliders, joints, and raycasting for interaction and combat systems. Students implement object pickup, projectile detection, and physics-driven puzzles.

Lesson 4 • 3D Character Controller and Animation

Implements a rigged character with locomotion, jumping, and root motion animation. Connects animator state machines to player input for responsive control.

Lesson 1 • Game Difficulty and AI Tuning

Balances AI aggression, reaction time, and accuracy across difficulty settings. Students implement dynamic difficulty adjustment tied to player performance metrics.

Lesson 2 • Finite State Machines for AI

Structures enemy behavior as discrete states with defined transitions and conditions. Students build patrol, chase, and attack FSMs for a combat enemy.

Lesson 3 • Behavior Trees and Decision Making

Introduces behavior tree nodes—selectors, sequences, and decorators—for modular AI logic. Students convert an FSM enemy into a behavior tree for improved scalability.

Lesson 4 • Pathfinding and Navigation Meshes

Bakes navigation meshes and implements A* pathfinding for agent movement. Students configure dynamic obstacles and off-mesh links for complex environments.

Lesson 1 • Animation Events and Game Feel

Uses animation events, hit-stop, and squash-and-stretch to create satisfying interactions. Students apply game feel principles to combat, movement, and UI transitions.

Lesson 2 • Game Audio Architecture

Designs an audio system with sound effects, music layers, and spatial audio. Students implement an audio manager that handles mixing, ducking, and pooling.

Lesson 3 • Screen Shake and Haptic Feedback

Implements procedural camera shake and controller rumble to reinforce impactful moments. Connects physical feedback to game events for improved game feel.

Lesson 4 • Particle Systems and VFX

Creates explosion, impact, and ambient particle effects using the engine's VFX tools. Students optimize particle budgets to maintain target frame rates.

Lesson 1 • Platform Build Configuration

Configures build settings, player settings, and platform-specific quality tiers for PC, console, and mobile. Students produce multi-platform builds from a single project.

Lesson 2 • Profiling and Performance Analysis

Uses engine profilers and GPU frame debuggers to identify CPU, GPU, and memory bottlenecks. Students establish performance budgets before optimizing any system.

Lesson 3 • Release Pipeline and Store Submission

Covers store listing requirements, age rating processes, and automated build pipelines. Students submit a build to a digital storefront and configure a basic CI/CD workflow.

Lesson 4 • Code and Asset Optimization

Refactors hot-path scripts, reduces garbage collection, and compresses audio and mesh assets. Students apply profiler-guided optimization rather than premature tuning.