implement unlock dependencies

src/lib/config/ConfigLoader.cpp

@@ -4,6 +4,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -383,6 +384,11 @@ RecipesConfig ConfigLoader::loadRecipes(const std::string& path)
             {
                 def.unlockAtStationLevel = static_cast<int>(*level);
             }
+            if (mt.contains("unlock_requires"))
+            {
+                def.unlockRequires = requireStringArray(mt["unlock_requires"], file,
+                    elemPath + ".unlock_requires");
+            }
         }
 
         // inputs may be omitted (e.g. miner recipes). An empty array is fine.
@@ -422,6 +428,10 @@ ShipsConfig ConfigLoader::loadShips(const std::string& path)
         ShipDef def;
         def.id                 = requireString(mt["id"],                 file, elemPath + ".id");
         def.unlockAtStationLevel = static_cast<int>(requireInt(mt["unlock_at_station_level"], file, elemPath + ".unlock_at_station_level"));
+        if (mt.contains("unlock_requires"))
+        {
+            def.unlockRequires = requireStringArray(mt["unlock_requires"], file, elemPath + ".unlock_requires");
+        }
         def.layout             = requireStringArray(mt["layout"],       file, elemPath + ".layout");
 
         // Schematic
@@ -573,6 +583,10 @@ ModulesConfig ConfigLoader::loadModules(const std::string& path)
         def.id                      = requireString(mt["id"], file, elemPath + ".id");
         def.unlockAtStationLevel    = static_cast<int>(
             mt["unlock_at_station_level"].value_or<int64_t>(-1));
+        if (mt.contains("unlock_requires"))
+        {
+            def.unlockRequires = requireStringArray(mt["unlock_requires"], file, elemPath + ".unlock_requires");
+        }
         def.surfaceMask             = requireStringArray(mt["surface_mask"], file, elemPath + ".surface_mask");
         def.productionTimeSeconds = requireDouble(
             mt["production_time_seconds"], file, elemPath + ".production_time_seconds");
@@ -685,6 +699,67 @@ ModulesConfig ConfigLoader::loadModules(const std::string& path)
     return cfg;
 }
 
+namespace
+{
+
+// Throws if any id in requiredIds is not a valid explicitly-unlockable schematic.
+void checkUnlockRequires(const std::vector<std::string>& requiredIds,
+                         const std::unordered_set<std::string>& schematicIds,
+                         const std::string& file,
+                         const std::string& path)
+{
+    for (const std::string& requiredId : requiredIds)
+    {
+        if (schematicIds.count(requiredId) == 0)
+        {
+            throw makeError(file, path,
+                "references unknown schematic '" + requiredId + "'");
+        }
+    }
+}
+
+// Validates that every id listed in an `unlock_requires` (REQ-LOCK-PREREQ)
+// resolves to an explicitly-unlockable schematic: a ship, a module, or an
+// assembler recipe that carries `unlock_at_station_level` (a recipe schematic,
+// per REQ-LOCK-EXPLICIT). An unresolved id is a config error surfaced at load.
+void validateUnlockRequires(const GameConfig& cfg)
+{
+    std::unordered_set<std::string> schematicIds;
+    for (const ShipDef& def : cfg.ships.ships)
+    {
+        schematicIds.insert(def.id);
+    }
+    for (const ModuleDef& def : cfg.modules.modules)
+    {
+        schematicIds.insert(def.id);
+    }
+    for (const RecipeDef& def : cfg.recipes.recipes)
+    {
+        if (def.building == BuildingType::Assembler && def.unlockAtStationLevel.has_value())
+        {
+            schematicIds.insert(def.id);
+        }
+    }
+
+    for (const ShipDef& def : cfg.ships.ships)
+    {
+        checkUnlockRequires(def.unlockRequires, schematicIds, "ships.toml",
+                            "ship '" + def.id + "'.unlock_requires");
+    }
+    for (const ModuleDef& def : cfg.modules.modules)
+    {
+        checkUnlockRequires(def.unlockRequires, schematicIds, "modules.toml",
+                            "module '" + def.id + "'.unlock_requires");
+    }
+    for (const RecipeDef& def : cfg.recipes.recipes)
+    {
+        checkUnlockRequires(def.unlockRequires, schematicIds, "recipes.toml",
+                            "recipe '" + def.id + "'.unlock_requires");
+    }
+}
+
+} // namespace
+
 GameConfig ConfigLoader::loadFromDirectory(const std::string& configDir)
 {
     GameConfig cfg;
@@ -694,6 +769,7 @@ GameConfig ConfigLoader::loadFromDirectory(const std::string& configDir)
     cfg.ships     = loadShips(configDir + "/ships.toml");
     cfg.stations  = loadStations(configDir + "/stations.toml");
     cfg.modules   = loadModules(configDir + "/modules.toml");
+    validateUnlockRequires(cfg);
     cfg.threatCosts = computeThreatCostTable(cfg);
     return cfg;
 }

src/lib/config/ModulesConfig.h

@@ -41,6 +41,9 @@ struct ModuleDef
 {
     std::string id;
     int unlockAtStationLevel;
+    // Prerequisite schematic ids that must be explicitly unlocked before this
+    // schematic can enter the drop pool (REQ-LOCK-PREREQ). Empty = none.
+    std::vector<std::string> unlockRequires;
     std::vector<std::string> surfaceMask;
     std::vector<RecipeIngredient> materials;
     double productionTimeSeconds;

src/lib/config/RecipesConfig.h

@@ -36,6 +36,10 @@ struct RecipeDef
     // at game start. >= 0 = locked; schematic enters drop pool at that station
     // level once the output item is implicitly unlocked (REQ-LOCK-EXPLICIT).
     std::optional<int> unlockAtStationLevel;
+    // Assembler recipe schematics only. Prerequisite schematic ids that must be
+    // explicitly unlocked before this schematic can enter the drop pool
+    // (REQ-LOCK-PREREQ). Empty = none.
+    std::vector<std::string> unlockRequires;
 };
 
 struct RecipesConfig

src/lib/config/ShipsConfig.h

@@ -36,6 +36,9 @@ struct ShipDef
 {
     std::string id;
     int unlockAtStationLevel;
+    // Prerequisite schematic ids that must be explicitly unlocked before this
+    // schematic can enter the drop pool (REQ-LOCK-PREREQ). Empty = none.
+    std::vector<std::string> unlockRequires;
     std::vector<std::string> layout;
 
     ShipSchematic schematic;

src/lib/sim/Simulation.cpp

@@ -635,12 +635,14 @@ void Simulation::generateSchematicChoices(int destroyedStationLevel)
     {
         if (def.unlockAtStationLevel < 0 || def.unlockAtStationLevel > destroyedStationLevel) { continue; }
         if (m_schematicLevels.at(def.id).unlocked) { continue; }
+        if (!prerequisitesSatisfied(def.unlockRequires)) { continue; }
         pool.push_back({def.id, DropType::Ship});
     }
     for (const ModuleDef& def : m_config.modules.modules)
     {
         if (def.unlockAtStationLevel < 0 || def.unlockAtStationLevel > destroyedStationLevel) { continue; }
         if (m_moduleSchematicLevels.at(def.id).unlocked) { continue; }
+        if (!prerequisitesSatisfied(def.unlockRequires)) { continue; }
         pool.push_back({def.id, DropType::Module});
     }
     for (const RecipeDef& def : m_config.recipes.recipes)
@@ -656,6 +658,7 @@ void Simulation::generateSchematicChoices(int destroyedStationLevel)
             if (m_unlockedItemIds.count(out.item) > 0) { outputUnlocked = true; break; }
         }
         if (!outputUnlocked) { continue; }
+        if (!prerequisitesSatisfied(def.unlockRequires)) { continue; }
         pool.push_back({def.id, DropType::Recipe});
     }
 
@@ -808,6 +811,32 @@ std::set<std::string> Simulation::getUnlockedModuleSchematicIds() const
     return ids;
 }
 
+bool Simulation::isSchematicIdExplicitlyUnlocked(const std::string& schematicId) const
+{
+    // A prerequisite is satisfied only by an explicitly-unlocked schematic
+    // (REQ-LOCK-PREREQ): a ship or module schematic marked unlocked, or a recipe
+    // schematic in the explicit-unlock set. Cross-type ids are looked up with
+    // find/count so an id from one namespace never throws against another.
+    const std::map<std::string, SchematicState>::const_iterator shipIt =
+        m_schematicLevels.find(schematicId);
+    if (shipIt != m_schematicLevels.end() && shipIt->second.unlocked) { return true; }
+
+    const std::map<std::string, SchematicState>::const_iterator moduleIt =
+        m_moduleSchematicLevels.find(schematicId);
+    if (moduleIt != m_moduleSchematicLevels.end() && moduleIt->second.unlocked) { return true; }
+
+    return m_unlockedRecipeSchematicIds.count(schematicId) > 0;
+}
+
+bool Simulation::prerequisitesSatisfied(const std::vector<std::string>& unlockRequires) const
+{
+    for (const std::string& requiredId : unlockRequires)
+    {
+        if (!isSchematicIdExplicitlyUnlocked(requiredId)) { return false; }
+    }
+    return true;
+}
+
 Simulation::UnlockedSets Simulation::computeUnlockedSets(
     const std::set<std::string>& unlockedShipSchematicIds,
     const std::set<std::string>& unlockedModuleSchematicIds,

src/lib/sim/Simulation.h

@@ -215,6 +215,12 @@ private:
     std::set<std::string> getUnlockedShipSchematicIds() const;
     std::set<std::string> getUnlockedModuleSchematicIds() const;
 
+    // True if schematicId names a currently explicitly-unlocked ship, module, or
+    // assembler recipe schematic (REQ-LOCK-PREREQ satisfaction basis).
+    bool isSchematicIdExplicitlyUnlocked(const std::string& schematicId) const;
+    // True if every prerequisite in unlockRequires is explicitly unlocked (REQ-LOCK-PREREQ).
+    bool prerequisitesSatisfied(const std::vector<std::string>& unlockRequires) const;
+
     // Display names (deduplicated, alphabetical) of output items of recipes in
     // hypothetical.recipeIds that are not yet in m_unlockedRecipeIds.
     std::vector<std::string> computeNewlyUnlockedItemNames(const UnlockedSets& hypothetical) const;

src/test/CMakeLists.txt

@@ -21,6 +21,7 @@ add_files(
     ShipModuleTest.cpp
     ThreatCostCalculatorTest.cpp
     RecipeSchematicTest.cpp
+    UnlockPrereqTest.cpp
     ArtifactWinConditionTest.cpp
     DeterminismTest.cpp
     CommandTest.cpp

src/test/ConfigLoaderTest.cpp

@@ -6,6 +6,7 @@
 #include <stdexcept>
 #include <string>
 #include <system_error>
+#include <vector>
 
 #include "BuildingType.h"
 #include "ConfigLoader.h"
@@ -343,3 +344,151 @@ duration_seconds = 1.0
         std::runtime_error);
 }
 
+// --- unlock_requires (REQ-LOCK-PREREQ) ------------------------------------
+
+namespace
+{
+
+// Copies every regular file from CONFIG_DIR into dir, giving tests a full,
+// valid config set they can then perturb before calling loadFromDirectory.
+void copyConfigInto(const std::filesystem::path& dir)
+{
+    for (const std::filesystem::directory_entry& entry :
+         std::filesystem::directory_iterator(std::string(CONFIG_DIR)))
+    {
+        if (entry.is_regular_file())
+        {
+            std::filesystem::copy_file(entry.path(), dir / entry.path().filename());
+        }
+    }
+}
+
+} // namespace
+
+TEST_CASE("unlock_requires parses into a ship def", "[config]")
+{
+    TempConfigDir dir;
+    writeFile(dir.path() / "ships.toml", R"(
+[[ship]]
+id = "alpha"
+unlock_at_station_level = 1
+unlock_requires = ["beta", "gamma"]
+layout = ["O"]
+[ship.schematic]
+materials = []
+production_time_seconds = 5
+[ship.health]
+hp = 10
+[ship.movement]
+speed_mps = 1
+main_acceleration_mpss = 1
+maneuvering_acceleration_mpss = 1
+angular_acceleration_radpss = 1
+max_rotation_speed_radps = 1
+[ship.sensor]
+sensor_range_m = 10
+)");
+
+    const ShipsConfig cfg = ConfigLoader::loadShips((dir.path() / "ships.toml").string());
+    REQUIRE(cfg.ships.size() == 1);
+    CHECK(cfg.ships[0].unlockRequires == std::vector<std::string>{"beta", "gamma"});
+}
+
+TEST_CASE("unlock_requires parses into a module def", "[config]")
+{
+    TempConfigDir dir;
+    writeFile(dir.path() / "modules.toml", R"(
+[[module]]
+id = "m1"
+unlock_at_station_level = 0
+unlock_requires = ["dep"]
+surface_mask = ["O"]
+materials = [{item = "iron_ingot", amount = 1}]
+production_time_seconds = 1
+fill_color = "#ffffff"
+glyph = "M"
+)");
+
+    const ModulesConfig cfg = ConfigLoader::loadModules((dir.path() / "modules.toml").string());
+    REQUIRE(cfg.modules.size() == 1);
+    CHECK(cfg.modules[0].unlockRequires == std::vector<std::string>{"dep"});
+}
+
+TEST_CASE("unlock_requires parses only for assembler recipes", "[config]")
+{
+    TempConfigDir dir;
+    writeFile(dir.path() / "recipes.toml", R"(
+[[recipe]]
+id = "gated_asm"
+building = "assembler"
+unlock_at_station_level = 1
+unlock_requires = ["prereq_recipe"]
+inputs = []
+outputs = [{item = "foo", amount = 1}]
+duration_seconds = 1.0
+
+[[recipe]]
+id = "a_miner"
+building = "miner"
+unlock_requires = ["ignored"]
+inputs = []
+outputs = [{item = "ore", amount = 1}]
+duration_seconds = 1.0
+)");
+
+    const RecipesConfig cfg = ConfigLoader::loadRecipes((dir.path() / "recipes.toml").string());
+    REQUIRE(cfg.recipes.size() == 2);
+    CHECK(cfg.recipes[0].unlockRequires == std::vector<std::string>{"prereq_recipe"});
+    // The field is only consumed for assembler recipe schematics; a miner recipe
+    // leaves it unparsed (empty).
+    CHECK(cfg.recipes[1].unlockRequires.empty());
+}
+
+TEST_CASE("unlock_requires referencing an unknown schematic is rejected at load", "[config]")
+{
+    TempConfigDir dir;
+    copyConfigInto(dir.path());
+
+    std::ofstream out((dir.path() / "recipes.toml").string(), std::ios::app);
+    out << "\n[[recipe]]\n"
+           "id = \"gated_bogus\"\n"
+           "building = \"assembler\"\n"
+           "unlock_at_station_level = 1\n"
+           "unlock_requires = [\"___does_not_exist___\"]\n"
+           "inputs = []\n"
+           "outputs = [{item = \"circuit_board\", amount = 1}]\n"
+           "duration_seconds = 1.0\n";
+    out.close();
+
+    try
+    {
+        ConfigLoader::loadFromDirectory(dir.path().string());
+        FAIL("Expected exception");
+    }
+    catch (const std::runtime_error& e)
+    {
+        const std::string msg = e.what();
+        REQUIRE(msg.find("___does_not_exist___") != std::string::npos);
+    }
+}
+
+TEST_CASE("unlock_requires referencing a real schematic loads without error", "[config]")
+{
+    TempConfigDir dir;
+    copyConfigInto(dir.path());
+
+    // "interceptor" is a ship schematic in the test config — a valid prerequisite.
+    std::ofstream out((dir.path() / "recipes.toml").string(), std::ios::app);
+    out << "\n[[recipe]]\n"
+           "id = \"gated_ok\"\n"
+           "building = \"assembler\"\n"
+           "unlock_at_station_level = 1\n"
+           "unlock_requires = [\"interceptor\"]\n"
+           "inputs = []\n"
+           "outputs = [{item = \"circuit_board\", amount = 1}]\n"
+           "duration_seconds = 1.0\n";
+    out.close();
+
+    REQUIRE_NOTHROW(ConfigLoader::loadFromDirectory(dir.path().string()));
+}
+

src/test/UnlockPrereqTest.cpp

@@ -0,0 +1,174 @@
+// Drop-pool behaviour for unlock_requires schematic prerequisites
+// (REQ-LOCK-PREREQ). A schematic enters the drop pool only when every id in its
+// unlock_requires is already explicitly unlocked, on top of the station-level
+// (and, for recipes, output-implicitly-unlocked) checks.
+//
+// Configs are built in memory (load the test config, then mutate) so each case
+// is isolated and does not perturb the shared test config used by other suites.
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "catch.hpp"
+
+#include "ConfigLoader.h"
+#include "FactionComponent.h"
+#include "GameConfig.h"
+#include "HealthComponent.h"
+#include "ModulesConfig.h"
+#include "RecipesConfig.h"
+#include "SchematicChoiceOption.h"
+#include "ShipsConfig.h"
+#include "Simulation.h"
+#include "SimulationTestAccess.h"
+#include "StationBodyComponent.h"
+
+namespace
+{
+
+GameConfig loadConfig()
+{
+    return ConfigLoader::loadFromDirectory(CONFIG_DIR);
+}
+
+ShipDef& findShip(GameConfig& cfg, const std::string& id)
+{
+    for (ShipDef& def : cfg.ships.ships)
+    {
+        if (def.id == id) { return def; }
+    }
+    FAIL("ship not found: " + id);
+    return cfg.ships.ships.front();
+}
+
+ModuleDef& findModule(GameConfig& cfg, const std::string& id)
+{
+    for (ModuleDef& def : cfg.modules.modules)
+    {
+        if (def.id == id) { return def; }
+    }
+    FAIL("module not found: " + id);
+    return cfg.modules.modules.front();
+}
+
+RecipeDef& findRecipe(GameConfig& cfg, const std::string& id)
+{
+    for (RecipeDef& def : cfg.recipes.recipes)
+    {
+        if (def.id == id) { return def; }
+    }
+    FAIL("recipe not found: " + id);
+    return cfg.recipes.recipes.front();
+}
+
+// Zeros the HP of both enemy defence stations and advances one tick so that
+// tickDeathsAndLoot fires, triggering the push and schematic choices.
+void killEnemyStations(Simulation& sim)
+{
+    sim.admin().forEach<StationBodyComponent, FactionComponent, HealthComponent>(
+        [](entt::entity, StationBodyComponent&, FactionComponent& faction, HealthComponent& health)
+        {
+            if (faction.isEnemy)
+            {
+                health.hp = 0.0f;
+            }
+        });
+    sim.tick();
+}
+
+void killEnemyStationsAndApply(Simulation& sim)
+{
+    killEnemyStations(sim);
+    if (sim.hasSchematicChoicesPending())
+    {
+        SimulationTestAccess::applySchematicChoice(sim, 0);
+    }
+}
+
+bool optionOffered(const Simulation& sim, const std::string& id)
+{
+    const std::vector<SchematicChoiceOption>& options = sim.getPendingSchematicChoices();
+    return std::any_of(options.begin(), options.end(),
+        [&](const SchematicChoiceOption& o) { return o.schematicId == id; });
+}
+
+} // namespace
+
+TEST_CASE("UnlockPrereq: a recipe gated behind a locked ship is withheld from the pool",
+          "[unlock_prereq]")
+{
+    // quick_circuit (assembler recipe, level 0, output circuit_board is implicitly
+    // unlocked) would normally be eligible at the first station destruction. Gate
+    // it behind repair_ship (ship, level 0, locked at game start).
+    GameConfig cfg = loadConfig();
+    findRecipe(cfg, "quick_circuit").unlockRequires = {"repair_ship"};
+
+    Simulation sim(std::move(cfg), 123);
+    REQUIRE_FALSE(sim.isSchematicUnlocked("repair_ship"));
+
+    killEnemyStations(sim);  // destroyed set level 0
+    REQUIRE(sim.hasSchematicChoicesPending());
+
+    // Prerequisite unmet -> the gated recipe must not be offered, while the
+    // prerequisite schematic itself (the only other eligible pick) is.
+    CHECK_FALSE(optionOffered(sim, "quick_circuit"));
+    CHECK(optionOffered(sim, "repair_ship"));
+}
+
+TEST_CASE("UnlockPrereq: the gated recipe becomes eligible once its prerequisite is unlocked",
+          "[unlock_prereq]")
+{
+    GameConfig cfg = loadConfig();
+    findRecipe(cfg, "quick_circuit").unlockRequires = {"repair_ship"};
+
+    Simulation sim(std::move(cfg), 123);
+
+    // Applying choice 0 each drop unlocks repair_ship first (the only eligible
+    // pick at level 0), which then opens quick_circuit for a later drop.
+    bool unlocked = false;
+    for (int i = 0; i < 150 && !unlocked; ++i)
+    {
+        killEnemyStationsAndApply(sim);
+        unlocked = sim.isRecipeUnlocked("quick_circuit");
+    }
+
+    CHECK(sim.isSchematicUnlocked("repair_ship"));  // prerequisite got unlocked along the way
+    CHECK(unlocked);
+}
+
+TEST_CASE("UnlockPrereq: a module gated behind another module is withheld until it unlocks",
+          "[unlock_prereq]")
+{
+    // Mirror the app-config demo (laser_cannon_m -> laser_cannon_l) using two
+    // test-config modules made lockable at the same station level.
+    GameConfig cfg = loadConfig();
+    findModule(cfg, "laser_cannon").unlockAtStationLevel = 0;
+    ModuleDef& armor = findModule(cfg, "armor_plate");
+    armor.unlockAtStationLevel = 0;
+    armor.unlockRequires = {"laser_cannon"};
+
+    Simulation sim(std::move(cfg), 7);
+    REQUIRE_FALSE(sim.isModuleSchematicUnlocked("laser_cannon"));
+    REQUIRE_FALSE(sim.isModuleSchematicUnlocked("armor_plate"));
+
+    killEnemyStations(sim);  // level 0
+    REQUIRE(sim.hasSchematicChoicesPending());
+    // armor_plate is gated behind the still-locked laser_cannon module.
+    CHECK_FALSE(optionOffered(sim, "armor_plate"));
+
+    // Drive the drops until the gated module unlocks; it can only do so after its
+    // prerequisite has itself been unlocked.
+    bool armorUnlocked = false;
+    for (int i = 0; i < 300 && !armorUnlocked; ++i)
+    {
+        killEnemyStationsAndApply(sim);
+        armorUnlocked = sim.isModuleSchematicUnlocked("armor_plate");
+        if (armorUnlocked)
+        {
+            CHECK(sim.isModuleSchematicUnlocked("laser_cannon"));
+        }
+    }
+    CHECK(armorUnlocked);
+}