1.
Programming Language: Python
2. Game Development Library: Pygame
Pygame is a popular library for 2D game development in Python. It provides functionalities
for handling graphics, sounds, input, and collision detection.
3. Data Structures:
2D Arrays (Lists of Lists in Python): To represent the grid-based maze layout where each
element in the array represents a cell in the maze (e.g., wall, path, special area).
Classes: To represent different entities in the game such as Cell, Player, and Enemy.
4. Maze Generation Algorithms:
Recursive Division Algorithm: A popular maze generation algorithm that is simple to
implement and creates mazes with a good balance of complexity and simplicity.
Prim's Algorithm: Another option for maze generation, which creates more natural and
organic-looking paths. It’s useful for variety in maze styles.
5. Graph Algorithms for Connectivity Checks:
Depth-First Search (DFS) or Breadth-First Search (BFS): To ensure that all parts of the
maze are reachable from the starting point and to check for path connectivity after the maze
generation.
6. Game Design Concepts:
Grid-Based Movement: Movement system based on navigating a grid layout where players
and enemies move from one cell to another.
Collision Detection: To prevent players and enemies from passing through walls.
Area Design: Specific functions to create distinct areas like gardens, dungeons, and libraries
within the maze.
7. Basic Game Mechanics:
Player and Enemy Movement: Logic for controlling player and enemy movements using
keyboard input .
Interactive Elements: Functions to add and manipulate special areas within the maze.
8. Testing and Debugging Tools:
Visual Debugging: Use visual output (e.g., print statements or basic rendering in Pygame) to
debug the maze generation and ensure elements are placed correctly.
9. Basic Visual Design and Audio:
Sprites and Textures: For representing different elements like walls, paths, special areas,
players, and enemies.
Sound Effects: Optional, using Pygame’s sound handling capabilities for interaction
feedback.
Visual sample
MVP
1. Core Gameplay Mechanics:
Grid-Based Maze Layout:
Create a simple grid-based maze using a maze generation algorithm (e.g., Recursive
Division).
Implement basic paths and walls for navigation.
Ensure at least one path exists from the player's starting point to the exit.
Player Movement:
Implement basic player movement using grid-based controls (e.g., arrow keys for
movement).
Include collision detection to prevent the player from walking through walls.
Simple Enemy AI:
Implement a basic enemy type that moves randomly within a confined area.
Include collision detection for enemies to avoid walking through walls.
Add basic enemy-player collision, reducing player health or ending the game on contact.
2. Interactive Elements:
Tower Centre:
Create a simple interactive object (Tower Centre) in the maze.
Include one or two basic commands (e.g., "Reveal Map" to display the entire maze for a few
seconds).
Implement simple consequences for these commands (e.g., "Reveal Map" shifts walls
slightly).
Basic HUD (Heads-Up Display):
Display player's health and remaining keys (if any) in a minimalist HUD.
Include a basic mini-map that shows explored sections of the maze.
3. Visual and Audio Design:
Minimalist 2D Graphics:
Use simple sprites or tile-based graphics for walls, paths, players, and enemies.
Ensure visual distinction between different types of cells (e.g., walls vs. paths).
Basic Sound Effects:
Add simple sound effects for player actions (e.g., movement, command execution) and
enemy encounters.
4. Distinct Areas (Simplified):
One Themed Area (e.g., Garden Area):
Implement one distinct themed area, such as a garden with simple decorative elements
(bushes, trees).
This can be expanded upon later to include more complex areas like dungeons or libraries.
5. Basic Game Loop and End Conditions:
Game Start and End:
Start the game at a designated player start point.
Implement a basic win condition (e.g., reaching an exit point).
Include a simple loss condition (e.g., player health reaches zero).
6. Basic Replayability:
Randomized Maze Layouts:
Randomly generate a new maze layout for each game session to enhance replayability.
Variable Enemy Behavior:
Enemies may change their patrol patterns slightly between sessions.
