Project Proposal

Object Oriented Programming

Title: “Veil of Secrets”
Group Members
Hamza Yaqoob (465444)
Abdul Ahad (456346)

Abstract:
The game concept revolves around a player trapped in a mysterious
dungeon with the ultimate goal of escaping. To achieve this, the player
must locate both the exit and the key that unlocks the exit door. The
game environment is designed as a maze-like dungeon filled with
various obstacles, traps, and enemies. Players will navigate through these
challenges, solving puzzles and uncovering hidden secrets along the
way. As they progress, they will unravel unsolved mysteries of the
dungeon, offering an immersive and dynamic gameplay experience.
This game combines exploration, problem-solving, and action, ensuring
that players remain engaged as they uncover the truth behind their
imprisonment and make their way toward freedom.

Introduction:
Trapped in a dark and mysterious dungeon, you awaken with no
memory of how you arrived. The cold, damp stone walls close in around
you as you realize the grim reality: escape is the only way out. The
dungeon is vast and labyrinthine, filled with hidden dangers, treacherous
traps, and sinister creatures that lurk in the shadows. The only way to
freedom is to uncover the dungeon's secrets, find the hidden exit, and
retrieve the key that will unlock your path to safety.
As you venture deeper into the dungeon’s maze-like corridors, each step
brings you face-to-face with new puzzles that challenge your mind,
enemies that test your combat skills, and obstacles that force you to think
on your feet. Along the way, you’ll uncover forgotten secrets, ancient
mysteries, and clues that reveal the dungeon’s dark past. But the deeper
you go, the more you realize that escaping is not just about surviving — it’s
about uncovering the truth behind your imprisonment.

What lies at the heart of this cursed place? Who or what put you here, and
why? As you solve puzzles, battle foes, and unravel the dungeon’s
secrets, you’ll draw closer to a revelation that could change everything. Will
you escape, or will you become just another forgotten soul lost in the
dungeon’s endless maze?

Related Work:
 Fantasy Dungeon Crawler Games
Inspired by classic 2D top-down dungeon fantasy games, our game
offers a unique twist on dungeon exploration. Trapped in a vast, maze-like
dungeon, you must navigate through traps, enemies, and puzzles to find
the exit. Along the way, you'll uncover hidden secrets and unravel the dark
mysteries of the dungeon. While the gameplay is inspired by traditional
dungeon crawlers, the story and world are completely original, offering a
fresh and immersive adventure.

Methodology:
The development of the dungeon exploration game
was approached using Object-Oriented
Programming (OOP) principles, implemented in C+
+ with the Raylib library for graphics and game
development. The methodology is outlined in the
following stages:
1. Conceptualization and Design:
The first step in the project was
conceptualizing the game mechanics and
designing the overall structure. The focus was
to create an engaging dungeon crawler where
the player navigates a maze, avoids traps,
fights enemies, and solves puzzles. At this
stage, the game’s core systems, such as
movement, combat, and the puzzle-solving
mechanics, were outlined. Special attention
was given to how OOP principles could be
applied to the game's design, ensuring
flexibility and scalability.
2. Object-Oriented Design:
The game was broken down into objects, with
each important element represented by a
class.
 Classes were defined for fundamental
game entities, such as the Player, Enemy,
Trap, Item, and Dungeon. Each class
 encapsulates relevant data and
functionality (e.g., player health,
movement, and interaction with the
environment).
 Inheritance was used to create subclasses
for specific types of enemies and traps,
each with unique behaviors but sharing
common attributes from their parent
classes. For example, different types of
enemies like "Goblin" and "Troll" could
inherit from a general Enemy class, with
their own specific attack patterns and
health.
 Encapsulation was used to protect
internal data (such as health or position)
while providing public methods for
interacting with those data points (e.g.,
moving the player, reducing health, etc.).
 Polymorphism was applied to allow for
different behaviors in similar objects. For
instance, the game could use
polymorphism to handle various enemy
types in combat, where each enemy class
might have its own implementation of how
it attacks the player.
3. Game Development and Implementation:
Development was done in C++ with the Raylib
library, which is well-suited for creating 2D
games. The following steps were involved:
 The game loop was implemented to
handle the flow of the game, including
input processing, game logic updates, and
rendering.
 Tile-based system: The dungeon was
created using a grid-based system, where
each tile is represented as an object, and
the player moves between tiles. Raylib’s
2D drawing functions were used to render
the tiles and objects on the screen.
 Raylib's input handling: Keyboard and
mouse inputs were processed using
Raylib’s built-in functions to control player
movement and interactions with objects.
 Collision detection was handled through
bounding box checks, using Raylib's
collision detection functions, to ensure that
the player, enemies, and traps interacted
properly with the dungeon’s environment.
4. Game Features Implementation:
Specific game features were built
incrementally, such as:
  Player movement: The player could
move within the dungeon using keyboard
inputs. The movement was limited by walls
and obstacles, with smooth transitions
between tiles.
 Combat mechanics: Enemies were given
basic AI, where they would patrol and react
to the player’s presence, attacking when in
range.
 Puzzles and traps: Interactive elements
such as switches, pressure plates, and
hidden doors were implemented using
Raylib’s 2D drawing and interaction
systems.
 Inventory and key items: Items such as
keys and health potions were handled with
inventory systems and used for solving
puzzles or surviving enemy encounters.
5. Testing and Debugging:
Once the game logic was implemented, a
thorough testing phase began to identify and
fix bugs. Unit tests were used to verify that
each class (Player, Enemy, Trap, etc.)
performed as expected in isolation. Playtesting
was also conducted to ensure that the overall
gameplay experience was fun, challenging, and
 bug-free. Debugging tools within Raylib and C+
+ were used to address any issues with
memory leaks, incorrect collision detection, or
unresponsive game mechanics

Purpose:
The purpose of this game is to apply and demonstrate the principles of
Object-Oriented Programming (OOP) in a practical and engaging
way. By developing a dungeon exploration game, I aim to showcase
my understanding of OOP concepts such as classes, inheritance,
polymorphism, encapsulation, and abstraction. Through the
creation of various game elements, including the player character,
enemies, traps, and puzzles, I will implement these core OOP
principles to build a dynamic and interactive game environment.
This project allows me to combine my programming skills with
creativity, while also providing an opportunity to learn and refine my
ability to design and develop complex systems using object-oriented
techniques.

Conclusion:
In conclusion, this game project serves as an effective application of
Object-Oriented Programming (OOP) principles, allowing me to
demonstrate my ability to design and implement complex
systems in a structured and efficient manner. By developing a
dungeon exploration game with various interactive elements, such
as puzzles, traps, and enemies, I have been able to apply key OOP
concepts such as inheritance, encapsulation, and
polymorphism. Through this process, I have not only enhanced my
technical skills but also gained valuable experience in game design
and problem-solving. The project has provided a solid foundation for
future endeavors in both game development and software
engineering, reinforcing my understanding of OOP and its practical
uses in creating dynamic, interactive applications.