Author SHA1 Message Date
soarqin 6d4953fc29 fix(uxassist): restore tech-tree arrows across save changes
Grow missing connection arrows when Peace-mode filtering is restored, preserving existing controls and native connection updates. Record the fix in UXAssist 1.7.0 and synchronize the manifest and bilingual documentation.
2026-11-02 20:59:58 +08:00
13 changed files with 82 additions and 877 deletions

No files matched your search

-2
View File
@@ -4,7 +4,6 @@
## Changlog ## Changlog
* 2.4.8 * 2.4.8
* `Mecha and Drones/Fleets invincible`: Fix mecha HP and energy shield protection failing when enabled after taking damage, and restore protection for space fleets.
* `Finish build immediately`: Fix possible errors when starting a new game. Construction begins after the opening cutscene ends or is skipped. * `Finish build immediately`: Fix possible errors when starting a new game. Construction begins after the opening cutscene ends or is skipped.
* `Belt signal item generation`: * `Belt signal item generation`:
* Improve raw-material, intermediate, by-product and proliferator statistics using current recipes, with production and consumption counted separately. Incomplete recipe data only pauses the affected upstream statistics; item generation continues. * Improve raw-material, intermediate, by-product and proliferator statistics using current recipes, with production and consumption counted separately. Incomplete recipe data only pauses the affected upstream statistics; item generation continues.
@@ -208,7 +207,6 @@
## 更新日志 ## 更新日志
* 2.4.8 * 2.4.8
* `机甲和战斗无人机无敌`:修复受伤后启用时机甲耐久度和能量护盾保护可能失效的问题,并恢复太空编队的无敌保护。
* `建造秒完成`:修复开始新游戏时可能报错的问题。建造会在开场动画播放结束或跳过后开始。 * `建造秒完成`:修复开始新游戏时可能报错的问题。建造会在开场动画播放结束或跳过后开始。
* `传送带信号物品生成`: * `传送带信号物品生成`:
* 按当前配方完善原料、中间产物、副产物和增产剂的统计,分别记录生产和消耗。配方数据不完整时,仅暂停受影响物品的上游统计,物品仍会正常生成。 * 按当前配方完善原料、中间产物、副产物和增产剂的统计,分别记录生产和消耗。配方数据不完整时,仅暂停受影响物品的上游统计,物品仍会正常生成。
+17 -28
View File
@@ -1,11 +1,10 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Reflection;
using System.Reflection.Emit; using System.Reflection.Emit;
using BepInEx.Configuration; using BepInEx.Configuration;
using HarmonyLib; using HarmonyLib;
using UXAssist.Common; using UXAssist.Common;
using UXAssist.Common.ModFeatures; using UXAssist.Common.ModFeatures;
using UXAssist.Common.Patching;
namespace CheatEnabler.Patches; namespace CheatEnabler.Patches;
@@ -49,37 +48,27 @@ public static class CombatPatch
); );
return matcher.InstructionEnumeration(); return matcher.InstructionEnumeration();
} }
// Harmony transpiler: Mecha_Invincible_Transpiler // Harmony transpiler: SkillSystem_DamageObject_Transpiler
// Target: Mecha.TakeDamage, Mecha.EnergyShieldResist (both overloads) // Target: SkillSystem.DamageGroundObjectByLocalCaster, SkillSystem.DamageGroundObjectByRemoteCaster, SkillSystem.DamageObject
// Fallback: Return original instructions if the invincibility check is not found. // Fallback: None — patch will fail loudly if the target method body changes.
[HarmonyTranspiler] [HarmonyTranspiler]
[HarmonyPatch(typeof(Mecha), nameof(Mecha.TakeDamage))]
[HarmonyPatch(typeof(Mecha), nameof(Mecha.EnergyShieldResist), [typeof(int)], [ArgumentType.Ref])]
[HarmonyPatch(typeof(Mecha), nameof(Mecha.EnergyShieldResist), [typeof(int), typeof(int)], [ArgumentType.Ref, ArgumentType.Out])]
private static IEnumerable<CodeInstruction> Mecha_Invincible_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
{
// Repatch the consumers too: an already inlined getter bypasses its own Harmony patch.
var original = instructions.ToList();
var matcher = new CodeMatcher(original, generator);
matcher.MatchForward(false, new CodeMatch(ci => ci.Calls(AccessTools.PropertyGetter(typeof(Player), nameof(Player.invincible)))));
if (matcher.IsInvalid) return matcher.Finish(original, CheatEnabler.Logger, nameof(Mecha_Invincible_Transpiler));
matcher.Set(OpCodes.Pop, null).Advance(1).Insert(new CodeInstruction(OpCodes.Ldc_I4_1));
return matcher.InstructionEnumeration();
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SkillSystem), nameof(SkillSystem.DamageGroundObjectByLocalCaster))] [HarmonyPatch(typeof(SkillSystem), nameof(SkillSystem.DamageGroundObjectByLocalCaster))]
[HarmonyPatch(typeof(SkillSystem), nameof(SkillSystem.DamageGroundObjectByRemoteCaster))] [HarmonyPatch(typeof(SkillSystem), nameof(SkillSystem.DamageGroundObjectByRemoteCaster))]
private static void SkillSystem_DamageGroundObject_Prefix(ref int damage, ref SkillTargetLocal target)
{
if (target.type == ETargetType.Craft) damage = 0;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SkillSystem), nameof(SkillSystem.DamageObject))] [HarmonyPatch(typeof(SkillSystem), nameof(SkillSystem.DamageObject))]
private static void SkillSystem_DamageObject_Prefix(ref int damage, ref SkillTarget target) private static IEnumerable<CodeInstruction> SkillSystem_DamageObject_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator, MethodBase __originalMethod)
{ {
if (target.type == ETargetType.Craft) damage = 0; var matcher = new CodeMatcher(instructions, generator);
matcher.MatchForward(false,
new CodeMatch(ci => ci.IsLdarg()),
new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(SkillTargetLocal), nameof(SkillTargetLocal.type))),
new CodeMatch(OpCodes.Ldc_I4_6),
new CodeMatch(ci => ci.opcode == OpCodes.Bne_Un || ci.opcode == OpCodes.Bne_Un_S)
);
matcher.Repeat(m => m.Advance(4).InsertAndAdvance(
new CodeInstruction(OpCodes.Ldc_I4_0),
new CodeInstruction(OpCodes.Starg_S, __originalMethod.Name == "DamageObject" ? 1 : 2)
));
return matcher.InstructionEnumeration();
} }
} }
+1 -3
View File
@@ -75,8 +75,7 @@
* Keep the highest-production shells and remove the others * Keep the highest-production shells and remove the others
* Duplicate the highest-production shells with a configurable shell count * Duplicate the highest-production shells with a configurable shell count
* Mecha/Combat: * Mecha/Combat:
* Mecha and Drones/Fleets invincible * Mecha and Drones/Fleets invicible
* Protects mecha HP and energy shields, ground combat drones, and space fleets, including when enabled during combat.
* Buildings invicible * Buildings invicible
* Enable warp without space warpers * Enable warp without space warpers
* Teleport to outer space * Teleport to outer space
@@ -181,7 +180,6 @@ The item icon selects the output; no hotkey is needed.
* 从发电量最高的壳复制戴森壳,可设置壳面数量 * 从发电量最高的壳复制戴森壳,可设置壳面数量
* 机甲/战斗: * 机甲/战斗:
* 机甲和战斗无人机无敌 * 机甲和战斗无人机无敌
* 保护机甲耐久度和能量护盾、地面战斗无人机和太空编队,战斗中开启同样生效。
* 建筑无敌 * 建筑无敌
* 无需空间翘曲器即可曲速飞行 * 无需空间翘曲器即可曲速飞行
* 传送到外太空 * 传送到外太空
+2 -6
View File
@@ -4,15 +4,13 @@
## Changlog ## Changlog
* 1.6.4 * 1.6.4
* `Blueprint descriptions`: Align `Auto-fill` with the description title while reserving space for the native icon button. Generation options follow the entry while scrolling and adjust at screen edges, with extra title padding, compact checkbox spacing, and text sized for the current language. Use a standard rectangular dropdown that overlays the footer without resizing the panel or moving its single `Generate` action. Close with the native X, an outside click, or Esc; Esc first closes an expanded list. Preserve the native inspector layout.
* `Hide battle-related techs in Peace mode`: Fix an array index error when opening the tech tree after switching from a Peace-mode save to a Combat-mode save in the same game process, including when disabling the option after loading another Peace-mode save. * `Hide battle-related techs in Peace mode`: Fix an array index error when opening the tech tree after switching from a Peace-mode save to a Combat-mode save in the same game process, including when disabling the option after loading another Peace-mode save.
* 1.6.3 * 1.6.3
* `Quick build Mining Machines`: * `Quick build Mining Machines`:
* Add a Factory-tab button to arrange ordinary Mining Machines densely around the nearest solid vein group. Each miner covers at least 3 nodes from that group, without including nearby groups. Layouts are not limited by stock; missing miners remain as ghosts awaiting materials. Placement respects construction range and does not include belts or power facilities. Click again to cancel a search. * Add a Factory-tab button to arrange ordinary Mining Machines densely around the nearest solid vein group. Each miner covers at least 3 nodes from that group, without including nearby groups. Layouts are not limited by stock; missing miners remain as ghosts awaiting materials. Placement respects construction range and does not include belts or power facilities. Click again to cancel a search.
* `Allow restoring/burying veins` is off by default, using only visible nodes without restoring or burying any. Enable it to restore unobstructed nodes away from Dark Fog Planetary Bases and allow unused nodes to be buried for better coverage. Nodes used by existing miners or miner ghosts are protected. * `Allow restoring/burying veins` is off by default, using only visible nodes without restoring or burying any. Enable it to restore unobstructed nodes away from Dark Fog Planetary Bases and allow unused nodes to be buried for better coverage. Nodes used by existing miners or miner ghosts are protected.
* `Blueprint descriptions`: * `Blueprint descriptions`:
* Add an `Auto-fill` entry to the native description header in the blueprint browser, copy, and paste inspectors. It opens generation options without moving native fields or covering the file list. Generation replaces the main description with material flows per minute, separating shortages, surpluses, inputs, outputs, and research use, and adds factory and logistics power demand to a `Power` custom field. * Add `Auto-fill description` to the blueprint browser, copy, and paste panels. It replaces the main description with full-load material flows per minute, separating shortages, surpluses, inputs, outputs, and research use, and adds factory and logistics power demand to a `Power` custom field.
* Choose `Final-product output` (the default on opening the inspector) to retain rated final outputs and show intermediate shortages and excess, or `Lowest intermediate throughput` to scale the final-product mix to the bottleneck using recipe ratios. Complete, balanceable chains have no internal shortages in the latter mode; unused intermediate capacity appears as excess. External inputs use the selected basis; power still covers every selected building at full load. If a balanced basis cannot be determined, the original description is kept.
* A `Proliferation` checkbox controls whether calculations include proliferation, defaulting to on when the blueprint contains a Spray Coater. Large rates use K/M/G where display precision is preserved, and numbers with four or more integer digits use comma thousands separators, including before suffixes; unknown values are marked separately. Other custom fields are preserved, and the blueprint still needs to be saved manually. * A `Proliferation` checkbox controls whether calculations include proliferation, defaulting to on when the blueprint contains a Spray Coater. Large rates use K/M/G where display precision is preserved, and numbers with four or more integer digits use comma thousands separators, including before suffixes; unknown values are marked separately. Other custom fields are preserved, and the blueprint still needs to be saved manually.
* `Sunlight at night`: Lighting now follows the camera, including planet view, and stays consistent across buildings, terrain, solar panels, and belts. Restore lighting correctly after switching planets, and return to native lighting when sailing, disabling the feature, or using white rendering mode. * `Sunlight at night`: Lighting now follows the camera, including planet view, and stays consistent across buildings, terrain, solar panels, and belts. Restore lighting correctly after switching planets, and return to native lighting when sailing, disabling the feature, or using white rendering mode.
* `Protect veins from exhaustion`: Fix the option failing to take effect in 1.6.2, restoring protection of configured vein reserves and minimum oil rates, along with the corresponding mining statistics. * `Protect veins from exhaustion`: Fix the option failing to take effect in 1.6.2, restoring protection of configured vein reserves and minimum oil rates, along with the corresponding mining statistics.
@@ -448,15 +446,13 @@
## 更新日志 ## 更新日志
* 1.6.4 * 1.6.4
* `蓝图说明`:「自动填写」入口与说明标题的文字基线对齐,并为原生图标按钮保留空间。生成选项滚动时跟随入口,在屏幕边缘调整位置;标题保留边距,复选框间距紧凑,文字尺寸适应当前语言。使用原生直边下拉框,展开时覆盖底部操作区域,面板尺寸和单个「生成说明」按钮的位置保持不变。可通过原生叉号、点击外部或 Esc 关闭;下拉列表展开时,Esc 先收起列表。保留原生检查面板布局。
* `在和平模式下隐藏战斗相关科技`:修复在同一次游戏运行中从和平模式存档切换到战斗模式存档后打开科技树时的数组越界,以及再次加载和平模式存档后关闭选项时的同类问题。 * `在和平模式下隐藏战斗相关科技`:修复在同一次游戏运行中从和平模式存档切换到战斗模式存档后打开科技树时的数组越界,以及再次加载和平模式存档后关闭选项时的同类问题。
* 1.6.3 * 1.6.3
* `快速铺设采矿机`: * `快速铺设采矿机`:
* 在「工厂」页增加按钮,自动在最近的固体矿脉周围密集铺设普通采矿机。每台至少覆盖选中矿脉的 3 个矿点,不混入附近其他矿脉。布局数量不受库存限制,采矿机不足的位置保留待建造虚影。遵守建造范围,不自动铺设传送带和电力设施。计算期间再次点击可取消。 * 在「工厂」页增加按钮,自动在最近的固体矿脉周围密集铺设普通采矿机。每台至少覆盖选中矿脉的 3 个矿点,不混入附近其他矿脉。布局数量不受库存限制,采矿机不足的位置保留待建造虚影。遵守建造范围,不自动铺设传送带和电力设施。计算期间再次点击可取消。
* 「允许恢复/掩埋矿物」默认关闭,仅使用可见矿点,不恢复或掩埋矿点。开启后可恢复未被建筑阻挡、且远离黑雾行星基地的矿点,并允许掩埋未使用的矿点来提高覆盖数;已有矿机和待建造矿机使用的矿点会受到保护。 * 「允许恢复/掩埋矿物」默认关闭,仅使用可见矿点,不恢复或掩埋矿点。开启后可恢复未被建筑阻挡、且远离黑雾行星基地的矿点,并允许掩埋未使用的矿点来提高覆盖数;已有矿机和待建造矿机使用的矿点会受到保护。
* `蓝图说明`: * `蓝图说明`:
* 在蓝图浏览、复制和粘贴检查面板的说明标题行增加「自动填写」入口,点击展开生成选项,不移动原生字段或遮挡文件列表。生成时用每分钟的物料流量替换原说明,分别列出「缺少」「多余」「输入」「输出」「研究」,并将工厂与物流耗电写入「耗电」自定义字段。 * 在蓝图浏览、复制和粘贴界面增加「自动填写说明」按钮,用满负荷运行时每分钟的物料流量替换原说明,分别列出「缺少」「多余」「输入」「输出」「研究」,并将工厂与物流耗电写入「耗电」自定义字段。
* 可选择「最终产物产量」(每次打开检查面板时的默认值),保留最终产物的额定产量并显示中间产物的缺口和余量;也可选择「最低产量中间产物」,按配方比例换算瓶颈,等比例缩放各最终产物。后一种模式下,数据完整且可平衡的生产链没有内部缺口,未使用的中间产能列为「多余」。外部输入采用所选基准,耗电仍按所选全部建筑满载估算。无法确定平衡基准时保留原说明。
* 可用「增产」复选框选择是否计入增产效果,蓝图含喷涂机时默认勾选。较大的流量在保留显示精度的前提下使用 K/M/G 单位;整数部分达到四位的数字用逗号每三位分隔,带单位时也适用。无法计算的数值单独标注。保留其他自定义字段,填写后仍需手动保存蓝图。 * 可用「增产」复选框选择是否计入增产效果,蓝图含喷涂机时默认勾选。较大的流量在保留显示精度的前提下使用 K/M/G 单位;整数部分达到四位的数字用逗号每三位分隔,带单位时也适用。无法计算的数值单独标注。保留其他自定义字段,填写后仍需手动保存蓝图。
* `夜间日光灯`:光照改为随镜头变化,行星视图也适用;建筑、地表、太阳能板和传送带的光照方向保持一致。切换行星后正确恢复光照,航行、关闭功能或进入白模渲染时恢复原版光照。 * `夜间日光灯`:光照改为随镜头变化,行星视图也适用;建筑、地表、太阳能板和传送带的光照方向保持一致。切换行星后正确恢复光照,航行、关闭功能或进入白模渲染时恢复原版光照。
* `保护矿脉不会枯竭`:修复 1.6.2 中开启后仍不生效的问题,恢复设定的矿脉剩余量、油井最低流速保护及相应开采统计。 * `保护矿脉不会枯竭`:修复 1.6.2 中开启后仍不生效的问题,恢复设定的矿脉剩余量、油井最低流速保护及相应开采统计。
-21
View File
@@ -6,15 +6,7 @@ public static class I18NKeys
{ {
public const string Unknown = "Unknown"; public const string Unknown = "Unknown";
public const string BlueprintAutoFillDescription = "UXAssist Blueprint Auto-fill description"; public const string BlueprintAutoFillDescription = "UXAssist Blueprint Auto-fill description";
public const string BlueprintGenerateDescription = "UXAssist Blueprint Generate Description";
public const string BlueprintDescriptionOptions = "UXAssist Blueprint Description Options";
public const string BlueprintDescriptionOptionsTip = "UXAssist Blueprint Description Options Tip";
public const string BlueprintProliferation = "UXAssist Blueprint Proliferation"; public const string BlueprintProliferation = "UXAssist Blueprint Proliferation";
public const string BlueprintProductionBasis = "UXAssist Blueprint Production Basis";
public const string BlueprintFinalProducts = "UXAssist Blueprint Final Products";
public const string BlueprintBottleneckIntermediate = "UXAssist Blueprint Bottleneck Intermediate";
public const string BlueprintProductionBasisTip = "UXAssist Blueprint Production Basis Tip";
public const string BlueprintBasisUnavailable = "Cannot determine a balanced intermediate throughput. Check building settings and production-chain outputs, or use final-product output.";
public const string BlueprintPower = "UXAssist Blueprint Power"; public const string BlueprintPower = "UXAssist Blueprint Power";
public const string BlueprintPowerEnglish = "Power"; public const string BlueprintPowerEnglish = "Power";
public const string BlueprintPowerChinese = "耗电"; public const string BlueprintPowerChinese = "耗电";
@@ -245,20 +237,7 @@ public static class I18NKeys
{ {
I18N.Add(Unknown, "Unknown", "未知"); I18N.Add(Unknown, "Unknown", "未知");
I18N.Add(BlueprintAutoFillDescription, "Auto-fill description", "自动填写说明"); I18N.Add(BlueprintAutoFillDescription, "Auto-fill description", "自动填写说明");
I18N.Add(BlueprintGenerateDescription, "Generate", "生成说明");
I18N.Add(BlueprintDescriptionOptions, "Auto-fill…", "自动填写…");
I18N.Add(BlueprintDescriptionOptionsTip,
"Choose production basis and proliferation, then fill the blueprint description.",
"选择产量基准和增产后,自动填写蓝图说明。");
I18N.Add(BlueprintProliferation, "Proliferation", "增产"); I18N.Add(BlueprintProliferation, "Proliferation", "增产");
I18N.Add(BlueprintProductionBasis, "Production basis", "产量基准");
I18N.Add(BlueprintFinalProducts, "Final-product output", "最终产物产量");
I18N.Add(BlueprintBottleneckIntermediate, "Lowest intermediate throughput", "最低产量中间产物");
I18N.Add(BlueprintProductionBasisTip,
"Final-product output (default): keep rated final outputs and show intermediate shortages and excess.\nLowest intermediate throughput: convert capacities through recipe ratios and scale all final outputs together to the bottleneck; complete, balanceable chains have no internal shortages. Excess shows unused intermediate capacity. Power still sizes all selected buildings at full load.\nUnknown settings or an unresolved output prevent balanced generation; the existing description is kept.",
"最终产物产量(默认):保留最终产物的额定产量,显示中间产物的缺口和余量。\n最低产量中间产物:按配方比例换算产能,以瓶颈等比例缩放各最终产物;数据完整且可平衡时没有内部缺口,「多余」表示未使用的中间产能。耗电仍按所选全部建筑满载估算。\n缺少参数或无法确定输出时,不生成平衡说明,保留原说明。");
I18N.Add(BlueprintBasisUnavailable, BlueprintBasisUnavailable,
"无法确定可平衡的中间产物产量,原说明已保留。请检查建筑参数和生产链输出,或改用最终产物产量基准。");
I18N.Add(BlueprintPower, BlueprintPowerEnglish, BlueprintPowerChinese); I18N.Add(BlueprintPower, BlueprintPowerEnglish, BlueprintPowerChinese);
I18N.Add(BlueprintInputLine, "Input: ", "输入:"); I18N.Add(BlueprintInputLine, "Input: ", "输入:");
I18N.Add(BlueprintOutputLine, "Output: ", "输出:"); I18N.Add(BlueprintOutputLine, "Output: ", "输出:");
+50 -328
View File
@@ -70,12 +70,6 @@ public class BlueprintDescriptionPatch : PatchImpl<BlueprintDescriptionPatch>
} }
} }
[HarmonyPostfix, HarmonyPatch(typeof(UIBlueprintInspector), nameof(UIBlueprintInspector._OnUpdate))]
private static void OnUpdate(UIBlueprintInspector __instance)
{
if (Inspectors.TryGetValue(__instance, out var controls)) controls.HandleInput();
}
[HarmonyPostfix, HarmonyPatch(typeof(UIBlueprintInspector), nameof(UIBlueprintInspector.OnLanguageChanged))] [HarmonyPostfix, HarmonyPatch(typeof(UIBlueprintInspector), nameof(UIBlueprintInspector.OnLanguageChanged))]
private static void OnLanguageChanged(UIBlueprintInspector __instance) private static void OnLanguageChanged(UIBlueprintInspector __instance)
{ {
@@ -108,134 +102,38 @@ public class BlueprintDescriptionPatch : PatchImpl<BlueprintDescriptionPatch>
private sealed class InspectorControls private sealed class InspectorControls
{ {
private const float Left = 12f; private const float Left = 22f;
private const float ControlsGap = 6f; private const float ControlsGap = 12f;
private readonly UIBlueprintInspector _inspector; private readonly UIBlueprintInspector _inspector;
private RectTransform _panel; private readonly float _controlsHeight;
private UIButton _entry;
private Text _entryText;
private UIButton _button; private UIButton _button;
private Text _buttonText; private Text _buttonText;
private UIButton _closeButton;
private Text _title;
private readonly Vector3[] _corners = new Vector3[4];
private readonly Canvas _canvas;
private readonly RectTransform _viewport;
private readonly Text _descriptionLabel;
private readonly RectTransform _descriptionIcon;
private bool _optionsOpen;
private MyCheckBox _checkbox; private MyCheckBox _checkbox;
private UIComboBox _basisCombo;
private Text _basisLabel;
private UIButton _basisHelp;
private BlueprintData _currentBlueprint; private BlueprintData _currentBlueprint;
private bool _manualProliferation; private bool _manualProliferation;
private bool _layoutApplied;
public InspectorControls(UIBlueprintInspector inspector) public InspectorControls(UIBlueprintInspector inspector)
{ {
_inspector = inspector; _inspector = inspector;
_canvas = inspector.rectTrans.GetComponentInParent<Canvas>().rootCanvas;
_viewport = inspector.descGroupTrans.GetComponentInParent<ScrollRect>()?.viewport;
_descriptionLabel = inspector.descGroupTrans.Find("label").GetComponent<Text>();
_descriptionIcon = (RectTransform)inspector.descTextInput.transform.Find("sel-icon-btn");
try try
{ {
// The native description has a 22px title row above its editable text. _button = LayoutHelper.AddButton(Left, 0, inspector.group1,
_entry = LayoutHelper.AddButton(0, 0, inspector.descGroupTrans, I18NKeys.BlueprintAutoFillDescription, 15, "blueprint-auto-fill-description", Generate);
I18NKeys.BlueprintDescriptionOptions, 12, "blueprint-description-options", ToggleOptions);
_entryText = _entry.transform.Find("button-text").GetComponent<Text>();
_entry.tips = inspector.tipButton2.tips;
_entry.tips.topLevel = true;
_entryText.resizeTextForBestFit = false;
Util.NormalizeRectWithMargin(_entryText, 0, 8, 0, 8);
// Reuse the native background, including its blur material, only while options are open.
var source = UIRoot.instance.uiGame.inserterWindow.transform.Find("panel-bg").GetComponent<Image>();
_panel = UnityEngine.Object.Instantiate(source, inspector.rectTrans).rectTransform;
_panel.gameObject.name = "uxassist-blueprint-description-options";
_panel.gameObject.SetActive(false);
for (var i = _panel.childCount - 1; i >= 0; i--)
{
var child = _panel.GetChild(i).gameObject;
child.SetActive(false);
UnityEngine.Object.Destroy(child);
}
_panel.anchorMin = _panel.anchorMax = new Vector2(0, 1);
_panel.pivot = new Vector2(0, 1);
_panel.GetComponent<Image>().raycastTarget = true;
_title = LayoutHelper.AddText(Left, 10, _panel, I18NKeys.BlueprintAutoFillDescription, 16);
_title.color = _entryText.color;
var closeSource = UIRoot.instance.uiGame.inserterWindow.transform
.Find("panel-bg/btn-box/close-wnd-btn").GetComponent<UIButton>();
_closeButton = UnityEngine.Object.Instantiate(closeSource, _panel);
Util.ResetButton(_closeButton);
// The source's persistent callback closes the original inserter window.
_closeButton.button.onClick = new Button.ButtonClickedEvent();
_closeButton.button.onClick.AddListener(CloseOptions);
Util.NormalizeRectWithTopRight(_closeButton, 0, 0, _panel);
_button = LayoutHelper.AddButton(0, 0, _panel,
I18NKeys.BlueprintGenerateDescription, 15, "blueprint-auto-fill-description", Generate);
_buttonText = _button.transform.Find("button-text").GetComponent<Text>(); _buttonText = _button.transform.Find("button-text").GetComponent<Text>();
_buttonText.resizeTextForBestFit = false; _checkbox = MyCheckBox.CreateCheckBox(Left, 0, inspector.group1, false,
_buttonText.alignment = TextAnchor.MiddleCenter; I18NKeys.BlueprintProliferation.Translate(), 15).WithSmallerBox(22f);
Util.NormalizeRectWithMargin(_buttonText, 4, 10, 4, 10);
_checkbox = MyCheckBox.CreateCheckBox(Left, 42, _panel, false,
I18NKeys.BlueprintProliferation.Translate(), 15);
_checkbox.rectTrans.sizeDelta = new Vector2(20, 20);
_checkbox.checkImage.rectTransform.sizeDelta = new Vector2(20, 20);
_checkbox.labelText.verticalOverflow = VerticalWrapMode.Overflow;
_checkbox.gameObject.name = "blueprint-proliferation"; _checkbox.gameObject.name = "blueprint-proliferation";
_checkbox.OnChecked += OnProliferationChecked; _checkbox.OnChecked += OnProliferationChecked;
_basisLabel = LayoutHelper.AddText(Left, 68, _panel, I18NKeys.BlueprintProductionBasis, 14);
_basisCombo = UnityEngine.Object.Instantiate(UIRoot.instance.optionWindow.resolutionComp, _panel);
_basisCombo.gameObject.name = "blueprint-production-basis";
_basisCombo.gameObject.SetActive(true);
foreach (var button in _basisCombo.GetComponentsInChildren<UIButton>(true)) Util.ResetButton(button);
var combo = _basisCombo;
// Runtime resolution rows are cloned as children, but their private tracking list is not serialized.
for (var i = combo.m_DropDownContent.childCount - 1; i >= 0; i--)
{
var button = combo.m_DropDownContent.GetChild(i).GetComponent<Button>();
if (!button || button == combo.m_ListItemRes) continue;
button.gameObject.SetActive(false);
UnityEngine.Object.Destroy(button.gameObject);
}
combo.ItemButtons.Clear();
combo.Items.Clear();
combo.onSubmit = new UIComboBox.SubmitEvent();
combo.onItemIndexChange = new UIComboBox.ChangeEvent();
combo.CanInput = false;
combo.autoWidth = false;
combo.parentSibling = false;
combo.itemIndex = -1;
combo.isDroppedDown = false;
combo.m_DropDownContent.anchoredPosition = Vector2.zero;
combo.m_DropDownList.gameObject.SetActive(false);
combo.m_EmptyItemRes.gameObject.SetActive(false);
combo.m_SelectionBG.gameObject.SetActive(false);
combo.m_Scrollbar.gameObject.SetActive(false);
Util.NormalizeRectWithMargin(_basisCombo.transform.Find("Main Button"), 0, 0, 0, 0);
combo.m_Text.alignment = TextAnchor.MiddleLeft;
combo.m_Text.fontSize = 14;
combo.m_Text.resizeTextForBestFit = false;
combo.m_Text.horizontalOverflow = HorizontalWrapMode.Overflow;
combo.m_Text.verticalOverflow = VerticalWrapMode.Overflow;
Util.NormalizeRectWithMargin(combo.m_Text, 2, 8, 2, 30);
var itemText = combo.m_ListItemRes.GetComponentInChildren<Text>();
itemText.alignment = TextAnchor.MiddleLeft;
itemText.fontSize = 14;
itemText.resizeTextForBestFit = false;
itemText.horizontalOverflow = HorizontalWrapMode.Overflow;
itemText.verticalOverflow = VerticalWrapMode.Overflow;
Util.NormalizeRectWithMargin(itemText, 2, 8, 2, 8);
_basisHelp = LayoutHelper.AddTipsButton(Left, 68, _panel,
I18NKeys.BlueprintProductionBasis.Translate(), I18NKeys.BlueprintProductionBasisTip.Translate(), "");
UpdateLabels(); UpdateLabels();
_controlsHeight = Math.Max(_button.transform.GetComponent<RectTransform>().rect.height,
_checkbox.rectTrans.rect.height) + 10f;
} }
catch catch
{ {
Destroy(); if (_button) UnityEngine.Object.Destroy(_button.gameObject);
if (_checkbox) UnityEngine.Object.Destroy(_checkbox.gameObject);
throw; throw;
} }
} }
@@ -244,232 +142,65 @@ public class BlueprintDescriptionPatch : PatchImpl<BlueprintDescriptionPatch>
{ {
_currentBlueprint = null; _currentBlueprint = null;
_manualProliferation = false; _manualProliferation = false;
_basisCombo.itemIndex = 0;
if (_inspector.blueprint != null) SyncDefault(); if (_inspector.blueprint != null) SyncDefault();
else _checkbox.Checked = false; else _checkbox.Checked = false;
CloseOptions();
UpdateLabels();
} }
public void Refresh() public void Refresh()
{ {
SyncDefault(); SyncDefault();
PositionEntry(); if (!_layoutApplied)
} _inspector.group1.anchoredPosition += new Vector2(0, -_controlsHeight);
PositionControls();
private void ToggleOptions() _inspector.group2.anchoredPosition += new Vector2(0, -_controlsHeight);
{ _inspector.group3.anchoredPosition += new Vector2(0, -_controlsHeight);
if (_optionsOpen) _inspector.group4.anchoredPosition += new Vector2(0, -_controlsHeight);
{ _inspector.contentTrans.sizeDelta += new Vector2(0, _controlsHeight);
CloseOptions(); _layoutApplied = true;
return;
}
_optionsOpen = true;
_panel.SetAsLastSibling();
_panel.gameObject.SetActive(true);
PositionOptions();
if (_optionsOpen) Canvas.willRenderCanvases += PositionOptions;
}
private void CloseOptions()
{
Canvas.willRenderCanvases -= PositionOptions;
_optionsOpen = false;
if (_panel) _panel.gameObject.SetActive(false);
}
public void HandleInput()
{
PositionEntry();
if (!_optionsOpen) return;
var combo = _basisCombo;
if (VFInput.escape)
{
if (combo.isDroppedDown)
{
combo.isDroppedDown = false;
combo.m_DropDownList.gameObject.SetActive(false);
}
else CloseOptions();
VFInput.UseEscape();
return;
}
if (!Input.GetMouseButtonDown(0) && !Input.GetMouseButtonDown(1) && !Input.GetMouseButtonDown(2)) return;
var mouse = (Vector2)Input.mousePosition;
if (RectTransformUtility.RectangleContainsScreenPoint(_panel, mouse, _canvas.worldCamera) ||
RectTransformUtility.RectangleContainsScreenPoint((RectTransform)_entry.transform, mouse, _canvas.worldCamera) ||
combo.isDroppedDown && RectTransformUtility.RectangleContainsScreenPoint(combo.m_DropDownList, mouse, _canvas.worldCamera))
return;
CloseOptions();
}
private Rect BoundsIn(RectTransform rect, Transform parent)
{
rect.GetWorldCorners(_corners);
var min = new Vector2(float.PositiveInfinity, float.PositiveInfinity);
var max = new Vector2(float.NegativeInfinity, float.NegativeInfinity);
foreach (var corner in _corners)
{
var point = parent.InverseTransformPoint(corner);
min = Vector2.Min(min, point);
max = Vector2.Max(max, point);
}
return Rect.MinMaxRect(min.x, min.y, max.x, max.y);
}
private void PositionEntry()
{
var parent = _inspector.descGroupTrans;
var label = BoundsIn(_descriptionLabel.rectTransform, parent);
var labelWidth = parent.InverseTransformVector(_descriptionLabel.transform.TransformVector(
new Vector3(Util.GetPreferredWidth(_descriptionLabel), 0, 0))).x;
var left = label.xMin + labelWidth + 8;
var right = Math.Min(parent.rect.xMax, BoundsIn(_descriptionIcon, parent).xMin) - 8;
var entryRect = (RectTransform)_entry.transform;
var visible = _inspector.blueprint != null && left + entryRect.rect.width <= right;
_entry.gameObject.SetActive(visible);
if (!visible) return;
Util.NormalizeRectWithTopLeft(_entry, left - parent.rect.xMin,
parent.rect.yMax - label.yMax, parent);
}
private void PositionOptions()
{
if (!_optionsOpen) return;
if (!_entry || !_entry.gameObject.activeInHierarchy)
{
CloseOptions();
return;
}
var anchor = BoundsIn((RectTransform)_entry.transform, _panel.parent);
var screen = BoundsIn((RectTransform)_canvas.transform, _panel.parent);
if (!anchor.Overlaps(screen) || _viewport && !anchor.Overlaps(BoundsIn(_viewport, _panel.parent)))
{
CloseOptions();
return;
}
if (!TryGetPopupPosition(anchor, screen, _panel.sizeDelta, out var position))
{
CloseOptions();
return;
}
var parent = (RectTransform)_panel.parent;
_panel.anchoredPosition = position - new Vector2(parent.rect.xMin, parent.rect.yMax);
}
private static bool TryGetPopupPosition(Rect anchor, Rect screen, Vector2 size, out Vector2 position)
{
const float gap = 6;
const float margin = 8;
position = default;
if (size.x > screen.width - margin * 2 || size.y > screen.height - margin * 2) return false;
var left = Math.Max(screen.xMin + margin,
Math.Min(anchor.xMax - size.x, screen.xMax - margin - size.x));
var top = anchor.yMin - gap;
if (top - size.y < screen.yMin + margin)
top = anchor.yMax + gap + size.y;
top = Math.Min(screen.yMax - margin, Math.Max(screen.yMin + margin + size.y, top));
position = new Vector2(left, top);
return true;
} }
public void UpdateLabels() public void UpdateLabels()
{ {
_entryText.font = _descriptionLabel.font; _buttonText.text = I18NKeys.BlueprintAutoFillDescription.Translate();
_entryText.fontSize = _descriptionLabel.fontSize;
_entryText.fontStyle = _descriptionLabel.fontStyle;
_entryText.lineSpacing = _descriptionLabel.lineSpacing;
_entryText.alignment = _descriptionLabel.alignment;
_entryText.text = I18NKeys.BlueprintDescriptionOptions.Translate();
((RectTransform)_entry.transform).sizeDelta =
new Vector2(Util.GetPreferredWidth(_entryText) + 20, 22);
_entry.tips.tipTitle = I18NKeys.BlueprintAutoFillDescription.Translate();
_entry.tips.tipText = I18NKeys.BlueprintDescriptionOptionsTip.Translate();
_entry.UpdateTip();
_title.text = I18NKeys.BlueprintAutoFillDescription.Translate();
_buttonText.text = I18NKeys.BlueprintGenerateDescription.Translate();
_checkbox.SetLabelText(I18NKeys.BlueprintProliferation.Translate()); _checkbox.SetLabelText(I18NKeys.BlueprintProliferation.Translate());
_basisLabel.text = I18NKeys.BlueprintProductionBasis.Translate(); var width = Math.Max(160f, Util.GetPreferredWidth(_buttonText) + 26f);
var combo = _basisCombo; _button.transform.GetComponent<RectTransform>().sizeDelta =
var index = Math.Max(0, combo.itemIndex); new Vector2(width, _button.transform.GetComponent<RectTransform>().sizeDelta.y);
combo.Items = [I18NKeys.BlueprintFinalProducts.Translate(), I18NKeys.BlueprintBottleneckIntermediate.Translate()]; if (_layoutApplied) PositionControls();
combo.DropDownCount = combo.Items.Count;
_basisHelp.tips.tipTitle = I18NKeys.BlueprintProductionBasis.Translate();
_basisHelp.tips.tipText = I18NKeys.BlueprintProductionBasisTip.Translate();
_basisHelp.UpdateTip();
var image = _panel.GetComponent<Image>();
// Sliced window artwork has transparent borders; content margins start inside its visible fill.
var padding = UnityEngine.Sprites.DataUtility.GetPadding(image.sprite) / image.pixelsPerUnit;
var left = Mathf.Ceil(padding.x) + Left;
var right = Mathf.Ceil(padding.z) + Left;
var top = Mathf.Ceil(padding.w) + 18;
var titleHeight = Math.Max(30, Mathf.Ceil(_title.preferredHeight) + 4);
var titleLeft = left + 12;
Util.NormalizeRectWithTopLeft(_title, titleLeft, top, _panel);
Util.NormalizeRectWithTopRight(_closeButton, right, top, _panel);
var rowTop = top + titleHeight + 8;
var labelHeight = Math.Max(26, Mathf.Ceil(_checkbox.labelText.preferredHeight) + 4);
Util.NormalizeRectWithTopLeft(_checkbox, left, rowTop + (labelHeight - 20) / 2, _panel);
var checkLabel = _checkbox.labelText.rectTransform;
checkLabel.anchorMin = checkLabel.anchorMax = new Vector2(0, 0.5f);
checkLabel.pivot = new Vector2(0, 0.5f);
checkLabel.anchoredPosition = new Vector2(24, 0);
checkLabel.sizeDelta = new Vector2(Util.GetPreferredWidth(_checkbox.labelText) + 4, labelHeight);
rowTop += labelHeight + 8;
var labelWidth = Util.GetPreferredWidth(_basisLabel);
var itemText = combo.m_ListItemRes.GetComponentInChildren<Text>();
var comboWidth = 180f;
var textHeight = 0f;
foreach (var item in combo.Items)
{
combo.m_Text.text = item;
itemText.text = item;
comboWidth = Math.Max(comboWidth, Util.GetPreferredWidth(combo.m_Text) + 42);
textHeight = Math.Max(textHeight, Math.Max(combo.m_Text.preferredHeight, itemText.preferredHeight));
}
combo.itemIndex = index;
combo.ItemHeight = (int)Math.Max(24, Mathf.Ceil(textHeight) + 4);
var rowHeight = Math.Max(28, Math.Max(Mathf.Ceil(_basisLabel.preferredHeight), Mathf.Ceil(textHeight)) + 4);
Util.NormalizeRectWithTopLeft(_basisLabel, left, rowTop, _panel);
_basisLabel.rectTransform.sizeDelta = new Vector2(labelWidth, rowHeight);
var helpRect = (RectTransform)_basisHelp.transform;
Util.NormalizeRectWithTopLeft(_basisHelp, left + labelWidth + ControlsGap,
rowTop + (rowHeight - helpRect.rect.height) / 2, _panel);
var comboLeft = left + labelWidth + ControlsGap + helpRect.rect.width + ControlsGap;
Util.NormalizeRectWithTopLeft(_basisCombo, comboLeft, rowTop, _panel);
var comboRect = (RectTransform)_basisCombo.transform;
comboRect.sizeDelta = new Vector2(comboWidth, rowHeight);
var width = Math.Max(90f, Util.GetPreferredWidth(_buttonText) + 20);
((RectTransform)_button.transform).sizeDelta = new Vector2(width,
Math.Max(30, Mathf.Ceil(_buttonText.preferredHeight) + 8));
var popupWidth = Math.Max(320, Math.Max(comboLeft + comboWidth + right,
Util.GetPreferredWidth(_title) + titleLeft + right + 50));
var footerTop = rowTop + rowHeight + 16;
var bottom = Mathf.Ceil(padding.y) + Left;
_panel.sizeDelta = new Vector2(popupWidth, footerTop + ((RectTransform)_button.transform).rect.height + bottom);
Util.NormalizeRectWithTopRight(_button, right, footerTop, _panel);
_title.rectTransform.sizeDelta = new Vector2(popupWidth - titleLeft - right - 50, titleHeight);
PositionEntry();
PositionOptions();
} }
public void Destroy() public void Destroy()
{ {
CloseOptions(); if (_layoutApplied && _inspector)
if (_entry)
{ {
_entry.button.onClick.RemoveListener(ToggleOptions); _inspector.group1.anchoredPosition += new Vector2(0, _controlsHeight);
UnityEngine.Object.Destroy(_entry.gameObject); _inspector.group2.anchoredPosition += new Vector2(0, _controlsHeight);
_inspector.group3.anchoredPosition += new Vector2(0, _controlsHeight);
_inspector.group4.anchoredPosition += new Vector2(0, _controlsHeight);
_inspector.contentTrans.sizeDelta += new Vector2(0, -_controlsHeight);
_layoutApplied = false;
} }
if (_button) if (_button)
{
_button.button.onClick.RemoveListener(Generate); _button.button.onClick.RemoveListener(Generate);
if (_closeButton) UnityEngine.Object.Destroy(_button.gameObject);
_closeButton.button.onClick.RemoveListener(CloseOptions); }
if (_checkbox) if (_checkbox)
{
_checkbox.OnChecked -= OnProliferationChecked; _checkbox.OnChecked -= OnProliferationChecked;
if (!_panel) return; UnityEngine.Object.Destroy(_checkbox.gameObject);
_panel.gameObject.SetActive(false); }
UnityEngine.Object.Destroy(_panel.gameObject); }
private void PositionControls()
{
var buttonRect = _button.transform.GetComponent<RectTransform>();
var top = 4f - _controlsHeight;
Util.NormalizeRectWithTopLeft(_button, Left, top, _inspector.group1);
Util.NormalizeRectWithTopLeft(_checkbox, Left + buttonRect.rect.width + ControlsGap,
top + (buttonRect.rect.height - _checkbox.rectTrans.rect.height) / 2f, _inspector.group1);
} }
private void SyncDefault() private void SyncDefault()
@@ -477,7 +208,6 @@ public class BlueprintDescriptionPatch : PatchImpl<BlueprintDescriptionPatch>
var blueprint = _inspector.blueprint; var blueprint = _inspector.blueprint;
if (!ReferenceEquals(blueprint, _currentBlueprint)) if (!ReferenceEquals(blueprint, _currentBlueprint))
{ {
CloseOptions();
_currentBlueprint = blueprint; _currentBlueprint = blueprint;
_manualProliferation = false; _manualProliferation = false;
} }
@@ -536,14 +266,7 @@ public class BlueprintDescriptionPatch : PatchImpl<BlueprintDescriptionPatch>
return; return;
} }
var request = capture.CreateRequest(_checkbox.Checked); var report = new FactoryBlackBoxAnalyzer(catalog).Analyze(capture.CreateRequest(_checkbox.Checked));
request.ProductionBasis = (BlueprintProductionBasis)_basisCombo.itemIndex;
var report = new FactoryBlackBoxAnalyzer(catalog).Analyze(request);
if (report.Diagnostics.Any(diagnostic => diagnostic.Code == ProductionDiagnosticCode.BlueprintBasisUnavailable))
{
UIRealtimeTip.Popup(I18NKeys.BlueprintBasisUnavailable.Translate());
return;
}
if (report.Status == ProductionStatus.Failed || report.Status == ProductionStatus.DataNotReady) if (report.Status == ProductionStatus.Failed || report.Status == ProductionStatus.DataNotReady)
{ {
UIRealtimeTip.Popup((report.Status == ProductionStatus.DataNotReady UIRealtimeTip.Popup((report.Status == ProductionStatus.DataNotReady
@@ -597,7 +320,6 @@ public class BlueprintDescriptionPatch : PatchImpl<BlueprintDescriptionPatch>
throw; throw;
} }
CloseOptions();
if (!report.MaterialComplete || !report.PowerBreakdown.FactoryComplete || if (!report.MaterialComplete || !report.PowerBreakdown.FactoryComplete ||
!report.PowerBreakdown.LogisticsComplete) !report.PowerBreakdown.LogisticsComplete)
UIRealtimeTip.Popup(I18NKeys.BlueprintPartial.Translate()); UIRealtimeTip.Popup(I18NKeys.BlueprintPartial.Translate());
@@ -1,148 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using static UXAssist.Production.ProductionMath;
namespace UXAssist.Production;
internal static class BlueprintBottleneckBalance
{
private const double Tolerance = 1e-7;
internal static bool TryCalculate(IReadOnlyList<BlackBoxProcessGroup> processes,
IReadOnlyDictionary<int, double> production, IReadOnlyDictionary<int, double> consumption,
ISet<int> researchMatrixSinks,
out SortedDictionary<int, double> balancedProduction, out SortedDictionary<int, double> balancedConsumption,
out IReadOnlyDictionary<int, BlackBoxItemClassification> balancedClassifications,
out IReadOnlyDictionary<int, double> balancedNet)
{
balancedProduction = null;
balancedConsumption = null;
balancedClassifications = null;
balancedNet = null;
if (production.Count == 0 && consumption.Count == 0)
{
balancedProduction = new SortedDictionary<int, double>();
balancedConsumption = new SortedDictionary<int, double>();
balancedClassifications = new Dictionary<int, BlackBoxItemClassification>();
balancedNet = new Dictionary<int, double>();
return true;
}
var groups = processes.GroupBy(process => process.StableKey, StringComparer.Ordinal)
.OrderBy(group => group.Key, StringComparer.Ordinal)
.Select(group => (source: group.First(), count: group.Sum(process => process.Count))).ToArray();
var produced = new HashSet<int>(groups.SelectMany(group => group.source.NetPerBuilding)
.Where(flow => flow.Value > BlackBoxMaterialClassifier.Tolerance).Select(flow => flow.Key));
var consumed = new HashSet<int>(groups.SelectMany(group => group.source.NetPerBuilding)
.Where(flow => flow.Value < -BlackBoxMaterialClassifier.Tolerance).Select(flow => flow.Key));
var items = produced.OrderBy(itemId => itemId).ToArray();
// Normalize only the scale variable; the solver still resolves shared demand, recipe ratios, and cycles together.
var commonScale = items.Where(consumed.Contains).Select(itemId => production[itemId] / consumption[itemId])
.Aggregate(1.0, Math.Min);
var targets = items.Where(itemId => !consumed.Contains(itemId) || researchMatrixSinks.Contains(itemId))
.ToDictionary(itemId => itemId, itemId => Math.Max(0, production[itemId] -
(consumption.TryGetValue(itemId, out var amount) ? amount : 0)));
// Launchers, generators, and precise research can terminate a chain without an item output.
var sinks = Enumerable.Range(0, groups.Length).Where(index =>
groups[index].source.NetPerBuilding.Values.Any(value => value < -BlackBoxMaterialClassifier.Tolerance) &&
!groups[index].source.NetPerBuilding.Values.Any(value => value > BlackBoxMaterialClassifier.Tolerance))
.ToArray();
if (!targets.Values.Any(FinitePositive) && sinks.Length == 0) return false;
var scaleColumn = groups.Length;
var surplusStart = scaleColumn + 1;
var capacitySlackStart = surplusStart + items.Length;
var columnCount = capacitySlackStart + groups.Length + 1;
var matrix = new double[items.Length + groups.Length + 1 + sinks.Length, columnCount];
var rhs = new double[matrix.GetLength(0)];
var maximizeOutput = new double[columnCount];
var minimizeUse = new double[columnCount];
var minimizeSurplus = new double[columnCount];
maximizeOutput[scaleColumn] = -1;
for (var row = 0; row < items.Length; row++)
{
var itemId = items[row];
var rowScale = Math.Max(production[itemId], consumption.TryGetValue(itemId, out var amount) ? amount : 0);
for (var index = 0; index < groups.Length; index++)
if (groups[index].source.NetPerBuilding.TryGetValue(itemId, out var net))
matrix[row, index] = net * groups[index].count / rowScale;
if (targets.TryGetValue(itemId, out var target)) matrix[row, scaleColumn] = -target / rowScale * commonScale;
matrix[row, surplusStart + row] = -1;
minimizeSurplus[surplusStart + row] = 1;
}
for (var index = 0; index <= groups.Length; index++)
{
var row = items.Length + index;
matrix[row, index] = index < groups.Length ? 1 : commonScale;
matrix[row, capacitySlackStart + index] = 1;
rhs[row] = 1;
if (index < groups.Length) minimizeUse[index] = groups[index].count;
}
for (var index = 0; index < sinks.Length; index++)
{
var row = items.Length + groups.Length + 1 + index;
matrix[row, sinks[index]] = 1;
matrix[row, scaleColumn] = -commonScale;
}
var solution = TwoPhaseSimplex.Solve(matrix, rhs,
new[] { maximizeOutput, minimizeUse, minimizeSurplus }, 20000, CancellationToken.None);
if (solution.Status != LinearSolveStatus.Optimal || !FinitePositive(solution.Values[scaleColumn])) return false;
for (var row = 0; row < rhs.Length; row++)
{
var residual = -rhs[row];
for (var column = 0; column < columnCount; column++) residual += matrix[row, column] * solution.Values[column];
if (Math.Abs(residual) > Tolerance) return false;
}
balancedProduction = new SortedDictionary<int, double>(production.ToDictionary(flow => flow.Key, _ => 0.0));
balancedConsumption = new SortedDictionary<int, double>(consumption.ToDictionary(flow => flow.Key, _ => 0.0));
var unusedProduction = new Dictionary<int, double>();
for (var index = 0; index < groups.Length; index++)
{
var group = groups[index];
var utilized = Math.Min(1, solution.Values[index]) * group.count;
var executions = group.source.Process.CyclesPerBuildingPerMinute * utilized;
foreach (var flow in group.source.Process.OutputsPerCycle)
AddFlow(balancedProduction, flow.Key, flow.Value * executions);
foreach (var flow in group.source.Process.InputsPerCycle)
AddFlow(balancedConsumption, flow.Key, flow.Value * executions);
foreach (var flow in group.source.NetPerBuilding)
if (flow.Value > 0) AddFlow(unusedProduction, flow.Key, flow.Value * (group.count - utilized));
}
var netFlows = new Dictionary<int, double>();
var result = new Dictionary<int, BlackBoxItemClassification>();
var allItems = new SortedSet<int>(production.Keys);
allItems.UnionWith(consumption.Keys);
foreach (var itemId in allItems)
{
var grossProduced = balancedProduction.TryGetValue(itemId, out var p) ? p : 0;
var grossConsumed = balancedConsumption.TryGetValue(itemId, out var c) ? c : 0;
var net = grossProduced - grossConsumed;
if (targets.TryGetValue(itemId, out var target))
{
var required = target * solution.Values[scaleColumn] * commonScale;
if (net < required - Tolerance * Math.Max(1, required)) return false;
}
if (Math.Abs(net) <= Tolerance * Math.Max(1, Math.Max(grossProduced, grossConsumed))) net = 0;
netFlows[itemId] = net;
var intermediate = produced.Contains(itemId) && consumed.Contains(itemId);
if (intermediate && net < 0) return false;
var research = researchMatrixSinks.Contains(itemId);
var researchProduct = research && net > 0;
result[itemId] = new BlackBoxItemClassification(produced.Contains(itemId) && !consumed.Contains(itemId) || researchProduct,
researchProduct, 0,
intermediate && !research && unusedProduction.TryGetValue(itemId, out var unused) ? unused : 0,
intermediate && !research ? Math.Max(0, net) : 0);
}
balancedClassifications = result;
balancedNet = netFlows;
return true;
}
}
+2 -28
View File
@@ -31,18 +31,11 @@ public sealed class ProductionBuildingSnapshot
} }
} }
public enum BlueprintProductionBasis
{
FinalProducts,
BottleneckIntermediate
}
public sealed class FactoryBlackBoxRequest public sealed class FactoryBlackBoxRequest
{ {
public List<ProductionBuildingSnapshot> Buildings { get; } = new List<ProductionBuildingSnapshot>(); public List<ProductionBuildingSnapshot> Buildings { get; } = new List<ProductionBuildingSnapshot>();
public List<ProductionDiagnostic> CaptureDiagnostics { get; } = new List<ProductionDiagnostic>(); public List<ProductionDiagnostic> CaptureDiagnostics { get; } = new List<ProductionDiagnostic>();
public bool ProliferationEnabled { get; set; } public bool ProliferationEnabled { get; set; }
public BlueprintProductionBasis ProductionBasis { get; set; }
} }
public sealed class FactoryBlackBoxAnalyzer public sealed class FactoryBlackBoxAnalyzer
@@ -257,27 +250,8 @@ public sealed class FactoryBlackBoxAnalyzer
var matrixSinkItems = hasResearchMatrixSink var matrixSinkItems = hasResearchMatrixSink
? new HashSet<int>(_catalog.ResearchMatrixItemIds) : new HashSet<int>(); ? new HashSet<int>(_catalog.ResearchMatrixItemIds) : new HashSet<int>();
IReadOnlyDictionary<int, BlackBoxItemClassification> classifications = null; var classifications = BlackBoxMaterialClassifier.Classify(processGroups, grossProduction, grossConsumption,
IReadOnlyDictionary<int, double> steadyStateBalance = null; materialComplete, uncertainDemandItems, unknownDemand, matrixSinkItems, out var steadyStateBalance);
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<ProductionItemFlow>(); var flows = new List<ProductionItemFlow>();
var allItems = new SortedSet<int>(grossProduction.Keys); var allItems = new SortedSet<int>(grossProduction.Keys);
allItems.UnionWith(grossConsumption.Keys); allItems.UnionWith(grossConsumption.Keys);
+1 -2
View File
@@ -116,8 +116,7 @@ public enum ProductionDiagnosticCode
Unbounded, Unbounded,
IterationLimit, IterationLimit,
Cancelled, Cancelled,
ConservationFailure, ConservationFailure
BlueprintBasisUnavailable
} }
public sealed class ProductionDiagnostic public sealed class ProductionDiagnostic
+4 -10
View File
@@ -17,11 +17,8 @@
* Strict hotkey dectection for build menu, thus building hotkeys(0~9, F1~F10, X, U) are not triggered while holding Ctrl/Alt/Shift. * Strict hotkey dectection for build menu, thus building hotkeys(0~9, F1~F10, X, U) are not triggered while holding Ctrl/Alt/Shift.
* Fix a bug that warning popup on `Veins Utilization` upgraded to level 8000+ * Fix a bug that warning popup on `Veins Utilization` upgraded to level 8000+
* Sort blueprint structures before saving, to reduce generated blueprint data size a little * Sort blueprint structures before saving, to reduce generated blueprint data size a little
* Add an `Auto-fill` entry to the description header in the blueprint browser, copy, and paste inspectors. Click it to open options beside the entry without moving or resizing native fields; the popup follows the entry while scrolling and adjusts its position at screen edges * Add an `Auto-fill description` button and a `Proliferation` checkbox to the blueprint browser, copy, and paste panels, to fill the description with the blueprint's material flows per minute and its power demand
* The popup has an `Auto-fill description` title, a native X close button, proliferation and production-basis options, and one `Generate` button at the bottom. The dropdown overlays the footer without resizing the popup or moving the action. Close with the X, an outside click, or Esc; when the dropdown is open, Esc closes it first. Successful generation closes the popup. * Replaces the main description with full-load material flows and writes power demand to a `Power` custom field, preserving other custom fields. Proliferation defaults to on when the blueprint contains a Spray Coater. Save the blueprint manually to keep the changes.
* `Production basis` defaults to `Final-product output` each time the inspector opens, retaining rated final outputs and showing intermediate shortages and excess. Choose `Lowest intermediate throughput` to scale the final-product mix together to the bottleneck, using recipe ratios and shared intermediate demand. Complete, balanceable chains then have no internal shortages; unused intermediate capacity appears as excess. External inputs and final outputs use the same basis.
* `Proliferation` defaults to on when the blueprint contains a Spray Coater; it can be changed manually. Power demand still estimates all selected buildings at full load in either production basis.
* Replaces the main description with material flows per minute and writes power demand to a `Power` custom field, preserving other custom fields. If the bottleneck basis cannot be determined, the existing description is kept; check missing building settings and chain outputs, or select `Final-product output`. Save the blueprint manually to keep generated changes.
* Large material rates use the largest exact `K`/`M`/`G` suffix with at most one decimal place; rates that cannot be shortened without losing display precision keep their ordinary format. Numbers with four or more integer digits use comma thousands separators, including before suffixes (for example, `12,345` and `1,234.5K`). * Large material rates use the largest exact `K`/`M`/`G` suffix with at most one decimal place; rates that cannot be shortened without losing display precision keep their ordinary format. Numbers with four or more integer digits use comma thousands separators, including before suffixes (for example, `12,345` and `1,234.5K`).
* Increase maximum count of Metadata Instantiations to 20000 (from 2000) * Increase maximum count of Metadata Instantiations to 20000 (from 2000)
* Increase capacity of player order queue to 128 (from 16) * Increase capacity of player order queue to 128 (from 16)
@@ -226,11 +223,8 @@
* 更严格的建造菜单热键检测,因此在按住Ctrl/Alt/Shift时不再会触发建造热键(0~9, F1~F10, X, U) * 更严格的建造菜单热键检测,因此在按住Ctrl/Alt/Shift时不再会触发建造热键(0~9, F1~F10, X, U)
* 修复了`矿物利用`升级到8000级以上时弹出警告的bug * 修复了`矿物利用`升级到8000级以上时弹出警告的bug
* 保存蓝图前对建筑进行排序,以减少生成的蓝图数据大小 * 保存蓝图前对建筑进行排序,以减少生成的蓝图数据大小
* 在蓝图浏览、复制和粘贴检查面板的说明标题行增加「自动填写」入口,点击后在入口旁打开生成选项,不移动或缩放原生字段;滚动时弹出面板跟随入口,并在屏幕边缘调整位置 * 在蓝图浏览、复制和粘贴界面增加「自动填写说明」按钮和「增产」复选框,用蓝图每分钟的物料流量和耗电自动填写说明
* 面板包含「自动填写说明」标题、原生叉号关闭按钮、增产和产量基准选项,以及底部单个「生成说明」按钮。展开下拉列表时,列表覆盖在底部操作区域前方,面板尺寸和按钮位置保持不变。可通过叉号、点击外部或 Esc 关闭;下拉列表展开时,Esc 先收起列表。生成成功后关闭面板。 * 用满负荷运行时的物料流量替换原说明,将耗电写入「耗电」自定义字段,保留其他自定义字段。蓝图含喷涂机时默认勾选增产。填写后需手动保存蓝图。
* 每次打开检查面板时,「产量基准」默认为「最终产物产量」,保留最终产物的额定产量,并显示中间产物的缺口和余量。选择「最低产量中间产物」后,按配方比例和共享中间物料的需求换算瓶颈,等比例缩放各最终产物。数据完整且可平衡的生产链没有内部缺口,未使用的中间产能列为「多余」;外部输入和最终输出采用同一基准。
* 蓝图含喷涂机时默认勾选「增产」,也可手动修改。两种产量基准均按所选全部建筑满载估算耗电。
* 用每分钟的物料流量替换原说明,将耗电写入「耗电」自定义字段,保留其他自定义字段。无法确定瓶颈基准时保留原说明;可检查缺失的建筑参数和生产链输出,或改选「最终产物产量」。填写后需手动保存蓝图。
* 较大的物料流量使用能精确表示的最大 `K`/`M`/`G` 单位,小数最多一位;无法在保留显示精度的前提下缩写时,保留普通数字格式。整数部分达到四位的数字用逗号每三位分隔,带单位时也适用,例如 `12,345` 和 `1,234.5K`。 * 较大的物料流量使用能精确表示的最大 `K`/`M`/`G` 单位,小数最多一位;无法在保留显示精度的前提下缩写时,保留普通数字格式。整数部分达到四位的数字用逗号每三位分隔,带单位时也适用,例如 `12,345` 和 `1,234.5K`。
* 将元数据提取的最大数量增加到20000(原来为2000) * 将元数据提取的最大数量增加到20000(原来为2000)
* 将玩家指令队列的容量增加到128(原来为16) * 将玩家指令队列的容量增加到128(原来为16)
@@ -1,82 +0,0 @@
# Blueprint Description Validation
This document records the native layout evidence for the UXAssist description-header entry and the checks needed for in-game acceptance. Compilation and managed production checks do not establish compatibility with other blueprint mods.
## Native evidence
Original installed DSP sources, rechecked on 2026-11-05 after discovery through the Steam registry and `steamapps/libraryfolders.vdf`:
- Original assembly: `D:/Steam/steamapps/common/Dyson Sphere Program/DSPGAME_Data/Managed/Assembly-CSharp.dll`, SHA-256 `EF314425DADE51F529F184F07BE136CD3C2660A6A81515603C7226FBE7AB1D8C`.
- Original `UnityEngine.UI.dll`, SHA-256 `C5ACC25EBD597B586D323AF506FB88E760322550940F1A3B0EA4FC8143FCB26C`.
- Native UI assets: `DSPGAME_Data/level0`, SHA-256 `04655A46BBEB113113688BCDC0E0EA8EC5F128B348E32194FC9743ADB48C8E91`.
- The installed version history ends at `0.10.35.29151`; the Steam manifest reports build ID `25955035`. Assembly file version `0.0.0.0` alone does not identify this game build.
Native `UIBlueprintInspector.Refresh` owns description and group sizes, later group positions, and scroll content height. UXAssist positions only its own entry and popup.
The relevant original methods can be reproduced by decompiling the following types from the original assembly:
| Native method | Observed behavior |
| --- | --- |
| `UIBlueprintInspector.Refresh(bool forModify, bool refreshComponent, bool refreshCode, bool loadExistHead = false)` | Controls native group sizes, later group positions, and content height; reloads the main description input only when `forModify` is false. |
| `UIBlueprintInspector._OnOpen()` and `_OnClose()` | Refresh and open native settings for the relevant mode; clear the blueprint on close. |
| `ManualBehaviour._Close()` | Deactivates the inspector GameObject, hiding children. |
| `UIBlueprintInspector.OnCustomFieldEndEdit(string str)` and `CollectExternalFields(int excludeTargetId = -1)` | Collect, escape, and validate pending custom-field edits through the native path. |
| `UIBlueprintInspector.OnCopyClick()`, `OnSaveChangesClick()`, and `OnSaveClick()` | Serialize or save the current blueprint with the game's native workflow. |
The native description input starts 22 pixels below its title. The entry copies the title's font, size, style, line spacing, and alignment, with zero top text inset, while its hit rectangle stays 22 pixels high. It follows the title's measured text width plus 8 pixels and reserves 8 pixels before the actual native icon, including when the icon is inactive. It hides if it cannot fit. The title's 30-pixel Text rectangle must not become the button's hit rectangle, which would extend into the input below. Native labels, inputs, groups, scroll content, and settings retain their layout.
`UIBlueprintInspector.Refresh(forModify: true)` does not reload `descTextInput`. Successful generation must assign both the blueprint description and its input before using the native modification refresh. Pending custom fields must first pass through the native field collection and escaping rules. Native copy and save handlers serialize the current blueprint, so they remain the actions used to share or persist a generated description.
Reinspect the installed original assemblies and assets after a game update; the publicized compile-time references omit method bodies.
## Anchored options and native conventions
The popup uses the entry's world corners, transformed into its parent's coordinates, and actual root-canvas bounds. Placement prefers below the entry with a 6-pixel gap and aligned right edges, flips above when needed, and clamps against an 8-pixel canvas inset. A panel too large for that area is closed. `Canvas.willRenderCanvases` reconciles placement while open. An inactive or fully clipped entry closes its popup.
The panel has a title and native X, proliferation, production basis with help, and one footer `Generate` action. Content insets include the sliced sprite's approximately 13-pixel horizontal and 11-pixel vertical trim before pixels-per-unit conversion. The title has extra left and top clearance from the visible border. The 20-pixel checkbox has an independently sized label with a 4-pixel gap and vertical overflow allowed; label height remains at least 26 pixels or preferred glyph height plus padding. The panel and footer are sized from the form alone. Opening the dropdown overlays the footer without resizing the popup or moving the action.
The X comes from `inserterWindow/panel-bg/btn-box/close-wnd-btn`: a 40-by-30 native button with a centered 16-by-16 icon and a transparent 30-by-19 raycast child. Its original serialized `Button.onClick` targets the original inserter window's `_Close`. The owned clone replaces the entire `Button.ButtonClickedEvent` before adding its popup callback; removing runtime listeners alone would leave that persistent callback active.
The production-basis selector directly clones the standard rectangular `optionWindow.resolutionComp`. Cloned runtime resolution rows are removed and submit/change events are replaced before the two production choices are assigned, so changing the owned selection cannot change native resolution settings. The main caption uses 8-pixel left and 30-pixel right insets; row text uses 8-pixel horizontal insets. Native row selection closes the list, with no extra submit-close handler. The shared combo helper is unchanged.
| Original source | Behavior used by the popup |
| --- | --- |
| `UIRoot._OnUpdate()` and `EscapeInputLogic()` | Give native message boxes Escape priority before the game UI updates. |
| `UIGame._OnUpdate()` | Updates blueprint inspectors before later native picker and function-window Escape handlers. The owned inspector postfix consumes Escape after closing an expanded dropdown or its popup. |
| `UIItemPicker._OnUpdate()` | Tests left, right, and middle clicks outside a screen rectangle using the overlay canvas camera. The owned test also accepts the entry and an open dropdown. |
| `UIPopupMenu.SetState()` | Constrains popup placement to game UI bounds and brings it to the front. |
| Native inserter close-button subtree and combo row event routing | Supply the actual X artwork/hit area and the select-then-close event order. |
Original font, sprite, header, standard-resolution-control, and close-button captures and focused decompilations are retained in the external task evidence under `2026-11-05-UXAssist-BlueprintTextLayout/`, including `standard-controls/`. Native generator rules support keeping glyph height independent of checkbox size; native header captures identify the icon's actual 20-pixel slot. Source analysis and embedded-font calculations do not execute Unity's runtime preferred-size calculation, rasterization, or interaction. Investigation reports remain outside the repository.
## Recorded checks
The placement harness extracts the actual private `TryGetPopupPosition` method and compiles it with data-only `Rect` and `Vector2` substitutes. It checks supplied bounds, including parent transforms, canvas edges, below/above placement, and oversized-panel rejection. This validates the placement calculation, not current text rendering. Run font and sprite analysis against the current source and captured standard control.
For this revision, the normal Release build passed with 0 warnings and 0 errors, and `git diff --check` passed. These checks do not execute Unity rendering or interaction.
## Managed production checks
Run the production checks and normal UXAssist build from the repository root:
```powershell
dotnet run --project UXAssist/tools/ProductionCheck/ProductionCheck.csproj -c Release
dotnet build UXAssist/UXAssist.csproj -c Release --no-restore
git diff --check
```
The production-basis cases check an undersupplied chain, recipe-ratio conversion, shared intermediate demand, joint products, a cycle with an output, research-matrix outlets, no internal intermediate, power-only selections, very different capacity scales, and unavailable material settings or final output. A successful bottleneck report must conserve material, normalize inputs and outputs to the same throughput, preserve rated group capacity and power, and avoid internal shortages. Existing default-mode expectations must continue to pass.
## Manual acceptance
No in-game, Unity event-loop, or third-party mod integration test has been performed for this change. Repeat these checks at the target profile's resolutions and UI scales, with each installed blueprint UI mod. The header entry avoids native layout writes but another mod may use the same extension space.
1. Open each inspector in English and Simplified Chinese with different custom-field counts. Confirm the entry text shares the native title's baseline. Focus the description input so its icon appears; the entry must remain before that icon and its clickable area must not cover the input below. Open the options and check title clearance, compact checkbox spacing, visible captions, native X, and one footer action. At screen edges, confirm it flips or shifts into available canvas space.
2. Scroll while the popup is open. Confirm it follows the entry after native layout and closes when the entry is fully clipped. Expand native foundation, fill-only, and reform settings; all native fields must retain their positions and sizes, and scrolling must reach every field.
3. Open the rectangular production-basis list. Confirm text has clear left padding and space for the arrow. The list must overlay the footer without changing panel size or footer position. Select each item and confirm it closes the list without generating text or changing the native resolution setting. Reopen the popup and change language; selector dimensions and text spacing must remain valid.
4. Close the popup with its X; the inspector and an open inserter window must remain open. Reopen and click outside with the left, right, and middle mouse buttons: the popup should close, and the clicked native control or world target should retain its normal behavior. Press Esc with the list expanded: only the list should close. Press Esc again: the popup should close while the inspector stays open. With a native message box present, its Escape handler must retain priority.
5. Reopen each inspector and repeatedly refresh or change the blueprint selection. Confirm there is one entry, options are initially closed, the production basis resets to final-product output on opening, Spray Coaters set the automatic proliferation default, and a manual checkbox choice survives content refreshes in the current session. Successful generation, a replacement blueprint, and inspector closure must dismiss the popup.
6. Generate both production bases for an unbalanced chain. Final-product output should retain rated final capacity and show the missing intermediate; lowest intermediate throughput should reduce the common final-output mix, use correspondingly reduced external inputs, and show no internal shortage when the chain is complete and balanceable. Power should remain the same full-load estimate. Check necessary coproduct output separately from unused intermediate capacity.
7. Edit the description and unrelated custom fields before generating. Generate twice, including with 20 custom fields and with existing English or Chinese power fields. Confirm unrelated edits survive, duplicate power fields are consolidated, and failed generation leaves the prior description and fields intact. Include missing building settings, an unavailable bottleneck basis, and the native description length limit.
8. Save, copy the share code, and reopen or paste the blueprint through the native buttons. Confirm the generated main description, power field, and unrelated fields persist correctly. With a research-mode lab, confirm net produced matrices appear under Research without fabricated matrix imports or research speed.
9. Restart the test profile without UXAssist, then restore it and restart again. Confirm the entry and options are absent without UXAssist, native fields keep their normal layout in both cases, and repeated opening and generation work with the installed blueprint mods. `OnDisable` and inspector-destruction cleanup are code-review checks unless a development harness exercises them; a supported user-facing hot-disable workflow is not assumed.
+5 -18
View File
@@ -40,16 +40,12 @@ When proliferation is enabled, ordinary recipes default to their native extra-pr
## Fixed-building analysis ## Fixed-building analysis
By default, the black box evaluates each selected building at full load, even if another selected building cannot provide all its inputs. It does not simulate belt layouts, startup storage, or logistics throughput. Missing inputs appear as `RequiredExternalSupply`; byproducts and internal deficits retain producer and consumer group attribution. `GrossProduction` and `GrossConsumption` remain separate even when a recipe returns some of its own input. Material classification uses each process's net per-item flow, so that return cannot become a false external requirement or coproduct. The optional blueprint production basis below changes material ledgers only when explicitly requested. The black box evaluates each selected building at full load, even if another selected building cannot provide all its inputs. It does not simulate belt layouts, startup storage, or logistics throughput. Missing inputs appear as `RequiredExternalSupply`; byproducts and internal deficits retain producer and consumer group attribution. `GrossProduction` and `GrossConsumption` remain separate even when a recipe returns some of its own input. Material classification uses each process's net per-item flow, so that return cannot become a false external requirement or coproduct.
`IntermediateShortage` records the missing externally supplied portion of an item produced and consumed within the selection. `OverbuildSurplus` and `CoproductSurplus` are independent nullable amounts; both can be positive for the same item. Equivalent buildings are grouped by recipe, building, proliferation mode, speed, and operating settings in stable order. Whole-building reductions are tested against every item's shared balance: no final-product capacity may decrease and no internal shortage may increase. The reduction identifies redundancy only; gross flows, original full-load inputs, outputs, and power never change. Coproduct supply counts only retained whole buildings required by a process's other products, and internal net consumption is credited before exposing the remainder. Headroom from a single-output producer or a joint process's limiting product remains ordinary balance, not a coproduct. When materials are incomplete, overbuild and coproduct amounts are unknown rather than fabricated from a partial layout. `IntermediateShortage` records the missing externally supplied portion of an item produced and consumed within the selection. `OverbuildSurplus` and `CoproductSurplus` are independent nullable amounts; both can be positive for the same item. Equivalent buildings are grouped by recipe, building, proliferation mode, speed, and operating settings in stable order. Whole-building reductions are tested against every item's shared balance: no final-product capacity may decrease and no internal shortage may increase. The reduction identifies redundancy only; gross flows, original full-load inputs, outputs, and power never change. Coproduct supply counts only retained whole buildings required by a process's other products, and internal net consumption is credited before exposing the remainder. Headroom from a single-output producer or a joint process's limiting product remains ordinary balance, not a coproduct. When materials are incomplete, overbuild and coproduct amounts are unknown rather than fabricated from a partial layout.
`SteadyStateExternalSupply` is a separate input estimate from the known processes. After whole-building classification for complete selections, a fractional reduction of surplus intermediate producers propagates downstream limits through upstream processes. The reduction stops after a bounded number of passes, because a lossless cycle such as charging and discharging accumulators can otherwise pass a tiny leftover around indefinitely; stopping early only keeps the input estimate conservative. Every reduction applies to the entire process, keeps rated final-product capacity, and never worsens an existing intermediate shortage; deterministic grouping and ordering keep results independent of blueprint building order. For partial selections, skip whole-building classification but still cap independently known upstream inputs against known demand. Protect any known inputs of an unresolved downstream process, or all known products if its possible inputs are unknown, instead of treating its demand as zero. Only the blueprint description uses this estimate, marked as a known portion when incomplete. Gross ledgers, `RequiredExternalSupply`, uncertain overbuild and coproduct classification, independently known rated outputs, and power retain their original meaning. `SteadyStateExternalSupply` is a separate input estimate from the known processes. After whole-building classification for complete selections, a fractional reduction of surplus intermediate producers propagates downstream limits through upstream processes. The reduction stops after a bounded number of passes, because a lossless cycle such as charging and discharging accumulators can otherwise pass a tiny leftover around indefinitely; stopping early only keeps the input estimate conservative. Every reduction applies to the entire process, keeps rated final-product capacity, and never worsens an existing intermediate shortage; deterministic grouping and ordering keep results independent of blueprint building order. For partial selections, skip whole-building classification but still cap independently known upstream inputs against known demand. Protect any known inputs of an unresolved downstream process, or all known products if its possible inputs are unknown, instead of treating its demand as zero. Only the blueprint description uses this estimate, marked as a known portion when incomplete. Gross ledgers, `RequiredExternalSupply`, uncertain overbuild and coproduct classification, independently known rated outputs, and power retain their original meaning.
`FactoryBlackBoxRequest.ProductionBasis` defaults to `BlueprintProductionBasis.FinalProducts`, preserving these existing full-load semantics for all callers. The blueprint inspector can explicitly select `BottleneckIntermediate`. This mode reuses `TwoPhaseSimplex` to maximize one common fraction, no greater than 1, of the selected final-product mix, bounded by each selected process's capacity. Terminal consumers without item outputs, such as launchers, fuel generators, or precisely configured research, operate at that same fraction. Every internally produced material must balance without external imports; only materials with no selected producer can enter from outside. Capacities are converted through recipe ratios and shared consumption, rather than comparing different items' absolute per-minute rates. Joint products and selected cycles participate in the same balance; no unselected recipe is introduced. After maximizing the common fraction, the solver minimizes used building capacity, then remaining normalized surplus.
On a successful bottleneck calculation, all material ledgers, external inputs, final outputs, and research-matrix outlets use the normalized process rates. Unused positive intermediate capacity, including fractional building capacity, is reported as excess. This measures spare rated capacity rather than actual surplus stock or extra throughput; that capacity may not be simultaneously attainable from the normalized upstream flow. Surplus necessarily produced alongside required joint products remains coproduct output. A complete, balanceable chain therefore has no internal shortage within numerical tolerance. `Groups` and power retain the full selected building capacities, so normalized material rates must not be used to infer reduced power demand. Unknown material data, an unidentified final outlet, zero feasible throughput, or a failed or limited solve produces `BlueprintBasisUnavailable`; the inspector then preserves the existing description and fields. A pure cycle without a final outlet cannot establish this basis. A selection with no internal intermediate can retain its rated final output; a known selection with no material flows can still generate its power field without a material solve. Independently unknown power does not become known through balancing.
```csharp ```csharp
var capture = BlueprintSelectionReader.Capture(factory, selectedObjectIds); var capture = BlueprintSelectionReader.Capture(factory, selectedObjectIds);
var selection = capture.CreateRequest(proliferationEnabled: true); var selection = capture.CreateRequest(proliferationEnabled: true);
@@ -70,19 +66,11 @@ Native research uses the current lab technology's matrix point requirements, wit
## Blueprint descriptions ## Blueprint descriptions
The shared `UIBlueprintInspector` in browser, copy, and paste modes adds a compact `Auto-fill` entry after the measured native description title, with an 8-pixel gap. Its text copies the native title's font, size, style, line spacing, and alignment, with a zero top inset; its hit rectangle stays within the 22-pixel header. Reserve the actual native icon button's bounds and another 8-pixel gap even when that icon is inactive; hide the owned entry if it cannot fit. Its options panel is an owned child of `inspector.rectTrans`, outside the scroll mask. On opening, actual entry corners and root-canvas bounds are converted into that parent's coordinates. The private placement method in `InspectorControls` prefers a position below the entry with their right edges aligned, flips above when needed, and clamps against canvas bounds; a panel too large for those bounds is closed. A `Canvas.willRenderCanvases` subscription follows the entry after native layout and scrolling only while the options are open; hiding the entry or scrolling it completely outside its viewport closes the popup. Native fields, groups, anchors, and scroll height remain owned by the game. Closing, disabling, and destruction unsubscribe the positioning callback and remove only owned controls as appropriate. The shared `UIBlueprintInspector` in browser, copy, and paste modes hosts `Auto-fill description` with `Proliferation` immediately to its right in one row above every description box. Move the first native inspector group down once, and offset later groups and the scroll height after each native refresh so the controls do not split the smaller fields from the main description. The checkbox initially reflects the blueprint's Spray Coater prefab capability and tracks content changes until manually changed in the current editing session; changing it does not modify the blueprint. Clicking the button captures only `blueprint.buildings` with `BlueprintSelectionReader.FromBlueprint` on the game thread, then runs `FactoryBlackBoxAnalyzer` against the captured catalog. The maximum supported proliferation level applies while each building keeps its acceleration or extra-products mode. Input coating is assumed to be supplied externally; no spray routing or spray consumption is inferred from the Spray Coater.
The options use a title and the actual native X subtree, followed by proliferation, production basis with help, and one `Generate` action at the lower right. Content margins start inside the sliced background's visible fill: add `DataUtility.GetPadding(sprite) / image.pixelsPerUnit` to the desired gaps. The title has 12 pixels more left inset than the body and 18 pixels after the top sprite trim. Keep the 20-pixel checkbox independent of its label's height, at least 26 pixels or preferred glyph height plus padding, with vertical overflow allowed and a 4-pixel horizontal gap. Owned button and combo captions disable inherited best-fit sizing and have explicit text insets. Localized preferred sizes determine the form dimensions; opening the dropdown overlays the footer without changing panel size or footer position. The cloned X must receive a new `Button.ButtonClickedEvent`: its source has a persistent callback to the original inserter window that `RemoveAllListeners` does not remove. `BlueprintDescriptionFormatter` builds replacement multiline `blueprint.desc` text in this order: optional `Missing:` and `Excess:` lines for intermediate shortages and true overbuild; `Input:` for external inputs capped by downstream demand; `Output:` for ordinary final products and necessary coproduct surplus; and `Research:` for positive net matrix production accepted by a selected research-mode lab. Each warning category has one label followed by comma-separated items; warnings do not repeat in Input, and a matrix on Research does not repeat in Output. It uses `SteadyStateExternalSupply` for complete and independently known partial inputs, labeling partial values as known portions. The assumed lab adds no numerical matrix consumption or external input; other buildings' known matrix demand is subtracted from the Research rate. Omit each empty line, including Research when no produced matrix remains. A single optional `Power` custom field separates factory and configured logistics consumption, omitting categories with no demand and removing the field altogether if neither consumes power; a present but unknown category displays `Unknown` rather than zero. Material rates remain items per minute even though the description labels omit the unit. Rates are rounded only for display. Large displayed rates use the largest exact K/M/G suffix with at most one decimal place (for example, 1,234,000 becomes 1,234K); if no suffix preserves that display precision, keep the ordinary number. Numbers with four or more integer digits use comma thousands separators, including coefficients before material or power units. Rates are ordered by item ID within each category, and use native item icon/name tags with comma-separated entries inside each description line. Uncertain final-product, overbuild, or coproduct conclusions are omitted. Veins and other scene objects are not blueprint entries or requested parameters.
The production-basis selector directly clones the standard rectangular `optionWindow.resolutionComp` as an owned `UIComboBox`. Remove cloned runtime resolution rows, clear items, and replace its submit/change events before assigning the two production choices. Keep the native row-selection and dropdown behavior; the main caption has 8-pixel left and 30-pixel right insets, and the row template has 8-pixel horizontal insets. Main and item captions use single-line overflow so measuring preferred height before the new width is assigned cannot wrap against the previous width. The shared combo helper is unchanged. `BlueprintDescriptionFields` matches only exact English or Simplified Chinese power field titles, updates or removes matching power fields, and collapses duplicate matches; all other fields, including input/output custom fields, stay intact. The inspector first collects pending custom-field edits, checks the native 2,000-character description limit and `kMaxFieldCount`, and applies native `ExternalFieldEscape` and `ExternalFieldUnescape` rules to the remaining power field. An invalid blueprint, unavailable catalog, failed calculation, malformed fields, overlong description, or insufficient capacity does not overwrite the description or generated fields. A successful update replaces the original description, synchronizes its native input control, and refreshes the inspector and share-code preview through the native modification path, leaving save and copy actions to the native buttons. Native `Refresh` recalculates the later groups' positions and the scroll height but not the first group's position, and `Refresh(forModify: true)` does not reload `descTextInput`, so assign it explicitly. `BlueprintData.Validate` strips newlines from custom fields, so multiline text belongs only in the main description. Recheck these inspector behaviors against the original DLL after game updates. The formatting and field updater remain pure-managed so `ProductionCheck` can verify them without loading Unity.
Handle dismissal in the owning inspector's `_OnUpdate` postfix. Processed `VFInput.escape` respects an earlier native message-box handler; close an expanded dropdown first, otherwise close the popup, then consume Escape before later native window-closing handlers run. Left, right, or middle clicks outside the popup, entry, and open dropdown close the options while preserving the clicked native target's normal behavior. Successful generation, blueprint replacement, and inspector closure also close the options.
Each inspector open resets the basis to `Final-product output`, retaining existing calculation behavior; selecting `Lowest intermediate throughput` opts into `BottleneckIntermediate` for generation. The checkbox initially reflects the blueprint's Spray Coater prefab capability and tracks content changes until manually changed in the current editing session; changing it does not modify the blueprint. Generation captures only `blueprint.buildings` with `BlueprintSelectionReader.FromBlueprint` on the game thread, then runs `FactoryBlackBoxAnalyzer` against the captured catalog. A successful bottleneck solve supplies classification and steady-state balances directly; the original classifier runs only in final-product mode or after an unavailable bottleneck result. The maximum supported proliferation level applies while each building keeps its acceleration or extra-products mode. Input coating is assumed to be supplied externally; no spray routing or spray consumption is inferred from the Spray Coater.
`BlueprintDescriptionFormatter` builds replacement multiline `blueprint.desc` text in this order: optional `Missing:` and `Excess:` lines for intermediate shortages and excess classified by the selected production basis; `Input:` for external inputs capped by downstream demand; `Output:` for ordinary final products and necessary coproduct surplus; and `Research:` for positive net matrix production accepted by a selected research-mode lab. Each warning category has one label followed by comma-separated items; warnings do not repeat in Input, and a matrix on Research does not repeat in Output. It uses `SteadyStateExternalSupply` for complete and independently known partial inputs, labeling partial values as known portions. The assumed lab adds no numerical matrix consumption or external input; other buildings' known matrix demand is subtracted from the Research rate. Omit each empty line, including Research when no produced matrix remains. A single optional `Power` custom field separates factory and configured logistics consumption, omitting categories with no demand and removing the field altogether if neither consumes power; a present but unknown category displays `Unknown` rather than zero. Material rates remain items per minute even though the description labels omit the unit. Rates are rounded only for display. Large displayed rates use the largest exact K/M/G suffix with at most one decimal place (for example, 1,234,000 becomes 1,234K); if no suffix preserves that display precision, keep the ordinary number. Numbers with four or more integer digits use comma thousands separators, including coefficients before material or power units. Rates are ordered by item ID within each category, and use native item icon/name tags with comma-separated entries inside each description line. Uncertain final-product, overbuild, or coproduct conclusions are omitted. Veins and other scene objects are not blueprint entries or requested parameters.
`BlueprintDescriptionFields` matches only exact English or Simplified Chinese power field titles, updates or removes matching power fields, and collapses duplicate matches; all other fields, including input/output custom fields, stay intact. The inspector first collects pending custom-field edits, checks the native 2,000-character description limit and `kMaxFieldCount`, and applies native `ExternalFieldEscape` and `ExternalFieldUnescape` rules to the remaining power field. An invalid blueprint, unavailable catalog, failed calculation or bottleneck basis, malformed fields, overlong description, or insufficient capacity does not overwrite the description or generated fields. A successful update replaces the original description, synchronizes its native input control, and refreshes the inspector and share-code preview through the native modification path, leaving save and copy actions to the native buttons. Native `Refresh` owns the groups' positions and scroll height. `Refresh(forModify: true)` does not reload `descTextInput`, so assign it explicitly. `BlueprintData.Validate` strips newlines from custom fields, so multiline text belongs only in the main description. Recheck these inspector behaviors against the original DLL after game updates. The formatting and field updater remain pure-managed so `ProductionCheck` can verify them without loading Unity. See [blueprint description validation](BlueprintDescriptionValidation.md) for native layout evidence and manual compatibility checks.
## Special-process settings ## Special-process settings
@@ -135,8 +123,7 @@ Use a test game for the following manual checks. Compare full-load rates only wi
- Select miners at different machine speeds, including one with a backed-up output, a gas collector, and renewable generators. Check native miner power scaling, full-load miner output regardless of the output backlog, per-minute gas output without added grid demand, and ideal rated renewable power rather than local conditions. - Select miners at different machine speeds, including one with a backed-up output, a gas collector, and renewable generators. Check native miner power scaling, full-load miner output regardless of the output backlog, per-minute gas output without added grid demand, and ideal rated renewable power rather than local conditions.
- Select ray receivers in both modes, fuel generators, ejectors, and silos. Toggle proliferation and compare working power, generation, accumulator exchange, and Dyson demand as separate quantities. In a sandbox game, capture boosted artificial stars and launchers, and confirm that blueprint analysis of boosted buildings requires `BoostEnabled`. - Select ray receivers in both modes, fuel generators, ejectors, and silos. Toggle proliferation and compare working power, generation, accumulator exchange, and Dyson demand as separate quantities. In a sandbox game, capture boosted artificial stars and launchers, and confirm that blueprint analysis of boosted buildings requires `BoostEnabled`.
- Remove an upstream producer from a mixed production selection. Confirm that downstream capacity is unchanged and the missing material appears as required external supply. Add one producer more than downstream demand needs, and confirm that only that whole building's output is reported as excess. - Remove an upstream producer from a mixed production selection. Confirm that downstream capacity is unchanged and the missing material appears as required external supply. Add one producer more than downstream demand needs, and confirm that only that whole building's output is reported as excess.
- In browser, copy, and paste inspectors, check that the localized options follow their header entry when scrolling and use the available canvas space. Verify the native X, outside-click dismissal, and Escape priority, including an expanded dropdown and a native message box. Confirm both dropdown rows fit above the footer, options close after successful generation or inspector closure, and native settings and description fields retain their positions. Check Spray Coater defaults and manual overrides, generate twice and at the 20-field limit, and verify pending edits, unrelated fields, native item tags, and save/copy behavior. - In browser, copy, and paste inspectors, check localized control placement, Spray Coater defaults and manual overrides, and native item tags in the generated description and `Power` field. Generate twice and at the 20-field limit; verify that pending manual edits, unrelated fields, save/copy behavior, and ordinary blueprint sharing remain intact. Compare joint-production overbuild with necessary coproduct output without replacing original full-load rates or power.
- Compare both production bases on an undersupplied chain, uneven recipe ratios, shared intermediate branches, and a joint-product chain. Final-product mode must retain rated final outputs and expose intermediate shortages. Bottleneck mode must scale final outputs together, update raw inputs to the same throughput, and leave no internal shortage for a complete, balanceable chain. Confirm unused intermediate capacity and necessary coproduct output remain distinct, and that power stays at the same full-load estimate. Test a chain without internal intermediates, missing building settings, and a cycle without a final outlet; an unavailable bottleneck basis must preserve existing description and fields.
- Place one research-mode lab alongside one or all six matrix production chains. Confirm the matrices' positive net production appears only in the Research line, other final products stay in Output, and known in-blueprint matrix consumption reduces the Research rate. Do not fabricate lab matrix imports, excess, or an estimated lab consumption rate; change current technology, add more labs, and toggle proliferation to check matrix routing stays independent while full working power updates. Without the lab, normal matrix output and overbuild rules resume. - Place one research-mode lab alongside one or all six matrix production chains. Confirm the matrices' positive net production appears only in the Research line, other final products stay in Output, and known in-blueprint matrix consumption reduces the Research rate. Do not fabricate lab matrix imports, excess, or an estimated lab consumption rate; change current technology, add more labs, and toggle proliferation to check matrix routing stays independent while full working power updates. Without the lab, normal matrix output and overbuild rules resume.
- Combine planner targets with shared coproducts, explicit raw-material boundaries, and alternate selected recipes. Confirm material conservation, shared surplus reuse, and no introduction of unselected recipes. - Combine planner targets with shared coproducts, explicit raw-material boundaries, and alternate selected recipes. Confirm material conservation, shared surplus reuse, and no introduction of unselected recipes.
- Toggle belt-signal proliferation and reload a game. Confirm that existing belts use the new catalog, item generation continues, and fractional production and consumption statistics remain independent. - Toggle belt-signal proliferation and reload a game. Confirm that existing belts use the new catalog, item generation continues, and fractional production and consumption statistics remain independent.
-201
View File
@@ -31,7 +31,6 @@ internal static class Program
BlueprintMixedProducersAndCycles(); BlueprintMixedProducersAndCycles();
SteadyStateLosslessCycle(); SteadyStateLosslessCycle();
BlueprintProliferationAndCompleteness(); BlueprintProliferationAndCompleteness();
BlueprintProductionBases();
BlueprintDescriptionFormattingAndFields(); BlueprintDescriptionFormattingAndFields();
LogisticsChargingPower(); LogisticsChargingPower();
FractionationFlow(); FractionationFlow();
@@ -2021,206 +2020,6 @@ internal static class Program
"an unresolved but known downstream input prevents underestimating its upstream supply"); "an unresolved but known downstream input prevents underestimating its upstream supply");
} }
private static void BlueprintProductionBases()
{
var analyzer = new FactoryBlackBoxAnalyzer(BlueprintCatalog());
var request = BlueprintRequest(1);
var rated = analyzer.Analyze(request);
Equal(60, rated.ItemFlows[2].IntermediateShortage,
"default final-product basis retains the selected downstream shortage");
request.ProductionBasis = BlueprintProductionBasis.BottleneckIntermediate;
var balanced = analyzer.Analyze(request);
Check(balanced.MaterialComplete && !balanced.Diagnostics.Any(), "bottleneck coproduct chain is complete");
Equal(0.5, balanced.ItemFlows[4].NetFlow, "limiting A capacity halves final output");
Equal(1, balanced.ItemFlows[1].SteadyStateExternalSupply.Value, "raw input uses the same feasible basis");
Equal(45, balanced.ItemFlows[3].CoproductSurplus.Value, "joint output retains its unavoidable B45 surplus");
Equal(0, balanced.ItemFlows[2].IntermediateShortage, "bottleneck mode solves rather than hides missing A");
Equal(60, balanced.ItemFlows[2].GrossConsumption, "downstream consumption is actually reduced");
Equal(rated.Power.ConsumptionWatts, balanced.Power.ConsumptionWatts,
"power still sizes all selected facilities at rated load");
Equal(rated.Groups[1].ExecutionsPerMinute, balanced.Groups[1].ExecutionsPerMinute,
"selected group capacities stay available separately from basis material flows");
var labels = new BlueprintDescriptionLabels("Factory power", "Logistics power", "Missing: ",
"Excess: ", "Unknown", "(known portion)", "Input: ", "Output: ", "Research: ");
var balancedText = BlueprintDescriptionFormatter.Format(balanced, TestItemTag, labels);
Check(!balancedText.Warnings.Contains("Missing:"), "a solved bottleneck does not format an internal shortage");
Check(balancedText.Input == TestItemTag(1) + " x1", "formatted input uses normalized raw demand");
Check(balancedText.Output == TestItemTag(3) + " x45, " + TestItemTag(4) + " x0.5",
"formatted output uses the same normalized final and coproduct rates");
var ratioCatalog = BasisCatalog(new[]
{
Recipe(801, new[] { (1, 1.0) }, new[] { (2, 0.5) }),
Recipe(802, new[] { (1, 1.0) }, new[] { (3, 100.0) }),
Recipe(803, new[] { (2, 1.0), (3, 100.0) }, new[] { (4, 10.0) })
});
var ratioRequest = BasisRequest(801, 802, 803);
var ratio = new FactoryBlackBoxAnalyzer(ratioCatalog).Analyze(ratioRequest);
Equal(5, ratio.ItemFlows[4].NetFlow, "different intermediate units are converted through recipe ratios");
Equal(50, ratio.ItemFlows[3].GrossConsumption, "large-count ingredient uses normalized demand");
Equal(50, ratio.ItemFlows[3].OverbuildSurplus.Value, "unused intermediate capacity is excess");
Equal(1.5, ratio.ItemFlows[1].SteadyStateExternalSupply.Value, "external inputs share the selected basis");
Check(ratio.ItemFlows.Values.All(flow => flow.IntermediateShortage == 0),
"ratio-scaled complete chain has no internal missing material");
var ratioReverse = BasisRequest(803, 802, 801);
var reversed = new FactoryBlackBoxAnalyzer(ratioCatalog).Analyze(ratioReverse);
foreach (var flow in ratio.ItemFlows.Values)
{
Equal(flow.GrossProduction, reversed.ItemFlows[flow.ItemId].GrossProduction,
"bottleneck production is independent of selection order");
Equal(flow.GrossConsumption, reversed.ItemFlows[flow.ItemId].GrossConsumption,
"bottleneck consumption is independent of selection order");
}
var unevenCatalog = BasisCatalog(new[]
{
Recipe(804, new[] { (1, 1.0) }, new[] { (2, 0.5) }),
Recipe(805, new[] { (2, 1e8) }, new[] { (4, 1e8) })
});
var uneven = new FactoryBlackBoxAnalyzer(unevenCatalog).Analyze(BasisRequest(804, 805));
Check(!uneven.Diagnostics.Any(), "a small common fraction can still represent meaningful known throughput");
Equal(0.5, uneven.ItemFlows[4].NetFlow, "large capacity ratios do not become a false zero-throughput failure");
var sharedCatalog = BasisCatalog(new[]
{
Recipe(811, new[] { (1, 1.0) }, new[] { (2, 3.0) }),
Recipe(812, new[] { (2, 2.0) }, new[] { (3, 3.0) }),
Recipe(813, new[] { (2, 3.0) }, new[] { (4, 4.0) })
});
var shared = new FactoryBlackBoxAnalyzer(sharedCatalog).Analyze(BasisRequest(811, 812, 813));
Equal(1.8, shared.ItemFlows[3].NetFlow, "shared material scales the first final branch by 3/5");
Equal(2.4, shared.ItemFlows[4].NetFlow, "shared material scales the second final branch by 3/5");
Equal(3, shared.ItemFlows[2].GrossConsumption, "shared demand sums both branches");
Equal(1, shared.ItemFlows[1].RequiredExternalSupply, "shared branches use one common raw-input ledger");
Equal(1, shared.ItemFlows[1].SteadyStateExternalSupply.Value,
"steady-state supply matches the normalized shared-branch ledger");
foreach (var report in new[] { balanced, ratio, shared })
foreach (var flow in report.ItemFlows.Values.Where(flow => flow.ProducerGroups.Count > 0 &&
flow.ConsumerGroups.Count > 0))
Check(flow.NetFlow >= -1e-7 * Math.Max(1, Math.Max(flow.GrossProduction, flow.GrossConsumption)),
"normalized gross ledgers conserve internal material within relative tolerance");
var knownMaterialsRequest = BlueprintRequest(1);
knownMaterialsRequest.ProductionBasis = BlueprintProductionBasis.BottleneckIntermediate;
knownMaterialsRequest.Buildings.Add(new ProductionBuildingSnapshot(3, 30, 0, 1, ProliferationMode.None));
var unknownPower = analyzer.Analyze(knownMaterialsRequest);
Check(unknownPower.MaterialComplete && !unknownPower.PowerComplete && !unknownPower.Diagnostics.Any(
diagnostic => diagnostic.Code == ProductionDiagnosticCode.BlueprintBasisUnavailable),
"unknown logistics power does not discard independently known bottleneck materials");
Equal(0.5, unknownPower.ItemFlows[4].NetFlow, "known material throughput survives unknown power");
var powerOnlyRequest = new FactoryBlackBoxRequest
{ ProductionBasis = BlueprintProductionBasis.BottleneckIntermediate };
powerOnlyRequest.Buildings.Add(new ProductionBuildingSnapshot(1, 31, 0, 1, ProliferationMode.None));
powerOnlyRequest.Buildings.Add(new ProductionBuildingSnapshot(2, 30, 0, 1, ProliferationMode.None,
operatingParameters: new Dictionary<string, double> { ["ChargePowerWatts"] = 500 }));
var powerOnly = analyzer.Analyze(powerOnlyRequest);
Check(powerOnly.MaterialComplete && powerOnly.PowerComplete && !powerOnly.Diagnostics.Any(),
"known power-only blueprints have an empty material ledger that needs no basis reduction");
Check(powerOnly.ItemFlows.Count == 0, "power-only blueprints do not fabricate material rates");
var powerOnlyText = BlueprintDescriptionFormatter.Format(powerOnly, TestItemTag, labels);
Check(powerOnlyText.Description.Length == 0 && powerOnlyText.Power == "Factory power 900W | Logistics power 500W",
"power-only generation keeps its useful power field under the bottleneck option");
powerOnlyRequest.ProductionBasis = BlueprintProductionBasis.FinalProducts;
Equal(analyzer.Analyze(powerOnlyRequest).Power.ConsumptionWatts, powerOnly.Power.ConsumptionWatts,
"power-only layouts have the same selected capacity under either material basis");
var cycleCatalog = BasisCatalog(new[]
{
Recipe(821, new[] { (1, 1.0) }, new[] { (2, 0.5) }),
Recipe(822, new[] { (2, 2.0) }, new[] { (3, 1.0) }),
Recipe(823, new[] { (3, 1.0) }, new[] { (2, 1.0), (4, 1.0) })
});
var cycle = new FactoryBlackBoxAnalyzer(cycleCatalog).Analyze(BasisRequest(821, 822, 823));
Equal(0.5, cycle.ItemFlows[4].NetFlow, "returned intermediate participates in the bottleneck solve");
Equal(0, cycle.ItemFlows[2].NetFlow, "cyclic first material conserves at normalized throughput");
Equal(0, cycle.ItemFlows[3].NetFlow, "cyclic second material conserves at normalized throughput");
Check(cycle.ItemFlows.Values.All(flow => flow.IntermediateShortage == 0),
"a feasible cycle has no internal missing material");
var single = new FactoryBlackBoxAnalyzer(ratioCatalog).Analyze(BasisRequest(801));
Equal(0.5, single.ItemFlows[2].NetFlow, "no-intermediate selection keeps final capacity");
Equal(1, single.ItemFlows[1].SteadyStateExternalSupply.Value, "no-intermediate raw input remains known");
var subset = new FactoryBlackBoxAnalyzer(ratioCatalog).Analyze(BasisRequest(803));
Equal(10, subset.ItemFlows[4].NetFlow, "a blueprint subset treats absent upstream stages as external");
Equal(100, subset.ItemFlows[3].SteadyStateExternalSupply.Value,
"an absent producer remains a real external input");
var unknownRequest = BasisRequest(801, 803, 9999);
var unknown = new FactoryBlackBoxAnalyzer(ratioCatalog).Analyze(unknownRequest);
Check(!unknown.MaterialComplete && unknown.Diagnostics.Any(diagnostic =>
diagnostic.Code == ProductionDiagnosticCode.BlueprintBasisUnavailable),
"unknown production prevents claiming a complete bottleneck balance");
Equal(0.5, unknown.ItemFlows[2].IntermediateShortage,
"unavailable basis preserves the original known shortage");
var closed = new FactoryBlackBoxAnalyzer(BlueprintCatalog()).Analyze(BasisRequest(621, 622));
Check(closed.Diagnostics.Any(diagnostic => diagnostic.Code == ProductionDiagnosticCode.BlueprintBasisUnavailable),
"a pure closed loop has no final output from which to choose a common basis");
var infeasibleCatalog = BasisCatalog(new[]
{
Recipe(831, new[] { (2, 1.0) }, new[] { (3, 1.0), (4, 1.0) }),
Recipe(832, new[] { (3, 1.0) }, new[] { (2, 0.5) })
});
var infeasible = new FactoryBlackBoxAnalyzer(infeasibleCatalog).Analyze(BasisRequest(831, 832));
Check(infeasible.Diagnostics.Any(diagnostic =>
diagnostic.Code == ProductionDiagnosticCode.BlueprintBasisUnavailable),
"zero feasible final throughput cannot masquerade as a balanced zero-output description");
Equal(1, infeasible.ItemFlows[4].NetFlow, "infeasible basis keeps the original known final rate");
var sinkCatalog = BasisCatalog(new[]
{
Recipe(841, new[] { (1, 1.0) }, new[] { (2, 0.5) }),
Recipe(842, new[] { (2, 1.0) }, Array.Empty<(int, double)>())
});
var sink = new FactoryBlackBoxAnalyzer(sinkCatalog).Analyze(BasisRequest(841, 842));
Check(!sink.Diagnostics.Any(), "a consuming terminal process supplies a non-item final target");
Equal(0.5, sink.ItemFlows[2].GrossConsumption,
"a non-item terminal consumer follows the bottleneck instead of silently idling");
var researchCatalog = new ProductionCatalog(ratioCatalog.Items.Values, ratioCatalog.Recipes.Values,
ratioCatalog.Buildings.Values, new[] { 0.0 }, new[] { 0.0 }, new[] { 1.0 },
researchMatrixItemIds: new[] { 2 });
var researchRequest = BasisRequest(801, 803);
researchRequest.Buildings.Add(new ProductionBuildingSnapshot(9, 11, 0, 1, ProliferationMode.None,
operatingParameters: new Dictionary<string, double>
{ ["ResearchMode"] = 1, ["ResearchMatrixSink"] = 1 }));
var research = new FactoryBlackBoxAnalyzer(researchCatalog).Analyze(researchRequest);
Equal(5, research.ItemFlows[4].NetFlow, "known matrix consumption still constrains the final product");
Equal(0, research.ItemFlows[2].NetFlow, "matrix outlet does not fabricate extra matrix consumption");
Check(!research.ItemFlows[2].IsResearchProduct, "no positive matrix net means no research output");
var matrixOnlyRequest = BasisRequest(801);
matrixOnlyRequest.Buildings.Add(researchRequest.Buildings.Last());
var matrixOnly = new FactoryBlackBoxAnalyzer(researchCatalog).Analyze(matrixOnlyRequest);
Equal(0.5, matrixOnly.ItemFlows[2].NetFlow, "research outlet preserves produced matrices as a final target");
Check(matrixOnly.ItemFlows[2].IsResearchProduct, "positive matrix net remains a research product");
var researchConsumedRequest = BasisRequest(801, 803);
researchConsumedRequest.Buildings[0] = new ProductionBuildingSnapshot(1, 10, 801, 3,
ProliferationMode.None);
researchConsumedRequest.Buildings.Add(researchRequest.Buildings.Last());
var researchConsumed = new FactoryBlackBoxAnalyzer(researchCatalog).Analyze(researchConsumedRequest);
Equal(0.5, researchConsumed.ItemFlows[2].NetFlow,
"positive research matrix output subtracts real downstream matrix use");
Check(researchConsumed.ItemFlows[2].IsResearchProduct,
"matrix outlets preserve the positive net target alongside an ordinary final product");
}
private static ProductionCatalog BasisCatalog(IEnumerable<ProductionRecipe> recipes)
{
return new ProductionCatalog(Enumerable.Range(1, 4)
.Select(id => new ProductionItem(id, 0, id == 1, false, 0, 0)), recipes,
new[]
{
new ProductionBuilding(10, ProductionRecipeCategory.Assemble, 1, 1000, 100),
new ProductionBuilding(11, ProductionRecipeCategory.Research, 1, 2000, 200)
}, new[] { 0.0 }, new[] { 0.0 }, new[] { 1.0 });
}
private static FactoryBlackBoxRequest BasisRequest(params int[] recipes)
{
var request = new FactoryBlackBoxRequest { ProductionBasis = BlueprintProductionBasis.BottleneckIntermediate };
for (var index = 0; index < recipes.Length; index++)
request.Buildings.Add(new ProductionBuildingSnapshot(index + 1, 10, recipes[index], 1,
ProliferationMode.None));
return request;
}
private static void BlueprintDescriptionFormattingAndFields() private static void BlueprintDescriptionFormattingAndFields()
{ {
var labels = new BlueprintDescriptionLabels("工厂耗电", "物流耗电", "缺少:", "多余:", "未知", var labels = new BlueprintDescriptionLabels("工厂耗电", "物流耗电", "缺少:", "多余:", "未知",