Added support for masteries

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

16 files changed, 362 insertions, 107 deletions

@@ -3,5 +3,6 @@ cmake_minimum_required(VERSION 3.28)
 project(lingo2_archipelago)
 
 add_subdirectory(proto)
+add_subdirectory(tools/util)
 add_subdirectory(tools/assign_ids)
 add_subdirectory(tools/datapacker)
@@ -18,3 +18,9 @@ class Lingo2PlayerLogic:
         for door in world.static_logic.objects.doors:
             if door.type in [common_pb2.DoorType.STANDARD, common_pb2.DoorType.LOCATION_ONLY]:
                 self.locations_by_room.setdefault(door.room_id, []).append(PlayerLocation(door.ap_id))
+
+        for letter in world.static_logic.objects.letters:
+            self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id))
+
+        for mastery in world.static_logic.objects.masteries:
+            self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id))
@@ -26,5 +26,17 @@ class Lingo2StaticLogic:
                 item_name = f"{self.objects.maps[door.map_id].name} - {door.name}"
                 self.item_id_to_name[door.ap_id] = item_name
 
+        for letter in self.objects.letters:
+            letter_name = f"{letter.key.upper()}{'' if letter.double else '2'}"
+            location_name = f"{self.objects.maps[self.objects.rooms[letter.room_id].map_id].name} - {letter_name}"
+            self.location_id_to_name[letter.ap_id] = location_name
+
+            if not letter.double:
+                self.item_id_to_name[letter.ap_id] = letter_name
+
+        for mastery in self.objects.masteries:
+            location_name = f"{self.objects.maps[self.objects.rooms[mastery.room_id].map_id].name} - Mastery"
+            self.location_id_to_name[mastery.ap_id] = location_name
+
         self.item_name_to_id = {name: ap_id for ap_id, name in self.item_id_to_name.items()}
         self.location_name_to_id = {name: ap_id for ap_id, name in self.location_id_to_name.items()}
@@ -641,6 +641,97 @@ maps {
   }
 }
 maps {
+  key: "the_butterfly"
+  value {
+    rooms {
+      key: "Main Area"
+      value {
+        panels {
+          key: "ARTICLE"
+          value: 262
+        }
+        panels {
+          key: "BOOK"
+          value: 263
+        }
+        panels {
+          key: "BUILDING"
+          value: 256
+        }
+        panels {
+          key: "CATERPILLAR"
+          value: 258
+        }
+        panels {
+          key: "CONSTITUTION"
+          value: 252
+        }
+        panels {
+          key: "CREATURE"
+          value: 261
+        }
+        panels {
+          key: "GAME"
+          value: 253
+        }
+        panels {
+          key: "GENE"
+          value: 260
+        }
+        panels {
+          key: "KNOWLEDGE"
+          value: 259
+        }
+        panels {
+          key: "PERSONALITY"
+          value: 251
+        }
+        panels {
+          key: "POSITION (1)"
+          value: 265
+        }
+        panels {
+          key: "POSITION (2)"
+          value: 266
+        }
+        panels {
+          key: "POSITION (3)"
+          value: 267
+        }
+        panels {
+          key: "SCHOOL"
+          value: 255
+        }
+        panels {
+          key: "SCIENCE"
+          value: 254
+        }
+        panels {
+          key: "SPECIES"
+          value: 250
+        }
+        panels {
+          key: "STRUCTURE"
+          value: 257
+        }
+        panels {
+          key: "TEXT"
+          value: 264
+        }
+      }
+    }
+    rooms {
+      key: "Mastery"
+      value {
+        masteries {
+          key: "MASTERY"
+          value: 268
+        }
+      }
+    }
+  }
+}
+maps {
   key: "the_entry"
   value {
     doors {
@@ -1171,107 +1262,43 @@ maps {
     }
   }
 }
-special {
-  key: "A"
-  value: 105
-}
-special {
-  key: "B"
-  value: 106
-}
-special {
-  key: "C"
-  value: 107
-}
-special {
-  key: "D"
-  value: 108
-}
-special {
-  key: "E"
-  value: 109
-}
-special {
-  key: "F"
-  value: 110
-}
-special {
-  key: "G"
-  value: 111
-}
-special {
-  key: "H"
-  value: 112
-}
-special {
-  key: "I"
-  value: 113
-}
-special {
-  key: "J"
-  value: 114
-}
-special {
-  key: "K"
-  value: 115
-}
-special {
-  key: "L"
-  value: 116
-}
-special {
-  key: "M"
-  value: 117
-}
-special {
-  key: "N"
-  value: 118
-}
-special {
-  key: "O"
-  value: 119
-}
-special {
-  key: "P"
-  value: 120
-}
-special {
-  key: "Q"
-  value: 121
+letters {
+  key: "a2"
+  value: 277
 }
-special {
-  key: "R"
-  value: 122
+letters {
+  key: "b2"
+  value: 269
 }
-special {
-  key: "S"
-  value: 123
+letters {
+  key: "d1"
+  value: 271
 }
-special {
-  key: "T"
-  value: 124
+letters {
+  key: "h1"
+  value: 273
 }
-special {
-  key: "U"
-  value: 125
+letters {
+  key: "i1"
+  value: 274
 }
-special {
-  key: "V"
-  value: 126
+letters {
+  key: "l1"
+  value: 270
 }
-special {
-  key: "W"
-  value: 127
+letters {
+  key: "n1"
+  value: 275
 }
-special {
-  key: "X"
-  value: 128
+letters {
+  key: "q2"
+  value: 249
 }
-special {
-  key: "Y"
-  value: 129
+letters {
+  key: "t1"
+  value: 276
 }
-special {
-  key: "Z"
-  value: 130
+letters {
+  key: "x1"
+  value: 272
 }
@@ -7,11 +7,6 @@ message Proxy {
   string path = 2;
 }
 
-message Letter {
-  string key = 1;
-  bool double = 2;
-}
-
 enum DoorType {
   DOOR_TYPE_UNKNOWN = 0;
 
@@ -83,6 +83,26 @@ message Port {
   uint64 required_door = 6;
 }
 
+message Letter {
+  uint64 id = 3;
+  uint64 ap_id = 5;
+  uint64 room_id = 4;
+
+  string key = 1;
+  bool double = 2;
+
+  string path = 6;
+}
+
+message Mastery {
+  uint64 id = 1;
+  uint64 ap_id = 2;
+  uint64 room_id = 3;
+
+  string name = 4;
+  string path = 5;
+}
+
 message Room {
   uint64 id = 1;
   uint64 map_id = 8;
@@ -91,9 +111,10 @@ message Room {
 
   repeated uint64 panels = 4;
   repeated uint64 paintings = 5;
-  repeated Letter letters = 6;
+  repeated uint64 letters = 6;
   repeated uint64 ports = 7;
   repeated uint64 doors = 9;
+  repeated uint64 masteries = 10;
 }
 
 message Map {
@@ -108,6 +129,8 @@ message AllObjects {
   repeated Panel panels = 3;
   repeated Painting paintings = 4;
   repeated Port ports = 5;
+  repeated Letter letters = 9;
+  repeated Mastery masteries = 10;
   repeated Connection connections = 6;
   map<string, uint64> special_ids = 8;
 }
@@ -153,6 +153,7 @@ message HumanRoom {
 message IdMappings {
   message RoomIds {
     map<string, uint64> panels = 1;
+    map<string, uint64> masteries = 2;
   }
 
   message MapIds {
@@ -162,4 +163,5 @@ message IdMappings {
 
   map<string, MapIds> maps = 1;
   map<string, uint64> special = 2;
+  map<string, uint64> letters = 3;
 }
@@ -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_ */