/projects/persephones-escape

Persephone's Escape

2D action-platformer built in C# with a custom SDL-based game framework, featuring combat, enemy AI, level progression, score tracking, and a fully coded gameplay loop.

game development

Persephone's Escape

Persephone's Escape is a 2D action-platformer built in C# on top of a lightweight custom SDL-based game framework rather than a large commercial engine. The project centers on guiding Persephone through a hostile underworld-inspired world filled with platforming sections, enemy encounters, projectile combat, hazards, and a final boss sequence. What makes the project especially interesting is that it goes beyond a simple class assignment or scripted demo: it includes a start menu flow, player naming, persistent score handling, UI systems, animation handling, collision logic, level separation, enemy behaviors, health and charge mechanics, win/lose states, and custom asset/audio integration. The result is a game that reflects both gameplay programming and systems thinking, since much of the work involves wiring together engine utilities, rendering, input, collision, state management, and content loading into one coherent loop.

date: 2024status: shipped

GitHub

overview

Many student games stop at isolated mechanics: a character can move, or enemies exist, or menus compile, but the experience does not fully connect. This project aimed to build a more complete and cohesive game by tying together platforming, combat, progression, UI, persistence, and game-state transitions inside a custom framework.

implementation

Built the gameplay loop in C# using a custom SDL-based engine layer for graphics, input, content loading, text rendering, and audio playback.

Implemented the player controller with movement, jumping, gravity handling, floor logic, directional animation, and a charge-based mobility system.

Added enemy entities with follow-radius logic, health bars, player collision handling, death behavior, and progression-aware interaction tied to the player's current level.

Implemented combat systems including spear/projectile behavior, damage interactions, hazard collisions, and entity despawning after defeat.

Created environment and progression logic through blocks, pits, sliding surfaces, flowers, fire hazards, level separators, and camera-aware rendering.

Built menu and UX systems including a start menu, rules screen, credit screen, player name input, win/lose screens, and a scoreboard flow.

Integrated file I/O for persistent score/stat handling so player outcomes could be written and later surfaced through the scoreboard interface.

Connected textures, sprite animation, fonts, music, sound effects, and parallax/background presentation into a more polished end-to-end game experience.

challenges

Because the game sits on a lightweight custom framework rather than a full engine like Unity, more gameplay infrastructure had to be handled directly in code, including state transitions, asset flow, and low-level object coordination.

Collision and movement logic needed to feel consistent across multiple object types such as platforms, hazards, enemies, projectiles, and level transitions.

A game only feels complete when its systems connect properly, so menus, input, UI, persistence, and gameplay all had to work together rather than as isolated features.

Balancing code organization across engine utilities and game-specific logic required thinking carefully about separation of responsibilities and update order.

outcomes

Delivered a playable 2D action-platformer with a real progression loop instead of a disconnected mechanics prototype.

Strengthened experience in gameplay programming, engine-oriented thinking, collision systems, UI/game-state flow, and content integration.

Showed the ability to work below the level of a commercial game engine by building on top of SDL and directly managing the systems that make a game feel cohesive.

Created a project that is especially strong for a portfolio because it demonstrates both technical implementation and product-like completeness.

architecture notes

The project is structured around a central game loop that updates menus, player state, enemies, hazards, world entities, UI elements, and end-state transitions depending on the current phase of play.

Game objects are organized as entities with rendering and collision behavior, while supporting systems such as audio, text rendering, health bars, charge bars, and camera transforms operate as reusable engine-side utilities.

The gameplay layer includes multiple interacting systems: player movement and jumping, collision with blocks and pits, NPC follow behavior, projectile combat, environmental hazards, collectibles, level separators, and a boss encounter.

Persistent and menu-facing systems such as player naming, score display, and file-backed score reads/writes help the project feel like a real game product rather than only a mechanics prototype.

stack

C#SDL2.NETCustom Game Framework2D Collision SystemsJSON/File IO

highlights

Built a complete 2D action-platformer loop with menus, player control, hazards, enemies, boss encounters, win/lose states, and score tracking.

Worked in C# on top of a custom SDL-based framework, handling rendering, input, audio, camera behavior, collision logic, and gameplay systems directly in code.

Implemented combat and progression systems including projectile attacks, health and charge bars, enemy interactions, checkpoints/level transitions, and persistent score flow.

Integrated game content such as textures, animation states, background layers, UI screens, audio, and file-backed score handling into a single playable experience.

metrics

game style

2D action-platformer

framework

custom SDL engine

state flow

menu to boss to scoreboard

media

Persephone's Escape UI and gameplay systems

Menus, player-state tracking, health and charge systems, and moment-to-moment gameplay were implemented directly in C# on top of a custom SDL framework.

Tile sheet consisting of self drawn art that would be animated by scrolling over it.