using System; using System.Collections.Generic; using System.Linq; using static UXAssist.Production.ProductionMath; namespace UXAssist.Production; public sealed class ProductionBuildingSnapshot { public int ObjectId { get; } public int BuildingItemId { get; } public int RecipeId { get; } public int Count { get; } public ProliferationMode ProliferationMode { get; } public double? SpeedFactor { get; } public IReadOnlyDictionary OperatingParameters { get; } public ProductionBuildingSnapshot(int objectId, int buildingItemId, int recipeId, int count, ProliferationMode proliferationMode, double? speedFactor = null, IEnumerable> operatingParameters = null) { ObjectId = objectId; BuildingItemId = buildingItemId; RecipeId = recipeId; Count = count; ProliferationMode = proliferationMode; SpeedFactor = speedFactor; OperatingParameters = new System.Collections.ObjectModel.ReadOnlyDictionary( operatingParameters?.ToDictionary(entry => entry.Key, entry => entry.Value) ?? new Dictionary()); } } public enum BlueprintProductionBasis { FinalProducts, BottleneckIntermediate } public sealed class FactoryBlackBoxRequest { public List Buildings { get; } = new List(); public List CaptureDiagnostics { get; } = new List(); public bool ProliferationEnabled { get; set; } public BlueprintProductionBasis ProductionBasis { get; set; } } public sealed class FactoryBlackBoxAnalyzer { private readonly ProductionCatalog _catalog; private readonly ProcessEvaluator _evaluator; public FactoryBlackBoxAnalyzer(ProductionCatalog catalog, ProcessEvaluator evaluator = null) { _catalog = catalog; _evaluator = evaluator ?? new ProcessEvaluator(); } public ProductionReport Analyze(FactoryBlackBoxRequest request) { if (_catalog == null) return ProductionReport.Failure(new ProductionDiagnostic(ProductionDiagnosticCode.DataNotReady, "Production data is not loaded.")); if (request == null) return ProductionReport.Failure(new ProductionDiagnostic(ProductionDiagnosticCode.InvalidRequest, "A building selection is required.")); var diagnostics = new List(request.CaptureDiagnostics); var groups = new List(); var processGroups = new List(); var grossProduction = new SortedDictionary(); var grossConsumption = new SortedDictionary(); var producers = new Dictionary>(); var consumers = new Dictionary>(); var hasResearchMatrixSink = false; var uncertainDemandItems = new HashSet(); var selectedIds = new HashSet(); var skippedSelection = diagnostics.Any(diagnostic => diagnostic.Code == ProductionDiagnosticCode.InvalidRequest || diagnostic.Code == ProductionDiagnosticCode.UnknownItem || diagnostic.Code == ProductionDiagnosticCode.DataNotReady); var unknownDemand = skippedSelection; var materialComplete = !skippedSelection; var factoryPowerComplete = !skippedSelection; var logisticsPowerComplete = !skippedSelection; var totalPowerKnown = !skippedSelection; var factoryConsumptionWatts = 0.0; var logisticsConsumptionWatts = 0.0; var generationWatts = 0.0; var chargingWatts = 0.0; var dischargingWatts = 0.0; var dysonRequirementWatts = 0.0; foreach (var snapshot in request.Buildings) { if (snapshot == null || snapshot.Count <= 0) { diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.InvalidRequest, "A selected building has an invalid count.")); materialComplete = false; factoryPowerComplete = false; logisticsPowerComplete = false; unknownDemand = true; continue; } if (snapshot.ObjectId != 0 && !selectedIds.Add(snapshot.ObjectId)) { diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.DuplicateSelection, "A selected building was already included.", buildingItemId: snapshot.BuildingItemId)); continue; } if (!_catalog.Buildings.TryGetValue(snapshot.BuildingItemId, out var building)) { diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.UnsupportedProcess, "The selected building is not supported by the catalog.", buildingItemId: snapshot.BuildingItemId)); materialComplete = false; factoryPowerComplete = false; logisticsPowerComplete = false; unknownDemand = true; continue; } if (snapshot.RecipeId != 0 && snapshot.OperatingParameters.TryGetValue("ResearchMode", out var activeResearchMode) && activeResearchMode > 0) { diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.InvalidRequest, "A research-mode lab cannot also run a manufacturing recipe.", recipeId: snapshot.RecipeId, buildingItemId: snapshot.BuildingItemId)); materialComplete = false; factoryPowerComplete = false; logisticsPowerComplete = false; unknownDemand = true; continue; } if (snapshot.RecipeId == 0 && building.Kind == ProductionBuildingKind.Logistics) { double? logisticsWatts = null; if (!snapshot.OperatingParameters.TryGetValue("ChargePowerWatts", out var chargePowerWatts)) diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.MissingOperatingParameter, "The selected logistics facility needs its configured charging power.", buildingItemId: snapshot.BuildingItemId)); else if (!FiniteNonnegative(chargePowerWatts * snapshot.Count)) diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.InvalidRequest, "The selected logistics charging power must be finite and nonnegative.", buildingItemId: snapshot.BuildingItemId)); else logisticsWatts = chargePowerWatts * snapshot.Count; if (logisticsWatts.HasValue) logisticsConsumptionWatts += logisticsWatts.Value; else logisticsPowerComplete = false; groups.Add(PowerOnlyGroup(snapshot.Count, logisticsWatts)); continue; } if (snapshot.RecipeId == 0 && (building.Kind == ProductionBuildingKind.Ordinary || building.Kind == ProductionBuildingKind.Auxiliary)) { if (building.Kind == ProductionBuildingKind.Auxiliary || !snapshot.OperatingParameters.TryGetValue("ResearchMode", out var researchMode) || researchMode <= 0) { var idleWatts = (building.Kind == ProductionBuildingKind.Auxiliary ? building.WorkingPowerWatts : building.IdlePowerWatts) * snapshot.Count; factoryConsumptionWatts += idleWatts; groups.Add(PowerOnlyGroup(snapshot.Count, idleWatts)); continue; } } ProductionRecipe recipe = null; if (snapshot.RecipeId != 0 && !_catalog.Recipes.TryGetValue(snapshot.RecipeId, out recipe)) { diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.UnknownRecipe, "The selected building's recipe is missing.", recipeId: snapshot.RecipeId, buildingItemId: snapshot.BuildingItemId)); materialComplete = false; factoryPowerComplete = false; unknownDemand = true; continue; } if (snapshot.SpeedFactor.HasValue) building = building.WithSpeedFactor(snapshot.SpeedFactor.Value); var mode = request.ProliferationEnabled ? FullProliferationMode(building, snapshot) : ProliferationMode.None; if (IsResearchModeLab(building, snapshot) && _catalog.MaximumProliferationLevel == 0) mode = ProliferationMode.None; var researchMatrixSink = IsResearchModeLab(building, snapshot) && snapshot.OperatingParameters.TryGetValue("ResearchMatrixSink", out var sinkSetting) && sinkSetting == 1 && _catalog.ResearchMatrixItemIds.Count > 0; if (researchMatrixSink) hasResearchMatrixSink = true; if (!_evaluator.TryEvaluate(_catalog, recipe, building, mode, mode == ProliferationMode.None ? 0 : _catalog.MaximumProliferationLevel, snapshot.OperatingParameters, out var process, out var diagnostic)) { diagnostics.Add(diagnostic); if (building.Kind != ProductionBuildingKind.RenewableGenerator && !researchMatrixSink) materialComplete = false; if (recipe != null) uncertainDemandItems.UnionWith(recipe.Inputs.Keys); else if (building.Kind != ProductionBuildingKind.Miner && building.Kind != ProductionBuildingKind.Collector && building.Kind != ProductionBuildingKind.RenewableGenerator && !researchMatrixSink) unknownDemand = true; if (TryGetConsumptionWithoutMaterials(building, snapshot, diagnostic, mode, out var knownWatts)) { if (!IsResearchModeLab(building, snapshot)) totalPowerKnown = false; factoryConsumptionWatts += knownWatts; groups.Add(PowerOnlyGroup(snapshot.Count, knownWatts)); } else { totalPowerKnown = false; factoryPowerComplete = false; } continue; } if (diagnostic != null) diagnostics.Add(diagnostic); if (!process.PowerKnown) totalPowerKnown = false; if (!FiniteNonnegative(process.WorkingPowerWatts * snapshot.Count)) factoryPowerComplete = false; var cycleRate = process.CyclesPerBuildingPerMinute; var output = ScaleFlows(process.OutputsPerCycle, cycleRate * snapshot.Count); var input = ScaleFlows(process.InputsPerCycle, cycleRate * snapshot.Count); 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); } var watts = process.WorkingPowerWatts * snapshot.Count; factoryConsumptionWatts += watts; generationWatts += process.GenerationWatts * snapshot.Count; chargingWatts += process.AccumulatorChargingWatts * snapshot.Count; dischargingWatts += process.AccumulatorDischargingWatts * snapshot.Count; dysonRequirementWatts += (process.DysonSphereRequirementWatts ?? 0) * snapshot.Count; groups.Add(new ProductionGroupFlow(process, snapshot.Count, cycleRate * snapshot.Count, snapshot.Count, snapshot.Count, watts, watts, output, input, process.GenerationWatts * snapshot.Count, process.AccumulatorChargingWatts * snapshot.Count, process.AccumulatorDischargingWatts * snapshot.Count, process.DysonSphereRequirementWatts * snapshot.Count, cycleRate * snapshot.Count * process.LaunchesPerCycle, cycleRate * snapshot.Count * process.ResearchHashesPerCycle)); processGroups.Add(new BlackBoxProcessGroup(process, snapshot)); } var matrixSinkItems = hasResearchMatrixSink ? new HashSet(_catalog.ResearchMatrixItemIds) : new HashSet(); IReadOnlyDictionary classifications = null; IReadOnlyDictionary steadyStateBalance = null; if (request.ProductionBasis == BlueprintProductionBasis.BottleneckIntermediate) { if (!materialComplete || !BlueprintBottleneckBalance.TryCalculate(processGroups, grossProduction, grossConsumption, matrixSinkItems, out var balancedProduction, out var balancedConsumption, out var balancedClassifications, out var balancedNet)) diagnostics.Add(new ProductionDiagnostic(ProductionDiagnosticCode.BlueprintBasisUnavailable, "A complete material selection with a feasible final output is required for the bottleneck basis.")); else { grossProduction = balancedProduction; grossConsumption = balancedConsumption; classifications = balancedClassifications; steadyStateBalance = balancedNet; } } if (classifications == null) classifications = BlackBoxMaterialClassifier.Classify(processGroups, grossProduction, grossConsumption, materialComplete, uncertainDemandItems, unknownDemand, matrixSinkItems, out steadyStateBalance); var flows = new List(); var allItems = new SortedSet(grossProduction.Keys); allItems.UnionWith(grossConsumption.Keys); foreach (var itemId in allItems) { var produced = grossProduction.TryGetValue(itemId, out var p) ? p : 0; var consumed = grossConsumption.TryGetValue(itemId, out var c) ? c : 0; var net = produced - consumed; var classification = classifications[itemId]; flows.Add(new ProductionItemFlow(itemId, produced, consumed, 0, 0, 0, Math.Max(0, net), Math.Max(0, -net), classification.IsFinalProduct, producers.TryGetValue(itemId, out var producing) ? producing : Array.Empty(), consumers.TryGetValue(itemId, out var usingItem) ? usingItem : Array.Empty(), classification.IntermediateShortage, classification.OverbuildSurplus, classification.CoproductSurplus, Math.Max(0, -steadyStateBalance[itemId]), classification.IsResearchProduct)); } var powerComplete = factoryPowerComplete && logisticsPowerComplete && totalPowerKnown; var consumptionWatts = factoryConsumptionWatts + logisticsConsumptionWatts; var power = powerComplete ? new ProductionPower(consumptionWatts, consumptionWatts, generationWatts, chargingWatts, dischargingWatts, dysonRequirementWatts, ProductionPowerScope.SelectedFacilities) : null; var status = materialComplete && powerComplete && diagnostics.Count == 0 ? ProductionStatus.Complete : materialComplete || powerComplete || groups.Count > 0 ? ProductionStatus.Partial : ProductionStatus.Failed; return new ProductionReport(status, materialComplete, powerComplete, flows, groups, diagnostics, power, new ProductionPowerBreakdown(factoryConsumptionWatts, logisticsConsumptionWatts, factoryPowerComplete, logisticsPowerComplete)); } private static ProliferationMode FullProliferationMode(ProductionBuilding building, ProductionBuildingSnapshot snapshot) { var parameters = snapshot.OperatingParameters; switch (building.Kind) { case ProductionBuildingKind.Fractionator: case ProductionBuildingKind.FuelGenerator: case ProductionBuildingKind.Ejector: case ProductionBuildingKind.Silo: return ProliferationMode.Speedup; case ProductionBuildingKind.Exchanger: return parameters.TryGetValue("Mode0", out var exchangerMode) && exchangerMode != 0 ? ProliferationMode.Speedup : snapshot.ProliferationMode; case ProductionBuildingKind.RayReceiver: return parameters.TryGetValue("LensItemId", out var lensId) && lensId > 0 ? ProliferationMode.Speedup : ProliferationMode.None; case ProductionBuildingKind.Collector: return ProliferationMode.None; default: return building.Category == ProductionRecipeCategory.Research && snapshot.RecipeId == 0 && parameters.TryGetValue("ResearchMode", out var researchMode) && researchMode > 0 ? ProliferationMode.ExtraProducts : snapshot.ProliferationMode; } } private bool TryGetConsumptionWithoutMaterials(ProductionBuilding building, ProductionBuildingSnapshot snapshot, ProductionDiagnostic diagnostic, ProliferationMode mode, out double watts) { watts = 0; if (IsResearchModeLab(building, snapshot)) { // Research-mode labs only receive extra products, and only when a proliferation level exists. var multiplier = 1.0; if (mode != ProliferationMode.None && !_catalog.TryGetProliferation(_catalog.MaximumProliferationLevel, out _, out _, out multiplier)) return false; watts = building.WorkingPowerWatts * multiplier * snapshot.Count; return FinitePositive(watts); } if (diagnostic?.Code != ProductionDiagnosticCode.MissingOperatingParameter) return false; if (building.Kind == ProductionBuildingKind.Collector) return true; if (building.Kind != ProductionBuildingKind.Miner) return false; var speed = snapshot.OperatingParameters.TryGetValue("MachineSpeedFactor", out var capturedSpeed) ? capturedSpeed : 1; if (!FinitePositive(speed)) return false; var ratio = speed * speed; watts = (building.WorkingPowerWatts * ratio + building.IdlePowerWatts * (1 - ratio)) * snapshot.Count; return FiniteNonnegative(watts); } private static bool IsResearchModeLab(ProductionBuilding building, ProductionBuildingSnapshot snapshot) { return building.Kind == ProductionBuildingKind.Ordinary && building.Category == ProductionRecipeCategory.Research && snapshot.RecipeId == 0 && snapshot.OperatingParameters.TryGetValue("ResearchMode", out var researchMode) && researchMode == 1; } private static ProductionGroupFlow PowerOnlyGroup(int count, double? watts) { return new ProductionGroupFlow(null, count, 0, count, count, watts, watts, Array.Empty>(), Array.Empty>()); } }