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.
🎯 Objectives
Section titled “🎯 Objectives”- 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.
✒️ Description
Section titled “✒️ Description”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!
🗓️ Timeline
Section titled “🗓️ Timeline”| 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! |
📜 The Contract
Section titled “📜 The Contract”Two words come up a lot in this project:
- Your proposal is the whole
README.mdyou 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:
- The core, which is required for everyone.
- Major features, the mechanics that make your game your game. Each team member owns 2.
- 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.
✍️ Writing a Row
Section titled “✍️ Writing a Row”Every row in your contract says three things:
- Where it will live in your code: the class, file, or folder.
- When it’s done: something I can see happen in your game. “Pressing
Pfreezes all enemies and the timer; pressingPagain resumes” is a good done-when. “Uses tweens for polish” is not. - 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.
❓ Common Questions
Section titled “❓ Common Questions”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.
How do I know what counts as half done?
Section titled “How do I know what counts as half done?”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.
What do I put for Git usage?
Section titled “What do I put for Git usage?”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.
🤖 Using AI for Your Contract
Section titled “🤖 Using AI for Your Contract”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.
⚖️ Grading a Row
Section titled “⚖️ Grading a Row”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. |
🧱 Core (40 points)
Section titled “🧱 Core (40 points)”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. |
🤖 Global State Machine
Section titled “🤖 Global State Machine”- At the very least, you should have one global state machine that controls the state of the game, like
TitleScreenState,PlayState, andGameOverState(you can rename them). - This must match the state diagram in your proposal.
📖 Instructions
Section titled “📖 Instructions”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.
🌿 Git Usage
Section titled “🌿 Git Usage”- 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 intomain. - 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.
🧬 Inheritance
Section titled “🧬 Inheritance”- 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.
🏷️ Types & JSDoc
Section titled “🏷️ Types & JSDoc”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
@paramon its own line and an@returnsfor functions that return something. - A typedef used by more than one file goes in
src/globals.d.ts, like theBirdTypesandEnemyTypetypedefs 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:
Like Git usage, this row has no file, and the Contract Builder fills in its done-when and partial for you.
⭐ Major Features (10 points each)
Section titled “⭐ Major Features (10 points each)”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) |
🔧 Techniques
Section titled “🔧 Techniques”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.
🏗️ Architecture
Section titled “🏗️ Architecture”| 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. |
🎮 Gameplay Systems
Section titled “🎮 Gameplay Systems”| 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. |
🧃 Feel
Section titled “🧃 Feel”| 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.

🧪 Custom
Section titled “🧪 Custom”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.
📐 Proposal
Section titled “📐 Proposal”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:
- A pitch: the genre, the controls (e.g.,
wasdto move,spaceto jump), and the core loop in about 3 sentences. - 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. - State diagrams for your game states, plus your entity states if you chose Entity state machine.
- A types table for your inheritance.
- A wireframe: one rough sketch of your main gameplay screen. Hand drawn, Excalidraw, anything.
- Your assets: the images, sounds, and fonts you’ll use and where they come from. Always cite your sources!
- 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.
🤖 State Diagrams
Section titled “🤖 State Diagrams”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
🗺️ Types Table
Section titled “🗺️ Types Table”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.
🛠️ Other Engines
Section titled “🛠️ Other Engines”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.
What Counts
Section titled “What Counts”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 |
— |
Assets, Git, and the Template
Section titled “Assets, Git, and the Template”- 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
.gitignoreso generated folders (like Unity’sLibrary/) 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.
⏰ Deadlines
Section titled “⏰ Deadlines”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:
- Push your updated
README.md. - 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.
🔪 Vertical Slice (December 8)
Section titled “🔪 Vertical Slice (December 8)”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:
git tag slicegit push origin slice🕹️ Slice Day
Section titled “🕹️ Slice Day”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.
💬 Feedback Form
Section titled “💬 Feedback Form”The feedback form only asks about what’s already in the game:
- In the first 30 seconds, what did you think the goal was?
- Where did you get stuck or confused?
- What moment felt best?
- Looking at their contract, which item looks riskiest to finish in time?
- 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.
✅ Slice Grade (5%)
Section titled “✅ Slice Grade (5%)”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%).
- One level or round of your core loop is playable start to finish.
- Half your features work, one per team member.
- Whoever I ask can explain the code I point to.
- The
slicetag 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.
✏️ Contract Amendment (December 11)
Section titled “✏️ Contract Amendment (December 11)”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.
🎬 Final (December 16)
Section titled “🎬 Final (December 16)”There’s no live demo. Instead, your submission proves that your contract is met.
🎥 Video
Section titled “🎥 Video”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:
- Start a meeting, either with yourself or with your teammates.
- 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.
- Start recording the meeting, then walk through your contract.
- Stop the recording and end the meeting.
- Share the video file with me in a Teams chat.
📋 README Evidence
Section titled “📋 README Evidence”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.
📓 Devlog
Section titled “📓 Devlog”Include a team .devlog.md in the same format as your assignments, including your AI involvement category. See the course guide for the details.
🤝 Teammate Rating
Section titled “🤝 Teammate Rating”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.
🕹️ Game Jam
Section titled “🕹️ Game Jam”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.
🫥 Template
Section titled “🫥 Template”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.
📥 Submission
Section titled “📥 Submission”- Proposal, by November 17 @ 23:59: push your
README.mdand notify me on Teams. I’ll reply with feedback or a greenlight.- Optional resubmission, by November 27 @ 23:59: push your updated
README.mdand message me on Teams, or I won’t regrade it.
- Optional resubmission, by November 27 @ 23:59: push your updated
- Slice: push the
slicetag before class on December 8. - Amendment: push your updated contract and Playtest section by December 11.
- Final, by December 16 @ 23:59:
- Push your code, your
README.mdevidence, and your.devlog.md. - Share your video with me in Teams.
- Upload your game to the game jam.
- Fill in the teammate rating form.
- Push your code, your