← Back to Projects

Procedural Dungeon Generator (Star-Wars Themed)

My RoleSolo Programmer

Software & Languages UsedC++, Visual Studio 2022

Overview

Context

This project was a solo developed uiversity assigment , in which we were given 8 weeks to develop a text based game in pure C++, it was encouraged to go above & beyond what was taught in lesson.

Dungeon Shop | Re-stock on power ups and Weapons | Start of game purchase first set

Related:

The core focus for me was writing a complete game-style system in modern C++ using clean structure and safe memory management — including polymorphic item systems, enemy inheritance, wave generation, and strong input validation so the game never breaks on bad user input.

Key features:

• Grid-based dungeon navigation (visual dot-grid with player + goal)
• Random enemy positions (unique placements, never overlapping each other or key tiles)
• Wave combat (enemy types are randomised each encounter, so no wave feels identical)
• Coins + Shop + Inventory (weapons + power-ups with slot limits and refunds)
• Robust verification checks (trim/validate input, enforce inventory rules, prevent invalid states)
• Replayable Loop: navigate grid -> random enemy encounters -> survive randomised combat waves -> spend coins in a shop + inventory system -> continues until goal/exit is reached

Highlights

• The dungeon is a 12×12 dot grid (config::GRID_SIZE) rendered in console (displayGrid()), with:

  • P = player start
  • G = goal tile
  • . | 'E' = empty space | enemy also hidden
  

  When enemies positions not displayed

  Related:

• Enemy encounter positions are generated using a std::set<Position> so positions are unique by default.

• Spawns avoid key tiles (player start + goal), preventing unfair/buggy setups:

  • (0,0) and (GRID_SIZE-1, GRID_SIZE-1) are excluded.

// Grid.cpp (trimmed)
// Goal: generate unique enemy positions and avoid unfair spawns (start + goal)

std::set<Position> generateEnemyPositions(int count) {
    std::set<Position> enemyPositions;
    std::srand(static_cast<unsigned>(std::time(nullptr))); // different per run

    while (enemyPositions.size() < count) {
        int x = std::rand() % config::GRID_SIZE;
        int y = std::rand() % config::GRID_SIZE;

        // Avoid key tiles
        if ((x == 0 && y == 0) || (x == config::GRID_SIZE - 1 && y == config::GRID_SIZE - 1))
        {
          continue;
        }

        enemyPositions.insert({ x, y }); // std::set enforces uniqueness
    }

    return enemyPositions;
}

• Movement uses _getch() so navigation is responsive (no “press enter” needed).

This creates a simple but replayable overworld: the player explores, hits random encounters, and pushes toward the exit.

• Encounters trigger combat via the grid: stepping onto an enemy tile calls combatWave(player, wave).
• Waves are created with generateEnemyWave(5) and enemies are randomly selected, meaning you rarely fight the same composition twice.
• Combat is clean turn-based:
  • Player chooses an inventory item (weapon / power-up)
  • Enemies take their turn one-by-one
  • Defeated enemies are removed using erase(remove_if(...))

// Combat.cpp (trimmed)
// Goal: clean turn loop, remove dead enemies, reward coins if player survives

while (!enemies.empty() && player.getHealth() > 0) {
    player.combat(enemies, player);

    enemies.erase(
        std::remove_if(enemies.begin(), enemies.end(), isEnemyDefeated),
        enemies.end()
    );

    for (auto& e : enemies) {
        int damage = e->combat();
        player.takeDamage(damage);
        if (player.getHealth() <= 0) 
        {
          break;
        }
    }
}

if (player.getHealth() > 0) {
    player.addCoins(totalEnemyCoins(enemies));
    player.resetDamageBoost(); // buffs are wave-limited for fairness
}

• Coins are calculated per wave (totalEnemyCoins) and awarded only if the player survives, then buffs reset for fairness (resetDamageBoost()).
  

  Upon Entering Combat

  Related:

It’s a strong “game loop” showcase: encounter → combat → reward → prepare for next wave.

• Inventory is stored as std::map<int, std::unique_ptr<Item>>, so items are owned safely and cleaned up automatically.
• The shop uses a factory approach: each ShopItem stores a std::function<std::unique_ptr<Item>()> so buying an item creates the correct derived type at runtime.

// Shop.cpp (trimmed)
// Goal: each shop entry knows how to construct the correct derived Item type

std::map<int, ShopItem> shop = {
  {1, {25, "DL-44", "Min dmg: 20 | Max dmg: 50",
      [](){ return std::make_unique<DL44>(); }}},

  {5, {12, "Health Pack", "+300 health",
      [](){ return std::make_unique<PowerUps>("Health Pack", healthPack); }}}
};

• Items are polymorphic:
  • Weapon : Item (ammo, mags, reload logic, used flag)
  • PowerUps : Item (stores an action via std::function<void(Player&)>)
• Restrictions prevent broken loadouts:
  • Max 2 weapons + max 2 power-ups
  • You can’t leave the shop without at least one weapon
• Refund rules are handled (weapons marked as “used” can’t be refunded).
  

  Dungeon Shop

  Related:

General

• Weapons track damage, currentAmmo, ammoCapacity, and mags.
• Reloading happens automatically when ammo hits zero (if mags remain).
• If ammo + mags are empty, some weapons fall back to a melee hit (small guaranteed damage), so combat never hard-locks.
• Some weapons apply wave splash damage logic (total damage divided across enemies).

• Input is validated using helper functions:
  • whitespace trimming (trimWhiteSpace)
  • numeric checks (isInputInteger)
  • readable error output (errorMessage)
• Menus enforce valid ranges (e.g., start menu only accepts 1–2).
• Inventory decisions enforce safe states (can’t return to game with no weapon).

This kept the project stable — no crashing or broken states from bad input.

// GeneralErrorHandaling.cpp (trimmed)
// Goal: stop bad input from crashing menus / inventory logic

bool isInputInteger(string userInput) {
    if (userInput.empty())
    {
      return false;
    }

    for (char c : userInput)
        if (!std::isdigit(c)) 
        {
          return false;
        }

    return true;
}

string trimWhiteSpace(string& userInput) {
    string result = userInput;
    result.erase(std::remove_if(result.begin(), result.end(), ::isspace), result.end());
    return result;
}