Course Overview

A practical exploration of Object-Oriented Programming (OOP) and software design principles through the end-to-end development of a fully functional 2D Roguelike game. The project utilized Python to build custom game mechanics, focusing on event-driven state management, rendering pipelines, and collision physics.

Core Project: Python-Based Roguelike RPG

Co-developed an expansive, tile-based 2D RPG featuring dynamic map environments, scalable enemy logic, and encapsulated rendering systems.

Shop Scene

1. Game Engine & Rendering Subsystems

Architected a centralized GameManager infrastructure to orchestrate global event loops, entity updates, and frame-by-frame rendering.

  • Dynamic Camera Tracking: Implemented a continuous camera tracking system across multiple large-scale environments, including the City, Wild, and Boss Room. Engineered the tracking math by calculating the player’s intended movement delta and applying the inverse translation vector to all environmental entities, ensuring the protagonist remains strictly centered while simulating world movement.
  • Hierarchical Scene Construction: Designed a tile-based rendering engine (Scene.py, Tile.py) that systematically iterates through and draws base map tiles, interactive obstacles (like damage-inducing fire pits), and dynamic characters to maintain accurate spatial depth. Game Scene

2. Physics & Collision Handling

Developed a robust movement resolution and collision detection system to handle interactions between the user, environmental boundaries, and active NPCs.

  • Decoupled Axis Movement: Mitigated physical lock-up anomalies by mathematically isolating horizontal (try_move_width) and vertical (try_move_height) velocity updates. Evaluated spatial boundary collisions independently per axis, applying immediate rollback translations upon collision detection.
  • Event-Driven Interactions: Leveraged Pygame’s built-in collision detection to broadcast specific interaction events to a global event queue. The centralized GameManager asynchronously processed these payloads to trigger deterministic state changes, such as continuous health depletion or UI dialogue initialization.

3. Game State Management & Mechanics

Designed strictly encapsulated Object-Oriented classes to govern resource pipelines, combat logic, and procedural difficulty scaling.

  • Procedural Difficulty & Progression: Engineered a dynamic leveling system where enemy parameters (health, attack, defense) and economic drop rates automatically scale upon each transition into the combat zone.
  • Turn-Based Combat Logic: Implemented encapsulated state machines within modular UI components (BattleBox) to handle alternating execution turns between the player and specific enemy classes, including standard mobs and Boss entities.
  • Modular Sub-systems: Integrated an independent, stateful Blackjack module (Blackjack.py) into the dialogue system, featuring randomized drawing algorithms intentionally weighted to increase player win probability. Black Jack
  • Resource Optimization Interface: Developed a custom mouse-driven Graphical User Interface (ShoppingBox) allowing users to dynamically reallocate their two primary resources—gold and health—for stat upgrades or unique enemy debuffs.

Technical Stack

  • Languages: Python
  • Concepts: Object-Oriented Programming (OOP), Event-Driven Architecture, 2D Vector Translation, Collision Rollback, State Machines.
  • Tools: Pygame