Skip to content

Project Requirements

  • 💯 Worth:
    • Proposal: 5%
    • Vertical Slice: 5%
    • Final: 20%
  • 📅 Due:
    • Proposal: November 17 @ 23:59 (hard deadline)
    • Proposal Resubmission (optional): November 27 @ 23:59
    • Vertical Slice: December 8, in class
    • Contract Amendment: December 11 @ 23:59
    • Final: December 16 @ 23:59
  • 🚫 Penalty: No option for lates. You submit what you have been able to accomplish by the final deadline.
  • Combine everything you’ve learned during this course to create your own video game.
  • Plan your game as a contract, build it in steps, and prove each part works.

This is it - the culmination of all the skills and knowledge about game development over this past semester. It’s like fighting the final boss at the end of a game. I know you have everything it takes to conquer it! 😉

You can work alone or in a team of up to 3, formed by November 17. That class is async, so it’s up to you to find your teammates. You do not have to work with someone from your own section. Bigger teams sign bigger contracts, so pick teammates you trust to show up.

The game itself is largely up to you - I want you to get creative!

When What
November 17 Async class: form your team and write your proposal. Due at 23:59.
November 27 Optional: resubmit your proposal with my feedback by 23:59 and message me on Teams.
Once greenlit Start building. One branch per feature.
December 8 Vertical Slice day in class. Half your features working, slice tag pushed.
December 11 Contract Amendment: swap items based on what you learned at the slice.
December 16 Final: video, README evidence, devlog, itch.io upload.
December 17-22 Game jam voting. Play each other’s games!

Two words come up a lot in this project:

  • Your proposal is the whole README.md you hand in on November 17: your pitch, contract, diagrams, types table, wireframe, and assets. I greenlight the proposal, and it’s worth 5%.
  • Your contract is the table of rows inside your proposal, listing exactly what you’ll build. You choose its rows from the menu below, and I grade your final on exactly what’s in it. Deliver everything in your contract and you get 100% on the final.

Every contract has three parts:

  1. The core, which is required for everyone.
  2. Major features, the mechanics that make your game your game. Each team member owns 2.
  3. Techniques, chosen from the menu to fit your game.
Team size Core Features Techniques Total
Solo 40 2 × 10 = 20 40 100
Duo 40 4 × 10 = 40 50 130
Trio 40 6 × 10 = 60 60 160

Your grade is the points you earn divided by the team total, capped at 100%. You may sign up for up to 10% extra (110 solo, 143 duo, 176 trio) as a safety net. If one item breaks at the last minute, the extra points cover it.

You build your contract in the Contract Builder, which checks these rules for you as you type.

Every row in your contract says three things:

  1. Where it will live in your code: the class, file, or folder.
  2. When it’s done: something I can see happen in your game. “Pressing P freezes all enemies and the timer; pressing P again resumes” is a good done-when. “Uses tweens for polish” is not.
  3. What counts as partial, meaning half done: Ex. “Pause freezes enemies but not the timer.”

Features also name the team member who is in charge of building it.

How do I know which file to put if I haven’t written any code yet?

Section titled “How do I know which file to put if I haven’t written any code yet?”

Write down your plan. Name the class or file you expect to create, the same way the course games do, ex. PlayerGrapplingState, src/objects/Hook.js, src/services/EnemyFactory.js. It doesn’t have to be right. If the code ends up somewhere else, update it in your amendment, and the code links in your final evidence show me where it really is. I’ll never mark you down for a different file name.

What I’m checking is that you’ve thought about it. “Somewhere in PlayState” for a boss fight tells me you haven’t.

Ask yourself: if I ran out of time halfway through this, what working piece could I still show? That’s your partial. It’s usually your done-when with one part missing:

Done when Partial
Click an anchor to swing across a gap, release to fly off The hook attaches but the player doesn’t swing
Every 500 m the tiles, hazards, and music change The tiles change but the hazards don’t
Best distance survives a page reload and shows on the title It’s saved but not shown
The boss has 3 phases, each with a new attack Only the first phase

A partial still has to be something I can see. “Half the code is written” isn’t a partial.

Git usage has no file, so the Contract Builder doesn’t ask for one. Its done-when and partial are filled in for you, the same as Types & JSDoc. You can keep them as they are:

  • Done when: one branch per feature merged into main, with commits on at least 10 different days.
  • Partial: branches are used, but most commits are in the last week.

You’re allowed to use AI to help you write your contract. But you must read everything it gives you and hand me a polished contract you understand and agree with, because you’re the one who has to build it.

Here’s what tells me nobody read the output:

  • _done-when_s that don’t describe anything I can see, like “Enhances the player experience” or “Provides engaging gameplay”.
  • Features or techniques that don’t match your pitch, or that your game doesn’t need.
  • Where columns that don’t match the files and classes in the rest of your proposal.
  • The same sentence repeated across rows, or partials that are just “partially implemented”.

If I find AI filler, or it’s clear you didn’t pay attention to the output, you lose 1 mark out of 5 on your proposal, and you keep losing it even after you fix the contract. I also won’t greenlight your proposal until the contract is rewritten.

Like everywhere else in this course, cite your AI usage in your devlog.

Each row is graded one of three ways:

Mark Points When
✅ Met Full Everything in the done-when is shown working.
🟡 Partial Half Your partial line is met, or it works with a visible bug.
❌ Not met 0 Not shown, or doesn’t work.

Every game has these, regardless of genre.

Item Pts Example done-when
Global state machine 10 At least a title, play, and end state. Every transition in my state diagram can be triggered in the game.
Instructions 5 A first-time player learns the controls and goal from the game itself.
Git usage 5 One branch per feature merged into main, with commits on at least 10 different days.
Inheritance 10 At least one base class with 2 or more subclasses. Shared fields and methods live in the base class, and each subclass adds or overrides its own behaviour.
Types & JSDoc 10 The Checks workflow passes on the final commit, every function and class has a JSDoc block, and typedefs shared by more than one file live in src/globals.d.ts.
  • At the very least, you should have one global state machine that controls the state of the game, like TitleScreenState, PlayState, and GameOverState (you can rename them).
  • This must match the state diagram in your proposal.

Your game needs a way to teach players how to play. Don’t assume everyone will intuitively know your controls or mechanics. At the slice, your peers will play your game without you explaining anything, so you’ll find out fast!

Pick one:

  • An instructions state that shows the controls and goal, opened from your title screen.
  • A tutorial level that teaches the mechanics one at a time.
  • Instructions outside the canvas in HTML/CSS, like a collapsible section or a modal window.
  • I want to see that you’re using Git throughout your development process, not just as a submission tool!
  • Each major feature gets its own branch (e.g., feature/grappling-hook). Once it’s complete, merge it back into main.
  • Your commits should tell a story. Commit often with descriptive messages like “Add player jump animation” or “Fix collision bug with platforms”. No giant commits that say “added everything”!
  • I’ll look at when your commits happened. A project that appears all at once in the last two days is a red flag.
  • When you have different “types” of anything in your game, that’s the telltale sign you need inheritance. In Breakout we had types of power-ups. In Angry Birds, we had types of birds.
  • Put the shared code in the base class so the subclasses only contain what makes them different.
  • This must match the types table in your proposal.

Every game in this course has had JSDoc types, a jsconfig.json that turns on type checking, and a src/globals.d.ts for shared typedefs. Your project needs them too:

  • Every function and class has a JSDoc block, with each @param on its own line and an @returns for functions that return something.
  • A typedef used by more than one file goes in src/globals.d.ts, like the BirdTypes and EnemyType typedefs in Angry Birds and Zelda. A typedef only one file uses can stay in that file.
  • Biome and CheckJS pass with zero errors.

The template’s Checks workflow runs Biome and CheckJS on every push. A red ❌ next to a commit on GitHub means one of them failed; open the run to see why. Don’t wait until December 16 to find out. Run the same checks before you push:

Terminal window
npx @biomejs/[email protected] check .
npx -p [email protected] tsc --project jsconfig.json --noEmit

Like Git usage, this row has no file, and the Contract Builder fills in its done-when and partial for you.

A major feature is a mechanic the player interacts with that needs its own class(es) and/or state(s), and that I can see working in under 30 seconds of video. Each team member owns exactly 2 features.

✅ Counts as a feature ❌ Doesn’t count
Boss fight with phases Title screen, pause menu
Inventory and item use Particles, screen shake (that’s a technique)
Shop or upgrades between levels High score table (that’s a technique)
Grappling hook, dash, wall-jump Sound effects (that’s a technique)
Turn-based combat “Multiple levels” with nothing new in them
Enemy type with distinct behaviour Reskinned enemies with the same behaviour
Crafting, dialogue tree, level editor Fonts, HUD (that’s a technique)

Fill your technique points (40 solo, 50 duo, 60 trio) from the menu below. Pick what fits your game. An endless runner doesn’t need a win condition, and a match-3 doesn’t need a physics engine.

A technique can live inside one of your features. If your boss fight uses its own state machine, that also counts for Entity state machine.

Item Pts Example done-when
Entity state machine 10 The player or an enemy switches between states like idle, walk, and attack, each with its own update and render. Needs an entity state diagram in your proposal.
Factory 5 All enemies are created through a factory, like EnemyFactory.createInstance(type). No new Subclass() anywhere else.
Strategy 5 Enemies are given a movement strategy (chase, patrol, wander) chosen by name. The enemy class never checks which one it has.
Observer 5 The HUD subscribes to the player and redraws the hearts when health changes. The player doesn’t know the HUD exists.
Adapter 5 A class wraps a library (Matter.js, localStorage, the Gamepad API) behind the interface the rest of the game expects, so nothing else calls the library directly.
Enums 5 No magic strings or numbers for states, types, sounds, or images.
State stack 5 A pause, dialogue, or menu overlay draws over a frozen play state and returns to it unchanged.
Object pooling 5 Bullets or particles are reused from a pool, shown with a debug counter.
Data-driven content 10 Levels, enemies, or items load from JSON or a Tiled map. Adding one needs no code change.
Item Pts Example done-when
Collision 10 AABB, tilemap, hitboxes, or mouse hit-testing on a grid. Whatever fits your game.
Physics engine 10 Matter.js bodies drive the core mechanic, not just decoration.
Online multiplayer 10 Two players on different computers play together in real time using ARRR (free, no server to run).
Goal structure 5 Win and loss, or rising difficulty and loss, or a timed score attack.
Scoring / rewards 5 Points, medals, or unlocks are earned and shown.
Persistence, minimal 5 High scores or settings survive a page reload.
Persistence, save/load 10 Quit mid-game, reload the page, and resume where you left off. Pick this or minimal, not both.
Pause 5 Pressing a key freezes everything (entities, timers, tweens), and pressing it again resumes.
Camera / scrolling 5 The camera follows the player through a level larger than the canvas.
Gamepad input 5 The whole game, menus included, is playable with a controller, with a deadzone on the stick. The keyboard still works, and unplugging mid-game doesn’t crash.
AI / pathfinding 10 An enemy routes around obstacles to reach the player (e.g., A* or BFS on a grid).
Procedural generation 10 Levels or maps are different on each run, following rules you describe.
Item Pts Example done-when
Sprites 5 No coloured rectangles. Every entity and object uses a sprite.
Animations 5 Entities animate from sprite sheets in at least 2 states (e.g., walk and attack).
Tweens 5 At least 2 different values are tweened, e.g., a fade between states and an entity’s movement.
Juice 10 At least 3 effects, like particles on hit, screen shake, hit flash, or knockback.
Sound & music 5 Background music, plus sound effects for the UI and at least 3 gameplay actions.
HUD & fonts 5 Health, score, and objective are visible at a glance, with a separate font for the title.

“Juice” refers to all the little visual and audio effects that make your game feel satisfying. Notice in the GIF below how the top version is technically functional but feels flat? The bottom version has particles, screen shake, staggering enemies, and death animations. This classic 15 minute talk by Martin Jonasson and Petri Purho explains juice brilliantly.

Juice

You may add one technique that isn’t on the menu, like shaders, a replay system, or local multiplayer. Describe it in your proposal and I’ll set its weight (5 or 10) when I greenlight it.

Your proposal is the plan for your whole game. it includes your contract, plus the diagrams, wireframe, and assets behind it. It makes you think about states, classes, and scope before you write any code.

The proposal is the README.md of your repo. Look at the sample proposal in the template to see how it should look. If you’re not familiar with markdown, do this short tutorial.

It must include:

  1. A pitch: the genre, the controls (e.g., w a s d to move, space to jump), and the core loop in about 3 sentences.
  2. Your contract, built with the Contract Builder. It gives you a link and Markdown to paste into your README.md. The link is your contract.
  3. State diagrams for your game states, plus your entity states if you chose Entity state machine.
  4. A types table for your inheritance.
  5. A wireframe: one rough sketch of your main gameplay screen. Hand drawn, Excalidraw, anything.
  6. Your assets: the images, sounds, and fonts you’ll use and where they come from. Always cite your sources!
  7. Your code packages: every library, plugin, or package you didn’t write (npm, the Unity Asset Store, Godot plugins, etc.) and what you use it for. Your engine itself and the course lib/ folder don’t need listing. A package can’t earn you a contract row since anything it does for you isn’t yours to claim.

Write your state diagrams in Mermaid. GitHub renders them in your README.md automatically. Before you submit, check that:

  • Every arrow is labelled with what causes it (e.g., Play --> GameOver: lives == 0).
  • No state is a dead end. Every state except a final one has a way out.
stateDiagram-v2
    [*] --> Title
    Title --> Play: Enter
    Title --> Instructions: I
    Instructions --> Title: Escape
    Play --> GameOver: hit hazard
    GameOver --> Title: Enter

Instead of a class diagram, list each “thing” in your game that has different types. Here’s what Breakout’s would look like:

Thing with types Base class Subclasses What the base class shares
Power-up PowerUp MultiBallPowerUp, KeyPowerUp, ShootingPowerUp, SpeedUpPowerUp, SpeedDownPowerUp, ThroughBallPowerUp Position, sprite, falling, collision, collect()
Brick — — (tier and colour are just data) —

Notice the Brick row. Deciding whether something needs subclasses or just different data is the type of design decision I’m looking for.

You may use another engine (Unity, Godot, Phaser, etc.) if I approve it. Message me before you start your proposal with the engine and why you want it, then justify it again in your proposal. I won’t be able to help you as much, and every item in your contract still applies. Whatever you use, all the code must be in your repo.

Engines do a lot for you, so one rule decides what you can claim: you get credit for the code you write. Anything the engine or a package does through a checkbox, an editor setting, a drop-in component, or a single call that does the whole item isn’t yours to claim. The one exception is Physics engine since using your engine’s physics counts, the same way Matter.js does.

For the items an engine changes the most, here’s what counts. Write your done-when for these rows in your own words, and I’ll check it at greenlight.

Item Counts Doesn’t count
Global state machine, Entity state machine State classes you write, like the ones in the course games (Unity, Godot). A game state may load a scene. The engine’s animation state graph (Animator), or scene loads called from buttons
Inheritance Your own base class with 2 or more subclasses Inheriting from the engine’s classes (MonoBehaviour, Node)
Collision Collision checks you decide on: attack hitboxes that are only active during a swing, raycasts or overlap checks for the ground or line of sight, or collision layers that change gameplay Colliders plus a collision callback (OnCollisionEnter, body_entered)
Physics engine The engine’s physics bodies drive the core mechanic —
AI / pathfinding Pathfinding you write The engine’s navmesh (NavMeshAgent, NavigationAgent2D)
Data-driven content Your code builds levels, enemies, or items from data files (JSON, Tiled maps, ScriptableObjects, Resources) Levels built as scenes in the editor
Object pooling A pool, yours or the engine’s (ObjectPool<T>), with objects reset on reuse and shown with a debug counter —
Pause Gameplay, timers, and music freeze and resume, while the pause menu still animates and takes input Only setting the time scale or pausing the scene tree
Camera / scrolling Following the player plus behaviour you write: stopping at the level’s edges, looking ahead, moving between rooms, etc. A follow camera from a component or a child node (Cinemachine, Camera2D)
Animations The engine’s animator (Animator, AnimationPlayer) with clips in at least 2 states —
Tweens The engine’s tweens or a tween library (DOTween, Tween), the same as the course’s tween library —
Types & JSDoc Doc comments on every class and function (/// in C#, ## in GDScript), static types everywhere (type hints in GDScript), zero compiler or editor warnings, and types shared by more than one file in their own files —
  • Asset store licences often forbid sharing the files. Check that each asset’s licence allows it in your repo, and keep your repo private.
  • Commit your engine’s .gitignore so generated folders (like Unity’s Library/) stay out of your repo, and use Git LFS for large models, textures, and audio.
  • The template’s Checks and Build for itch.io workflows only work for JavaScript games. Delete both from .github/workflows/, and upload your engine’s own build to itch.io.

The proposal is due November 17 @ 23:59. This is a hard deadline. If you submit late, I’ll grade your proposal on November 27 and you can’t resubmit. What you get is what you get.

If you submit on time, I’ll spend the next couple of days giving you feedback. You then have the option to integrate it and resubmit by November 27 @ 23:59:

  1. Push your updated README.md.
  2. Message me on Teams to tell me it’s ready.

I’ll regrade it, and once it meets all the requirements, it’s greenlit and you can start building. After November 27, your proposal grade is final.

A vertical slice is a thin, playable piece of your real game. It’s one level or round of your core loop, start to finish, with real assets. A title screen with no gameplay is not a slice.

At the slice, you must have half your features working (1 solo, 2 duo, 3 trio). Each team member shows one of their features. Before class, tag the commit you’re demoing:

Terminal window
git tag slice
git push origin slice

We’ll run the class like an arcade. Half the teams host while the other half play, then we swap.

When you’re hosting, your game runs on your laptop and your peers play it while you stay silent. Don’t explain anything! Watch where they get confused and take notes. While you’re hosting, I’ll visit your station and ask you to explain parts of your code. I pick who answers, so everyone on the team should know the code.

When you’re playing, you’ll play 3 assigned games for about 8 minutes each. After each one, scan the station’s QR code and fill in the feedback form.

Before slice day, make a copy of my feedback form template, print or display its QR code next to your laptop, and keep the responses.

The feedback form only asks about what’s already in the game:

  1. In the first 30 seconds, what did you think the goal was?
  2. Where did you get stuck or confused?
  3. What moment felt best?
  4. Looking at their contract, which item looks riskiest to finish in time?
  5. If they had to cut one thing, what should it be?

You can only suggest adding something if you also say what it replaces. You have about a week left, so feedback should be about the game they’re actually building.

Each item is worth a quarter of your slice grade and gets one of four marks: Met (100%), Mostly (75%), Hardly (25%), or None (0%).

  1. One level or round of your core loop is playable start to finish.
  2. Half your features work, one per team member.
  3. Whoever I ask can explain the code I point to.
  4. The slice tag is pushed and your commits are spread over time.

If you’re absent on slice day, you lose the slice points. There is no make-up.

Now that you’ve built half your game and watched people play it, you know a lot more than you did when you wrote your proposal. You get one chance to amend your contract. Open your contract link, make your changes in the Contract Builder, and paste the new link and Markdown into your README.md.

You can swap or drop any technique or feature, as long as:

  • The core stays.
  • You still have 2 features per team member. You can swap a feature for a different one, but not drop it.
  • Your total stays between 100% and 110% of your team total.
  • Every new row has a done-when and a partial.

Also add a short Playtest section to your README.md that includes what your playtesters told you, and what you’re changing because of it.

If your amendment follows these rules, it’s accepted. You don’t need to wait for my approval.

There’s no live demo. Instead, your submission proves that your contract is met.

Your video walks through your contract in the same order as your table:

  • It’s at most 5 minutes solo, 7 minutes duo, or 9 minutes trio.
  • It starts with 30 seconds of gameplay.
  • For each row, show it working in the game, then show the code in your editor.
  • The owner of each feature narrates it, explaining how it works and why it’s built that way. Every team member must be heard.

Record it in Microsoft Teams:

  1. Start a meeting, either with yourself or with your teammates.
  2. Share your screen. In the sharing toolbar, turn on Share sound and Optimize for video, so I can hear your game and the motion stays smooth.
  3. Start recording the meeting, then walk through your contract.
  4. Stop the recording and end the meeting.
  5. Share the video file with me in a Teams chat.

In the Contract Builder’s Final evidence tab, fill in each row:

  • The timestamp in your video where the row is shown (e.g., 2:15).
  • A link to the file and line on GitHub.
  • Your self-assessment: ✅ Met, 🟡 Partial, or ❌ Not met. Please be honest, I’ll confirm or change each one.

Then paste the updated link and Markdown into your README.md. If it isn’t in the video, it isn’t met.

Include a team .devlog.md in the same format as your assignments, including your AI involvement category. See the course guide for the details.

For duos and trios, each member fills in an anonymous form rating their teammates’ contributions. By default, everyone on a team gets the same grade. A low rating makes me look at your Git history and slice notes, and if they confirm a member didn’t contribute, I’ll grade that member individually.

Every game gets uploaded to our class game jam on itch.io. The jam is hidden, so only people with the link can see it. Please don’t share it outside the class.

  • Minify your build before uploading so future students can’t copy your source code. The template’s Build for itch.io workflow does this for you on every push. See the template’s README.md.
  • Your game page needs a cover image, a GIF of your gameplay, and a one-sentence pitch. That’s what makes people click on your game!
  • Upload by December 16 @ 23:59, along with your final submission.
  • Voting runs December 17-22. Play and rate at least 5 games. It’s not graded, it’s just for fun and bragging rights.

If you don’t want your game on itch.io for privacy reasons, message me and you can skip the upload.

Accept the final project on Classroom50 to get your own copy of the template.

The starter template contains a skeleton file/folder structure based on the games we’ve done this semester. Mainly, it contains the lib/ files required to build the various components of your game, plus the sample proposal. It’s up to you if you want to use it or not, but I think it’s a useful starting point.

  1. Proposal, by November 17 @ 23:59: push your README.md and notify me on Teams. I’ll reply with feedback or a greenlight.
    • Optional resubmission, by November 27 @ 23:59: push your updated README.md and message me on Teams, or I won’t regrade it.
  2. Slice: push the slice tag before class on December 8.
  3. Amendment: push your updated contract and Playtest section by December 11.
  4. Final, by December 16 @ 23:59:
    • Push your code, your README.md evidence, and your .devlog.md.
    • Share your video with me in Teams.
    • Upload your game to the game jam.
    • Fill in the teammate rating form.