Better solution to a ton of switch cases in command line game

I’m currently writing a project in c++
to turn the book “Fighting Fantasy” into a command line game. For those of you who don’t know, Fighting Fantasy is an interactive novel game where you start on page one and based on decisions you make, you flip to different pages. For example, on page 1 “you arrive at a cave, flip to page 30 to go east, flip to page 40 to go west.”

Now the way I currently have this implemented is: I have all the mechanics of the game (items, stats, battles, etc.) abstracted into different files/functions and my main function serves as the control. I treat every page as an event, so for example, if the player goes east, then the event is set to 30. There’s a MASSIVE switch case inside a while loop that’s inside main, and each case calls the functions required to run the specific mechanics for that page, then sets the next event before it loops again.

Now, there are 400 events in this book, which means 400 cases. My question is, is it poor design to have that many cases? Or is it okay in this situation since it’s a very simple/logical way of navigating the book/story? Furthermore, if this really poor, what suggestions would you have for improving the logic flow for this game?

Thank you!

If all your program does is print the text content of a page and then perform an action afterwards, and if this action is either to

1. go to the next page, or
2. jump to a certain page number, or
3. ask the user a question and perform an action depending on the response, or
4. exit the program,

then you could assign a struct action to every page and to every possible choice of a question, and define struct action and struct question like this:

struct question;
struct action
{
enum class types
{
GO_TO_NEXT_PAGE,
JUMP_TO_PAGE,
ASK_QUESTION,
EXIT_PROGRAM
} type;
union
{
//this member is only valid when "type" is JUMP_TO_PAGE
int target;
//this member is only valid when "type" is ASK_QUESTION
question *q;
};
};
struct question
{
const char* text;
std::vector<action> actions;
};

That way, if you have an array of objects that each represent a page and if every such object contains a struct action, you will only need the program logic necessary to process these actions. You will be able to add pages to the game without the need of adding additional program logic.

Here is an example of a full working program:

#include <iostream>
#include <vector>
#include <exception>
struct question;
struct action
{
enum class types
{
GO_TO_NEXT_PAGE,
JUMP_TO_PAGE,
ASK_QUESTION,
EXIT_PROGRAM
} type;
union
{
//this member is only valid when "type" is JUMP_TO_PAGE
int target;
//this member is only valid when "type" is ASK_QUESTION
question* q;
};
};
struct question
{
const char* text;
std::vector<action> actions;
};
struct page
{
const char* text;
action a;
};
//this function initializes all game data and
//returns a pointer to the first page
page* init_game()
{
//create questions
static question questions[] =
{
//question 0
{
"Do you want to\n"
"1. head west, or\n"
"2. head east?\n"
"Enter choice: ",
{
{
.type = action::types::GO_TO_NEXT_PAGE,
.target = -1
},
{
.type = action::types::JUMP_TO_PAGE,
.target = 2
}
}
},
//question 1
{
"Do you want to\n"
"1. fight the ogre, or\n"
"2. run away?\n"
"Enter choice: ",
{
{
.type = action::types::GO_TO_NEXT_PAGE,
.target = -1
},
{
.type = action::types::JUMP_TO_PAGE,
.target = 4
}
}
}
};
//create pages
static page pages[] =
{
//NOTE: The page numbers printed by the game are
//      1-based, whereas the page numbers inside
//      the program's code are 0-based.
//page 0
{
"You are in a forest. To the west, you see a\n"
"river. To the east, you see an ogre.\n",
{
.type = action::types::ASK_QUESTION,
.q = &questions[0]
}
},
//page 1
{
"You reach the river. After drinking some water out\n"
"of the river, you find nothing further of interest,\n"
"so you head back east to the forest.\n",
{
.type = action::types::JUMP_TO_PAGE,
.target = 0
}
},
//page 2
{
"You are being attacked by an ogre.\n",
{
.type = action::types::ASK_QUESTION,
.q = &questions[1]
}
},
//page 3
{
"You hit the ogre with your sword and kill it.\n",
{
.type = action::types::EXIT_PROGRAM,
.target = -1
}
},
//page 4
{
"While you attempt to run away, the ogre\n"
"throws its axe at you and it kills you.\n",
{
.type = action::types::EXIT_PROGRAM,
.target = -1
}
}
};
return &pages[0];
}
void game_logic( page* pages )
{
int page_num = 0;
for (;;)
{
//print the page content
std::cout << "Page " << page_num + 1 << ":\n";
std::cout << pages[page_num].text;
//perform action(s) for the page
action* a = &pages[page_num].a;
for (;;)
{
switch ( a->type )
{
case action::types::GO_TO_NEXT_PAGE:
page_num++;
break;
case action::types::JUMP_TO_PAGE:
page_num = a->target;
break;
case action::types::ASK_QUESTION:
{
int answer;
//print the question
std::cout << a->q->text;
//get response
std::cin >> answer;
if ( !std::cin )
throw std::runtime_error( "input error" );
//perform the next action                    
a = &a->q->actions.at(answer-1);
continue;
}
case action::types::EXIT_PROGRAM:
return;
default:
throw std::runtime_error( "internal error" );
}
//add spacing
std::cout << '\n';
//we have completed all actions, so break out
//of infinite loop
break;
}
}
}
int main()
{
page* first = init_game();
try
{
game_logic( first );
}
catch ( const std::exception &e )
{
std::cerr << "Exception occurred: " << e.what() << '\n';
}
}

This program has the following behavior:

Page 1:
You are in a forest. To the west, you see a
river. To the east, you see an ogre.
Do you want to
1. head west, or
2. head east?
Enter choice: 1
Page 2:
You reach the river. After drinking some water out
of the river, you find nothing further of interest,
so you head back east to the forest.
Page 1:
You are in a forest. To the west, you see a
river. To the east, you see an ogre.
Do you want to
1. head west, or
2. head east?
Enter choice: 2
Page 3:
You are being attacked by an ogre.
Do you want to
1. fight the ogre, or
2. run away?
Enter choice: 2
Page 5:
While you attempt to run away, the ogre
throws its axe at you and it kills you.

Ok, that didn't go well, so let's try a different choice:

Page 1:
You are in a forest. To the west, you see a
river. To the east, you see an ogre.
Do you want to
1. head west, or
2. head east?
Enter choice: 2
Page 3:
You are being attacked by an ogre.
Do you want to
1. fight the ogre, or
2. run away?
Enter choice: 1
Page 4:
You hit the ogre with your sword and kill it.