The question or thesis
Classic arcade games are unusually good study material for two audiences at once: designers learning what makes a system readable and replayable, and programmers learning the fundamentals of building a game. Each canonical arcade title isolates a small, legible cluster of mechanics, which is exactly what makes it both a clean design case study and a tractable first coding project.
This page synthesises the teaching framing in the Classic Games canon reference (see source-classic-games-canon) into two routes: a set of arcade design case studies, and a graded beginner coding progression aimed at Unity/C#. It deliberately leans on small original projects inspired by recognisable patterns rather than reproductions of the original games.
What the evidence suggests
Arcade classics as design case studies
The source nominates eight arcade titles as the most useful design case studies, each demonstrating one or two clearly transferable ideas (source: source-classic-games-canon):
- Pong (1972) — minimal rules and immediate readability; the baseline for competitive legibility.
- Breakout (1976) — collision response, score, level clearance, and difficulty tuning; the move from two-player bat-and-ball to solo score-attack.
- Space Invaders (1978) — wave pressure, enemy formations, and lives; the fixed-screen shooter as a mass genre.
- Pac-Man (1980) — maze readability, enemy behaviour, and power reversal; see the fuller treatment in pac-man.
- Donkey Kong (1981) — authored platform challenges and character identity; the origin point for Mario.
- Robotron: 2084 (1982) — enemy archetypes and spatial survival pressure; the defining twin-stick shooter.
- Out Run (1986) — mood, flow, music, and route choice; atmosphere as a design pillar.
- Street Fighter II (1991) — asymmetric characters and competitive mastery; see the fuller treatment in street-fighter-ii.
The recurring design lessons across these examples connect to existing wiki concepts: immediate, readable feedback (game-feel); escalating challenge against player skill (flow, smooth-learning-curves); the arcade-era rule that good games are easy to learn and hard to master (bushnells-law); and score-chasing and lives as session-shaping pressure (lives, time-limits). Street Fighter II is notable precisely because it violates Bushnell’s Law and succeeds anyway through social context.
Arcade classics as a beginner coding progression
The source rates arcade-style games for beginner-coding suitability and recommends a build order. The pedagogical logic is that each step introduces one new class of problem on top of skills already practised (source: source-classic-games-canon):
| Step | Model game | Minimal version to build | New skill introduced |
|---|---|---|---|
| 1 | Pong | Two paddles, ball, score, win condition | Input, continuous collision, reflection, the game loop |
| 2 | Breakout | Paddle, bouncing ball, destructible bricks | Collision response, arrays/lists, level reset, scoring |
| 3 | Snake | Grid snake, food, growth, self-collision | Grid logic, queues/lists, timed stepping |
| 4 | Space Invaders | Player ship, grid enemies, bullets, lives | Enemy formations, timers, projectile pooling, state changes |
| 5 | Asteroids | Rotating ship, thrust, bullets, wrapping asteroids | Vector movement, screen wrapping, spawning, object splitting |
| 6 | Frogger | Frog crossing lanes of hazards | Grid movement, moving hazards, timing windows |
| 7 | Pac-Man-lite | Maze, pellets, player, one or two ghosts | Tilemaps, simple pathfinding, finite state machines |
| 8 | Robotron-lite | Twin-stick move and shoot, enemy swarms | Twin-stick input, enemy steering, survival arenas |
The recommended order is Pong → Breakout → Snake → Space Invaders → Asteroids → Frogger → Pac-Man-lite → Robotron-lite. As the source puts it, this “moves from simple continuous collision, to grid logic, to wave systems, to pathfinding and state machines.” The strongest first projects are Pong, Breakout, Snake, and a very small Space Invaders variant.
Mapping the progression onto the wiki’s Unity/C# material
Each step has direct support elsewhere in the wiki, so the progression doubles as a route through the programming track:
- Pong / Breakout — the game loop and input live in monobehaviour-lifecycle and unity-input; movement and collision in unity-transform, unity-rigidbody2d, and unity-collider2d-and-triggers; brick lists in csharp-collections. Runnable worked examples for both steps are in
code/unity-csharp/arcade-classics/(pong/andbreakout/), each with scene-setup notes and an extension ladder. - Snake / Frogger — grid stepping and timed updates build on csharp-control-flow and
Time.deltaTimefrom monobehaviour-lifecycle; lane and tile layout connect to unity-tilemap. Runnable Snake (grid logic, list-based body, timed stepping) and Frogger (grid hop against continuous lane hazards, timing, level boundaries) are incode/unity-csharp/arcade-classics/snake/and.../frogger/. - Space Invaders — projectile reuse motivates the object-pool-pattern; wave and game state motivate csharp-enums and unity-gamemanager-pattern. A runnable example (marching formation, timer-driven firing, shared bullet pool, state machine) is in
code/unity-csharp/arcade-classics/space-invaders/. - Pac-Man-lite — maze movement uses unity-tilemap; ghost behaviour is a natural first ai-state-machine-pattern and an entry to pathfinding-algorithms. A runnable example (BFS-pathing ghosts driven by a Scatter/Chase/Frightened FSM over a tile maze) is in
code/unity-csharp/arcade-classics/pac-man-lite/. - Robotron-lite — twin-stick control uses unity-input-system; enemy movement is an introduction to steering-behaviours. A runnable example (twin-stick fire, seek + separation steering, accelerating spawner) is in
code/unity-csharp/arcade-classics/robotron-lite/.
Polish across all of these — screen shake, hit feedback, sound on impact — is where game-feel turns a working clone into something that feels like the original.
Disagreements or tensions
- Cloning versus originality. The source is explicit that the goal is “a small, legal, original project inspired by a recognisable design pattern,” not a reproduction. The named titles (Pong, Pac-Man, etc.) are trademarked; students should treat them as design references and ship original art, naming, and theming.
- Difficulty ratings are coarse. The source rates Pac-Man as “medium” and Street Fighter II-style projects as “higher,” but these hide large variance — a one-ghost maze is far simpler than faithful ghost AI, and a two-character fighter with input buffering is well beyond most first projects.
- Design value and coding value do not always align. Out Run is a rich design case study (flow, mood, route choice) but a comparatively awkward early coding project because pseudo-3D projection is conceptually heavier than its place in the list suggests.
What to investigate next
- Several titles cited only briefly here — Space Invaders, Asteroids, Donkey Kong, Robotron: 2084 — are good candidates for full notable-game pages with deeper grounding, ideally cross-checked against source-vintage-games-2.
- The full eight-step progression now has runnable worked examples under
code/unity-csharp/arcade-classics/: Pong (1), Breakout (2), Snake (3), Space Invaders (4), Asteroids (5), Frogger (6), Pac-Man-lite (7), and Robotron-lite (8). Natural next work: replace theDebug.LogHUDs with on-screen UI/TMP, and pool the projectile-heavy examples (Space Invaders, Asteroids, Robotron) using the object-pool-pattern. - The broad 1958–2026 standout canon in the source is a useful index for history-of-games but has not been reproduced here; it could seed a separate historical reference page if needed.
Related
source-classic-games-canon · history-of-games · bushnells-law · game-feel · flow · smooth-learning-curves · pac-man · street-fighter-ii · tetris · object-pool-pattern · ai-state-machine-pattern · pathfinding-algorithms · overview-beginner-2d-unity-route · source-vintage-games-2