Added "endings" object type

8 files changed, 105 insertions, 1 deletions

@@ -87,6 +87,12 @@ class AssignIds {
       }
     }
 
+    for (const auto& [_, id] : id_mappings_.endings()) {
+      if (id > next_id_) {
+        next_id_ = id;
+      }
+    }
+
     next_id_++;
   }
 
@@ -195,6 +201,13 @@ class AssignIds {
         masteries[h_mastery.name()] = next_id_++;
       }
     }
+
+    for (const HumanEnding& h_ending : h_room.endings()) {
+      if (!id_mappings_.endings().contains(h_ending.name())) {
+        auto& endings = *id_mappings_.mutable_endings();
+        endings[h_ending.name()] = next_id_++;
+      }
+    }
   }
 
  private:
@@ -205,6 +205,22 @@ uint64_t Container::FindLetterByName(std::string letter_name) {
   }
 }
 
+uint64_t Container::FindOrAddEnding(std::string ending_name) {
+  auto it = ending_id_by_name_.find(ending_name);
+  if (it == ending_id_by_name_.end()) {
+    uint64_t new_id = all_objects_.endings_size();
+    Ending* ending = all_objects_.add_endings();
+    ending->set_id(new_id);
+    ending->set_name(ending_name);
+
+    ending_id_by_name_[ending_name] = new_id;
+
+    return new_id;
+  } else {
+    return it->second;
+  }
+}
+
 uint64_t Container::FindOrAddMastery(std::optional<std::string> map_name,
                                      std::optional<std::string> room_name,
                                      std::string mastery_name,
@@ -40,6 +40,8 @@ class Container {
 
   uint64_t FindLetterByName(std::string letter_name);
 
+  uint64_t FindOrAddEnding(std::string ending_name);
+
   uint64_t FindOrAddMastery(std::optional<std::string> map_name,
                             std::optional<std::string> room_name,
                             std::string mastery_name,
@@ -79,6 +81,7 @@ class Container {
       keyholder_id_by_map_room_keyholder_names_;
   std::map<std::string, std::map<std::string, uint64_t>>
       door_id_by_map_door_names_;
+  std::map<std::string, uint64_t> ending_id_by_name_;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -115,6 +115,10 @@ class DataPacker {
       room.add_keyholders(
           ProcessKeyholder(h_keyholder, current_map_name, room.name()));
     }
+
+    for (const HumanEnding& h_ending : h_room.endings()) {
+      room.add_endings(ProcessEnding(h_ending, current_map_name, room.name()));
+    }
   }
 
   uint64_t ProcessPanel(const HumanPanel& h_panel,
@@ -266,6 +270,19 @@ class DataPacker {
     return keyholder_id;
   }
 
+  uint64_t ProcessEnding(const HumanEnding& h_ending,
+                         const std::string& current_map_name,
+                         const std::string& current_room_name) {
+    uint64_t ending_id = container_.FindOrAddEnding(h_ending.name());
+    Ending& ending = *container_.all_objects().mutable_endings(ending_id);
+
+    ending.set_room_id(container_.FindOrAddRoom(
+        current_map_name, current_room_name, std::nullopt));
+    ending.set_path(h_ending.path());
+
+    return ending_id;
+  }
+
   void ProcessDoorsFile(std::filesystem::path path,
                         const std::string& current_map_name) {
     if (!std::filesystem::exists(path)) {
@@ -526,6 +543,11 @@ class DataPacker {
       uint64_t letter_id = container_.FindLetterByName(letter_name);
       container_.all_objects().mutable_letters(letter_id)->set_ap_id(ap_id);
     }
+
+    for (const auto& [ending_name, ap_id] : ids.endings()) {
+      uint64_t ending_id = container_.FindOrAddEnding(ending_name);
+      container_.all_objects().mutable_endings(ending_id)->set_ap_id(ap_id);
+    }
   }
 
   std::string mapdir_;
@@ -75,6 +75,13 @@ IdMappings ReadIdsFromYaml(const std::string& filename) {
     }
   }
 
+  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>()] =
@@ -127,6 +134,11 @@ void WriteIdsAsYaml(const IdMappings& ids, const std::string& filename) {
     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;
@@ -62,7 +62,7 @@ class HumanProcessor {
   }
 
   void ProcessMetadataFile(std::filesystem::path path,
-    const std::string& current_map_name) {
+                           const std::string& current_map_name) {
     if (!std::filesystem::exists(path)) {
       return;
     }
@@ -115,6 +115,10 @@ class HumanProcessor {
     for (const HumanKeyholder& h_keyholder : h_room.keyholders()) {
       ProcessKeyholder(h_keyholder, current_map_name, h_room.name());
     }
+
+    for (const HumanEnding& h_ending : h_room.endings()) {
+      ProcessEnding(h_ending, current_map_name, h_room.name());
+    }
   }
 
   void ProcessPanel(const HumanPanel& h_panel,
@@ -235,6 +239,20 @@ class HumanProcessor {
     map_info.game_nodes[h_keyholder.path()].uses++;
   }
 
+  void ProcessEnding(const HumanEnding& h_ending,
+                     const std::string& current_map_name,
+                     const std::string& current_room_name) {
+    EndingInfo& ending_info = info_.endings[h_ending.name()];
+
+    RoomIdentifier room_identifier;
+    room_identifier.set_map(current_map_name);
+    room_identifier.set_name(current_room_name);
+    ending_info.defined_in.push_back(room_identifier);
+
+    MapInfo& map_info = info_.maps[current_map_name];
+    map_info.game_nodes[h_ending.path()].uses++;
+  }
+
   void ProcessDoorsFile(std::filesystem::path path,
                         const std::string& current_map_name) {
     if (!std::filesystem::exists(path)) {
@@ -90,6 +90,10 @@ struct LetterInfo {
   std::vector<RoomIdentifier> defined_in;
 };
 
+struct EndingInfo {
+  std::vector<RoomIdentifier> defined_in;
+};
+
 struct CollectedInfo {
   std::map<std::string, MapInfo> maps;
   std::map<RoomIdentifier, RoomInfo, RoomIdentifierLess> rooms;
@@ -100,6 +104,7 @@ struct CollectedInfo {
   std::map<KeyholderIdentifier, KeyholderInfo, KeyholderIdentifierLess>
       keyholders;
   std::map<LetterIdentifier, LetterInfo> letters;
+  std::map<std::string, EndingInfo> endings;
 };
 
 }  // namespace com::fourisland::lingo2_archipelago
@@ -238,6 +238,18 @@ void ValidateLetter(const LetterIdentifier& letter_identifier,
   }
 }
 
+void ValidateEnding(const std::string& ending_name,
+                    const EndingInfo& ending_info) {
+  if (ending_info.defined_in.size() > 1) {
+    std::cout << "Ending " << ending_name
+              << " was defined in multiple places:" << std::endl;
+
+    for (const RoomIdentifier& room_identifier : ending_info.defined_in) {
+      std::cout << "    " << room_identifier.ShortDebugString() << std::endl;
+    }
+  }
+}
+
 }  // namespace
 
 void ValidateCollectedInfo(const CollectedInfo& info) {
@@ -265,6 +277,9 @@ void ValidateCollectedInfo(const CollectedInfo& info) {
   for (const auto& [letter_identifier, letter_info] : info.letters) {
     ValidateLetter(letter_identifier, letter_info);
   }
+  for (const auto& [ending_name, ending_info] : info.endings) {
+    ValidateEnding(ending_name, ending_info);
+  }
 }
 
 }  // namespace com::fourisland::lingo2_archipelago