5 files changed, 487 insertions, 1 deletions

@@ -1,10 +1,13 @@
 find_package(Protobuf REQUIRED)
+find_package(yaml-cpp REQUIRED)
 
 add_library(util
+  godot_scene.cpp
   identifiers.cpp
+  ids_yaml_format.cpp
   naming.cpp
 )
 set_property(TARGET util PROPERTY CXX_STANDARD 20)
 set_property(TARGET util PROPERTY CXX_STANDARD_REQUIRED ON)
 target_include_directories(util PUBLIC ${CMAKE_BINARY_DIR})
-target_link_libraries(util PUBLIC protos protobuf::libprotobuf)
+target_link_libraries(util PUBLIC protos protobuf::libprotobuf yaml-cpp::yaml-cpp)
@@ -0,0 +1,207 @@
+#include "godot_scene.h"
+
+#include <fstream>
+#include <sstream>
+#include <string_view>
+#include <variant>
+
+namespace com::fourisland::lingo2_archipelago {
+
+namespace {
+
+struct Heading {
+  std::string type;
+
+  std::string id;
+  std::string path;
+  std::string resource_type;
+
+  std::string name;
+  std::string parent;
+  GodotInstanceType instance_type;
+};
+
+Heading ParseTscnHeading(std::string_view line) {
+  std::string original_line(line);
+  Heading heading;
+
+  if (line[0] != '[') {
+    std::ostringstream errormsg;
+    errormsg << "Heading must start with [." << std::endl
+             << "Bad heading: " << original_line;
+    throw std::invalid_argument(errormsg.str());
+  }
+
+  line.remove_prefix(1);
+  int divider = line.find_first_of(" ]");
+  if (divider == std::string_view::npos) {
+    std::ostringstream errormsg;
+    errormsg << "Malformatted heading: " << line << std::endl
+             << "Original line: " << original_line;
+    throw std::invalid_argument(errormsg.str());
+  }
+
+  heading.type = std::string(line.substr(0, divider));
+  line.remove_prefix(divider + 1);
+
+  while (!line.empty()) {
+    divider = line.find_first_of("=");
+    if (divider == std::string_view::npos) {
+      std::ostringstream errormsg;
+      errormsg << "Malformatted heading: " << line << std::endl
+               << "Original line: " << original_line;
+      throw std::invalid_argument(errormsg.str());
+    }
+
+    std::string key(line.substr(0, divider));
+    line.remove_prefix(divider + 1);
+
+    if (line[0] == '"') {
+      line.remove_prefix(1);
+      divider = line.find_first_of("\"");
+
+      if (divider == std::string_view::npos) {
+        std::ostringstream errormsg;
+        errormsg << "Malformatted heading: " << line << std::endl
+                 << "Original line: " << original_line;
+        throw std::invalid_argument(errormsg.str());
+      }
+
+      std::string strval(line.substr(0, divider));
+      line.remove_prefix(divider + 2);
+
+      if (key == "name") {
+        heading.name = strval;
+      } else if (key == "parent") {
+        heading.parent = strval;
+      } else if (key == "path") {
+        heading.path = strval;
+      } else if (key == "type") {
+        heading.resource_type = strval;
+      } else if (key == "id") {
+        heading.id = strval;
+      }
+    } else if (line[0] == 'S' || line[0] == 'E') {
+      GodotInstanceType rrval;
+      char internal = line[0];
+
+      line.remove_prefix(13);  // SubResource("
+      divider = line.find_first_of("\"");
+
+      if (divider == std::string_view::npos) {
+        std::ostringstream errormsg;
+        errormsg << "Malformatted heading: " << line << std::endl
+                 << "Original line: " << original_line;
+        throw std::invalid_argument(errormsg.str());
+      }
+
+      std::string refid = std::string(line.substr(0, divider));
+      line.remove_prefix(divider + 3);
+
+      GodotInstanceType instance_type;
+      if (internal == 'E') {
+        instance_type = GodotExtResourceRef{.id = refid};
+      } else {
+        // SubResource is not supported right now.
+      }
+
+      if (key == "instance") {
+        heading.instance_type = instance_type;
+      } else {
+        // Other keys aren't supported right now.
+      }
+    } else {
+      divider = line.find_first_of(" ]");
+
+      if (divider == std::string_view::npos) {
+        std::ostringstream errormsg;
+        errormsg << "Malformatted heading: " << line << std::endl
+                 << "Original line: " << original_line;
+        throw std::invalid_argument(errormsg.str());
+      }
+
+      int numval = std::atoi(line.substr(0, divider).data());
+      line.remove_prefix(divider + 1);
+
+      // keyvals_[key] = numval;
+    }
+  }
+
+  return heading;
+}
+
+}  // namespace
+
+std::string GodotNode::GetPath() const {
+  if (parent.empty() || parent == ".") {
+    return name;
+  } else {
+    return parent + "/" + name;
+  }
+}
+
+GodotScene ReadGodotSceneFromFile(const std::string& path) {
+  std::map<std::string, GodotExtResource> ext_resources;
+  std::vector<GodotNode> nodes;
+
+  std::ifstream input(path);
+
+  std::string line;
+  bool section_started = false;
+  Heading cur_heading;
+  std::ostringstream cur_value;
+  bool value_started = false;
+  auto handle_end_of_section = [&]() {
+    section_started = false;
+    value_started = false;
+
+    if (cur_heading.type == "sub_resource") {
+      // sub_resources_[std::get<int>(cur_heading.GetKeyval("id"))] =
+      // {cur_heading, cur_value.str(), ""};
+    } else {
+      // other_.emplace_back(cur_heading, cur_value.str());
+    }
+
+    cur_value = {};
+  };
+  while (std::getline(input, line)) {
+    if (section_started && (line.empty() || line[0] == '[')) {
+      handle_end_of_section();
+    }
+    if (!line.empty() && line[0] == '[') {
+      Heading heading = ParseTscnHeading(line);
+      if (heading.type == "gd_scene") {
+        // file_descriptor_ = heading;
+      } else if (heading.type == "ext_resource") {
+        GodotExtResource ext_resource;
+        ext_resource.path = heading.path;
+        ext_resource.type = heading.resource_type;
+
+        ext_resources[heading.id] = ext_resource;
+      } else if (heading.type == "node") {
+        if (heading.parent != "") {
+          nodes.push_back(GodotNode{.name = heading.name,
+                                    .parent = heading.parent,
+                                    .instance_type = heading.instance_type});
+        }
+      } else {
+        cur_heading = heading;
+        section_started = true;
+      }
+    } else if (!line.empty()) {
+      if (value_started) {
+        cur_value << std::endl;
+      } else {
+        value_started = true;
+      }
+      cur_value << line;
+    }
+  }
+  if (section_started) {
+    handle_end_of_section();
+  }
+
+  return GodotScene(std::move(ext_resources), std::move(nodes));
+}
+
+}  // namespace com::fourisland::lingo2_archipelago
@@ -0,0 +1,57 @@
+#ifndef TOOLS_UTIL_TSCN_H_
+#define TOOLS_UTIL_TSCN_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <variant>
+#include <vector>
+
+namespace com::fourisland::lingo2_archipelago {
+
+struct GodotExtResource {
+  std::string type;
+  std::string path;
+};
+
+struct GodotExtResourceRef {
+  std::string id;
+};
+
+using GodotInstanceType = std::variant<std::monostate, GodotExtResourceRef>;
+
+struct GodotNode {
+  std::string name;
+  std::string parent;
+  GodotInstanceType instance_type;
+
+  std::string GetPath() const;
+};
+
+class GodotScene {
+ public:
+  GodotScene(std::map<std::string, GodotExtResource> ext_resources,
+             std::vector<GodotNode> nodes)
+      : ext_resources_(std::move(ext_resources)), nodes_(std::move(nodes)) {}
+
+  const GodotExtResource* GetExtResource(const std::string& id) const {
+    auto it = ext_resources_.find(id);
+    if (it != ext_resources_.end()) {
+      return &it->second;
+    } else {
+      return nullptr;
+    }
+  }
+  const std::vector<GodotNode>& GetNodes() const { return nodes_; }
+
+ private:
+  std::map<std::string, GodotExtResource> ext_resources_;
+  std::vector<GodotNode> nodes_;
+};
+
+GodotScene ReadGodotSceneFromFile(const std::string& path);
+
+}  // namespace com::fourisland::lingo2_archipelago
+
+#endif /* TOOLS_UTIL_TSCN_H_ */
@@ -0,0 +1,203 @@
+#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 (room_it.second["ports"]) {
+            for (const auto& port_it : room_it.second["ports"]) {
+              (*room_ids.mutable_ports())[port_it.first.as<std::string>()] =
+                  port_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>();
+    }
+  }
+
+  if (document["door_groups"]) {
+    for (const auto& group_it : document["door_groups"]) {
+      (*result.mutable_door_groups())[group_it.first.as<std::string>()] =
+          group_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;
+                             });
+
+          OperateOnSortedMap(
+              room_ids.ports(),
+              [&room_node](const std::string& port_name, uint64_t port_id) {
+                room_node["ports"][port_name] = port_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;
+                     });
+
+  OperateOnSortedMap(ids.door_groups(), [&result](const std::string& group_name,
+                                                  uint64_t group_id) {
+    result["door_groups"][group_name] = group_id;
+  });
+
+  std::ofstream output_stream(filename);
+  output_stream << result << std::endl;
+}
+
+}  // namespace com::fourisland::lingo2_archipelago
@@ -0,0 +1,16 @@
+#ifndef TOOLS_UTIL_IDS_YAML_FORMAT_H_
+#define TOOLS_UTIL_IDS_YAML_FORMAT_H_
+
+#include <string>
+
+#include "proto/human.pb.h"
+
+namespace com::fourisland::lingo2_archipelago {
+
+IdMappings ReadIdsFromYaml(const std::string& filename);
+
+void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename);
+
+}  // namespace com::fourisland::lingo2_archipelago
+
+#endif /* TOOLS_UTIL_IDS_YAML_FORMAT_H_ */