How do I fix my error handling so that my character can move to multiple rooms?

cout << "Next room not defined for the chosen option." << endl;

#include "StarterIncludeFile.hpp" //Assume that all needed includes are here. So if there is an include you need, it's wrapped in here
#include "entities.hpp"
#include "levels.hpp"
#include "outputHandling.hpp"
#include "playLevels.hpp"
#include "inputHandling.hpp"

int main() {
    createValidInput();
    Player player = createPlayer();
    vector<item> itemsInInventory = player.itemsInInventory;
    initializeLevelInfo();
    playGame();
    return 0;
}

vector<string> createOptions(string roomId, string progression);
string createDescription(string roomId, string progression);
vector<item> itemsOnFloor;

// Define a struct to hold level information
struct LevelInfo {
    std::string description;
    std::vector<std::string> options;
};

// Define a map to hold level information based on roomId and progression
std::unordered_map<std::string, std::unordered_map<std::string, LevelInfo>> levelInfo;

// Define a map to hold transitions between rooms based on choices
unordered_map<string, unordered_map<string, string>> transitions;

// Function to initialize level information
void initializeLevelInfo() {
    // Define descriptions and options for each level
    levelInfo["Introduction"]["beginning"] = {
        "In the vast expanse of the cosmos, humanity teeters on the edge of insignificance, our existence but a fleeting whisper in the echoing\nchambers of eternity.\n"
        "We scurry about like ants beneath the gaze of titanic beings, ancient gods who regard us with indifferent eyes, if they regard us at\nall.\n"
        "In this realm where mortal coils and consciousness unravel, we are but morsels of flesh adrift in a sea of shadows.\n\n"
        "Our cities, our achievements, our very essence, pale against the backdrop of cosmic indifference.\n"
        "Yet amidst the darkness, whispers linger of forgotten truths, of entities that loom beyond the veil of comprehension.\n"
        "Their presence whispers through the rustling leaves, their footsteps echoing in the silence of the night.\n\n"
        "There are those who speak of a shepherd, a figure shrouded in myths and legends, whose gaze transcends the boundaries of mortality.\n"
        "They say he walks among us, his presence a beacon of hope amidst the encroaching darkness.\n"
        "But beware, for even the shepherd's light may cast long shadows, and salvation may come at a price too terrible to comprehend.\n\n"
        "As you venture forth into this realm of uncertainty, remember the fragility of human life, the insignificance of our existence in the eyes of our gods and beings beyond mortal ken.\n"
        "For in this world of shadows and whispers, even the faintest glimmer of hope may be swallowed whole by the abyss.",
        {"Continue"} // No options for Introduction at beginning
    };
    
    levelInfo["StartingRoom_1_f_1"]["beginning"] = {
        "You wake up in your bedroom. It's not exactly the cleanest... or the brightest, but it's home.\n"
        "You rise out of bed and stand up.\n"
        "It's time to get to work... the day is fresh.",
        {"Walk Forward", "Check Inventory"}
    };
    
    //Beggining transitions
    // Define transitions between rooms based on choices
    transitions["Introduction"]["Option 1"] = "StartingRoom_1_f_1";
}

struct Level {
    string displayName;
    string levelAddress;
    int floorNumber;
    string description;
    vector<string> options;
    vector<item> itemsOnFloor;
    bool doesGameContinue;
};

// Function to create Level based on roomId and progression
Level createLevel(string roomId, string displayName, string progression, int floorNumber, vector<item> itemsOnFloor) {
    Level level;
    level.displayName = displayName; 
    level.levelAddress = roomId; 
    level.floorNumber = floorNumber;
    level.description = levelInfo[roomId][progression].description;
    level.options = levelInfo[roomId][progression].options;
    level.itemsOnFloor = itemsOnFloor;
    level.doesGameContinue = true; // Assuming game continues by default
    return level;
}

vector<Level> beginningLevels {
    createLevel("Introduction", "Introduction", "beginning", 0, {} /*No items on the floor*/),
    createLevel("StartingRoom_1_f_1", "Starting Room, Facing Forward", "beginning", 1, {{"Coins", 5, false, "Currency"}})
};

//Display the description of a beginning level
void displayDescription(string roomId, string progression) {
    string description;

    // Check if the roomId and progression combination exists in levelInfo
    if (levelInfo.find(roomId) != levelInfo.end() &&
        levelInfo[roomId].find(progression) != levelInfo[roomId].end()) {
        description = levelInfo[roomId][progression].description;
    }

    // If the description is not empty, display it
    if (!description.empty()) {
        cout << description << endl << endl;
    } else {
        cout << "Description not found for the given roomId and progression." << endl;
    }
}

// Display the options of a level
void displayOptions(string roomId, string progression) {
    vector<string> options;

    // Check if the roomId and progression combination exists in levelInfo
    if (levelInfo.find(roomId) != levelInfo.end() &&
        levelInfo[roomId].find(progression) != levelInfo[roomId].end()) {
        options = levelInfo[roomId][progression].options;
    } else {
        cout << "Room ID or progression not found." << endl;
        return;
    }
    
    cout << "Your options: " << endl;

    // If options are found, display them
    if (!options.empty()) {
        for (int i = 0; i < options.size(); ++i) { cout << i + 1 << ". " << options[i] << endl; }
    } else { cout << "No options available for this level." << endl; }

    cout << endl << endl;
}

struct item {
    string name;
    int quantityOnGround;
    bool hasBeenUsed;
    string className;
    int quantityCollected;
    int currentQuantity;
};

struct Player {
    int numberItems;
    int numberDeaths;
    vector<item> itemsInInventory;
    string roomAddress;
    int floorNumber;
};

//Initialize the player statistics
void initializePlayer(Player& player) {
    player.numberItems = 0;
    player.numberDeaths = 0;
    player.roomAddress = "Starting Room";
    player.floorNumber = 0;
    handItem(player, "NONE", 0, false, "NAN", 0, 0);
}

//Define the function to create a player
Player createPlayer() {
    Player player;
    initializePlayer(player);
    return player;
}

string actionChoice;
bool gameContinues = true;
string beginningProgressionRoomID = ""; //Change this room ID so that it is determined when you move to middle levels
string middleProgressionRoomID = ""; //Change this room ID so that it is determined when you move to final levels

// Function to play a level
int playLevel(string roomId, string progression) {
    displayDescription(roomId, progression);
    displayOptions(roomId, progression);
    cout << "What would you like to do? ";
    int actionChoice;
    cin >> actionChoice;
    return actionChoice;
}

void playGame() {
    string roomId = "Introduction"; // Start at the Introduction level
    string progression = "beginning";

    // Loop until the game ends
    while (true) {
        // Play the current level
        int choice = playLevel(roomId, progression);

        // Handle the player's choice
        if (choice >= 1 && choice <= levelInfo[roomId][progression].options.size()) {
            string chosenOption = levelInfo[roomId][progression].options[choice - 1];
            
            if (transitions.find(roomId) != transitions.end() &&
                transitions[roomId].find(chosenOption) != transitions[roomId].end()) {
                // Update progression based on the transition
                roomId = transitions[roomId][chosenOption];
                if (roomId == beginningProgressionRoomID) { progression = "middle"; /*Move to the "middle" level*/} else
                if (roomId == middleProgressionRoomID) { progression = "final"; /* Move to the "final" level*/ } else
                { progression = "beginning"; /*Move to the "beginning" level*/}
            } else {
                // Handle the case where the next room is not defined
                cout << "Next room not defined for the chosen option." << endl;
                return;
            }
        } else {
            // Handle the case of an invalid option
            cout << "Invalid option. Please choose again." << endl;
        }
    }
    
    endGame();
}

if (levelInfo.find(roomId) != levelInfo.end() &&
        levelInfo[roomId].find(progression) != levelInfo[roomId].end())