C++ Text-based Game - "Map" Implementation - c++

Question

I'm trying to create a text-based adventure game. I'm thinking I want the map to be represented by different nodes where each node corresponds to a distinct location and has node pointer variables (left, forward, and right) that should point to another node in the respective direction. I tried to implement it as a linked list, but with this data structure, I could only have each node point to one other node. I want each node to point to three other nodes. Which data structure could I use to implement this or is this even possible?

Answer 1

A linked datastructure would do a good job of doing what you want:
example:
class location
{
std::string loc_name;
std::vector<std::pair<std::string,location*>> connections;
std::string description;
public:
bool add_link(location* loc, std::string dicription_to, std::string dicription_from);
//other parameters + functions to manage class
}
This would allow you to create locations such as:
location* loc = new location("graveyard");
loc->description = "A spooky graveyard on a hill, a cool mist floats amongst the gravestones and monuments";
loc->add_link(crypt /*previously defined*/,
"An imposing mausoleum with an open door, steps inside lead down into darkness",
"Moonlight filters down from the top of some steps, a way out?");
loc.add_link(spooky_house /*previously defined*/,
"The North gate of the graveyard",
"The entrance to the house's spooky graveyard");
I'd reccommend creating a map file you could read in though. Possibly using a template like this:
locations file:
/*locations, format = "name; description"*/
Spooky House; house_description
Crypt; crypt_description
Graveyard; A spooky graveyard on a hill, a cool mist floats amongst the gravestones and monuments
links file:
/*links, format = "index # (from); index # (to); description (from->to); description (to->from)"*/
3;2;An imposing mausoleum with an open door, steps inside lead down into darkness; Moonlight filters down from the top of some steps, a way out?
3;1;The North gate of the graveyard;The entrance to the house's spooky graveyard;
Loading the map would be as simple as reading in all the locations and pushing them into a vector for storage, then adding the links in to connect them.

Answer 2

You could implement a custom linked datastructure with linked positions on the map like this:
struct Map_Node{
Map_Node *left;
Map_Node *right;
Map_Node *forward;
/* other needed field*/
};
Then, you need to do the memory management on your own. For example by using smart pointers.
std::shared_ptr<Map_Node> entry{ new MapNode };
std::shared_ptr<Map_Node> hallway{ new MapNode };
entry->forward = &*hallway;
//and so on
An easier but less efficient for getting the next file would be a std::map. If each position
has its unique ID, e.g. a string, you could store the IDs of the neighboring fields and move freely on the map by using the ID.
struct Map_Node{
std::string name;
std::string left;
std::string right;
std::string forward;
/* other needed field*/
};
std::map<std::string, Map_Node> map;
Map_Node entry;
entry.name = "entry";
map[entry.name] = entry;
Map_Node hallway;
hallway.name = "hallway";
map[hallway.name] = hallway;
//links between:
map["entry"].forward = "hallway";