Add building status light

src/lib/sim/BuildingSystem.cpp

@@ -951,43 +951,13 @@ void BuildingSystem::tickProduction(Tick currentTick)
         // recipe of their type in config order, running the first whose inputs
         // are satisfied (REQ-BLD-SMELTER, REQ-BLD-REPROCESSING). Other buildings
         // try only their selected recipe.
-        std::vector<const RecipeDef*> candidates;
-        if (autoRecipe)
-        {
-            for (const RecipeDef& r : m_config.recipes.recipes)
-            {
-                if (r.building == building.type && !r.inputs.empty())
-                {
-                    candidates.push_back(&r);
-                }
-            }
-        }
-        else
-        {
-            const RecipeDef* recipe = findRecipe(building.recipeId, building.type);
-            if (recipe)
-            {
-                candidates.push_back(recipe);
-            }
-        }
+        const std::vector<const RecipeDef*> candidates =
+            gatherCandidateRecipes(building);
 
         for (const RecipeDef* recipe : candidates)
         {
             // 1. All required inputs present?
-            bool inputsOk = true;
-            for (const RecipeIngredient& ing : recipe->inputs)
-            {
-                const ItemType type{ing.item};
-                const std::map<ItemType, int>::const_iterator it =
-                    building.inputBuffer.counts.find(type);
-                const int have = (it != building.inputBuffer.counts.end()) ? it->second : 0;
-                if (have < ing.amount)
-                {
-                    inputsOk = false;
-                    break;
-                }
-            }
-            if (!inputsOk)
+            if (!recipeInputsAvailable(building, *recipe))
             {
                 continue;
             }
@@ -1082,26 +1052,8 @@ void BuildingSystem::tickShipyardProduction(Tick currentTick)
         }
 
         // Build combined materials list (base + modules).
-        std::map<std::string, int> requiredMaterials;
-        for (const RecipeIngredient& ing : shipDef->schematic.materials)
-        {
-            requiredMaterials[ing.item] += ing.amount;
-        }
-        if (building.shipLayout.has_value())
-        {
-            for (const PlacedModule& pm : building.shipLayout->placedModules)
-            {
-                const ModuleDef* modDef = findModuleDef(pm.moduleId);
-                if (!modDef)
-                {
-                    continue;
-                }
-                for (const RecipeIngredient& ing : modDef->materials)
-                {
-                    requiredMaterials[ing.item] += ing.amount;
-                }
-            }
-        }
+        const std::map<std::string, int> requiredMaterials =
+            computeShipyardRequiredMaterials(building);
 
         // Idle: check if all combined materials are available.
         bool inputsOk = true;
@@ -1328,6 +1280,147 @@ int BuildingSystem::getActiveProductionBuildingCount() const
     return count;
 }
 
+std::vector<const RecipeDef*>
+BuildingSystem::gatherCandidateRecipes(const Building& b) const
+{
+    std::vector<const RecipeDef*> candidates;
+    if (isAutoRecipeBuildingType(b.type))
+    {
+        for (const RecipeDef& r : m_config.recipes.recipes)
+        {
+            if (r.building == b.type && !r.inputs.empty())
+            {
+                candidates.push_back(&r);
+            }
+        }
+    }
+    else
+    {
+        const RecipeDef* recipe = findRecipe(b.recipeId, b.type);
+        if (recipe)
+        {
+            candidates.push_back(recipe);
+        }
+    }
+    return candidates;
+}
+
+bool BuildingSystem::recipeInputsAvailable(const Building& b,
+                                           const RecipeDef& recipe) const
+{
+    for (const RecipeIngredient& ing : recipe.inputs)
+    {
+        const std::map<ItemType, int>::const_iterator it =
+            b.inputBuffer.counts.find(ItemType{ing.item});
+        const int have = (it != b.inputBuffer.counts.end()) ? it->second : 0;
+        if (have < ing.amount)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+std::map<std::string, int>
+BuildingSystem::computeShipyardRequiredMaterials(const Building& b) const
+{
+    std::map<std::string, int> requiredMaterials;
+    const ShipDef* shipDef = findShipDef(b.recipeId);
+    if (!shipDef)
+    {
+        return requiredMaterials;
+    }
+    for (const RecipeIngredient& ing : shipDef->schematic.materials)
+    {
+        requiredMaterials[ing.item] += ing.amount;
+    }
+    if (b.shipLayout.has_value())
+    {
+        for (const PlacedModule& pm : b.shipLayout->placedModules)
+        {
+            const ModuleDef* modDef = findModuleDef(pm.moduleId);
+            if (!modDef)
+            {
+                continue;
+            }
+            for (const RecipeIngredient& ing : modDef->materials)
+            {
+                requiredMaterials[ing.item] += ing.amount;
+            }
+        }
+    }
+    return requiredMaterials;
+}
+
+bool BuildingSystem::hasInputsToStart(const Building& b) const
+{
+    if (b.type == BuildingType::Shipyard)
+    {
+        const std::map<std::string, int> required =
+            computeShipyardRequiredMaterials(b);
+        for (const std::pair<const std::string, int>& req : required)
+        {
+            const std::map<ItemType, int>::const_iterator it =
+                b.inputBuffer.counts.find(ItemType{req.first});
+            const int have = (it != b.inputBuffer.counts.end()) ? it->second : 0;
+            if (have < req.second)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // Recipe buildings: startable if any candidate recipe's inputs are satisfied.
+    // A Miner recipe has no inputs, so an idle Miner is always startable and its
+    // only idle reason is a full output buffer.
+    for (const RecipeDef* recipe : gatherCandidateRecipes(b))
+    {
+        if (recipeInputsAvailable(b, *recipe))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+std::optional<ProductionStatus>
+BuildingSystem::getProductionStatus(const Building& building) const
+{
+    // Salvage Bay has no recipe or production cycle (REQ-BLD-SALVAGE-BAY): it is
+    // "producing" while it holds scrap to push out, and starved when empty.
+    if (building.type == BuildingType::SalvageBay)
+    {
+        return building.getOutputItemCount() >= 1 ? ProductionStatus::Producing
+                                                  : ProductionStatus::Starved;
+    }
+
+    // Only the five recipe/cycle production types show a status light besides the
+    // Salvage Bay; belts, splitters, tunnels, HQ, and stations show none.
+    if (!isProductionBuildingType(building.type))
+    {
+        return std::nullopt;
+    }
+
+    // Grey only applies to player-configured types; auto-recipe buildings
+    // (Smelter, Reprocessing Plant) always run an implicit recipe.
+    if (!isAutoRecipeBuildingType(building.type) && building.recipeId.empty())
+    {
+        return ProductionStatus::Unconfigured;
+    }
+
+    if (building.production.has_value())
+    {
+        return ProductionStatus::Producing;
+    }
+
+    // Idle: missing inputs (red) take precedence over a full output buffer
+    // (yellow). If inputs are present yet the building is idle, the only remaining
+    // reason it could not start a cycle is a full output buffer (REQ-MAT-CYCLE).
+    return hasInputsToStart(building) ? ProductionStatus::Blocked
+                                      : ProductionStatus::Starved;
+}
+
 std::vector<BuildingSystem::BeltTileInfo> BuildingSystem::getAllBeltTiles() const
 {
     std::vector<BeltTileInfo> result;