allow to unlock modules when destroying defence stations

src/lib/sim/Simulation.cpp

@@ -51,7 +51,13 @@ Simulation::Simulation(GameConfig config, unsigned int seed)
             {
                 return;
             }
-            m_shipSystem->spawn(id, it->second.level, pos, /*isEnemy=*/false, layout);
+            std::map<std::string, int> moduleLevels;
+            for (const auto& [mId, mState] : m_moduleSchematicLevels)
+            {
+                moduleLevels[mId] = mState.level;
+            }
+            m_shipSystem->spawn(id, it->second.level, pos, /*isEnemy=*/false, layout,
+                                moduleLevels);
         },
         m_rng);
     m_shipSystem     = std::make_unique<ShipSystem>(m_config, m_admin);
@@ -62,7 +68,7 @@ Simulation::Simulation(GameConfig config, unsigned int seed)
     m_waveSystem     = std::make_unique<WaveSystem>(m_config, m_rng);
     m_combatSystem   = std::make_unique<CombatSystem>(m_config);
 
-    // Initialize schematic unlock state.
+    // Initialize ship schematic unlock state.
     for (const ShipDef& def : m_config.ships.ships)
     {
         SchematicState state;
@@ -71,6 +77,15 @@ Simulation::Simulation(GameConfig config, unsigned int seed)
         m_schematicLevels[def.id] = state;
     }
 
+    // Initialize module schematic unlock state.
+    for (const ModuleDef& def : m_config.modules.modules)
+    {
+        SchematicState state;
+        state.unlocked = (def.unlockAtStationLevel == -1);
+        state.level    = (def.unlockAtStationLevel == -1) ? def.playerProductionLevel : 0;
+        m_moduleSchematicLevels[def.id] = state;
+    }
+
     placeInitialStructures();
 	registerForEvents();
 }
@@ -124,7 +139,13 @@ void Simulation::reset(unsigned int seed)
             {
                 return;
             }
-            m_shipSystem->spawn(id, it->second.level, pos, /*isEnemy=*/false, layout);
+            std::map<std::string, int> moduleLevels;
+            for (const auto& [mId, mState] : m_moduleSchematicLevels)
+            {
+                moduleLevels[mId] = mState.level;
+            }
+            m_shipSystem->spawn(id, it->second.level, pos, /*isEnemy=*/false, layout,
+                                moduleLevels);
         },
         m_rng);
     m_shipSystem     = std::make_unique<ShipSystem>(m_config, m_admin);
@@ -144,6 +165,15 @@ void Simulation::reset(unsigned int seed)
         m_schematicLevels[def.id] = state;
     }
 
+    m_moduleSchematicLevels.clear();
+    for (const ModuleDef& def : m_config.modules.modules)
+    {
+        SchematicState state;
+        state.unlocked = (def.unlockAtStationLevel == -1);
+        state.level    = (def.unlockAtStationLevel == -1) ? def.playerProductionLevel : 0;
+        m_moduleSchematicLevels[def.id] = state;
+    }
+
     placeInitialStructures();
 }
 
@@ -482,28 +512,37 @@ void Simulation::tickDeathsAndLoot()
 
 void Simulation::awardSchematicDrop(int destroyedStationLevel)
 {
-    std::vector<std::string> ids;
-    ids.reserve(m_config.ships.ships.size());
+    std::vector<std::pair<std::string, bool>> pool; // (id, isModule)
     for (const ShipDef& def : m_config.ships.ships)
     {
         if (def.unlockAtStationLevel == -1 || def.unlockAtStationLevel <= destroyedStationLevel)
         {
-            ids.push_back(def.id);
+            pool.push_back({def.id, false});
+        }
+    }
+    for (const ModuleDef& def : m_config.modules.modules)
+    {
+        if (def.unlockAtStationLevel == -1 || def.unlockAtStationLevel <= destroyedStationLevel)
+        {
+            pool.push_back({def.id, true});
         }
     }
 
-    std::uniform_int_distribution<int> dist(0, static_cast<int>(ids.size()) - 1);
-    const std::string chosen = ids[static_cast<std::size_t>(dist(m_rng))];
+    std::uniform_int_distribution<int> dist(0, static_cast<int>(pool.size()) - 1);
+    const auto& [chosen, isModule] = pool[static_cast<std::size_t>(dist(m_rng))];
 
-    SchematicState& state = m_schematicLevels.at(chosen);
+    SchematicState& state = isModule
+        ? m_moduleSchematicLevels.at(chosen)
+        : m_schematicLevels.at(chosen);
     const bool wasNew = !state.unlocked;
     state.unlocked = true;
     state.level   += 1;
 
     SchematicDropEvent evt;
-    evt.schematicId  = chosen;
-    evt.newLevel     = state.level;
-    evt.wasNewUnlock = wasNew;
+    evt.schematicId       = chosen;
+    evt.newLevel          = state.level;
+    evt.wasNewUnlock      = wasNew;
+    evt.isModuleSchematic = isModule;
     m_schematicDropEvents.push_back(evt);
 }
 
@@ -586,6 +625,28 @@ bool Simulation::isSchematicUnlocked(const std::string& shipId) const
     return it->second.unlocked;
 }
 
+int Simulation::moduleSchematicLevel(const std::string& moduleId) const
+{
+    const std::map<std::string, SchematicState>::const_iterator it =
+        m_moduleSchematicLevels.find(moduleId);
+    if (it == m_moduleSchematicLevels.end())
+    {
+        return 0;
+    }
+    return it->second.level;
+}
+
+bool Simulation::isModuleSchematicUnlocked(const std::string& moduleId) const
+{
+    const std::map<std::string, SchematicState>::const_iterator it =
+        m_moduleSchematicLevels.find(moduleId);
+    if (it == m_moduleSchematicLevels.end())
+    {
+        return false;
+    }
+    return it->second.unlocked;
+}
+
 BuildingId Simulation::tryPlaceBuilding(BuildingType type, QPoint anchor, Rotation rotation)
 {
     int cost = 0;