The assignments completed during the Harvard's GD50: Intro to Game Development course.
Disclaimer
All projects include base source code written by the course instructor Colton Ogden. I added the assignments and my own implementations on top of the original code.
A classic Pong recreation built with Lua and LÖVE2D. This lesson focuses on fundamentals like drawing, game state handling, simple physics, and implementing basic AI logic.
- Lua
- LÖVE2D
- Drawing Shapes
- Drawing Text
- Delta Time & Velocity
- Game State Management
- Basic OOP
- Box Collision (Hitboxes)
- Sound Effects (bfxr)
- Implement a basic AI for either Player 1 or Player 2 (or both).
- Completed the assignment as required.
- Implemented AI for both players.
- Added an autoplay toggle: both AIs can play against each other with no player input.
- Added an AI mistake chance to mimic human inaccuracy.
- Implemented logic for AI to serve the ball away from the opponent.
- Added full controls for both players so two humans can play.
- You can play against the AI on either side, and take control of an AI mid-autoplay. Autoplay shuts off only for the player you overwrite.
- The ball changes color (to red) based on a random velocity value.
- Power-ups:
- Speed up the ball
- “Power ball” that can’t be blocked
- Multiple balls (ball multiplication)
- Paddle speed modifiers (slow down / speed up paddles)
A Flappy Bird clone featuring procedural pipe generation, infinite scrolling backgrounds, game states, and performance-based rewards.
- Sprites
- Infinite Scrolling
- Procedural Generation
- State Machines
- Influence the generation of pipes to create more complex level patterns.
- Award the player a medal based on performance, along with their score.
- Implement a pause feature.
- Completed all assignment requirements.
- Added different sound effects for different medal results.
- A dynamic commentator system that reacts to your performance (e.g., praise, insults, hype commentary).
A Breakout clone featuring procedural level layouts, multiple powerups, particle effects, paddle upgrades, collision handling, and persistent save data.
- Sprite Sheets
- Procedural Layouts
- Managing State
- Levels
- Player Health
- Particle Systems
- Collision Detection
- Persistent Save Data
- Add a powerup that spawns two extra balls.
- Grow or shrink the paddle based on score increases or life loss.
- Add a locked brick that can only be opened with a key powerup, which should spawn only when such a brick exists and randomly like the ball powerup.
- Fixed the
recoverPointsbug. - Implemented logic to spawn a key again if it is lost.
- Added seven total powerups: multiple balls, bigger ball, smaller ball, big paddle, small paddle, fast paddle, slow paddle.
- When multiple balls exist, the player only loses health when all balls are destroyed.
- Each brick has a random chance to contain a powerup.
- When a brick breaks, it drops its assigned powerup if it has one.
- Display on-screen text to indicate which powerup was picked up.
- Implemented level saving and added the ability to continue from the last saved level.
A Match-3 puzzle game featuring animated tile movement, procedural grid generation, timed gameplay, shiny tile mechanics, variety-based scoring, and hint assistance.
- Anonymous Functions
- Tweening
- Timers
- Procedural Grids
- Sprite Art and Palettes
- Ensure Level 1 starts with simple flat blocks (first row of each color in the sprite sheet).
Later levels should include patterned blocks (triangle, cross, etc.) worth more points. - Add time on match: +1 second per matched tile.
- Add shiny tiles that destroy an entire row when matched, awarding points for every tile in the row.
- Only allow swapping if it results in a valid match.
If no possible matches remain, reset the board.
- Fixed the
setColorbug. - Introduced a new color every 3 levels and a new variety every 4 levels.
- Added optional mouse-based matching.
- Added particle effects on shiny tile matches.
- Implemented a hint system when the player is stuck (up to 3 hints max).
- Matching now checks both color and variety, not just color alone.
- Disable input when hint is active.
A procedurally generated 2D platformer inspired by Super Mario Bros, featuring tile-based worlds, animated entities, platformer physics, keys and locks, goal posts, powerups, enemies, camera movement, and scalable level progression.
- Tile Maps
- 2D Animation
- Procedural Level Generation
- Platformer Physics
- Basic AI
- Powerups
- Ensure the player always spawns above solid ground when entering the level.
- In
LevelMaker.lua, generate a random-colored key and matching lock block (fromkeys_and_locks.png).
Colliding with a key should unlock the block and make it disappear.
(I generate 4 collectible keys and show collected keys on screen.) - Once the lock has disappeared, trigger a goal post to spawn at the end of the level. Goal posts can be found in flags.png; feel free to use whichever one you’d like! Note that the flag and the pole are separated, so you’ll have to spawn a GameObject for each segment of the flag and one for the flag itself. (I spawn a gameobject as a pole and spawn an entity as the flag since its animated)
- Touching the goal post regenerates the level, restarts the player at the beginning,
increases the level length, and preserves score via parameters passed intoPlayState:enter.
(When the player unlocks the locks the camera moves to the flag and show that its up)
- Camera pan to the goal flag at the start of each level.
- Player becomes invincible while the camera is moving.
- Camera pan can be skipped with the Enter key.
- Added randomly generated water tiles.
- Fixed snail jitter when it has no room to move.
- Corrected the player collision box (original was too large).
- Added a red mushroom power-up for health restoration
(max hearts = 3; extra health converts to score). - Added visual health bars using heart icons.
The player cannot die unless all hearts are depleted.
- Climbing state for ascending the flag pole.
- Ladder tiles for climbing tall structures.
- Two new enemy types.
- A mushroom power-up granting temporary invincibility.
A top-down action adventure system inspired by classic Zelda dungeons, featuring randomized rooms, destructible objects, throwable items, enemy drops, event-driven interactions, and smooth screen transitions.
- Top-Down Perspective
- Infinite Dungeon Generation
- Hitboxes / Hurtboxes
- Events
- Screen Scrolling
- Data-Driven Design
- Implement randomly dropping hearts from enemies, restoring one full heart when collected.
- Add pots throughout the dungeon that the player can pick up.
Picking up a pot updates the player’s animation to the “carrying” state.
The player cannot swing their sword while carrying a pot. - Allow the player to throw carried pots.
Thrown pots travel straight in the direction the player is facing and disappear when:
• they hit a wall
• they travel more than four tiles
• they hit an enemy (dealing 1 damage)
- Pots can be broken by attacking them, and breaking a pot can drop a heart.
Broken pots remain on the ground instead of disappearing. - Pots break on collision depending on their health; they don’t shatter instantly.
- A random boss that can appear in the dungeon.
(unfinished)
A turn-based battle system inspired by classic Pokémon games, featuring layered state stacks, RPG stat progression, GUI elements, catching mechanics, party management, NPC interactions, and encounter logic.
- StateStacks
- Turn-Based Systems
- GUIs
- RPG Mechanics
- Implement a Level-Up Menu that appears immediately after the “Level Up” dialogue.
The menu must show, for each stat:
X + Y = Z
where X = starting stat, Y = stat increase for the level, and Z = resulting value.
- Added a state for catching Pokémon.
- Implemented party-based battles with multiple player Pokémon.
- Added NPC battles where the opponent also uses multiple Pokémon.
- Added an NPC with dialogue and an interact-to-battle sequence.
- Added a chance to fail running away, depending on the enemy’s level.
- Added random pokéball spawns when walking in tall grass.
- Implemented a field menu state for viewing the player’s party.