-
Notifications
You must be signed in to change notification settings - Fork 0
Glossary
The Glossary provides definitions for the most important terms, concepts, and abbreviations used throughout the Adventure-Game project and its documentation.
Whether you're new to C++, object-oriented programming, or RPG development, this page serves as a quick reference while exploring the project.
- General Terms
- Gameplay Terms
- Programming Terms
- Object-Oriented Programming
- Project-Specific Terms
- Development Terms
- Summary
The name of this project—a console-based RPG written in C++ that demonstrates object-oriented programming, modular architecture, and game development principles.
A genre of games where players control a character, improve statistics, collect equipment, and progress through gameplay.
Common RPG elements include:
- Character progression
- Equipment
- Inventory
- Loot
- Quests
- Statistics
A program that runs inside a command-line terminal instead of using a graphical user interface (GUI).
Adventure-Game currently uses a console interface.
An independent module responsible for a specific game mechanic.
Examples include:
- Character System
- Inventory System
- Weapon System
- Chest System
The player-controlled hero.
The Character stores:
- Personal information
- Statistics
- Inventory
- Equipped items
- Active effects
Numerical values describing the player's abilities.
Current statistics include:
- Health
- Strength
- Defense
- Agility
- Intelligence
- Gold
- Level
Represents how much damage the player can survive.
If health reaches zero, the character is defeated (planned gameplay behavior).
Determines physical attack power.
Higher strength increases weapon damage.
Reduces incoming damage.
Defense comes from:
- Base character stats
- Armor
- Weapon bonuses
Represents movement speed and reaction time.
Future versions may use agility for:
- Dodge chance
- Turn order
- Critical avoidance
Represents the character's mental abilities.
Reserved for future mechanics such as:
- Magic
- Skills
- Special abilities
The in-game currency.
Future uses include:
- Trading
- Shops
- Crafting
- Equipment upgrades
Represents character progression.
Future versions will connect levels with experience points and skill progression.
The storage system that holds every item collected by the player.
Adventure-Game uses a dynamically resizable inventory.
Items currently worn by the player.
Current equipment includes:
- Weapon
- Armor
An offensive item that increases attack power and may provide additional defense bonuses.
A defensive item that increases the player's protection.
A consumable item that modifies character statistics.
Potions disappear after use.
A loot container that generates random rewards.
Possible rewards include:
- Weapons
- Armor
- Potions
Items obtained during gameplay.
Loot is typically generated randomly.
Represents an item's condition.
Weapons and armor may become damaged or broken as gameplay mechanics evolve.
A special enhancement applied to equipment.
Enchanted items provide improved statistics compared to standard versions.
A temporary modification applied to the Character.
Examples include:
- Strength Buff
- Defense Buff
- Health Restoration
A blueprint used to create objects.
Examples:
- Character
- Weapon
- Potion
- Chest
An instance of a class.
For example:
Character hero;Here, hero is an object created from the Character class.
A reusable block of code that performs a specific task.
Examples:
DisplayInventory()
EquipWeapon()
AddItem()A named location used to store data.
Example:
int health = 100;A special function that initializes an object when it is created.
Example:
Character();A variable that stores the memory address of another object.
The inventory stores pointers to Item objects to support polymorphism.
Memory allocated during program execution.
Adventure-Game demonstrates dynamic allocation for the inventory system.
A programming paradigm centered around objects and classes.
Adventure-Game heavily relies on OOP principles.
Keeping data and the functions that operate on it inside the same class.
Example:
The Character class manages its own statistics.
A mechanism allowing one class to inherit functionality from another.
Example:
Item
├── Weapon
├── Armory
└── Potion
The ability to treat different object types through a common interface.
Example:
Item* item;This pointer can reference:
- Weapon
- Armory
- Potion
Exposing only essential functionality while hiding implementation details.
The abstract Item class provides a common interface for all collectible objects.
A class that cannot be instantiated directly.
Item serves as the abstract base class for collectible items.
A class that inherits from another class.
Examples:
- Weapon
- Armory
- Potion
The parent class from which other classes inherit.
Example:
Item
The abstract base class for every collectible object.
Current derived classes include:
- Weapon
- Armory
- Potion
The class responsible for storing and managing every item owned by the player.
The central gameplay system responsible for managing the player.
Manages currently equipped weapons and armor.
Handles weapon creation, statistics, durability, and equipment.
Handles defensive equipment and armor management.
Manages consumable items and their effects.
Responsible for generating randomized loot.
Framework responsible for preserving player progress between game sessions.
Represents the current part of the game.
Examples:
- Main Menu
- Inventory
- Gameplay
- Settings
A distributed version control system used to track changes in source code.
A cloud-based platform used to host, manage, and collaborate on software projects.
Adventure-Game is hosted on GitHub.
A project directory containing:
- Source code
- Documentation
- Assets
- Version history
A saved snapshot of project changes in Git.
An independent line of development.
Branches allow new features to be developed without affecting the main codebase.
A request to merge changes from one branch into another.
Pull Requests allow code review before changes are accepted.
A GitHub feature used to report bugs, request features, or discuss improvements.
A collection of documentation pages describing the project's architecture, gameplay systems, and development practices.
| Abbreviation | Meaning |
|---|---|
| RPG | Role-Playing Game |
| OOP | Object-Oriented Programming |
| STL | Standard Template Library |
| GUI | Graphical User Interface |
| CLI | Command-Line Interface |
| IDE | Integrated Development Environment |
| API | Application Programming Interface |
| PR | Pull Request |
| AI | Artificial Intelligence |
| HP | Health Points |
| XP | Experience Points (planned) |
| NPC | Non-Player Character (planned) |
The Glossary serves as a centralized reference for the terminology used throughout Adventure-Game and its documentation. By defining gameplay concepts, programming terminology, object-oriented principles, and project-specific vocabulary, it helps both players and developers better understand the project's architecture and design.
As Adventure-Game evolves, this glossary will continue to expand alongside new gameplay systems, technical features, and documentation, ensuring that the project's terminology remains clear, consistent, and accessible.