Added support for masteries

Also assigned IDs for the_butterfly, as well as already configured
letters.

9 files changed, 196 insertions, 7 deletions

@@ -5,5 +5,5 @@ add_executable(assign_ids
 )
 set_property(TARGET assign_ids PROPERTY CXX_STANDARD 20)
 set_property(TARGET assign_ids PROPERTY CXX_STANDARD_REQUIRED ON)
-target_include_directories(assign_ids PUBLIC ${CMAKE_BINARY_DIR})
-target_link_libraries(assign_ids PUBLIC protos protobuf::libprotobuf)
+target_include_directories(assign_ids PUBLIC ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/tools)
+target_link_libraries(assign_ids PUBLIC protos protobuf::libprotobuf util)
@@ -9,6 +9,7 @@
 #include <string>
 
 #include "proto/human.pb.h"
+#include "util/naming.h"
 
 namespace com::fourisland::lingo2_archipelago {
 namespace {
@@ -155,6 +156,35 @@ class AssignIds {
         panels[h_panel.name()] = next_id_++;
       }
     }
+
+    for (const HumanLetter& h_letter : h_room.letters()) {
+      std::string lettername =
+          GetLetterName(h_letter.key(), h_letter.double_());
+
+      if (!id_mappings_.letters().contains(lettername)) {
+        auto& letters = *id_mappings_.mutable_letters();
+        letters[lettername] = next_id_++;
+      }
+    }
+
+    for (const HumanMastery& h_mastery : h_room.masteries()) {
+      if (!id_mappings_.maps().contains(current_map_name) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .contains(h_room.name()) ||
+          !id_mappings_.maps()
+               .at(current_map_name)
+               .rooms()
+               .at(h_room.name())
+               .masteries()
+               .contains(h_mastery.name())) {
+        auto& maps = *id_mappings_.mutable_maps();
+        auto& rooms = *maps[current_map_name].mutable_rooms();
+        auto& masteries = *rooms[h_room.name()].mutable_masteries();
+        masteries[h_mastery.name()] = next_id_++;
+      }
+    }
   }
 
  private:
@@ -6,5 +6,5 @@ add_executable(datapacker
 )
 set_property(TARGET datapacker PROPERTY CXX_STANDARD 20)
 set_property(TARGET datapacker PROPERTY CXX_STANDARD_REQUIRED ON)
-target_include_directories(datapacker PUBLIC ${CMAKE_BINARY_DIR})
-target_link_libraries(datapacker PUBLIC protos protobuf::libprotobuf)
+target_include_directories(datapacker PUBLIC ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/tools)
+target_link_libraries(datapacker PUBLIC protos util protobuf::libprotobuf)
@@ -1,5 +1,9 @@
 #include "container.h"
 
+#include <iostream>
+
+#include "util/naming.h"
+
 namespace com::fourisland::lingo2_archipelago {
 
 uint64_t Container::FindOrAddMap(std::string map_name) {
@@ -169,6 +173,79 @@ uint64_t Container::FindOrAddPanel(std::optional<std::string> map_name,
   }
 }
 
+uint64_t Container::FindOrAddLetter(std::string key, bool double_) {
+  std::string letter_name = GetLetterName(key, double_);
+
+  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 (double_) {
+      letter->set_double_(double_);
+    }
+
+    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: " << letter_name << std::endl;
+    exit(2);
+  } else {
+    return it->second;
+  }
+}
+
+uint64_t Container::FindOrAddMastery(std::optional<std::string> map_name,
+                                     std::optional<std::string> room_name,
+                                     std::string mastery_name,
+                                     std::optional<std::string> map_fallback,
+                                     std::optional<std::string> room_fallback) {
+  if (!map_name) {
+    if (!map_fallback) {
+      std::cout << "No map name provided for " << mastery_name << std::endl;
+      map_name = "global";
+    } else {
+      map_name = map_fallback;
+    }
+  }
+
+  if (!room_name) {
+    if (!room_fallback) {
+      std::cout << "No room name provided for " << mastery_name << std::endl;
+      room_name = "global";
+    } else {
+      room_name = room_fallback;
+    }
+  }
+
+  auto& room_container =
+      mastery_id_by_map_room_mastery_names_[*map_name][*room_name];
+  auto it = room_container.find(mastery_name);
+  if (it == room_container.end()) {
+    uint64_t new_id = all_objects_.masteries_size();
+    Mastery* mastery = all_objects_.add_masteries();
+    mastery->set_id(new_id);
+    mastery->set_room_id(FindOrAddRoom(map_name, *room_name, std::nullopt));
+    mastery->set_name(mastery_name);
+
+    room_container[mastery_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 uint64_t Container::FindOrAddDoor(std::optional<std::string> map_name,
                                   std::string door_name,
                                   std::optional<std::string> map_fallback) {
@@ -36,6 +36,16 @@ class Container {
                           std::optional<std::string> map_fallback,
                           std::optional<std::string> room_fallback);
 
+  uint64_t FindOrAddLetter(std::string key, bool double_);
+
+  uint64_t FindLetterByName(std::string letter_name);
+
+  uint64_t FindOrAddMastery(std::optional<std::string> map_name,
+                            std::optional<std::string> room_name,
+                            std::string mastery_name,
+                            std::optional<std::string> map_fallback,
+                            std::optional<std::string> room_fallback);
+
   uint64_t FindOrAddDoor(std::optional<std::string> map_name,
                          std::string door_name,
                          std::optional<std::string> map_fallback);
@@ -56,6 +66,9 @@ class Container {
       port_id_by_map_room_port_names_;
   std::map<std::string, std::map<std::string, std::map<std::string, uint64_t>>>
       panel_id_by_map_room_panel_names_;
+  std::map<std::string, uint64_t> letter_id_by_name_;
+  std::map<std::string, std::map<std::string, std::map<std::string, uint64_t>>>
+      mastery_id_by_map_room_mastery_names_;
   std::map<std::string, std::map<std::string, uint64_t>>
       door_id_by_map_door_names_;
 };
@@ -101,9 +101,14 @@ class DataPacker {
       room.add_ports(ProcessPort(h_port, current_map_name, room.name()));
     }
 
-    std::copy(
-        h_room.letters().begin(), h_room.letters().end(),
-        google::protobuf::RepeatedFieldBackInserter(room.mutable_letters()));
+    for (const HumanLetter& h_letter : h_room.letters()) {
+      room.add_letters(ProcessLetter(h_letter, current_map_name, room.name()));
+    }
+
+    for (const HumanMastery& h_mastery : h_room.masteries()) {
+      room.add_masteries(
+          ProcessMastery(h_mastery, current_map_name, room.name()));
+    }
   }
 
   uint64_t ProcessPanel(const HumanPanel& h_panel,
@@ -197,6 +202,33 @@ class DataPacker {
     return port_id;
   }
 
+  uint64_t ProcessLetter(const HumanLetter& h_letter,
+                         const std::string& current_map_name,
+                         const std::string& current_room_name) {
+    uint64_t letter_id =
+        container_.FindOrAddLetter(h_letter.key(), h_letter.double_());
+    Letter& letter = *container_.all_objects().mutable_letters(letter_id);
+
+    letter.set_room_id(container_.FindOrAddRoom(
+        current_map_name, current_room_name, std::nullopt));
+    letter.set_path(h_letter.path());
+
+    return letter_id;
+  }
+
+  uint64_t ProcessMastery(const HumanMastery& h_mastery,
+                          const std::string& current_map_name,
+                          const std::string& current_room_name) {
+    uint64_t mastery_id = container_.FindOrAddMastery(
+        current_map_name, current_room_name, h_mastery.name(), std::nullopt,
+        std::nullopt);
+    Mastery& mastery = *container_.all_objects().mutable_masteries(mastery_id);
+
+    mastery.set_path(h_mastery.path());
+
+    return mastery_id;
+  }
+
   void ProcessDoorsFile(std::filesystem::path path,
                         const std::string& current_map_name) {
     if (!std::filesystem::exists(path)) {
@@ -410,6 +442,14 @@ class DataPacker {
               map_name, room_name, panel_name, std::nullopt, std::nullopt);
           container_.all_objects().mutable_panels(panel_id)->set_ap_id(ap_id);
         }
+
+        for (const auto& [mastery_name, ap_id] : room.masteries()) {
+          uint64_t mastery_id = container_.FindOrAddMastery(
+              map_name, room_name, mastery_name, std::nullopt, std::nullopt);
+          container_.all_objects()
+              .mutable_masteries(mastery_id)
+              ->set_ap_id(ap_id);
+        }
       }
     }
 
@@ -417,6 +457,11 @@ class DataPacker {
     for (const auto& [tag, id] : ids.special()) {
       specials[tag] = id;
     }
+
+    for (const auto& [letter_name, ap_id] : ids.letters()) {
+      uint64_t letter_id = container_.FindLetterByName(letter_name);
+      container_.all_objects().mutable_letters(letter_id)->set_ap_id(ap_id);
+    }
   }
 
   std::string mapdir_;
@@ -0,0 +1,5 @@
+add_library(util
+  naming.cpp
+)
+set_property(TARGET util PROPERTY CXX_STANDARD 20)
+set_property(TARGET util PROPERTY CXX_STANDARD_REQUIRED ON)
@@ -0,0 +1,11 @@
+#include "naming.h"
+
+#include <sstream>
+
+std::string GetLetterName(std::string key, bool double_) {
+  std::ostringstream lettername_s;
+  lettername_s << key;
+  lettername_s << (double_ ? "2" : "1");
+
+  return lettername_s.str();
+}
@@ -0,0 +1,8 @@
+#ifndef TOOLS_UTIL_NAMING_H_
+#define TOOLS_UTIL_NAMING_H_
+
+#include <string>
+
+std::string GetLetterName(std::string key, bool double_);
+
+#endif /* TOOLS_UTIL_NAMING_H_ */