#include "container.h" #include #include "util/naming.h" namespace com::fourisland::lingo2_archipelago { uint64_t Container::FindOrAddMap(std::string map_name) { auto it = map_id_by_name_.find(map_name); if (it == map_id_by_name_.end()) { uint64_t new_id = all_objects_.maps_size(); Map* map = all_objects_.add_maps(); map->set_id(new_id); map->set_name(map_name); map_id_by_name_[map_name] = new_id; return new_id; } else { return it->second; } } uint64_t Container::FindOrAddRoom(std::optional map_name, std::string room_name, std::optional map_fallback) { if (!map_name) { if (!map_fallback) { std::cout << "No map name provided for " << room_name << std::endl; map_name = "global"; } else { map_name = map_fallback; } } auto& map_container = room_id_by_map_room_names_[*map_name]; auto it = map_container.find(room_name); if (it == map_container.end()) { uint64_t new_id = all_objects_.rooms_size(); Room* room = all_objects_.add_rooms(); room->set_id(new_id); room->set_map_id(FindOrAddMap(*map_name)); room->set_name(room_name); map_container[room_name] = new_id; return new_id; } else { return it->second; } } uint64_t Container::FindOrAddPainting( std::optional map_name, std::optional room_name, std::string painting_name, std::optional map_fallback, std::optional room_fallback) { if (!map_name) { if (!map_fallback) { std::cout << "No map name provided for " << painting_name << std::endl; map_name = "global"; } else { map_name = map_fallback; } } if (!room_name) { if (!room_fallback) { std::cout << "No room name provided for " << painting_name << std::endl; room_name = "global"; } else { room_name = room_fallback; } } auto& room_container = painting_id_by_map_room_painting_names_[*map_name][*room_name]; auto it = room_container.find(painting_name); if (it == room_container.end()) { uint64_t new_id = all_objects_.paintings_size(); PaintingData* painting = all_objects_.add_paintings(); painting->set_id(new_id); painting->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt)); painting->set_name(painting_name); room_container[painting_name] = new_id; return new_id; } else { return it->second; } } uint64_t Container::FindOrAddPort(std::optional map_name, std::optional room_name, std::string port_name, std::optional map_fallback, std::optional room_fallback) { if (!map_name) { if (!map_fallback) { std::cout << "No map name provided for " << port_name << std::endl; map_name = "global"; } else { map_name = map_fallback; } } if (!room_name) { if (!room_fallback) { std::cout << "No room name provided for " << port_name << std::endl; room_name = "global"; } else { room_name = room_fallback; } } auto& room_container = port_id_by_map_room_port_names_[*map_name][*room_name]; auto it = room_container.find(port_name); if (it == room_container.end()) { uint64_t new_id = all_objects_.ports_size(); Port* port = all_objects_.add_ports(); port->set_id(new_id); port->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt)); port->set_name(port_name); room_container[port_name] = new_id; return new_id; } else { return it->second; } } uint64_t Container::FindOrAddPanel(std::optional map_name, std::optional room_name, std::string panel_name, std::optional map_fallback, std::optional room_fallback) { if (!map_name) { if (!map_fallback) { std::cout << "No map name provided for " << panel_name << std::endl; map_name = "global"; } else { map_name = map_fallback; } } if (!room_name) { if (!room_fallback) { std::cout << "No room name provided for " << panel_name << std::endl; room_name = "global"; } else { room_name = room_fallback; } } auto& room_container = panel_id_by_map_room_panel_names_[*map_name][*room_name]; auto it = room_container.find(panel_name); if (it == room_container.end()) { uint64_t new_id = all_objects_.panels_size(); PanelData* panel = all_objects_.add_panels(); panel->set_id(new_id); panel->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt)); panel->set_name(panel_name); room_container[panel_name] = new_id; return new_id; } else { return it->second; } } uint64_t Container::FindOrAddLetter(std::string key, bool level2) { std::string letter_name = GetLetterName(key, level2); auto it = letter_id_by_name_.find(letter_name); if (it == letter_id_by_name_.end()) { uint64_t new_id = all_objects_.letters_size(); Letter* letter = all_objects_.add_letters(); letter->set_id(new_id); letter->set_key(key); if (level2) { letter->set_level2(level2); } letter_id_by_name_[letter_name] = new_id; return new_id; } else { return it->second; } } uint64_t Container::FindLetterByName(std::string letter_name) { auto it = letter_id_by_name_.find(letter_name); if (it == letter_id_by_name_.end()) { std::cout << "Could not find letter by name: " << le

#include "godot_processor.h"

#include <filesystem>
#include <iostream>
#include <memory>
#include <set>

#include "structs.h"
#include "util/godot_scene.h"

namespace com::fourisland::lingo2_archipelago {

namespace {

static const std::set<std::string> kImportantNodeTypes = {
    "res://objects/nodes/panel.tscn", "res://objects/nodes/worldport.tscn",
    "res://objects/nodes/keyHolder.tscn",
    "res://objects/nodes/collectable.tscn"};

class GodotProcessor {
 public:
  GodotProcessor(const std::string& repodir, CollectedInfo& info)
      : repodir_(repodir), info_(info) {}

  void Run() {
    for (auto& [map_name, map_info] : info_.maps) {
      ProcessMap(map_name, map_info);
    }
  }

  void ProcessMap(const std::string& map_name, MapInfo& map_info) {
    std::filesystem::path scene_path = std::filesystem::path(repodir_) /
                                       "objects" / "scenes" /
                                       (map_name + ".tscn");
    std::string scene_path_str = scene_path.string();
    std::cout << "Processing " << scene_path_str << std::endl;

    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.instance_type)) {
      const GodotExtResourceRef& ext_resource_ref =
          std::get<GodotExtResourceRef>(node.instance_type);
      const GodotExtResource* ext_resource =
          scene.GetExtResource(ext_resource_ref.id);

      if (ext_resource != nullptr &&
          (kImportantNodeTypes.count(ext_resource->path) ||
           ext_resource->path.starts_with("res://objects/meshes/paintings/"))) {
        map_info.game_nodes[node.GetPath()].defined = true;
      }
    }
  }

 private:
  std::string repodir_;
  CollectedInfo& info_;
};

}  // namespace

void ProcessGodotData(const std::string& repodir, CollectedInfo& info) {
  GodotProcessor godot_processor(repodir, info);
  godot_processor.Run();
}

}  // namespace com::fourisland::lingo2_archipelago