Bounty hunt table codegen

src/Bin/CodeGen/CMakeLists.txt

@@ -8,6 +8,7 @@ set(BIN_CODEGEN_SOURCES
 set(BIN_CODEGEN_HEADERS
         CodeGenOptions.h
         CodeGenEnums.h
+        CodeGenFunctions.h
         CodeGenMap.h)
 
 if(NOT BUILD_PLATFORM STREQUAL "android")

src/Bin/CodeGen/CodeGen.cpp

@@ -2,6 +2,7 @@
 
 #include <set>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 #include <utility>
 
@@ -14,7 +15,10 @@
 #include "Engine/GameResourceManager.h"
 #include "Engine/MapInfo.h"
 
+#include "GUI/UI/Houses/TownHall.h"
+
 #include "Library/Lod/LodReader.h"
+#include "Library/Random/Random.h"
 #include "Library/Serialization/EnumSerialization.h"
 
 #include "Utility/Format.h"
@@ -30,19 +34,6 @@ static auto contains = [](const std::string &haystack, const std::string &needle
     return haystack.find(needle) != std::string::npos;
 };
 
-static std::string toUpperCaseEnum(const std::string &string) {
-    std::string result;
-    for (char c : trim(string)) {
-        if (isalnum(c)) {
-            result += static_cast<char>(toupper(c));
-        } else if (isspace(c) || c == '/' || c == '-') {
-            if (!result.ends_with('_'))
-                result += '_';
-        }
-    }
-    return result;
-}
-
 int runItemIdCodeGen(CodeGenOptions options, GameResourceManager *resourceManager) {
     ItemTable itemTable;
     itemTable.Initialize(resourceManager);
@@ -256,7 +247,19 @@ int runHouseIdCodeGen(CodeGenOptions options, GameResourceManager *resourceManag
     return 0;
 }
 
-std::string cleanupMonsterEnumName(std::string enumName) {
+MonsterStats loadMonsterStats(GameResourceManager *resourceManager) {
+    TriBlob dmonBlobs;
+    dmonBlobs.mm7 = resourceManager->getEventsFile("dmonlist.bin");
+
+    pMonsterList = new MonsterList;
+    deserialize(dmonBlobs, pMonsterList);
+
+    MonsterStats result;
+    result.Initialize(resourceManager->getEventsFile("monsters.txt"));
+    return result;
+}
+
+std::string cleanupMonsterIdEnumName(std::string enumName) {
     for (const char *prefix : {"ZBLASTERGUY", "ZULTRA_DRAGON", })
         if (enumName.starts_with(prefix))
             enumName = enumName.substr(1);
@@ -273,22 +276,15 @@ std::string cleanupMonsterEnumName(std::string enumName) {
 }
 
 int runMonsterIdCodeGen(CodeGenOptions options, GameResourceManager *resourceManager) {
-    TriBlob dmonBlobs;
-    dmonBlobs.mm7 = resourceManager->getEventsFile("dmonlist.bin");
-
-    pMonsterList = new MonsterList;
-    deserialize(dmonBlobs, pMonsterList);
-
-    MonsterStats monsterStats;
-    monsterStats.Initialize(resourceManager->getEventsFile("monsters.txt"));
+    MonsterStats monsterStats = loadMonsterStats(resourceManager);
 
     CodeGenMap map;
     map.insert(MONSTER_INVALID, "INVALID", "");
 
     for (const MonsterId i : allMonsters()) {
         const MonsterDesc &desc = pMonsterList->pMonsters[i];
         const MonsterInfo &info = monsterStats.pInfos[i];
-        std::string enumName = cleanupMonsterEnumName(toUpperCaseEnum(desc.pMonsterName));
+        std::string enumName = cleanupMonsterIdEnumName(toUpperCaseEnum(desc.pMonsterName));
 
         std::string comment = info.pName;
         if (comment == "peasant")
@@ -303,12 +299,20 @@ int runMonsterIdCodeGen(CodeGenOptions options, GameResourceManager *resourceMan
     return 0;
 }
 
-int runMonsterTypeCodeGen(CodeGenOptions options, GameResourceManager *resourceManager) {
-    TriBlob dmonBlobs;
-    dmonBlobs.mm7 = resourceManager->getEventsFile("dmonlist.bin");
+std::string cleanupMonsterTypeEnumName(std::string enumName) {
+    enumName = cleanupMonsterIdEnumName(enumName);
 
-    pMonsterList = new MonsterList;
-    deserialize(dmonBlobs, pMonsterList);
+    if (enumName.ends_with("_A")) {
+        enumName.resize(enumName.size() - 2);
+    } else if (!enumName.empty()) {
+        throw Exception("Invalid monster id name");
+    }
+
+    return enumName;
+}
+
+int runMonsterTypeCodeGen(CodeGenOptions options, GameResourceManager *resourceManager) {
+    MonsterStats monsterStats = loadMonsterStats(resourceManager);
 
     CodeGenMap map;
     map.insert(MONSTER_TYPE_INVALID, "INVALID", "");
@@ -319,13 +323,7 @@ int runMonsterTypeCodeGen(CodeGenOptions options, GameResourceManager *resourceM
             continue;
 
         const MonsterDesc &desc = pMonsterList->pMonsters[i];
-        std::string enumName = cleanupMonsterEnumName(toUpperCaseEnum(desc.pMonsterName));
-
-        if (enumName.ends_with("_A")) {
-            enumName.resize(enumName.size() - 2);
-        } else if (!enumName.empty()) {
-            throw Exception("Invalid monster id name");
-        }
+        std::string enumName = cleanupMonsterTypeEnumName(toUpperCaseEnum(desc.pMonsterName));
 
         map.insert(monsterTypeForMonsterId(i), enumName, "");
     }
@@ -334,6 +332,57 @@ int runMonsterTypeCodeGen(CodeGenOptions options, GameResourceManager *resourceM
     return 0;
 }
 
+int runBountyHuntCodegen(CodeGenOptions options, GameResourceManager *resourceManager) {
+    // Fill bounty hunt map.
+    grng = RandomEngine::create(RANDOM_ENGINE_SEQUENTIAL);
+    IndexedArray<std::unordered_set<MonsterId>, HOUSE_FIRST_TOWN_HALL, HOUSE_LAST_TOWN_HALL> monstersByTownHall;
+    for (const HouseId townHall : allTownhallHouses()) {
+        grng->seed(0);
+        while(true) {
+            MonsterId monsterId = GUIWindow_TownHall::randomMonsterForHunting(townHall);
+            if (!monstersByTownHall[townHall].insert(monsterId).second)
+                break;
+        }
+    }
+
+    // Invert the map.
+    std::unordered_map<MonsterId, std::unordered_set<HouseId>> townHallsByMonster;
+    for (const HouseId townHall : allTownhallHouses())
+        for (const MonsterId monsterId : monstersByTownHall[townHall])
+            townHallsByMonster[monsterId].insert(townHall);
+
+    // Reduce the map to monster types & check that it's actually reducible.
+    std::unordered_map<MonsterType, std::unordered_set<HouseId>> townHallsByMonsterType;
+    for (const MonsterId monsterId : allMonsters()) {
+        MonsterType monsterType = monsterTypeForMonsterId(monsterId);
+        if (townHallsByMonsterType.contains(monsterType) && townHallsByMonsterType[monsterType] != townHallsByMonster[monsterId])
+            throw Exception("Invalid bounty hunt record");
+
+        townHallsByMonsterType[monsterType] = townHallsByMonster[monsterId];
+    }
+
+    // Prepare output table.
+    std::vector<std::array<std::string, 8>> table;
+    for (const MonsterType monsterType : allMonsterTypes()) {
+        auto &line = table.emplace_back();
+        line[0] = fmt::format("{{{}, ", toString(monsterType));
+        line[1] = "{";
+        for (const HouseId townHall : townHallsByMonsterType[monsterType])
+            line[2 + std::to_underlying(townHall) - std::to_underlying(HOUSE_FIRST_TOWN_HALL)] = toString(townHall) + ", ";
+        for (size_t i = 6; i >= 2; i--) {
+            if (!line[i].empty()) {
+                line[i].resize(line[i].size() - 2); // Drop the last ", ".
+                break;
+            }
+        }
+        line[7] = "}},";
+    }
+
+    // Dump!
+    dumpAligned(stdout, "    ", table);
+    return 0;
+}
+
 int platformMain(int argc, char **argv) {
     try {
         CodeGenOptions options = CodeGenOptions::parse(argc, argv);
@@ -352,6 +401,7 @@ int platformMain(int argc, char **argv) {
         case CodeGenOptions::SUBCOMMAND_HOUSE_ID: return runHouseIdCodeGen(std::move(options), &resourceManager);
         case CodeGenOptions::SUBCOMMAND_MONSTER_ID: return runMonsterIdCodeGen(std::move(options), &resourceManager);
         case CodeGenOptions::SUBCOMMAND_MONSTER_TYPE: return runMonsterTypeCodeGen(std::move(options), &resourceManager);
+        case CodeGenOptions::SUBCOMMAND_BOUNTY_HUNT: return runBountyHuntCodegen(std::move(options), &resourceManager);
         default:
             assert(false);
             return 1;

src/Bin/CodeGen/CodeGenEnums.cpp

@@ -39,3 +39,6 @@ MM_DEFINE_ENUM_SERIALIZATION_FUNCTIONS(BuildingType, CASE_INSENSITIVE, {
     {BUILDING_SHADOW_GUILD,         "SHADOW_GUILD"},
     {BUILDING_ADVENTURERS_INN,      "ADVENTURERS_INN"},
 })
+
+MM_DEFINE_ENUM_MAGIC_SERIALIZATION_FUNCTIONS(HouseId)
+MM_DEFINE_ENUM_MAGIC_SERIALIZATION_FUNCTIONS(MonsterType)

src/Bin/CodeGen/CodeGenEnums.h

@@ -1,7 +1,10 @@
 #pragma once
 
 #include "Engine/Tables/BuildingTable.h"
+#include "Engine/Objects/MonsterEnums.h"
 
 #include "Library/Serialization/SerializationFwd.h"
 
 MM_DECLARE_SERIALIZATION_FUNCTIONS(BuildingType)
+MM_DECLARE_SERIALIZATION_FUNCTIONS(HouseId)
+MM_DECLARE_SERIALIZATION_FUNCTIONS(MonsterType)

src/Bin/CodeGen/CodeGenFunctions.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <cstdio>
+#include <cctype>
+#include <vector>
+#include <array>
+#include <string_view>
+#include <string>
+#include <algorithm>
+
+#include "Utility/Format.h"
+
+inline std::string toUpperCaseEnum(const std::string &string) {
+    std::string result;
+    for (char c : trim(string)) {
+        if (std::isalnum(c)) {
+            result += static_cast<char>(toupper(c));
+        } else if (std::isspace(c) || c == '/' || c == '-') {
+            if (!result.ends_with('_'))
+                result += '_';
+        }
+    }
+    return result;
+}
+
+template<size_t N>
+void dumpAligned(FILE *file, std::string_view prefix, const std::vector<std::array<std::string, N>> &table) {
+    std::array<size_t, N> maxLengths;
+    maxLengths.fill(0);
+
+    for (const auto &line : table)
+        for (size_t i = 0; i < line.size(); i++)
+            maxLengths[i] = std::max(maxLengths[i], line[i].size());
+
+    for (const auto &line : table) {
+        std::string output = std::string(prefix);
+        for (size_t i = 0; i < line.size(); i++) {
+            output += line[i];
+            output += std::string(maxLengths[i] - line[i].size(), ' ');
+        }
+        while (output.ends_with(' ')) // Note that we don't trim front.
+            output.pop_back();
+        fmt::println(file, "{}", output);
+    }
+}

src/Bin/CodeGen/CodeGenMap.h

@@ -11,6 +11,8 @@
 #include "Utility/Workaround/ToUnderlying.h"
 #include "Utility/Format.h"
 
+#include "CodeGenFunctions.h"
+
 class CodeGenMap {
  public:
     template<class Enum>
@@ -40,25 +42,16 @@ class CodeGenMap {
     }
 
     void dump(FILE *file, const std::string &prefix) {
-        std::vector<std::pair<std::string, std::string>> linesAndComments;
+        std::vector<std::array<std::string, 2>> linesAndComments;
         for (const auto &[value, name] : _nameByValue) {
             std::string comment = _commentByValue[value];
             if (!comment.empty())
-                comment = " // " + comment;
+                comment = "// " + comment;
 
-            linesAndComments.emplace_back(fmt::format("{}{} = {}", prefix, name, value), comment);
+            linesAndComments.push_back({fmt::format("{}{} = {}, ", prefix, name, value), comment});
         }
 
-        size_t maxLineLen = 0;
-        for (const auto &[line, _] : linesAndComments)
-            maxLineLen = std::max(maxLineLen, line.size());
-
-        for (const auto &[line, comment] : linesAndComments) {
-            std::string padding;
-            if (!comment.empty())
-                padding = std::string(maxLineLen - line.size(), ' ');
-            fmt::println(file, "    {},{}{}", line, padding, comment);
-        }
+        dumpAligned(file, "    ", linesAndComments);
     }
 
  private:

src/Bin/CodeGen/CodeGenOptions.cpp

@@ -36,16 +36,21 @@ CodeGenOptions CodeGenOptions::parse(int argc, char **argv) {
     CLI::App *monsterTypes = app->add_subcommand("monster_types", "Generate monster types enum")->fallthrough();
     monsterTypes->callback([&] { result.subcommand = SUBCOMMAND_MONSTER_TYPE; });
 
+    CLI::App *bountyHunt = app->add_subcommand("bounty_hunt", "Generate monster type / town hall table for bounty hunts")->fallthrough();
+    bountyHunt->callback([&] { result.subcommand = SUBCOMMAND_BOUNTY_HUNT; });
+
     try {
         app->parse(argc, argv);
     } catch (const CLI::ParseError &e) {
+        // TODO(captainurist): this is getting out of hand.
         bool isHelp =
             app->get_help_ptr()->as<bool>() ||
             items->get_help_ptr()->as<bool>() ||
             maps->get_help_ptr()->as<bool>() ||
             beacons->get_help_ptr()->as<bool>() ||
             monsters->get_help_ptr()->as<bool>() ||
-            monsterTypes->get_help_ptr()->as<bool>();
+            monsterTypes->get_help_ptr()->as<bool>() ||
+            bountyHunt->get_help_ptr()->as<bool>();
         if (isHelp) {
             app->exit(e);
             result.helpPrinted = true;

src/Bin/CodeGen/CodeGenOptions.h

@@ -11,6 +11,7 @@ struct CodeGenOptions : GameStarterOptions {
         SUBCOMMAND_HOUSE_ID,
         SUBCOMMAND_MONSTER_ID,
         SUBCOMMAND_MONSTER_TYPE,
+        SUBCOMMAND_BOUNTY_HUNT,
     };
     using enum Subcommand;