Annotated gift maps entrance as requiring cyan doors - lingo2-archipelago - Randomizer for LINGO 2 using Archipelago Multiworld

about summary refs log tree commit diff stats

path: root/data/maps/control_center/rooms/Tenacious Entrance.txtpb

diff options

author	Star Rauchenberger <fefferburbia@gmail.com>	2025-10-23 12:20:36 -0400
committer	Star Rauchenberger <fefferburbia@gmail.com>	2025-10-23 12:20:36 -0400
commit	b5942389aa81b2f10e57e27e1c39164b1197b111 (patch)
tree	7ddbed12d9ea27fd246ce78fd94c6f736f51aeaf /data/maps/control_center/rooms/Tenacious Entrance.txtpb
parent	8cfee29fe6500e96c3b8669c12ac944716e9aae4 (diff)
download	lingo2-archipelago-b5942389aa81b2f10e57e27e1c39164b1197b111.tar.gz lingo2-archipelago-b5942389aa81b2f10e57e27e1c39164b1197b111.tar.bz2 lingo2-archipelago-b5942389aa81b2f10e57e27e1c39164b1197b111.zip

Annotated gift maps entrance as requiring cyan doors

Diffstat (limited to 'data/maps/control_center/rooms/Tenacious Entrance.txtpb')

0 files changed, 0 insertions, 0 deletions

d='n139' href='#n139'>139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178

#include "ids_yaml_format.h"

#include <yaml-cpp/yaml.h>

#include <fstream>
#include <functional>

namespace com::fourisland::lingo2_archipelago {
namespace {

template <typename T>
void OperateOnSortedMap(
    const T& map, std::function<void(const std::string& name,
                                     const typename T::mapped_type& value)>
                      callback) {
  std::vector<std::string> names;
  for (const auto& it : map) {
    names.push_back(it.first);
  }

  std::sort(names.begin(), names.end());

  for (const std::string& name : names) {
    callback(name, map.at(name));
  }
}

}  // namespace

IdMappings ReadIdsFromYaml(const std::string& filename) {
  IdMappings result;

  YAML::Node document = YAML::LoadFile(filename);

  if (document["maps"]) {
    for (const auto& map_it : document["maps"]) {
      IdMappings::MapIds& map_ids =
          (*result.mutable_maps())[map_it.first.as<std::string>()];

      if (map_it.second["rooms"]) {
        for (const auto& room_it : map_it.second["rooms"]) {
          IdMappings::RoomIds& room_ids =
              (*map_ids.mutable_rooms())[room_it.first.as<std::string>()];

          if (room_it.second["panels"]) {
            for (const auto& panel_it : room_it.second["panels"]) {
              (*room_ids.mutable_panels())[panel_it.first.as<std::string>()] =
                  panel_it.second.as<uint64_t>();
            }
          }

          if (room_it.second["masteries"]) {
            for (const auto& mastery_it : room_it.second["masteries"]) {
              (*room_ids
                    .mutable_masteries())[mastery_it.first.as<std::string>()] =
                  mastery_it.second.as<uint64_t>();
            }
          }

          if (room_it.second["keyholders"]) {
            for (const auto& keyholder_it : room_it.second["keyholders"]) {
              (*room_ids.mutable_keyholders())[keyholder_it.first
                                                   .as<std::string>()] =
                  keyholder_it.second.as<uint64_t>();
            }
          }
        }
      }

      if (map_it.second["doors"]) {
        for (const auto& door_it : map_it.second["doors"]) {
          (*map_ids.mutable_doors())[door_it.first.as<std::string>()] =
              door_it.second.as<uint64_t>();
        }
      }
    }
  }

  if (document["letters"]) {
    for (const auto& letter_it : document["letters"]) {
      (*result.mutable_letters())[letter_it.first.as<std::string>()] =
          letter_it.second.as<uint64_t>();
    }
  }

  if (document["endings"]) {
    for (const auto& ending_it : document["endings"]) {
      (*result.mutable_endings())[ending_it.first.as<std::string>()] =
          ending_it.second.as<uint64_t>();
    }
  }

  if (document["special"]) {
    for (const auto& special_it : document["special"]) {
      (*result.mutable_special())[special_it.first.as<std::string>()] =
          special_it.second.as<uint64_t>();
    }
  }

  if (document["progressives"]) {
    for (const auto& prog_it : document["progressives"]) {
      (*result.mutable_progressives())[prog_it.first.as<std::string>()] =
          prog_it.second.as<uint64_t>();
    }
  }

  return result;
}

void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
  YAML::Node result;

  OperateOnSortedMap(ids.maps(), [&result](const std::string& map_name,
                                           const IdMappings::MapIds& map_ids) {
    YAML::Node map_node;

    OperateOnSortedMap(
        map_ids.rooms(), [&map_node](const std::string& room_name,
                                     const IdMappings::RoomIds& room_ids) {
          YAML::Node room_node;

          OperateOnSortedMap(
              room_ids.panels(),
              [&room_node](const std::string& panel_name, uint64_t panel_id) {
                room_node["panels"][panel_name] = panel_id;
              });

          OperateOnSortedMap(room_ids.masteries(),
                             [&room_node](const std::string& mastery_name,
                                          uint64_t mastery_id) {
                               room_node["masteries"][mastery_name] =
                                   mastery_id;
                             });

          OperateOnSortedMap(room_ids.keyholders(),
                             [&room_node](const std::string& keyholder_name,
                                          uint64_t keyholder_id) {
                               room_node["keyholders"][keyholder_name] =
                                   keyholder_id;
                             });

          map_node["rooms"][room_name] = std::move(room_node);
        });

    OperateOnSortedMap(
        map_ids.doors(),
        [&map_node](const std::string& door_name, uint64_t door_id) {
          map_node["doors"][door_name] = door_id;
        });

    result["maps"][map_name] = std::move(map_node);
  });

  OperateOnSortedMap(ids.letters(), [&result](const std::string& letter_name,
                                              uint64_t letter_id) {
    result["letters"][letter_name] = letter_id;
  });

  OperateOnSortedMap(ids.endings(), [&result](const std::string& ending_name,
                                              uint64_t ending_id) {
    result["endings"][ending_name] = ending_id;
  });

  OperateOnSortedMap(ids.special(), [&result](const std::string& special_name,
                                              uint64_t special_id) {
    result["special"][special_name] = special_id;
  });

  OperateOnSortedMap(ids.progressives(),
                     [&result](const std::string& prog_name, uint64_t prog_id) {
                       result["progressives"][prog_name] = prog_id;
                     });

  std::ofstream output_stream(filename);
  output_stream << result << std::endl;
}

}  // namespace com::fourisland::lingo2_archipelago


context:
space:
mode: