data/maps/the_bearer/README


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

This map is a bit of a mess. The top areas should make sense but the bottom area
is confusing because of the fact that many panels can be seen from multiple
places in the grid, and it is intended for you to solve them through the
transparent doors. The approach to this is threefold.

1. Panels that can be solved without opening any doors are all in the Entry
   region. This includes the two panels physically accessible from the warp
   hallways, as well as the two panels each that can be seen while standing next
   to those panels, for a total of six panels in the Entry region (plus the two
   that are actually upstairs).
2. The part of the grid behind where you enter is actually completely linear.
   There is one region for each grid square in this area, except for the middle
   two in the orange row. The regions are named after the positions you stand
   in, not the panels at those positions in the grid. Instead, each region
   contains the panel you can see from that position. This is why the two middle
   orange grid squares do not have regions, because they are solvable from the
   red row and entering the regions does nothing.
3. For the rest of the grid, each panel is visible from two other grid
   positions. To handle this, there is a region for every grid position you can
   stand in, and a region for every panel. The standing regions are connected to
   each adjacent grid square using event doors, and there is a oneway connection
   from each standing region into the panel regions for each panel that can be
   seen from that standing position.
#include "game_data.h"

#include <hkutil/string.h>
#include <yaml-cpp/yaml.h>

#include <iostream>

LingoColor GetColorForString(const std::string &str) {
  if (str == "black") {
    return LingoColor::kBlack;
  } else if (str == "red") {
    return LingoColor::kRed;
  } else if (str == "blue") {
    return LingoColor::kBlue;
  } else if (str == "yellow") {
    return LingoColor::kYellow;
  } else if (str == "orange") {
    return LingoColor::kOrange;
  } else if (str == "green") {
    return LingoColor::kGreen;
  } else if (str == "gray") {
    return LingoColor::kGray;
  } else if (str == "brown") {
    return LingoColor::kBrown;
  } else if (str == "purple") {
    return LingoColor::kPurple;
  } else {
    std::cout << "Invalid color: " << str << std::endl;
    return LingoColor::kNone;
  }
}

GameData::GameData() {
  YAML::Node lingo_config = YAML::LoadFile("assets/LL1.yaml");
  YAML::Node areas_config = YAML::LoadFile("assets/areas.yaml");

  rooms_.reserve(lingo_config.size() * 2);

  for (const auto &room_it : lingo_config) {
    int room_id = AddOrGetRoom(room_it.first.as<std::string>());
    Room &room_obj = rooms_[room_id];

    for (const auto &entrance_it : room_it.second["entrances"]) {
      int from_room_id = AddOrGetRoom(entrance_it.first.as<std::string>());
      Room &from_room_obj = rooms_[from_room_id];

      switch (entrance_it.second.Type()) {
        case YAML::NodeType::Scalar: {
          // This is just "true".
          from_room_obj.exits.push_back({.destination_room = room_id});
          break;
        }
        case YAML::NodeType::Map: {
          Exit exit_obj;
          exit_obj.destination_room = room_id;

          if (entrance_it.second["door"]) {
            std::string door_room = room_obj.name;
            if (entrance_it.second["room"]) {
              door_room = entrance_it.second["room"].as<std::string>();
            }
            exit_obj.door = AddOrGetDoor(
                door_room, entrance_it.second["door"].as<std::string>());
          }

          if (entrance_it.second["painting"]) {
            exit_obj.painting = entrance_it.second["painting"].as<bool>();
          }

          from_room_obj.exits.push_back(exit_obj);
          break;
        }
        case YAML::NodeType::Sequence: {
          for (const auto &option : entrance_it.second) {
            Exit exit_obj;
            exit_obj.destination_room = room_id;

            std::string door_room = room_obj.name;
            if (option["room"]) {
              door_room = option["room"].as<std::string>();
            }
            exit_obj.door =
                AddOrGetDoor(door_room, option["door"].as<std::string>());

            if (option["painting"]) {
              exit_obj.painting = option["painting"].as<bool>();
            }

            from_room_obj.exits.push_back(exit_obj);
          }

          break;
        }
        default: {
          // This shouldn't happen.
          std::cout << "Error reading game data: " << entrance_it << std::endl;
          break;
        }
      }
    }

    if (room_it.second["panels"]) {
      for (const auto &panel_it : room_it.second["panels"]) {
        int panel_id =
            AddOrGetPanel(room_obj.name, panel_it.first.as<std::string>());
        Panel &panel_obj = panels_[panel_id];

        if (panel_it.second["colors"]) {
          if (panel_it.second["colors"].IsScalar()) {
            panel_obj.colors.push_back(
                GetColorForString(panel_it.second["colors"].as<std::string>()));
          } else {
            for (const auto &color_node : panel_it.second["colors"]) {
              panel_obj.colors.push_back(
                  GetColorForString(color_node.as<std::string>()));
            }
          }
        }

        if (panel_it.second["required_room"]) {
          if (panel_it.second["required_room"].IsScalar()) {
            panel_obj.required_rooms.push_back(AddOrGetRoom(
                panel_it.second["required_room"].as<std::string>()));
          } else {
            for (const auto &rr_node : panel_it.second["required_room"]) {
              panel_obj.required_rooms.push_back(
                  AddOrGetRoom(rr_node.as<std::string>()));
            }
          }
        }

        if (panel_it.second["required_door"]) {
          if (panel_it.second["required_door"].IsMap()) {
            std::string rd_room = room_obj.name;
            if (panel_it.second["required_door"]["room"]) {
              rd_room =
                  panel_it.second["required_door"]["room"].as<std::string>();
            }

            panel_obj.required_doors.push_back(AddOrGetDoor(
                rd_room,
                panel_it.second["required_door"]["door"].as<std::string>()));
          } else {
            for (const auto &rr_node : panel_it.second["required_door"]) {
              std::string rd_room = room_obj.name;
              if (rr_node["room"]) {
                rd_room = rr_node["room"].as<std::string>();
              }

              panel_obj.required_doors.push_back(
                  AddOrGetDoor(rd_room, rr_node["door"].as<std::string>()));
            }
          }
        }

        if (panel_it.second["check"]) {
          panel_obj.check = panel_it.second["check"].as<bool>();
        }

        if (panel_it.second["achievement"]) {
          panel_obj.achievement = panel_it.second["achievement"].as<bool>();

          if (panel_obj.achievement) {
            achievement_panels_.push_back(panel_id);
          }
        }

        if (panel_it.second["exclude_reduce"]) {
          panel_obj.exclude_reduce =
              panel_it.second["exclude_reduce"].as<bool>();
        }
      }
    }

    if (room_it.second["doors"]) {
      for (const auto &door_it : room_it.second["doors"]) {
        int door_id =
            AddOrGetDoor(room_obj.name, door_it.first.as<std::string>());
        Door &door_obj = doors_[door_id];

        bool has_external_panels = false;
        std::vector<std::string> panel_names;

        for (const auto &panel_node : door_it.second["panels"]) {
          if (panel_node.IsScalar()) {
            panel_names.push_back(panel_node.as<std::string>());
            door_obj.panels.push_back(
                AddOrGetPanel(room_obj.name, panel_node.as<std::string>()));
          } else {
            has_external_panels = true;
            panel_names.push_back(panel_node["panel"].as<std::string>());
            door_obj.panels.push_back(
                AddOrGetPanel(panel_node["room"].as<std::string>(),
                              panel_node["panel"].as<std::string>()));
          }
        }

        if (door_it.second["skip_location"]) {
          door_obj.skip_location = door_it.second["skip_location"].as<bool>();
        }

        if (door_it.second["skip_item"]) {
          door_obj.skip_item = door_it.second["skip_item"].as<bool>();
        }

        if (door_it.second["event"]) {
          door_obj.skip_location = door_it.second["event"].as<bool>();
          door_obj.skip_item = door_it.second["event"].as<bool>();
        }

        if (door_it.second["item_name"]) {
          door_obj.item_name = door_it.second["item_name"].as<std::string>();
        } else if (!door_it.second["skip_item"] && !door_it.second["event"]) {
          door_obj.item_name = room_obj.name + " - " + door_obj.name;
        }

        if (door_it.second["group"]) {
          door_obj.group_name = door_it.second["group"].as<std::string>();
        }

        if (door_it.second["location_name"]) {
          door_obj.location_name =
              door_it.second["location_name"].as<std::string>();
        } else if (!door_it.second["skip_location"] &&
                   !door_it.second["event"]) {
          if (has_external_panels) {
            std::cout
                << room_obj.name << " - " << door_obj.name
                << " has panels from other rooms but does not have an explicit "
                   "location name and is not marked skip_location or event"
                << std::endl;
          }

          door_obj.location_name =
              room_obj.name + " - " + hatkirby::implode(panel_names, ", ");
        }

        if (door_it.second["include_reduce"]) {
          door_obj.exclude_reduce =
              !door_it.second["include_reduce"].as<bool>();
        }
      }
    }

    if (room_it.second["paintings"]) {
      for (const auto &painting : room_it.second["paintings"]) {
        std::string painting_id = painting["id"].as<std::string>();
        room_by_painting_[painting_id] = room_id;

        if (!painting["exit_only"] || !painting["exit_only"].as<bool>()) {
          PaintingExit painting_exit;
          painting_exit.id = painting_id;

          if (painting["required_door"]) {
            std::string rd_room = room_obj.name;
            if (painting["required_door"]["room"]) {
              rd_room = painting["required_door"]["room"].as<std::string>();
            }

            painting_exit.door = AddOrGetDoor(
                rd_room, painting["required_door"]["door"].as<std::string>());
          }

          room_obj.paintings.push_back(painting_exit);
        }
      }
    }

    if (room_it.second["progression"]) {
      for (const auto &progression_it : room_it.second["progression"]) {
        std::string progressive_item_name =
            progression_it.first.as<std::string>();

        int index = 1;
        for (const auto &stage : progression_it.second) {
          int door_id = -1;

          if (stage.IsScalar()) {
            door_id = AddOrGetDoor(room_obj.name, stage.as<std::string>());
          } else {
            door_id = AddOrGetDoor(stage["room"].as<std::string>(),
                                   stage["door"].as<std::string>());
          }

          doors_[door_id].progressives.push_back(
              {.item_name = progressive_item_name, .quantity = index});
          index++;
        }
      }
    }
  }

  map_areas_.reserve(areas_config.size());

  std::map<std::string, int> fold_areas;
  for (const auto &area_it : areas_config) {
    if (area_it.second["map"]) {
      int area_id = AddOrGetArea(area_it.first.as<std::string>());
      MapArea &area_obj = map_areas_[area_id];
      area_obj.map_x = area_it.second["map"][0].as<int>();
      area_obj.map_y = area_it.second["map"][1].as<int>();
    } else if (area_it.second["fold_into"]) {
      fold_areas[area_it.first.as<std::string>()] =
          AddOrGetArea(area_it.second["fold_into"].as<std::string>());
    }
  }

  for (const Panel &panel : panels_) {
    if (panel.check) {
      int room_id = panel.room;
      std::string room_name = rooms_[room_id].name;

      std::string area_name = room_name;
      if (fold_areas.count(room_name)) {
        int fold_area_id = fold_areas[room_name];
        area_name = map_areas_[fold_area_id].name;
      }

      int area_id = AddOrGetArea(area_name);
      MapArea &map_area = map_areas_[area_id];
      // room field should be the original room ID
      map_area.locations.push_back(
          {.name = panel.name,
           .ap_location_name = room_name + " - " + panel.name,
           .room = panel.room,
           .panels = {panel.id}});
    }
  }

  for (const Door &door : doors_) {
    if (!door.skip_location) {
      int room_id = door.room;
      std::string area_name = rooms_[room_id].name;
      std::string section_name;

      size_t divider_pos = door.location_name.find(" - ");
      if (divider_pos == std::string::npos) {
        section_name = door.location_name;
      } else {
        area_name = door.location_name.substr(0, divider_pos);
        section_name = door.location_name.substr(divider_pos + 3);
      }

      if (fold_areas.count(area_name)) {
        int fold_area_id = fold_areas[area_name];
        area_name = map_areas_[fold_area_id].name;
      }

      int area_id = AddOrGetArea(area_name);
      MapArea &map_area = map_areas_[area_id];
      // room field should be the original room ID
      map_area.locations.push_back({.name = section_name,
                                    .ap_location_name = door.location_name,
                                    .room = door.room,
                                    .panels = door.panels});
    }
  }
}

int GameData::AddOrGetRoom(std::string room) {
  if (!room_by_id_.count(room)) {
    room_by_id_[room] = rooms_.size();
    rooms_.push_back({.name = room});
  }

  return room_by_id_[room];
}

int GameData::AddOrGetDoor(std::string room, std::string door) {
  std::string full_name = room + " - " + door;

  if (!door_by_id_.count(full_name)) {
    door_by_id_[full_name] = doors_.size();
    doors_.push_back({.room = AddOrGetRoom(room), .name = door});
  }

  return door_by_id_[full_name];
}

int GameData::AddOrGetPanel(std::string room, std::string panel) {
  std::string full_name = room + " - " + panel;

  if (!panel_by_id_.count(full_name)) {
    int panel_id = panels_.size();
    panel_by_id_[full_name] = panel_id;
    panels_.push_back(
        {.id = panel_id, .room = AddOrGetRoom(room), .name = panel});
  }

  return panel_by_id_[full_name];
}

int GameData::AddOrGetArea(std::string area) {
  if (!area_by_id_.count(area)) {
    int area_id = map_areas_.size();
    area_by_id_[area] = area_id;
    map_areas_.push_back({.id = area_id, .name = area});
  }

  return area_by_id_[area];
}

const GameData &GetGameData() {
  static GameData *instance = new GameData();
  return *instance;
}