Files
DSP_Mods/UXAssist/Production/ProductionPlanner.Report.cs
T
soarqin d941de2810 fix(production): correct blueprint power and planner edge cases
Read the Advanced Mining Machine speed stored with station settings in prebuild
and blueprint captures, and count charging power nodes such as Satellite
Substations at their idle draw. Skip recipes that consume their own product when
choosing an item's default recipe, so Refined Oil uses Plasma Refining instead
of Reforming Refine.

Run each planner recipe in one proliferation mode and report conflicting
explicit modes, keep material flows for recipe types the catalog does not know,
and attribute receiver warnings to their recipe. Compare simplex ratio ties
relatively and drive out near-zero artificials without amplifying residuals.
Bound the steady-state reduction so lossless cycles cannot stall blueprint
descriptions, and choose power units after rounding.

Remove redundant code: share the numeric and flow helpers, and drop the unused
IsExcessIntermediate threshold, legacy constructor and Capture overloads, the
multi-field updater, and the unused proliferator source table.
2026-10-25 15:24:38 +08:00

203 lines
11 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using static UXAssist.Production.ProductionMath;
namespace UXAssist.Production;
public sealed partial class ProductionPlanner
{
private ProductionReport BuildReport(ProductionPlanRequest request, IDictionary<int, double> targets, int[] rows,
ProductionProcess[] processes, int[] importItems, double[] solution, int importStart, int surplusStart,
int proliferatorItemId, double spraysPerBottle, List<ProductionDiagnostic> warnings,
int[] reusableSprayItems, int sprayCreditStart)
{
var remainingSprayCredits = new Dictionary<int, double>();
for (var index = 0; index < reusableSprayItems.Length; index++)
remainingSprayCredits[reusableSprayItems[index]] = solution[sprayCreditStart + index];
var grossProduction = new Dictionary<int, double>();
var grossConsumption = new Dictionary<int, double>();
var producers = new Dictionary<int, List<int>>();
var consumers = new Dictionary<int, List<int>>();
var groups = new List<ProductionGroupFlow>();
var activeRecipes = new HashSet<int>();
var powerComplete = true;
var factoryPowerComplete = true;
var workingPower = 0.0;
var peakPower = 0.0;
var generationWatts = 0.0;
var chargingWatts = 0.0;
var dischargingWatts = 0.0;
var dysonRequirementWatts = 0.0;
for (var index = 0; index < processes.Length; index++)
{
var executions = solution[index];
if (executions <= 1e-9) continue;
var process = processes[index];
activeRecipes.Add(process.RecipeId);
var output = ScaleFlows(process.OutputsPerCycle, executions);
var input = ScaleFlows(process.InputsPerCycle, executions);
if (proliferatorItemId > 0 && SpraysInputs(process))
{
var sprays = process.SprayedInputsPerCycle * executions;
foreach (var itemId in reusableSprayItems)
{
var reused = Math.Min(remainingSprayCredits[itemId],
SprayedInputAmount(process, itemId) * executions);
remainingSprayCredits[itemId] -= reused;
sprays -= reused;
}
if (sprays > 0) AddFlow(input, proliferatorItemId, sprays / spraysPerBottle);
}
var groupIndex = groups.Count;
foreach (var flow in output)
{
AddFlow(grossProduction, flow.Key, flow.Value);
AddGroup(producers, flow.Key, groupIndex);
}
foreach (var flow in input)
{
AddFlow(grossConsumption, flow.Key, flow.Value);
AddGroup(consumers, flow.Key, groupIndex);
}
double? equivalentBuildings = null;
int? deploymentCount = null;
double? consumedWatts = null;
double? peakWatts = null;
if (process.HasBuilding && process.CyclesPerBuildingPerMinute > 0)
{
equivalentBuildings = executions / process.CyclesPerBuildingPerMinute;
if (!process.PowerKnown) powerComplete = false;
if (equivalentBuildings.Value > int.MaxValue || double.IsInfinity(equivalentBuildings.Value))
{
powerComplete = false;
factoryPowerComplete = false;
warnings.Add(new ProductionDiagnostic(ProductionDiagnosticCode.InvalidRequest,
"The rounded deployment count exceeds the supported range.", recipeId: process.RecipeId));
}
else
{
deploymentCount = Math.Max(1, (int)Math.Ceiling(equivalentBuildings.Value - 1e-9));
consumedWatts = equivalentBuildings.Value * process.WorkingPowerWatts;
peakWatts = deploymentCount.Value * process.WorkingPowerWatts;
if (!FiniteNonnegative(consumedWatts.Value)) factoryPowerComplete = false;
workingPower += consumedWatts.Value;
peakPower += peakWatts.Value;
generationWatts += equivalentBuildings.Value * process.GenerationWatts;
chargingWatts += equivalentBuildings.Value * process.AccumulatorChargingWatts;
dischargingWatts += equivalentBuildings.Value * process.AccumulatorDischargingWatts;
dysonRequirementWatts += equivalentBuildings.Value * (process.DysonSphereRequirementWatts ?? 0);
}
}
else
{
powerComplete = false;
factoryPowerComplete = false;
if (!warnings.Any(warning => warning.RecipeId == process.RecipeId &&
(warning.Code == ProductionDiagnosticCode.MissingBuilding ||
warning.Code == ProductionDiagnosticCode.IncompatibleBuilding)))
warnings.Add(new ProductionDiagnostic(ProductionDiagnosticCode.MissingBuilding,
"Select a building to calculate power for this recipe.", recipeId: process.RecipeId));
}
groups.Add(new ProductionGroupFlow(process, equivalentBuildings ?? 0, executions, equivalentBuildings,
deploymentCount, consumedWatts, peakWatts, output, input,
equivalentBuildings * process.GenerationWatts,
equivalentBuildings * process.AccumulatorChargingWatts,
equivalentBuildings * process.AccumulatorDischargingWatts,
equivalentBuildings * process.DysonSphereRequirementWatts,
executions * process.LaunchesPerCycle,
executions * process.ResearchHashesPerCycle));
}
var auxiliaryIds = new HashSet<int>();
foreach (var auxiliary in request.AuxiliaryBuildings)
{
if (auxiliary == null || auxiliary.Count <= 0 || auxiliary.RecipeId != 0)
{
powerComplete = false;
factoryPowerComplete = false;
warnings.Add(new ProductionDiagnostic(ProductionDiagnosticCode.InvalidRequest,
"Auxiliary power requires a positive building count and no production recipe."));
continue;
}
if (auxiliary.ObjectId != 0 && !auxiliaryIds.Add(auxiliary.ObjectId))
{
warnings.Add(new ProductionDiagnostic(ProductionDiagnosticCode.DuplicateSelection,
"An auxiliary building was selected more than once.",
buildingItemId: auxiliary.BuildingItemId));
continue;
}
if (!_catalog.Buildings.TryGetValue(auxiliary.BuildingItemId, out var building) ||
building.Kind != ProductionBuildingKind.Auxiliary ||
!FiniteNonnegative(building.WorkingPowerWatts * auxiliary.Count))
{
powerComplete = false;
factoryPowerComplete = false;
warnings.Add(new ProductionDiagnostic(ProductionDiagnosticCode.UnsupportedProcess,
"The auxiliary building has no rated working power.",
buildingItemId: auxiliary.BuildingItemId));
continue;
}
var watts = building.WorkingPowerWatts * auxiliary.Count;
workingPower += watts;
peakPower += watts;
var process = new ProductionProcess(0, building.ItemId, ProliferationMode.None, 0,
Array.Empty<KeyValuePair<int, double>>(), Array.Empty<KeyValuePair<int, double>>(),
1, building.WorkingPowerWatts, true);
groups.Add(new ProductionGroupFlow(process, auxiliary.Count, 0, auxiliary.Count,
auxiliary.Count, watts, watts, Array.Empty<KeyValuePair<int, double>>(),
Array.Empty<KeyValuePair<int, double>>()));
}
if (proliferatorItemId > 0 && request.SprayDeliveredItems.Count > 0)
{
var sprays = request.SprayDeliveredItems.Sum(itemId => targets[itemId]);
foreach (var itemId in reusableSprayItems)
{
if (request.SprayDeliveredItems.Contains(itemId)) sprays -= remainingSprayCredits[itemId];
}
if (sprays > 0) AddFlow(grossConsumption, proliferatorItemId, sprays / spraysPerBottle);
}
var imports = new Dictionary<int, double>();
for (var index = 0; index < importItems.Length; index++)
imports[importItems[index]] = solution[importStart + index];
var itemFlows = new List<ProductionItemFlow>();
for (var index = 0; index < rows.Length; index++)
{
var itemId = rows[index];
var produced = grossProduction.TryGetValue(itemId, out var production) ? production : 0;
var consumed = grossConsumption.TryGetValue(itemId, out var consumption) ? consumption : 0;
var imported = imports.TryGetValue(itemId, out var externalImport) ? externalImport : 0;
var known = request.KnownExternalSurplus.TryGetValue(itemId, out var knownSupply) ? knownSupply : 0;
var delivered = targets.TryGetValue(itemId, out var target) ? target : 0;
var surplus = solution[surplusStart + index];
var finalProduct = produced > 1e-9 && consumed <= 1e-9;
itemFlows.Add(new ProductionItemFlow(itemId, produced, consumed, imported, known, delivered, surplus,
imported, finalProduct,
producers.TryGetValue(itemId, out var producing) ? producing : Array.Empty<int>(),
consumers.TryGetValue(itemId, out var usingItem) ? usingItem : Array.Empty<int>()));
}
var diagnostics = warnings.Where(warning => warning.RecipeId == 0 || activeRecipes.Contains(warning.RecipeId))
.ToList();
var power = powerComplete ? new ProductionPower(workingPower, peakPower, generationWatts,
chargingWatts, dischargingWatts, dysonRequirementWatts,
request.AuxiliaryBuildings.Count == 0 ? ProductionPowerScope.ProductionBuildings :
ProductionPowerScope.ProductionBuildingsAndAuxiliary) : null;
var status = powerComplete && diagnostics.Count == 0 ? ProductionStatus.Complete : ProductionStatus.Partial;
return new ProductionReport(status, true, powerComplete, itemFlows, groups, diagnostics, power,
new ProductionPowerBreakdown(workingPower, 0, factoryPowerComplete, true));
}
}