Added the_repetitive

3 files changed, 40 insertions, 114 deletions

@@ -1,6 +1,7 @@
 #include "godot_scene.h"
 
 #include <absl/strings/str_split.h>
+#include <absl/strings/string_view.h>
 
 #include <fstream>
 #include <sstream>
@@ -10,32 +11,6 @@ namespace com::fourisland::lingo2_archipelago {
 
 namespace {
 
-class GodotSceneImpl : public GodotScene {
- public:
-  GodotSceneImpl(std::map<std::string, GodotExtResource> ext_resources,
-                 std::unique_ptr<GodotNode> root,
-                 std::vector<std::unique_ptr<GodotNode>> descendents)
-      : ext_resources_(std::move(ext_resources)),
-        root_(std::move(root)),
-        descendents_(std::move(descendents)) {}
-
-  virtual 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;
-    }
-  }
-
-  virtual const GodotNode& GetRoot() const { return *root_; }
-
- private:
-  std::map<std::string, GodotExtResource> ext_resources_;
-  std::unique_ptr<GodotNode> root_;
-  std::vector<std::unique_ptr<GodotNode>> descendents_;
-};
-
 struct Heading {
   std::string type;
 
@@ -159,45 +134,17 @@ Heading ParseTscnHeading(absl::string_view line) {
 
 }  // namespace
 
-void GodotNode::AddChild(GodotNode& child) {
-  children_[child.GetName()] = &child;
-  child.parent_ = this;
-}
-
 std::string GodotNode::GetPath() const {
-  if (parent_ == nullptr || parent_->GetName() == "") {
-    return name_;
+  if (parent.empty() || parent == ".") {
+    return name;
   } else {
-    return parent_->GetPath() + "/" + name_;
+    return parent + "/" + name;
   }
 }
 
-const GodotNode* GodotNode::GetNode(absl::string_view path) const {
-  std::vector<std::string> names = absl::StrSplit(path, "/");
-
-  auto it = children_.find(names[0]);
-  if (it == children_.end()) {
-    return nullptr;
-  } else {
-    if (names.size() == 1) {
-      return it->second;
-    } else {
-      path.remove_prefix(names[0].size() + 1);
-
-      return it->second->GetNode(path);
-    }
-  }
-}
-
-GodotNode* GodotNode::GetNode(absl::string_view path) {
-  return const_cast<GodotNode*>(
-      const_cast<const GodotNode*>(this)->GetNode(path));
-}
-
-std::unique_ptr<GodotScene> ReadGodotSceneFromFile(const std::string& path) {
+GodotScene ReadGodotSceneFromFile(const std::string& path) {
   std::map<std::string, GodotExtResource> ext_resources;
-  auto root = std::make_unique<GodotNode>("", GodotInstanceType{});
-  std::vector<std::unique_ptr<GodotNode>> descendents;
+  std::vector<GodotNode> nodes;
 
   std::ifstream input(path);
 
@@ -235,15 +182,9 @@ std::unique_ptr<GodotScene> ReadGodotSceneFromFile(const std::string& path) {
         ext_resources[heading.id] = ext_resource;
       } else if (heading.type == "node") {
         if (heading.parent != "") {
-          descendents.push_back(
-              std::make_unique<GodotNode>(heading.name, heading.instance_type));
-          GodotNode* child = descendents.back().get();
-
-          if (heading.parent == ".") {
-            root->AddChild(*child);
-          } else {
-            root->GetNode(heading.parent)->AddChild(*child);
-          }
+          nodes.push_back(GodotNode{.name = heading.name,
+                                    .parent = heading.parent,
+                                    .instance_type = heading.instance_type});
         }
       } else {
         cur_heading = heading;
@@ -262,8 +203,7 @@ std::unique_ptr<GodotScene> ReadGodotSceneFromFile(const std::string& path) {
     handle_end_of_section();
   }
 
-  return std::make_unique<GodotSceneImpl>(
-      std::move(ext_resources), std::move(root), std::move(descendents));
+  return GodotScene(std::move(ext_resources), std::move(nodes));
 }
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -1,13 +1,12 @@
 #ifndef TOOLS_UTIL_TSCN_H_
 #define TOOLS_UTIL_TSCN_H_
 
-#include <absl/strings/string_view.h>
-
 #include <map>
 #include <memory>
 #include <string>
-#include <string_view>
+#include <utility>
 #include <variant>
+#include <vector>
 
 namespace com::fourisland::lingo2_archipelago {
 
@@ -22,45 +21,36 @@ struct GodotExtResourceRef {
 
 using GodotInstanceType = std::variant<std::monostate, GodotExtResourceRef>;
 
-class GodotNode {
- public:
-  GodotNode(std::string name, GodotInstanceType instance_type)
-      : name_(std::move(name)), instance_type_(std::move(instance_type)) {}
-
-  const std::string& GetName() const { return name_; }
-
-  const GodotInstanceType& GetInstanceType() const { return instance_type_; }
-
-  const GodotNode* GetParent() const { return parent_; }
-  GodotNode* GetParent() { return parent_; }
+struct GodotNode {
+  std::string name;
+  std::string parent;
+  GodotInstanceType instance_type;
 
   std::string GetPath() const;
-
-  void AddChild(GodotNode& child);
-
-  const GodotNode* GetNode(absl::string_view path) const;
-  GodotNode* GetNode(absl::string_view path);
-
-  const std::map<std::string, GodotNode*> GetChildren() const {
-    return children_;
-  }
-
- private:
-  std::string name_;
-  GodotInstanceType instance_type_;
-
-  GodotNode* parent_ = nullptr;
-  std::map<std::string, GodotNode*> children_;
 };
 
 class GodotScene {
  public:
-  virtual const GodotExtResource* GetExtResource(
-      const std::string& id) const = 0;
-  virtual const GodotNode& GetRoot() const = 0;
+  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_;
 };
 
-std::unique_ptr<GodotScene> ReadGodotSceneFromFile(const std::string& path);
+GodotScene ReadGodotSceneFromFile(const std::string& path);
 
 }  // namespace com::fourisland::lingo2_archipelago
 
@@ -35,17 +35,17 @@ class GodotProcessor {
     std::string scene_path_str = scene_path.string();
     std::cout << "Processing " << scene_path_str << std::endl;
 
-    std::unique_ptr<GodotScene> scene =
-        ReadGodotSceneFromFile(scene_path_str);
-
-    ProcessMapNode(*scene, scene->GetRoot(), map_info);
+    GodotScene scene = ReadGodotSceneFromFile(scene_path_str);
+    for (const GodotNode& node : scene.GetNodes()) {
+      ProcessMapNode(scene, node, map_info);
+    }
   }
 
   void ProcessMapNode(const GodotScene& scene, const GodotNode& node,
                       MapInfo& map_info) {
-    if (std::holds_alternative<GodotExtResourceRef>(node.GetInstanceType())) {
+    if (std::holds_alternative<GodotExtResourceRef>(node.instance_type)) {
       const GodotExtResourceRef& ext_resource_ref =
-          std::get<GodotExtResourceRef>(node.GetInstanceType());
+          std::get<GodotExtResourceRef>(node.instance_type);
       const GodotExtResource* ext_resource =
           scene.GetExtResource(ext_resource_ref.id);
 
@@ -55,10 +55,6 @@ class GodotProcessor {
         map_info.game_nodes[node.GetPath()].defined = true;
       }
     }
-
-    for (const auto& [child_name, child_node] : node.GetChildren()) {
-      ProcessMapNode(scene, *child_node, map_info);
-    }
   }
 
  private: