update for new game update

.markdownlint.json

@@ -0,0 +1,7 @@
+{
+    "MD013": false,
+    "MD033": {
+        "allowed_elements": ["details", "summary"]
+    },
+    "MD041": false
+}

CheatEnabler/CHANGELOG.md

@@ -1,281 +1,323 @@
+<details>
+<summary>Read me in English</summary>
+
 ## Changlog
 
+* 2.4.0
+  * Support game version 0.10.33
+  * `Generate illegal dyson shell`: This function is open to all users now, enabling certain config entry is not needed any more.
+* 2.3.32
+  * `Complete Dyson Sphere Shells instantly`: Fix a crash.
+* 2.3.31
+  * New feature: `Unlock Dyson Sphere max orbit radius`
+  * `Remove metadata consumption record in current game`: Fix implementation
+  * Add 3 buttons for creating illegal Dyson Sphere Shells, you must enable `IllegalDysonShellFunctionsEnabled` of `DysonSphere` section in config to see them.
+    * `Generate an illegal dyson shell`
+    * `Keep max production shells and remove others`
+    * `Duplicate shells from that with highest production`
+* 2.3.30
+  * Fix a warning issue while `No condition build` or `No collision` is enabled.
+  * Increase performance for `Finish build immediately` greatly on pasting large blueprints.
+* 2.3.29
+  * Fix compatibility with game update 0.10.32.25779
+* 2.3.28
+  * New feature: `Instant hand-craft`.
+  * Fix some panels' display while `Infinite Natural Resources` is enabled.
+* 2.3.27
+  * `Skip bullet period` & `Eject anyway`: Fix compatibility with `Dyson Sphere Program v0.10.32.25496`.
 * 2.3.26
-  + Refactor codes to adapt to UXAssist 1.2.0
+  * Refactor codes to adapt to UXAssist 1.2.0
-    - You should update UXAssist to 1.2.0 or later before using this version.
+    * You should update UXAssist to 1.2.0 or later before using this version.
-  + `Complete Dyson Sphere Shells instantly`: Fix possible wrong production records.
+  * `Complete Dyson Sphere Shells instantly`: Fix possible wrong production records.
 * 2.3.25
-  + New feature: `Enable warp without space warpers`
+  * New feature: `Enable warp without space warpers`
-  + New feature: `Wind Turbines do global power coverage`
+  * New feature: `Wind Turbines do global power coverage`
-  + Fix an issue that `Complete Dyson Sphere Shells instantly` does not generate production records for solar sails.
+  * Fix an issue that `Complete Dyson Sphere Shells instantly` does not generate production records for solar sails.
-
-<details>
-<summary>Older versions</summary>
-
 * 2.3.24
-  + `Complete Dyson Sphere Shells instantly`: Fix a bug that may cause negative power in some cases
+  * `Complete Dyson Sphere Shells instantly`: Fix a bug that may cause negative power in some cases
 * 2.3.23
-  + New feature: `Complete Dyson Sphere Shells instantly` 
+  * New feature: `Complete Dyson Sphere Shells instantly`
-  + Fix a crash when config panel is opened before game is fully loaded
+  * Fix a crash when config panel is opened before game is fully loaded
 * 2.3.22
-  + Fix `Pump Anywhere`
+  * Fix `Pump Anywhere`
 * 2.3.21
-  + `Retrieve/Place items from/to remote planets on logistics control panel`: Items are put back to player's inventory when a slot is removed from the logistics station on remote planet.
+  * `Retrieve/Place items from/to remote planets on logistics control panel`: Items are put back to player's inventory when a slot is removed from the logistics station on remote planet.
-  + `Dev Shortcuts`: Camera Pose related shortcurts are working now.
+  * `Dev Shortcuts`: Camera Pose related shortcurts are working now.
 * 2.3.20
-  + New feature: `Retrieve/Place items from/to remote planets on logistics control panel`
+  * New feature: `Retrieve/Place items from/to remote planets on logistics control panel`
 * 2.3.19
-  + New features:
+  * New features:
-    + `Remove all metadata consumption records`
+    * `Remove all metadata consumption records`
-    + `Remove metadata consumption record in current game`
+    * `Remove metadata consumption record in current game`
-    + `Clear metadata flag which bans achievements`
+    * `Clear metadata flag which bans achievements`
 * 2.3.18
-  + New features:
+  * New features:
-    + `Teleport to outer space`, this will teleport you to the outer space which is 50 LYs far from the farthest star.
+    * `Teleport to outer space`, this will teleport you to the outer space which is 50 LYs far from the farthest star.
-    + `Teleport to selected astronomical`
+    * `Teleport to selected astronomical`
-  + Fix logic of `Unlock techs with key-modifiers`.
+  * Fix logic of `Unlock techs with key-modifiers`.
-  + `No condition build` does not hide rotation info of belts now.
+  * `No condition build` does not hide rotation info of belts now.
 * 2.3.17
-  + Make compatible with game version 0.10.30.23292
+  * Make compatible with game version 0.10.30.23292
 * 2.3.16
-  + Add 2 options to `Belt signal item generation`:
+  * Add 2 options to `Belt signal item generation`:
-    - `Count generations as production in statistics`
+    * `Count generations as production in statistics`
-    - `Count removals as consumption in statistics`
+    * `Count removals as consumption in statistics`
-  + New feature: `Increase maximum power usage in Logistic Stations and Advanced Mining Machines`
+  * New feature: `Increase maximum power usage in Logistic Stations and Advanced Mining Machines`
-    - Logistic Stations: Increased max charging power to 3GW(ILS) and 600MW(PLS) (10x of original)
+    * Logistic Stations: Increased max charging power to 3GW(ILS) and 600MW(PLS) (10x of original)
-    - Advanced Mining Machines: Increased max mining speed to 1000%
+    * Advanced Mining Machines: Increased max mining speed to 1000%
 * 2.3.15
-  + New features:
+  * New features:
-    - `Instant teleport (like that in Sandbox mode)`
+    * `Instant teleport (like that in Sandbox mode)`
-    - `Mecha and Drones/Fleets invicible`
+    * `Mecha and Drones/Fleets invicible`
-    - `Buildings invicible`
+    * `Buildings invicible`
 * 2.3.14
-  + Remove default shortcut key for `No condition build` and `No collision`, to avoid misoperation. You can still set them in system settings window manually if needed.
+  * Remove default shortcut key for `No condition build` and `No collision`, to avoid misoperation. You can still set them in system settings window manually if needed.
-  + Fix translation issue.
+  * Fix translation issue.
 * 2.3.13
-  + Fix a bug that shortcuts are not working and have display issue on settings window.
+  * Fix a bug that shortcuts are not working and have display issue on settings window.
 * 2.3.12
-  + Add a shortcut to toggle `No collision`, you can modify the shortcut on system settings window.
+  * Add a shortcut to toggle `No collision`, you can modify the shortcut on system settings window.
-  + Add realtime tips when toggling `No condition build` and `No collision` with shortcuts.
+  * Add realtime tips when toggling `No condition build` and `No collision` with shortcuts.
 * 2.3.11
-  + Add a shortcut to toggle `No condition build`, you can modify the shortcut on system settings window. This depends on [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) 1.0.15 or later.
+  * Add a shortcut to toggle `No condition build`, you can modify the shortcut on system settings window. This depends on [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) 1.0.15 or later.
 * 2.3.10
-  + Fix following functions not working in new game updates:
+  * Fix following functions not working in new game updates:
-    - `Pump Anywhere`
+    * `Pump Anywhere`
-    - `Terraform without enough soil piles`
+    * `Terraform without enough soil piles`
 * 2.3.9
-  + Support game version 0.10.28.21219
+  * Support game version 0.10.28.21219
 * 2.3.8
-  + Fix a crash on starting new games while `Finish build immediately` is enabled.
+  * Fix a crash on starting new games while `Finish build immediately` is enabled.
-  + Fix UI button width.
+  * Fix UI button width.
 * 2.3.7
-  + Support game version 0.10.28.20759
+  * Support game version 0.10.28.20759
-  + Fix belt signal that items' generation speed is not fit to number set sometimes.
+  * Fix belt signal that items' generation speed is not fit to number set sometimes.
 * 2.3.6
-  + Support for UXAssist's new function within `Finish build immediately`.
+  * Support for UXAssist's new function within `Finish build immediately`.
-  + Add a warning message when `Build without condition` is enabled.
+  * Add a warning message when `Build without condition` is enabled.
-  + Fix an issue in `Finish build immediately` that some buildings are not finished immediately.
+  * Fix an issue in `Finish build immediately` that some buildings are not finished immediately.
 * 2.3.5
-  + Fix another crash in `Skip bullet period`.
+  * Fix another crash in `Skip bullet period`.
 * 2.3.4
-  + Use new tab layout of UXAssist 1.0.2
+  * Use new tab layout of UXAssist 1.0.2
-  + Minor bug fixes
+  * Minor bug fixes
 * 2.3.3
-  + Fix a crash in `Skip bullet period`.
+  * Fix a crash in `Skip bullet period`.
-  + Unlock techs with Alt unlocks VeinUtil to 10000 instead of 7200 now, as bug fixed in UXAssist.
+  * Unlock techs with Alt unlocks VeinUtil to 10000 instead of 7200 now, as bug fixed in UXAssist.
 * 2.3.2
-  + Birth star options moved to [UniverseGenTweaks](https://dsp.thunderstore.io/package/soarqin/UniverseGenTweaks/)
+  * Birth star options moved to [UniverseGenTweaks](https://dsp.thunderstore.io/package/soarqin/UniverseGenTweaks/)
-  + Optimize `Quick absorb`, consumes less CPU time and take turns firing to nodes.
+  * Optimize `Quick absorb`, consumes less CPU time and take turns firing to nodes.
-  + `Fast Mining` ensures full output of oil extractors now.
+  * `Fast Mining` ensures full output of oil extractors now.
-  + Fix issue that `Belt signal generator` not working after switched off then on again.
+  * Fix issue that `Belt signal generator` not working after switched off then on again.
-  + Fix absorption issue by `Quick absorb` and `Skip bullet period` enabled at the same time.
+  * Fix absorption issue by `Quick absorb` and `Skip bullet period` enabled at the same time.
-  + Crash fix for some options
+  * Crash fix for some options
 * 2.3.1
-  + Add UXAssist to dependencies in manifest.
+  * Add UXAssist to dependencies in manifest.
 * 2.3.0
-  + Move some functions to an individual mod: [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)
+  * Move some functions to an individual mod: [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)
-  + Depends on [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) now, so that config panel is unified with UXAssist.
+  * Depends on [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) now, so that config panel is unified with UXAssist.
-  + Remove `LCtrl+A` from Dev Shortcuts, to avoid misoperation.
+  * Remove `LCtrl+A` from Dev Shortcuts, to avoid misoperation.
-  + Infinite bots/drones/vessels in `Architect mode` now.
+  * Infinite bots/drones/vessels in `Architect mode` now.
 * 2.2.7
-  + New function: `Construct only nodes but frames`
+  * New function: `Construct only nodes but frames`
-  + Opening config panel does not close inventory panel now
+  * Opening config panel does not close inventory panel now
-  + Remove `Input direction conflict` check while using `Remove some build conditions`
+  * Remove `Input direction conflict` check while using `Remove some build conditions`
-  + Fix a bug that prevents `Belt signal alt format` from switching number formats for current belt signals
+  * Fix a bug that prevents `Belt signal alt format` from switching number formats for current belt signals
 * 2.2.6
-  + New function: `Stop ejectors when available nodes are all filled up`
+  * New function: `Stop ejectors when available nodes are all filled up`
-  + Fix a bug that absorb solar sails on unfinised nodes
+  * Fix a bug that absorb solar sails on unfinised nodes
 * 2.2.5
-  + Skip all intermediate states and absorb solar sails instantly while enable `Quick absorb`, `Skip bullet period` and `Skip absorption period` at the same time.
+  * Skip all intermediate states and absorb solar sails instantly while enable `Quick absorb`, `Skip bullet period` and `Skip absorption period` at the same time.
-  + Fix a problem that `Quick absorb` does not absorb all solar sails instantly when most nodes are full.
+  * Fix a problem that `Quick absorb` does not absorb all solar sails instantly when most nodes are full.
-  + Fix crash while using with some mods
+  * Fix crash while using with some mods
 * 2.2.4
-  + New function: `Enable player actions in globe view`
+  * New function: `Enable player actions in globe view`
-  + Fix UI bug
+  * Fix UI bug
 * 2.2.3
-  + New function: `Remove some build conditions`
+  * New function: `Remove some build conditions`
-  + Fix compatibility with some mods
+  * Fix compatibility with some mods
 * 2.2.2
-  + New function: `Assign gamesave to currrnet account`
+  * New function: `Assign gamesave to currrnet account`
-  + New subfunction: `Belt signal alt format`
+  * New subfunction: `Belt signal alt format`
-  + Fix a crash on using `Initialize this Planet`
+  * Fix a crash on using `Initialize this Planet`
-  + Fix belt build in `Finish build immediately`
+  * Fix belt build in `Finish build immediately`
 * 2.2.1
-  + Check condition for miners even when `Build without condition` is enabled.
+  * Check condition for miners even when `Build without condition` is enabled.
-  + Fix a patch issue that may cause `Build without condition` not working.
+  * Fix a patch issue that may cause `Build without condition` not working.
 * 2.2.0
-  + Add some power related functions
+  * Add some power related functions
-  + Add a subfunction to belt signal item generation, which simulates production process of raws and intermediates on statistics
+  * Add a subfunction to belt signal item generation, which simulates production process of raws and intermediates on statistics
-  + Split some functions from Architect mode
+  * Split some functions from Architect mode
 * 2.1.0
-  + Belt signal item generation
+  * Belt signal item generation
-  + Fix window display priority which may cause tips to be covered by main window
+  * Fix window display priority which may cause tips to be covered by main window
 * 2.0.0
-  + Refactorying codes
+  * Refactorying codes
-  + UI implementation
+  * UI implementation
-  + Add a lot of functions
+  * Add a lot of functions
 * 1.0.0
-  + Initial release
+  * Initial release
 
 </details>
 
+<details>
+<summary>中文读我</summary>
+
 ## 更新日志
 
+* 2.4.0
+  * 支持游戏版本 0.10.33
+  * `生成仙术戴森壳`：此功能现在对所有用户开放，不再需要启用特定的配置项。
+* 2.3.32
+  * `立即完成戴森壳建造`：修复了一个崩溃问题
+* 2.3.31
+  * 新功能：`解锁戴森球最大轨道半径`
+  * `移除当前存档的元数据消耗记录`：修复实现
+  * 增加了3个用于制作仙术戴森壳的按钮，你必须在设置文件里开启`DysonSphere`分类的`IllegalDysonShellFunctionsEnabled`才能看到它们
+    * `生成单层仙术戴森壳`
+    * `保留发电量最高的戴森壳并移除其他戴森壳`
+    * `从发电量最高的壳复制戴森壳`
+* 2.3.30
+  * 修复了启用`无条件建造`或`无碰撞`时的警告问题
+  * 粘贴大规模蓝图时大幅提升`立即完成建造`的性能表现
+* 2.3.29
+  * 修复了与游戏更新0.10.32.25779的兼容性
+* 2.3.28
+  * 新功能：`快速手动制造`
+  * 修复了启用`自然资源采集不消耗`时部分面板的显示问题
+* 2.3.27
+  * `跳过子弹阶段`和`全球弹射`：修复了与`戴森球计划 v0.10.32.25496`的兼容性
 * 2.3.26
-  + 重构代码以适应UXAssist 1.2.0
+  * 重构代码以适应UXAssist 1.2.0
-    - 在使用此版本之前，您应先更新UXAssist到1.2.0或更高版本。
+    * 在使用此版本之前，您应先更新UXAssist到1.2.0或更高版本。
-  + `立即完成戴森壳建造`：修复了可能导致错误的生产记录的问题
+  * `立即完成戴森壳建造`：修复了可能导致错误的生产记录的问题
 * 2.3.25
-  + 新功能：`无需空间翘曲器即可曲速飞行`
+  * 新功能：`无需空间翘曲器即可曲速飞行`
-  + 新功能：`风力涡轮机供电覆盖全球`
+  * 新功能：`风力涡轮机供电覆盖全球`
-  + 修复了`立即完成戴森壳建造`未生成太阳帆生产记录的问题
+  * 修复了`立即完成戴森壳建造`未生成太阳帆生产记录的问题
-
+* 2.3.24
-<details>
+  * `立即完成戴森壳建造`：修复了在某些情况下可能导致发电为负的问题
-<summary>更早的版本</summary>
-
-2.3.24
-  + `立即完成戴森壳建造`：修复了在某些情况下可能导致发电为负的问题
 * 2.3.23
-  + 新功能：`立即完成戴森壳建造`
+  * 新功能：`立即完成戴森壳建造`
-  + 修复了在游戏完全加载前打开配置面板可能导致的崩溃问题
+  * 修复了在游戏完全加载前打开配置面板可能导致的崩溃问题
 * 2.3.22
-  + 修复了`平地抽水`
+  * 修复了`平地抽水`
 * 2.3.21
-  + `在物流总控面板上可以从非本地行星取放物品`：当从非本地星球的物流站移除槽位时，物品会放回玩家的背包
+  * `在物流总控面板上可以从非本地行星取放物品`：当从非本地星球的物流站移除槽位时，物品会放回玩家的背包
-  + `开发模式快捷键`：摄像机位(Pose)相关的快捷键现在生效了
+  * `开发模式快捷键`：摄像机位(Pose)相关的快捷键现在生效了
 * 2.3.20
-  + 新功能：`在物流总控面板上可以从非本地行星取放物品`
+  * 新功能：`在物流总控面板上可以从非本地行星取放物品`
 * 2.3.19
-  + 新功能：
+  * 新功能：
-    + `移除所有元数据消耗记录`
+    * `移除所有元数据消耗记录`
-    + `移除当前存档的元数据消耗记录`
+    * `移除当前存档的元数据消耗记录`
-    + `解除当前存档因使用元数据导致的成就限制`
+    * `解除当前存档因使用元数据导致的成就限制`
 * 2.3.18
-  + 新功能：
+  * 新功能：
-    + `传送到外太空`，这会将你传送到距离最远星球50光年的外太空
+    * `传送到外太空`，这会将你传送到距离最远星球50光年的外太空
-    + `传送到选中天体`
+    * `传送到选中天体`
-  + 修复了`组合键解锁科技`的逻辑
+  * 修复了`组合键解锁科技`的逻辑
-  + `无条件建造`现在不会隐藏传送带的旋转信息了
+  * `无条件建造`现在不会隐藏传送带的旋转信息了
 * 2.3.17
-  + 适配游戏版本0.10.30.23292
+  * 适配游戏版本0.10.30.23292
 * 2.3.16
-  + 为`传送带信号物品生成`添加了两个选项：
+  * 为`传送带信号物品生成`添加了两个选项：
-    - `统计信息里将生成计算为产物`
+    * `统计信息里将生成计算为产物`
-    - `统计信息里将移除计算为消耗`
+    * `统计信息里将移除计算为消耗`
-  + 新功能：`提升物流塔和大型采矿机的最大功耗`
+  * 新功能：`提升物流塔和大型采矿机的最大功耗`
-    - 物流塔：将最大充电功率提高到3GW(星际物流塔)和600MW(行星物流塔)（原来的10倍）
+    * 物流塔：将最大充电功率提高到3GW(星际物流塔)和600MW(行星物流塔)（原来的10倍）
-    - 大型采矿机：将最大采矿速度提高到1000%
+    * 大型采矿机：将最大采矿速度提高到1000%
 * 2.3.15
-  + 新功能：
+  * 新功能：
-    - `快速传送(和沙盒模式一样)`
+    * `快速传送(和沙盒模式一样)`
-    - `机甲和战斗无人机无敌`
+    * `机甲和战斗无人机无敌`
-    - `建筑无敌`
+    * `建筑无敌`
 * 2.3.14
-  + 移除了`无条件建造`和`无碰撞`的默认快捷键，以避免误操作。如有需要请手动在系统选项窗口中设置。
+  * 移除了`无条件建造`和`无碰撞`的默认快捷键，以避免误操作。如有需要请手动在系统选项窗口中设置。
-  + 修复了翻译问题。
+  * 修复了翻译问题。
 * 2.3.13
-  + 修复了快捷键无效和设置窗口上的按键显示问题
+  * 修复了快捷键无效和设置窗口上的按键显示问题
 * 2.3.12
-  + 添加了一个快捷键来切换`无碰撞`，你可以在系统设置面板中修改快捷键。
+  * 添加了一个快捷键来切换`无碰撞`，你可以在系统设置面板中修改快捷键。
-  + 在使用快捷键切换`无条件建造`和`无碰撞`时添加了实时提示信息。
+  * 在使用快捷键切换`无条件建造`和`无碰撞`时添加了实时提示信息。
 * 2.3.11
-  + 添加了一个快捷键来切换`无条件建造`，你可以在系统设置面板中修改快捷键。这依赖于[UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) 1.0.15或更高版本
+  * 添加了一个快捷键来切换`无条件建造`，你可以在系统设置面板中修改快捷键。这依赖于[UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) 1.0.15或更高版本
 * 2.3.10
-  + 修复了以下功能在新游戏版本中不生效的问题：
+  * 修复了以下功能在新游戏版本中不生效的问题：
-    - `平地抽水`
+    * `平地抽水`
-    - `沙土不够时依然可以整改地形`
+    * `沙土不够时依然可以整改地形`
 * 2.3.9
-  + 支持游戏版本0.10.28.21219
+  * 支持游戏版本0.10.28.21219
 * 2.3.8
-  + 修复了启用`建造秒完成`时开新游戏可能导致崩溃的问题
+  * 修复了启用`建造秒完成`时开新游戏可能导致崩溃的问题
-  + 修复了UI按钮宽度
+  * 修复了UI按钮宽度
 * 2.3.7
-  + 支持游戏版本0.10.28.20759
+  * 支持游戏版本0.10.28.20759
-  + 修复了传送带信号有时候物品生成速度和设置不匹配的问题
+  * 修复了传送带信号有时候物品生成速度和设置不匹配的问题
 * 2.3.6
-  + 在`建造秒完成`中支持UXAssist的新功能
+  * 在`建造秒完成`中支持UXAssist的新功能
-  + 在启用`无条件建造`时添加警告信息
+  * 在启用`无条件建造`时添加警告信息
-  + 修复了`建造秒完成`可能导致部分建筑无法立即完成的问题
+  * 修复了`建造秒完成`可能导致部分建筑无法立即完成的问题
 * 2.3.5
-  + 修复了`跳过子弹阶段`可能导致崩溃的问题
+  * 修复了`跳过子弹阶段`可能导致崩溃的问题
 * 2.3.4
-  + 使用UXAssist 1.0.2的新页签布局
+  * 使用UXAssist 1.0.2的新页签布局
-  + 修复了一些小bug
+  * 修复了一些小bug
 * 2.3.3
-  + 修复了`跳过子弹阶段`可能导致崩溃的问题
+  * 修复了`跳过子弹阶段`可能导致崩溃的问题
-  + 使用Alt解锁科技时，现在`矿物利用`的科技解锁到10000级而不是7200级，因为UXAssist已修复对应bug
+  * 使用Alt解锁科技时，现在`矿物利用`的科技解锁到10000级而不是7200级，因为UXAssist已修复对应bug
 * 2.3.2
-  + 母星系的选项移动到了[UniverseGenTweaks](https://dsp.thunderstore.io/package/soarqin/UniverseGenTweaks/)
+  * 母星系的选项移动到了[UniverseGenTweaks](https://dsp.thunderstore.io/package/soarqin/UniverseGenTweaks/)
-  + 优化了`快速吸收`，现在消耗更少的CPU，并且会轮流打向各节点
+  * 优化了`快速吸收`，现在消耗更少的CPU，并且会轮流打向各节点
-  + `高速采集`现在可以保证油井的最大产出
+  * `高速采集`现在可以保证油井的最大产出
-  + 修复了`传送带信号物品生成`在选项关闭后再次启用时不生效的问题
+  * 修复了`传送带信号物品生成`在选项关闭后再次启用时不生效的问题
-  + 修复了`快速吸收`和`跳过子弹阶段`同时启用时可能导致吸收计算错误的问题
+  * 修复了`快速吸收`和`跳过子弹阶段`同时启用时可能导致吸收计算错误的问题
-  + 修复了一些选项可能导致崩溃的问题
+  * 修复了一些选项可能导致崩溃的问题
 * 2.3.1
-  + 在manifest中添加UXAssist到依赖
+  * 在manifest中添加UXAssist到依赖
 * 2.3.0
-  + 将部分功能移动到单独的mod：[UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)
+  * 将部分功能移动到单独的mod：[UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)
-  + 现在依赖[UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)，因此配置面板与UXAssist合并
+  * 现在依赖[UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)，因此配置面板与UXAssist合并
-  + 从开发模式快捷键中移除`LCtrl+A`，以避免误操作
+  * 从开发模式快捷键中移除`LCtrl+A`，以避免误操作
-  + 现在`建筑师模式`中配送机/物流机/物流船也无限了
+  * 现在`建筑师模式`中配送机/物流机/物流船也无限了
 * 2.2.7
-  + 新功能：`只建造节点不建造框架`
+  * 新功能：`只建造节点不建造框架`
-  + 打开设置面板时不再关闭背包面板
+  * 打开设置面板时不再关闭背包面板
-  + 在`移除部分不影响游戏逻辑的建造条件`启用时移除`输入方向冲突`的检查条件
+  * 在`移除部分不影响游戏逻辑的建造条件`启用时移除`输入方向冲突`的检查条件
-  + 修复导致`传送带信号替换格式`不切换传送带信号数字格式的问题
+  * 修复导致`传送带信号替换格式`不切换传送带信号数字格式的问题
 * 2.2.6
-  + 新功能：`可用节点全部造完时停止弹射`
+  * 新功能：`可用节点全部造完时停止弹射`
-  + 修复了在未完成的节点上吸收太阳帆的问题
+  * 修复了在未完成的节点上吸收太阳帆的问题
 * 2.2.5
-  + 在同时启用`快速吸收`、`跳过子弹阶段`和`跳过吸收阶段`时，所有弹射的太阳帆会跳过所有中间环节立即吸收
+  * 在同时启用`快速吸收`、`跳过子弹阶段`和`跳过吸收阶段`时，所有弹射的太阳帆会跳过所有中间环节立即吸收
-  + 修复了`快速吸收`在大部分节点已满时无法立即吸收所有太阳帆的问题
+  * 修复了`快速吸收`在大部分节点已满时无法立即吸收所有太阳帆的问题
-  + 修复了与一些mod的兼容性问题
+  * 修复了与一些mod的兼容性问题
 * 2.2.4
-  + 新功能：`在行星视图中允许玩家操作`
+  * 新功能：`在行星视图中允许玩家操作`
-  + 修复了UI显示问题
+  * 修复了UI显示问题
 * 2.2.3
-  + 新功能：`移除部分不影响游戏逻辑的建造条件`
+  * 新功能：`移除部分不影响游戏逻辑的建造条件`
-  + 修复了与一些mod的兼容性问题
+  * 修复了与一些mod的兼容性问题
 * 2.2.2
-  + 新功能：`将游戏存档绑定给当前账号`
+  * 新功能：`将游戏存档绑定给当前账号`
-  + 新子功能：`传送带信号替换格式`
+  * 新子功能：`传送带信号替换格式`
-  + 修复了`初始化本行星`可能导致崩溃的问题
+  * 修复了`初始化本行星`可能导致崩溃的问题
-  + 修复了`建造秒完成`中传送带建造的问题
+  * 修复了`建造秒完成`中传送带建造的问题
 * 2.2.1
-  + 即使在启用`无条件建造`时依然检查矿机的建造条件
+  * 即使在启用`无条件建造`时依然检查矿机的建造条件
-  + 修复一个可能导致`无条件建造`不生效的问题
+  * 修复一个可能导致`无条件建造`不生效的问题
 * 2.2.0
-  + 添加了一些发电相关功能
+  * 添加了一些发电相关功能
-  + 为传送带信号物品生成添加了一个子功能，在统计面板模拟了原材料和中间产物的生产过程
+  * 为传送带信号物品生成添加了一个子功能，在统计面板模拟了原材料和中间产物的生产过程
-  + 从建筑师模式中分离了一些功能
+  * 从建筑师模式中分离了一些功能
 * 2.1.0
-  + 传送带信号物品生成
+  * 传送带信号物品生成
-  + 修复窗口显示优先级可能导致提示信息被主窗口遮挡的问题
+  * 修复窗口显示优先级可能导致提示信息被主窗口遮挡的问题
 * 2.0.0
-  + 重构代码
+  * 重构代码
-  + UI实现
+  * UI实现
-  + 添加了很多功能
+  * 添加了很多功能
 * 1.0.0
-  + 初始版本
+  * 初始版本
 
 </details>

CheatEnabler/CheatEnabler.cs

@@ -63,12 +63,16 @@ public class CheatEnabler : BaseUnityPlugin
             "Can pump water anywhere (while water type is not None)");
         PlanetPatch.TerraformAnywayEnabled = Config.Bind("Planet", "TerraformAnyway", false,
             "Can do terraform without enough soil piless");
+        PlayerPatch.InstantHandCraftEnabled = Config.Bind("Player", "InstantHandCraft", false,
+            "Enable instant hand-craft");
         PlayerPatch.InstantTeleportEnabled = Config.Bind("Player", "InstantTeleport", false,
             "Enable instant teleport (like that in Sandbox mode)");
         PlayerPatch.WarpWithoutSpaceWarpersEnabled = Config.Bind("Player", "WarpWithoutWarper", false,
             "Enable warp without warper");
         DysonSpherePatch.SkipBulletEnabled = Config.Bind("DysonSphere", "SkipBullet", false,
             "Skip bullet");
+        DysonSpherePatch.FireAllBulletsEnabled = Config.Bind("DysonSphere", "FireAllBullets", false,
+            "Fire all bullets at once");
         DysonSpherePatch.SkipAbsorbEnabled = Config.Bind("DysonSphere", "SkipAbsorb", false,
             "Skip absorption");
         DysonSpherePatch.QuickAbsorbEnabled = Config.Bind("DysonSphere", "QuickAbsorb", false,
@@ -79,6 +83,14 @@ public class CheatEnabler : BaseUnityPlugin
             "Overclock ejector");
         DysonSpherePatch.OverclockSiloEnabled = Config.Bind("DysonSphere", "OverclockSilo", false,
             "Overclock silo");
+        DysonSpherePatch.UnlockMaxOrbitRadiusEnabled = Config.Bind("DysonSphere", "UnlockMaxOrbitRadius", false,
+            "Unlock Dyson Sphere max orbit radius");
+        DysonSpherePatch.UnlockMaxOrbitRadiusValue = Config.Bind("DysonSphere", "MaxOrbitRadiusValue", 10_000_000f,
+            "Unlocked Dyson Sphere max orbit radius value");
+        Functions.DysonSphereFunctions.IllegalDysonShellFunctionsEnabled = Config.Bind("DysonSphere", "IllegalDysonShellFunctions", false,
+            "Enable illegal dyson shell functions");
+        Functions.DysonSphereFunctions.ShellsCountForFunctions = Config.Bind("DysonSphere", "ShellsCountForFunctions", 2048,
+            "Shells count for various functions");
         CombatPatch.MechaInvincibleEnabled = Config.Bind("Battle", "MechaInvincible", false,
             "Mecha and Drones/Fleets invincible");
         CombatPatch.BuildingsInvincibleEnabled = Config.Bind("Battle", "BuildingsInvincible", false,
@@ -104,6 +116,6 @@ public class CheatEnabler : BaseUnityPlugin
     private void Update()
     {
         if (VFInput.inputing) return;
-        FactoryPatch.OnUpdate();
+        FactoryPatch.OnInputUpdate();
     }
 }

CheatEnabler/CheatEnabler.csproj

@@ -5,7 +5,7 @@
     <TargetFramework>net472</TargetFramework>
     <BepInExPluginGuid>org.soardev.cheatenabler</BepInExPluginGuid>
     <Description>DSP MOD - CheatEnabler</Description>
-    <Version>2.3.26</Version>
+    <Version>2.4.0</Version>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <LangVersion>latest</LangVersion>
     <PackageId>CheatEnabler</PackageId>
@@ -16,19 +16,28 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="UnityEngine.Modules" Version="2022.3.53" IncludeAssets="compile" />
-    <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
+    <!-- <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" /> -->
   </ItemGroup>
-  
+
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Reference Include="Assembly-CSharp">
+      <HintPath>..\AssemblyFromGame\Assembly-CSharp.dll</HintPath>
+    </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>..\AssemblyFromGame\UnityEngine.UI.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\UXAssist\UXAssist.csproj" />
   </ItemGroup>
 
-  <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
+  <Target Name="PostBuild" AfterTargets="PostBuildEvent">
     <Exec Command="del /F /Q package\$(ProjectName)-$(Version).zip&#xA;powershell Compress-Archive -Force -DestinationPath 'package/$(ProjectName)-$(Version).zip' -Path '$(TargetPath)', package/icon.png, package/manifest.json, README.md, CHANGELOG.md" />
   </Target>
 </Project>

CheatEnabler/Functions/PlayerFunctions.cs

@@ -106,7 +106,7 @@ public static class PlayerFunctions
 
         if (itemCnt.All(cnt => cnt == 0))
         {
-            UIMessageBox.Show("Remove all metadata consumption records".Translate(), "NoMetadataConsumptionRecord".Translate(), "OK".Translate(), 0);
+            UIMessageBox.Show("Remove all metadata consumption records".Translate(), "NoMetadataConsumptionRecord".Translate(), "OK".Translate(), UIMessageBox.INFO);
             return;
         }
         var msg = "ClearAllMetadataConsumptionDetails".Translate();
@@ -117,7 +117,7 @@ public static class PlayerFunctions
                 msg += $"\n  {LDB.items.Select(i + 6001).propertyName} x{itemCnt[i]}";
             }
         }
-        UIMessageBox.Show("Remove all metadata consumption records".Translate(), msg, "取消".Translate(), "确定".Translate(), 2, null, () =>
+        UIMessageBox.Show("Remove all metadata consumption records".Translate(), msg, "取消".Translate(), "确定".Translate(), UIMessageBox.QUESTION, null, () =>
         {
             foreach (var data in propertySystem.propertyDatas)
             {
@@ -143,17 +143,18 @@ public static class PlayerFunctions
         var clusterPropertyData = propertySystem.propertyDatas.FirstOrDefault(cpd => cpd.seedKey == seedKey);
         if (clusterPropertyData == null)
         {
-            UIMessageBox.Show("Remove metadata consumption record in current game".Translate(), "NoMetadataConsumptionRecord".Translate(), "OK".Translate(), 0);
+            UIMessageBox.Show("Remove metadata consumption record in current game".Translate(), "NoMetadataConsumptionRecord".Translate(), "OK".Translate(), UIMessageBox.INFO);
             return;
         }
-        foreach (var cons in clusterPropertyData.totalConsumption.Where(cons => cons.id is >= 6001 and <= 6006))
+        var currentGamePropertyData = GameMain.data.history.propertyData;
+        foreach (var cons in currentGamePropertyData.totalConsumption.Where(cons => cons.id is >= 6001 and <= 6006))
         {
             itemCnt[cons.id - 6001] += cons.count;
         }
 
         if (itemCnt.All(cnt => cnt == 0))
         {
-            UIMessageBox.Show("Remove metadata consumption record in current game".Translate(), "NoMetadataConsumptionRecord".Translate(), "OK".Translate(), 0);
+            UIMessageBox.Show("Remove metadata consumption record in current game".Translate(), "NoMetadataConsumptionRecord".Translate(), "OK".Translate(), UIMessageBox.INFO);
             return;
         }
         var msg = "ClearCurrentMetadataConsumptionDetails".Translate();
@@ -164,13 +165,17 @@ public static class PlayerFunctions
                 msg += $"\n  {LDB.items.Select(i + 6001).propertyName} x{itemCnt[i]}";
             }
         }
-        UIMessageBox.Show("Remove metadata consumption record in current game".Translate(), msg, "取消".Translate(), "确定".Translate(), 2, null, () =>
+        UIMessageBox.Show("Remove metadata consumption record in current game".Translate(), msg, "取消".Translate(), "确定".Translate(), UIMessageBox.QUESTION, null, () =>
         {
             for (var i = 0; i < clusterPropertyData.totalConsumption.Count; i++)
             {
                 if (clusterPropertyData.totalConsumption[i].count == 0) continue;
                 var id = clusterPropertyData.totalConsumption[i].id;
-                clusterPropertyData.totalConsumption[i] = new IDCNT(id, 0);
+                if (id < 6001 || id > 6006) continue;
+                var currentGameCount = itemCnt[id - 6001];
+                if (currentGameCount == 0) continue;
+                var totalCount = clusterPropertyData.totalConsumption[i].count;
+                clusterPropertyData.totalConsumption[i] = new IDCNT(id, totalCount > currentGameCount ? totalCount - currentGameCount : 0);
             }
             PurgePropertySystem(propertySystem);
             propertySystem.SaveToFile();

CheatEnabler/Patches/CombatPatch.cs

@@ -30,7 +30,7 @@ public static class CombatPatch
         MechaInvincible.Enable(false);
     }
 
-    private class MechaInvincible: PatchImpl<MechaInvincible>
+    private class MechaInvincible : PatchImpl<MechaInvincible>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(Player), nameof(Player.invincible), MethodType.Getter)]
@@ -65,7 +65,7 @@ public static class CombatPatch
         }
     }
 
-    private class BuildingsInvincible: PatchImpl<BuildingsInvincible>
+    private class BuildingsInvincible : PatchImpl<BuildingsInvincible>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(SkillSystem), nameof(SkillSystem.DamageGroundObjectByLocalCaster))]

CheatEnabler/Patches/DysonSpherePatch.cs

@@ -4,17 +4,21 @@ using System.Reflection.Emit;
 using BepInEx.Configuration;
 using HarmonyLib;
 using UXAssist.Common;
+using GameLogicProc = UXAssist.Common.GameLogic;
 
 namespace CheatEnabler.Patches;
 
-public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
+public class DysonSpherePatch : PatchImpl<DysonSpherePatch>
 {
     public static ConfigEntry<bool> SkipBulletEnabled;
+    public static ConfigEntry<bool> FireAllBulletsEnabled;
     public static ConfigEntry<bool> SkipAbsorbEnabled;
     public static ConfigEntry<bool> QuickAbsorbEnabled;
     public static ConfigEntry<bool> EjectAnywayEnabled;
     public static ConfigEntry<bool> OverclockEjectorEnabled;
     public static ConfigEntry<bool> OverclockSiloEnabled;
+    public static ConfigEntry<bool> UnlockMaxOrbitRadiusEnabled;
+    public static ConfigEntry<float> UnlockMaxOrbitRadiusValue;
     private static bool _instantAbsorb;
 
     public static void Init()
@@ -25,6 +29,9 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         EjectAnywayEnabled.SettingChanged += (_, _) => EjectAnywayPatch.Enable(EjectAnywayEnabled.Value);
         OverclockEjectorEnabled.SettingChanged += (_, _) => OverclockEjector.Enable(OverclockEjectorEnabled.Value);
         OverclockSiloEnabled.SettingChanged += (_, _) => OverclockSilo.Enable(OverclockSiloEnabled.Value);
+        UnlockMaxOrbitRadiusEnabled.SettingChanged += (_, _) => UnlockMaxOrbitRadius.Enable(UnlockMaxOrbitRadiusEnabled.Value);
+
+        FireAllBulletsEnabled.SettingChanged += (_, _) => SkipBulletPatch.SetFireAllBullets(FireAllBulletsEnabled.Value);
     }
 
     public static void Start()
@@ -35,9 +42,11 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         EjectAnywayPatch.Enable(EjectAnywayEnabled.Value);
         OverclockEjector.Enable(OverclockEjectorEnabled.Value);
         OverclockSilo.Enable(OverclockSiloEnabled.Value);
+        UnlockMaxOrbitRadius.Enable(UnlockMaxOrbitRadiusEnabled.Value);
         Enable(true);
+        SkipBulletPatch.SetFireAllBullets(FireAllBulletsEnabled.Value);
     }
-    
+
     public static void Uninit()
     {
         Enable(false);
@@ -47,8 +56,16 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         EjectAnywayPatch.Enable(false);
         OverclockEjector.Enable(false);
         OverclockSilo.Enable(false);
+        UnlockMaxOrbitRadius.Enable(false);
     }
-        
+
+    // [HarmonyPostfix]
+    // [HarmonyPatch(typeof(DysonShell), nameof(DysonShell.ImportFromBlueprint))]
+    // private static void DysonShell_ImportFromBlueprint_Postfix(DysonShell __instance)
+    // {
+    //     CheatEnabler.Logger.LogDebug($"[DysonShell.ImportFromBlueprint] vertCount={__instance.vertexCount}, cpPerVertex={__instance.cpPerVertex}, cpMax={__instance.cellPointMax}");
+    // }
+
     [HarmonyTranspiler]
     [HarmonyPatch(typeof(DysonNode), nameof(DysonNode.OrderConstructCp))]
     private static IEnumerable<CodeInstruction> DysonNode_OrderConstructCp_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
@@ -83,12 +100,18 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         return matcher.InstructionEnumeration();
     }
 
-    private class SkipBulletPatch: PatchImpl<SkipBulletPatch>
+    private class SkipBulletPatch : PatchImpl<SkipBulletPatch>
     {
         private static long _sailLifeTime;
         private static DysonSailCache[][] _sailsCache;
         private static int[] _sailsCacheLen, _sailsCacheCapacity;
-        
+        private static bool _fireAllBullets;
+
+        public static void SetFireAllBullets(bool value)
+        {
+            _fireAllBullets = value;
+        }
+
         private struct DysonSailCache
         {
             public DysonSail Sail;
@@ -111,12 +134,12 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         {
             UpdateSailLifeTime();
             UpdateSailsCacheForThisGame();
-            GameLogic.OnGameBegin += GameMain_Begin_Postfix;
+            GameLogicProc.OnGameBegin += GameMain_Begin_Postfix;
         }
 
         protected override void OnDisable()
         {
-            GameLogic.OnGameBegin -= GameMain_Begin_Postfix;
+            GameLogicProc.OnGameBegin -= GameMain_Begin_Postfix;
         }
 
         private static void UpdateSailLifeTime()
@@ -136,7 +159,7 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             Array.Clear(_sailsCacheLen, 0, starCount);
             Array.Clear(_sailsCacheCapacity, 0, starCount);
         }
-        
+
         private static void SetSailsCacheCapacity(int index, int capacity)
         {
             var newCache = new DysonSailCache[capacity];
@@ -164,7 +187,7 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                 UpdateSailLifeTime();
             }
         }
-        
+
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(EjectorComponent), nameof(EjectorComponent.InternalUpdate))]
         private static IEnumerable<CodeInstruction> EjectorComponent_InternalUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
@@ -175,25 +198,28 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             ).Advance(2);
             var start = matcher.Pos;
             matcher.MatchForward(false,
-                new CodeMatch(OpCodes.Pop)
+                new CodeMatch(OpCodes.Ldc_I4_M1),
-            ).Advance(1);
+                new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.direction)))
+            ).Advance(2);
             var end = matcher.Pos;
             matcher.Start().Advance(start).RemoveInstructions(end - start).Insert(
-                new CodeInstruction(OpCodes.Ldarg_2),
                 new CodeInstruction(OpCodes.Ldarg_0),
-                new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.orbitId))),
+                new CodeInstruction(OpCodes.Ldarg_3),
-                new CodeInstruction(OpCodes.Ldloc_S, 8),
+                new CodeInstruction(OpCodes.Ldloc_S, 9),
-                new CodeInstruction(OpCodes.Ldloc_S, 10),
+                new CodeInstruction(OpCodes.Ldloc_S, 11),
+                new CodeInstruction(OpCodes.Ldarg_S, 6),
                 new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(SkipBulletPatch), nameof(SkipBulletPatch.AddDysonSail)))
             );
             return matcher.InstructionEnumeration();
         }
 
-        private static void AddDysonSail(DysonSwarm swarm, int orbitId, VectorLF3 uPos, VectorLF3 endVec)
+        private static void AddDysonSail(ref EjectorComponent ejector, DysonSwarm swarm, VectorLF3 uPos, VectorLF3 endVec, int[] consumeRegister)
         {
             var index = swarm.starData.index;
+            var orbitId = ejector.orbitId;
             var delta1 = endVec - swarm.starData.uPosition;
             var delta2 = VectorLF3.Cross(endVec - uPos, swarm.orbits[orbitId].up).normalized * Math.Sqrt(swarm.dysonSphere.gravity / swarm.orbits[orbitId].radius);
+            var bulletCount = ejector.bulletCount;
             lock (swarm)
             {
                 var cache = _sailsCache[index];
@@ -203,6 +229,24 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                     SetSailsCacheCapacity(index, 256);
                     cache = _sailsCache[index];
                 }
+                if (_fireAllBullets)
+                {
+                    var capacity = _sailsCacheCapacity[index];
+                    var leastCapacity = len + bulletCount;
+                    if (leastCapacity > capacity)
+                    {
+                        do
+                        {
+                            capacity *= 2;
+                        } while (leastCapacity > capacity);
+                        SetSailsCacheCapacity(index, capacity);
+                        cache = _sailsCache[index];
+                    }
+                    _sailsCacheLen[index] = len + bulletCount;
+                    var end = len + bulletCount;
+                    for (var i = len; i < end; i++)
+                        cache[i].FromData(delta1, delta2 + RandomTable.SphericNormal(ref swarm.randSeed, 0.5), orbitId);
+                }
                 else
                 {
                     var capacity = _sailsCacheCapacity[index];
@@ -211,14 +255,48 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                         SetSailsCacheCapacity(index, capacity * 2);
                         cache = _sailsCache[index];
                     }
+                    _sailsCacheLen[index] = len + 1;
+                    cache[len].FromData(delta1, delta2 + RandomTable.SphericNormal(ref swarm.randSeed, 0.5), orbitId);
                 }
-                _sailsCacheLen[index] = len + 1;
-                cache[len].FromData(delta1, delta2 + RandomTable.SphericNormal(ref swarm.randSeed, 0.5), orbitId);
             }
+
+            if (_fireAllBullets)
+            {
+                if (!ejector.incUsed)
+                {
+                    ejector.incUsed = ejector.bulletInc >= bulletCount;
+                }
+                ejector.bulletInc = 0;
+                ejector.bulletCount = 0;
+                lock (consumeRegister)
+                {
+                    consumeRegister[ejector.bulletId] += bulletCount;
+                }
+            }
+            else
+            {
+                var inc = ejector.bulletInc / bulletCount;
+                if (!ejector.incUsed)
+                {
+                    ejector.incUsed = inc > 0;
+                }
+                ejector.bulletInc -= inc;
+                ejector.bulletCount = bulletCount - 1;
+                if (ejector.bulletCount == 0)
+                {
+                    ejector.bulletInc = 0;
+                }
+                lock (consumeRegister)
+                {
+                    consumeRegister[ejector.bulletId]++;
+                }
+            }
+            ejector.time = ejector.coldSpend;
+            ejector.direction = -1;
         }
 
         [HarmonyPrefix]
-        [HarmonyPatch(typeof(DysonSwarm), "GameTick")]
+        [HarmonyPatch(typeof(DysonSwarm), nameof(DysonSwarm.GameTick))]
         public static void DysonSwarm_GameTick_Prefix(DysonSwarm __instance, long time)
         {
             var index = __instance.starData.index;
@@ -256,9 +334,9 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                                 if (node.ConstructCp() == null) break;
                                 if (idx == 0)
                                 {
-                                    sphereProductRegister[11901] += len;
+                                    sphereProductRegister[ProductionStatistics.SOLAR_SAIL_ID] += len;
-                                    sphereConsumeRegister[11901] += len;
+                                    sphereConsumeRegister[ProductionStatistics.SOLAR_SAIL_ID] += len;
-                                    sphereProductRegister[11903] += len;
+                                    sphereProductRegister[ProductionStatistics.DYSON_CELL_ID] += len;
                                     return;
                                 }
                                 idx--;
@@ -269,9 +347,9 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                 var absorbCnt = len - 1 - idx;
                 if (absorbCnt > 0)
                 {
-                    sphereProductRegister[11901] += absorbCnt;
+                    sphereProductRegister[ProductionStatistics.SOLAR_SAIL_ID] += absorbCnt;
-                    sphereConsumeRegister[11901] += absorbCnt;
+                    sphereConsumeRegister[ProductionStatistics.SOLAR_SAIL_ID] += absorbCnt;
-                    sphereProductRegister[11903] += absorbCnt;
+                    sphereProductRegister[ProductionStatistics.DYSON_CELL_ID] += absorbCnt;
                 }
             }
             for (; idx >= 0; idx--)
@@ -280,8 +358,8 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             }
         }
     }
-    
+
-    private class SkipAbsorbPatch: PatchImpl<SkipAbsorbPatch>
+    private class SkipAbsorbPatch : PatchImpl<SkipAbsorbPatch>
     {
         protected override void OnEnable()
         {
@@ -304,7 +382,7 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             ).Advance(1).RemoveInstructions(matcher.Length - matcher.Pos).Insert(
                 // if (node.ConstructCp() != null)
                 // {
-                //     this.dysonSphere.productRegister[11903]++;
+                //     this.dysonSphere.productRegister[ProductionStatistics.DYSON_CELL_ID]++;
                 // }
                 new CodeInstruction(OpCodes.Ldarg_1),
                 new CodeInstruction(OpCodes.Callvirt, AccessTools.Method(typeof(DysonNode), nameof(DysonNode.ConstructCp))),
@@ -312,19 +390,19 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                 new CodeInstruction(OpCodes.Ldarg_0),
                 new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(DysonSwarm), nameof(DysonSwarm.dysonSphere))),
                 new CodeInstruction(OpCodes.Call, AccessTools.PropertyGetter(typeof(DysonSphere), nameof(DysonSphere.productRegister))),
-                new CodeInstruction(OpCodes.Ldc_I4, 11903),
+                new CodeInstruction(OpCodes.Ldc_I4, ProductionStatistics.DYSON_CELL_ID),
                 new CodeInstruction(OpCodes.Ldelema, typeof(int)),
                 new CodeInstruction(OpCodes.Dup),
                 new CodeInstruction(OpCodes.Ldind_I4),
                 new CodeInstruction(OpCodes.Ldc_I4_1),
                 new CodeInstruction(OpCodes.Add),
                 new CodeInstruction(OpCodes.Stind_I4),
-                
+
                 // this.RemoveSolarSail(index);
                 new CodeInstruction(OpCodes.Ldarg_0).WithLabels(label1),
                 new CodeInstruction(OpCodes.Ldloc_1),
                 new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(DysonSwarm), nameof(DysonSwarm.RemoveSolarSail))),
-                
+
                 // return false;
                 new CodeInstruction(OpCodes.Ldc_I4_1),
                 new CodeInstruction(OpCodes.Ret)
@@ -332,8 +410,8 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             return matcher.InstructionEnumeration();
         }
     }
-    
+
-    private class QuickAbsorbPatch: PatchImpl<QuickAbsorbPatch>
+    private class QuickAbsorbPatch : PatchImpl<QuickAbsorbPatch>
     {
         protected override void OnEnable()
         {
@@ -363,7 +441,7 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             /* Insert a RETURN before old absorption functions */
             return matcher.InstructionEnumeration();
         }
-        
+
         private static void DoAbsorb(DysonSphereLayer layer, long gameTick)
         {
             var nodeCount = layer.nodeCursor - 1;
@@ -383,43 +461,42 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             }
         }
     }
-    
+
-    private class EjectAnywayPatch: PatchImpl<EjectAnywayPatch>
+    private class EjectAnywayPatch : PatchImpl<EjectAnywayPatch>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(EjectorComponent), nameof(EjectorComponent.InternalUpdate))]
         private static IEnumerable<CodeInstruction> EjectorComponent_InternalUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
         {
             var matcher = new CodeMatcher(instructions, generator);
-            matcher.MatchForward(false,
+            matcher.End().MatchBack(false,
                 new CodeMatch(instr => instr.opcode == OpCodes.Ldc_R8 && Math.Abs((double)instr.operand - 0.08715574) < 0.00000001)
             );
             var start = matcher.Pos - 3;
             matcher.MatchForward(false,
-                new CodeMatch(OpCodes.And)
+                new CodeMatch(OpCodes.Ldarg_0),
-            ).Advance(1).MatchForward(false,
+                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.bulletCount)))
-                new CodeMatch(OpCodes.And)
             );
-            var end = matcher.Pos - 2;
+            var end = matcher.Pos;
-            /* Remove angle checking codes, then add:
+            matcher.Start().Advance(start).RemoveInstructions(end - start).MatchForward(false,
-             *   V_13 = this.bulletCount > 0;
+                new CodeMatch(ci => ci.IsStloc())
-             */
+            ).Advance(1);
-            matcher.Start().Advance(start).RemoveInstructions(end - start).Insert(
+            start = matcher.Pos;
-                new CodeInstruction(OpCodes.Ldarg_0),
+            matcher.MatchForward(false,
-                new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.bulletCount))),
+                new CodeMatch(OpCodes.Ldarg_0),
-                new CodeInstruction(OpCodes.Ldc_I4_0),
+                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.autoOrbit)))
-                new CodeInstruction(OpCodes.Cgt),
-                new CodeInstruction(OpCodes.Stloc_S, 13)
             );
+            end = matcher.Pos;
+            matcher.Start().Advance(start).RemoveInstructions(end - start);
             return matcher.InstructionEnumeration();
         }
     }
 
-    private class OverclockEjector: PatchImpl<OverclockEjector>
+    private class OverclockEjector : PatchImpl<OverclockEjector>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(EjectorComponent), nameof(EjectorComponent.InternalUpdate))]
-        private static IEnumerable<CodeInstruction> EjectAndSiloComponent_InternalUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+        private static IEnumerable<CodeInstruction> EjectComponent_InternalUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
         {
             var matcher = new CodeMatcher(instructions, generator);
             /* Add a multiply to ejector speed */
@@ -468,11 +545,11 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         }
     }
 
-    private class OverclockSilo: PatchImpl<OverclockSilo>
+    private class OverclockSilo : PatchImpl<OverclockSilo>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(SiloComponent), nameof(SiloComponent.InternalUpdate))]
-        private static IEnumerable<CodeInstruction> EjectAndSiloComponent_InternalUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+        private static IEnumerable<CodeInstruction> SiloComponent_InternalUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
         {
             var matcher = new CodeMatcher(instructions, generator);
             /* Add a multiply to ejector speed */
@@ -520,4 +597,53 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
             return matcher.InstructionEnumeration();
         }
     }
+
+    private class UnlockMaxOrbitRadius : PatchImpl<UnlockMaxOrbitRadius>
+    {
+        protected override void OnEnable()
+        {
+            OnViewStarChange(null, null);
+            UnlockMaxOrbitRadiusValue.SettingChanged += OnViewStarChange;
+        }
+
+        protected override void OnDisable()
+        {
+            OnViewStarChange(null, null);
+            UnlockMaxOrbitRadiusValue.SettingChanged -= OnViewStarChange;
+        }
+
+        public static void OnViewStarChange(object o, EventArgs e)
+        {
+            var dysonEditor = UIRoot.instance?.uiGame?.dysonEditor;
+            if (dysonEditor == null || !dysonEditor.gameObject.activeSelf) return;
+            dysonEditor.selection?.onViewStarChange?.Invoke();
+        }
+
+        [HarmonyTranspiler]
+        [HarmonyPatch(typeof(DysonSphere), nameof(DysonSphere.CheckLayerRadius))]
+        [HarmonyPatch(typeof(DysonSphere), nameof(DysonSphere.CheckSwarmRadius))]
+        [HarmonyPatch(typeof(DysonSphere), nameof(DysonSphere.QueryLayerRadius))]
+        [HarmonyPatch(typeof(DysonSphere), nameof(DysonSphere.QuerySwarmRadius))]
+        [HarmonyPatch(typeof(UIDEAddLayerDialogue), nameof(UIDEAddLayerDialogue.OnViewStarChange))]
+        [HarmonyPatch(typeof(UIDEAddSwarmDialogue), nameof(UIDEAddSwarmDialogue.OnViewStarChange))]
+        [HarmonyPatch(typeof(UIDysonEditor), nameof(UIDysonEditor.OnViewStarChange))]
+        [HarmonyPatch(typeof(UIDESwarmOrbitInfo), nameof(UIDESwarmOrbitInfo._OnInit))]
+        [HarmonyPatch(typeof(UIDysonOrbitPreview), nameof(UIDysonOrbitPreview.UpdateAscNodeGizmos))]
+        private static IEnumerable<CodeInstruction> MaxOrbitRadiusPatch_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+        {
+            var matcher = new CodeMatcher(instructions, generator);
+            matcher.MatchForward(false,
+                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(DysonSphere), nameof(DysonSphere.maxOrbitRadius)))
+            );
+            matcher.Repeat(m =>
+            {
+                m.Advance(1).InsertAndAdvance(
+                    new CodeInstruction(OpCodes.Pop),
+                    new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(DysonSpherePatch), nameof(UnlockMaxOrbitRadiusValue))),
+                    new CodeInstruction(OpCodes.Call, AccessTools.PropertyGetter(typeof(ConfigEntry<float>), nameof(ConfigEntry<float>.Value)))
+                );
+            });
+            return matcher.InstructionEnumeration();
+        }
+    }
 }

CheatEnabler/Patches/FactoryPatch.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection.Emit;
 using BepInEx.Configuration;
 using CommonAPI.Systems;
@@ -7,10 +8,11 @@ using HarmonyLib;
 using UnityEngine;
 using UnityEngine.UI;
 using UXAssist.Common;
+using GameLogicProc = UXAssist.Common.GameLogic;
 
 namespace CheatEnabler.Patches;
 
-public class FactoryPatch: PatchImpl<FactoryPatch>
+public class FactoryPatch : PatchImpl<FactoryPatch>
 {
     public static ConfigEntry<bool> ImmediateEnabled;
     public static ConfigEntry<bool> ArchitectModeEnabled;
@@ -36,23 +38,23 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
     public static void Init()
     {
         _noConditionKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
-            {
+        {
-                key = new CombineKey(0, 0, ECombineKeyAction.OnceClick, true),
+            key = new CombineKey(0, 0, ECombineKeyAction.OnceClick, true),
-                conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
+            conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
-                name = "ToggleNoCondition",
+            name = "ToggleNoCondition",
-                canOverride = true
+            canOverride = true
-            }
+        }
         );
         _noCollisionKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
-            {
+        {
-                key = new CombineKey(0, 0, ECombineKeyAction.OnceClick, true),
+            key = new CombineKey(0, 0, ECombineKeyAction.OnceClick, true),
-                conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
+            conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
-                name = "ToggleNoCollision",
+            name = "ToggleNoCollision",
-                canOverride = true
+            canOverride = true
-            }
+        }
         );
-        I18N.Add("KEYToggleNoCondition", "Toggle No Condition Build", "切换无条件建造");
+        I18N.Add("KEYToggleNoCondition", "[CE] Toggle No Condition Build", "[CE] 切换无条件建造");
-        I18N.Add("KEYToggleNoCollision", "Toggle No Collision", "切换无碰撞");
+        I18N.Add("KEYToggleNoCollision", "[CE] Toggle No Collision", "[CE] 切换无碰撞");
         I18N.Add("NoConditionOn", "No condition build is enabled!", "无条件建造已开启");
         I18N.Add("NoConditionOff", "No condition build is disabled!", "无条件建造已关闭");
         I18N.Add("NoCollisionOn", "No collision is enabled!", "无碰撞已开启");
@@ -91,14 +93,16 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         GreaterPowerUsageInLogistics.Enable(GreaterPowerUsageInLogisticsEnabled.Value);
         ControlPanelRemoteLogistics.Enable(ControlPanelRemoteLogisticsEnabled.Value);
         Enable(true);
-        GameLogic.OnGameBegin += GameMain_Begin_Postfix_For_ImmBuild;
+        CargoTrafficPatch.Enable(true);
-        GameLogic.OnDataLoaded += OnDataLoaded;
+        GameLogicProc.OnGameBegin += GameMain_Begin_Postfix_For_ImmBuild;
+        GameLogicProc.OnDataLoaded += OnDataLoaded;
     }
 
     public static void Uninit()
     {
-        GameLogic.OnDataLoaded -= OnDataLoaded;
+        GameLogicProc.OnDataLoaded -= OnDataLoaded;
-        GameLogic.OnGameBegin -= GameMain_Begin_Postfix_For_ImmBuild;
+        GameLogicProc.OnGameBegin -= GameMain_Begin_Postfix_For_ImmBuild;
+        CargoTrafficPatch.Enable(false);
         Enable(false);
         ImmediateBuild.Enable(false);
         ArchitectMode.Enable(false);
@@ -114,9 +118,18 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         ControlPanelRemoteLogistics.Enable(false);
     }
 
-    private static void OnDataLoaded() => WindTurbinesPowerGlobalCoverage.Enable(WindTurbinesPowerGlobalCoverageEnabled.Value);
+    private static HashSet<int> _beltIds = [];
+    private static HashSet<int> _alterBeltRendererIds;
+    private static HashSet<int> _alterPathRendererIds;
+    private static HashSet<int> _refreshPathUVIds;
 
-    public static void OnUpdate()
+    private static void OnDataLoaded()
+    {
+        WindTurbinesPowerGlobalCoverage.Enable(WindTurbinesPowerGlobalCoverageEnabled.Value);
+        _beltIds ??= [.. LDB.items.dataArray.Where(i => i.prefabDesc.isBelt).Select(i => i.ID)];
+    }
+
+    public static void OnInputUpdate()
     {
         if (_noConditionKey.keyValue)
         {
@@ -148,31 +161,124 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
 
     public static void ArrivePlanet(PlanetFactory factory)
     {
+        if (factory.prebuildCount <= 0) return;
         var imm = ImmediateEnabled.Value;
         var architect = ArchitectModeEnabled.Value;
         if ((!imm && !architect) || GameMain.gameScenario == null) return;
         var prebuilds = factory.prebuildPool;
-        if (imm) factory.BeginFlattenTerrain();
+        if (imm)
-        for (var i = factory.prebuildCursor - 1; i > 0; i--)
         {
-            if (prebuilds[i].id != i) continue;
+            var anyBelt = false;
-            if (prebuilds[i].itemRequired > 0)
+            var anyBuilt = false;
+            _alterBeltRendererIds ??= [];
+            _alterPathRendererIds ??= [];
+            _refreshPathUVIds ??= [];
+            CargoTrafficPatch.IsBatchBuilding = true;
+            factory.BeginFlattenTerrain();
+            factory.cargoTraffic._batch_buffer_no_refresh = true;
+            PlanetFactory.batchBuild = true;
+            CargoTrafficPatch.DisableRefreshBatchesBuffers = true;
+            for (var i = factory.prebuildCursor - 1; i > 0; i--)
             {
-                if (!architect) continue;
+                ref var pb = ref prebuilds[i];
-                prebuilds[i].itemRequired = 0;
+                if (pb.id != i || pb.isDestroyed) continue;
-                if (imm)
+                if (pb.itemRequired > 0)
-                    factory.BuildFinally(GameMain.mainPlayer, i, false);
+                {
-                else
+                    if (!architect) continue;
-                    factory.AlterPrebuildModelState(i);
+                    pb.itemRequired = 0;
+                }
+                anyBelt = anyBelt || _beltIds.Contains(pb.protoId);
+                factory.BuildFinally(GameMain.mainPlayer, i, false);
+                anyBuilt = true;
             }
-            else
+            PlanetFactory.batchBuild = false;
+            factory.cargoTraffic._batch_buffer_no_refresh = false;
+            factory.EndFlattenTerrain();
+            CargoTrafficPatch.IsBatchBuilding = false;
+            var cargoTraffic = factory.cargoTraffic;
+            var entityPool = factory.entityPool;
+            var colChunks = factory.planet.physics?.colChunks;
+            foreach (var beltId in _alterBeltRendererIds)
             {
-                if (imm)
+                cargoTraffic.AlterBeltRenderer(beltId, entityPool, colChunks, false);
-                    factory.BuildFinally(GameMain.mainPlayer, i, false);
+            }
+            foreach (var pathId in _alterPathRendererIds)
+            {
+                cargoTraffic.AlterPathRenderer(pathId, false);
+            }
+            foreach (var pathId in _refreshPathUVIds)
+            {
+                cargoTraffic.RefreshPathUV(pathId);
+            }
+            _alterBeltRendererIds.Clear();
+            _alterPathRendererIds.Clear();
+            _refreshPathUVIds.Clear();
+            CargoTrafficPatch.DisableRefreshBatchesBuffers = false;
+            if (anyBelt)
+            {
+                factory.cargoTraffic.RefreshBeltBatchesBuffers();
+                factory.cargoTraffic.RefreshPathBatchesBuffers();
+            }
+            if (anyBuilt)
+            {
+                factory.planet.physics?.raycastLogic?.NotifyBatchObjectRemove();
+                factory.planet.audio?.SetPlanetAudioDirty();
             }
         }
+        else if (architect)
+        {
+            for (var i = factory.prebuildCursor - 1; i > 0; i--)
+            {
+                ref var pb = ref prebuilds[i];
+                if (pb.id != i || pb.isDestroyed || pb.itemRequired == 0) continue;
+                pb.itemRequired = 0;
+                factory.AlterPrebuildModelState(i);
+            }
+        }
+    }
 
-        if (imm) factory.EndFlattenTerrain();
+    private class CargoTrafficPatch : PatchImpl<CargoTrafficPatch>
+    {
+        public static bool IsBatchBuilding;
+        public static bool DisableRefreshBatchesBuffers;
+        [HarmonyPrefix]
+        [HarmonyPriority(Priority.First)]
+        [HarmonyPatch(typeof(CargoTraffic), nameof(CargoTraffic.AlterBeltRenderer))]
+        private static bool CargoTraffic_AlterBeltRenderer_Prefix(int beltId)
+        {
+            if (!IsBatchBuilding) return true;
+            _alterBeltRendererIds.Add(beltId);
+            return false;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPriority(Priority.First)]
+        [HarmonyPatch(typeof(CargoTraffic), nameof(CargoTraffic.AlterPathRenderer))]
+        private static bool CargoTraffic_AlterPathRenderer_Prefix(int pathId)
+        {
+            if (!IsBatchBuilding) return true;
+            _alterPathRendererIds.Add(pathId);
+            return false;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPriority(Priority.First)]
+        [HarmonyPatch(typeof(CargoTraffic), nameof(CargoTraffic.RefreshPathUV))]
+        private static bool CargoTraffic_RefreshPathUV_Prefix(int pathId)
+        {
+            if (!IsBatchBuilding) return true;
+            _refreshPathUVIds.Add(pathId);
+            return false;
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPriority(Priority.First)]
+        [HarmonyPatch(typeof(CargoTraffic), nameof(CargoTraffic.RefreshBeltBatchesBuffers))]
+        [HarmonyPatch(typeof(CargoTraffic), nameof(CargoTraffic.RefreshPathBatchesBuffers))]
+        private static bool CargoTraffic_RefreshBeltBatchesBuffers_Prefix()
+        {
+            return !DisableRefreshBatchesBuffers;
+        }
     }
 
     [HarmonyPostfix]
@@ -188,6 +294,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
 
     private static void GameMain_Begin_Postfix_For_ImmBuild()
     {
+        if (DSPGame.IsMenuDemo) return;
         var factory = GameMain.mainPlayer?.factory;
         if (factory != null)
         {
@@ -235,7 +342,8 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         matcher.Repeat(m =>
         {
             var label1 = generator.DefineLabel();
-            m.Advance(1).RemoveInstructions(2).InsertAndAdvance(
+            m.Advance(3).InsertAndAdvance(
+                new CodeInstruction(OpCodes.Ldarg_0),
                 Transpilers.EmitDelegate((WarningSystem w) =>
                     {
                         if (NoConditionEnabled.Value)
@@ -265,7 +373,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         return matcher.InstructionEnumeration();
     }
 
-    private class ImmediateBuild: PatchImpl<ImmediateBuild>
+    private class ImmediateBuild : PatchImpl<ImmediateBuild>
     {
         protected override void OnEnable()
         {
@@ -311,6 +419,40 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
             return matcher.InstructionEnumeration();
         }
 
+        /*
+        [HarmonyTranspiler]
+        [HarmonyPatch(typeof(ConstructionSystem), nameof(ConstructionSystem.AddBuildTargetToModules))]
+        private static IEnumerable<CodeInstruction> ConstructionSystem_AddBuildTargetToModules_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+        {
+            var matcher = new CodeMatcher(instructions, generator);
+            // 13	0035	ldarg.0
+            // 14	0036	ldfld	class Player ConstructionSystem::player
+            // 15	003B	callvirt	instance class Mecha Player::get_mecha()
+            // 16	0040	ldfld	float32 Mecha::buildArea
+            // 17	0045	stloc.0
+            matcher.MatchForward(false,
+                new CodeMatch(OpCodes.Ldarg_0),
+                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(ConstructionSystem), nameof(ConstructionSystem.player))),
+                new CodeMatch(OpCodes.Callvirt, AccessTools.PropertyGetter(typeof(Player), nameof(Player.mecha))),
+                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(Mecha), nameof(Mecha.buildArea))),
+                new CodeMatch(ci => ci.IsStloc())
+            );
+            var labels = matcher.Labels;
+            matcher.Labels = [];
+            matcher.Insert(
+                new CodeInstruction(OpCodes.Ldarg_0).WithLabels(labels),
+                new CodeInstruction(OpCodes.Ldarg_1),
+                Transpilers.EmitDelegate((ConstructionSystem constructionSystem, int objId) =>
+                {
+                    var player = constructionSystem.player;
+                    player.factory.BuildFinally(player, objId);
+                }),
+                new CodeInstruction(OpCodes.Ret)
+            );
+            return matcher.InstructionEnumeration();
+        }
+        */
+
         [HarmonyPostfix]
         [HarmonyPatch(typeof(UXAssist.Functions.PlanetFunctions), nameof(UXAssist.Functions.PlanetFunctions.BuildOrbitalCollectors))]
         private static void UXAssist_PlanetFunctions_BuildOrbitalCollectors_Postfix()
@@ -323,7 +465,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    private class ArchitectMode: PatchImpl<ArchitectMode>
+    private class ArchitectMode : PatchImpl<ArchitectMode>
     {
         private static bool[] _canBuildItems;
 
@@ -354,7 +496,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
 
         [HarmonyPostfix]
-        [HarmonyPatch(typeof(StorageComponent), "GetItemCount", typeof(int))]
+        [HarmonyPatch(typeof(StorageComponent), nameof(StorageComponent.GetItemCount), typeof(int))]
         public static void GetItemCountPatch(StorageComponent __instance, int itemId, ref int __result)
         {
             if (__result > 99) return;
@@ -377,7 +519,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    private class NoConditionBuild: PatchImpl<NoConditionBuild>
+    private class NoConditionBuild : PatchImpl<NoConditionBuild>
     {
         protected override void OnEnable()
         {
@@ -465,7 +607,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    public class BeltSignalGenerator: PatchImpl<BeltSignalGenerator>
+    public class BeltSignalGenerator : PatchImpl<BeltSignalGenerator>
     {
         private static Dictionary<int, BeltSignal>[] _signalBelts;
         private static Dictionary<long, int> _portalFrom;
@@ -487,12 +629,12 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         protected override void OnEnable()
         {
             InitSignalBelts();
-            GameLogic.OnGameBegin += GameMain_Begin_Postfix;
+            GameLogicProc.OnGameBegin += GameMain_Begin_Postfix;
         }
 
         protected override void OnDisable()
         {
-            GameLogic.OnGameBegin -= GameMain_Begin_Postfix;
+            GameLogicProc.OnGameBegin -= GameMain_Begin_Postfix;
             _initialized = false;
             _signalBelts = null;
             _signalBeltsCapacity = 0;
@@ -629,7 +771,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
                 inc = 0;
                 speedLimit = number;
             }
-            
+
             if (speedLimit > 3600) speedLimit = 3600;
 
             var signalBelts = GetOrCreateSignalBelts(factory);
@@ -665,13 +807,13 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
             var result = new Dictionary<int, float>();
             var extra = new Dictionary<int, float>();
             CalculateAllProductions(result, extra, itemId);
-            foreach (var p in extra)
-            {
-                if (result.TryGetValue(itemId, out var v) && v >= p.Value) continue;
-                result[itemId] = p.Value;
-            }
 
             result.Remove(itemId);
+
+            foreach (var p in extra)
+            {
+                result[p.Key] = (result.TryGetValue(p.Key, out var v) ? v : 0) + p.Value;
+            }
             var cnt = result.Count;
             if (cnt == 0)
             {
@@ -725,15 +867,16 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
 
         private static void GameMain_Begin_Postfix()
         {
+            if (DSPGame.IsMenuDemo) return;
             if (BeltSignalGeneratorEnabled.Value) InitSignalBelts();
             InitItemSources();
         }
-    
+
         [HarmonyPostfix]
         [HarmonyPatch(typeof(DigitalSystem), MethodType.Constructor, typeof(PlanetData))]
         private static void DigitalSystem_Constructor_Postfix(PlanetData _planet)
         {
-            if (!BeltSignalGeneratorEnabled.Value) return; 
+            if (!BeltSignalGeneratorEnabled.Value) return;
             var player = GameMain.mainPlayer;
             if (player == null) return;
             var factory = _planet?.factory;
@@ -849,139 +992,149 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         public static void ProcessBeltSignals()
         {
             if (!_initialized) return;
-            var factories = GameMain.data?.factories;
+            var data = GameMain.data;
+            var factories = data?.factories;
             if (factories == null) return;
-            PerformanceMonitor.BeginSample(ECpuWorkEntry.Belt);
+            DeepProfiler.BeginSample(DPEntry.Belt);
-            foreach (var factory in factories)
+            for (var index = data.factoryCount - 1; index >= 0; index--)
             {
+                var factory = factories[index];
                 if (factory == null) continue;
-                var belts = GetSignalBelts(factory.index);
+                var belts = GetSignalBelts(index);
                 if (belts == null || belts.Count == 0) continue;
-                var factoryProductionStat = GameMain.statistics.production.factoryStatPool[factory.index];
+                var factoryProductionStat = GameMain.statistics.production.factoryStatPool[index];
                 var productRegister = factoryProductionStat.productRegister;
                 var consumeRegister = factoryProductionStat.consumeRegister;
                 var countRecipe = BeltSignalCountRecipeEnabled.Value;
                 var cargoTraffic = factory.cargoTraffic;
+                var beltCount = cargoTraffic.beltCursor;
+                List<int> beltsToRemove = null;
                 foreach (var pair in belts)
                 {
+                    if (pair.Key >= beltCount)
+                    {
+                        if (beltsToRemove == null)
+                            beltsToRemove = [pair.Key];
+                        else
+                            beltsToRemove.Add(pair.Key);
+                        continue;
+                    }
                     var beltSignal = pair.Value;
                     var signalId = beltSignal.SignalId;
                     switch (signalId)
                     {
                         case 404:
-                        {
-                            var beltId = pair.Key;
-                            ref var belt = ref cargoTraffic.beltPool[beltId];
-                            var cargoPath = cargoTraffic.GetCargoPath(belt.segPathId);
-                            if (cargoPath == null) continue;
-                            int itemId;
-                            if ((itemId = cargoPath.TryPickItem(belt.segIndex + belt.segPivotOffset - 5, 12, out var stack, out _)) > 0)
                             {
-                                if (BeltSignalCountRemEnabled.Value) consumeRegister[itemId] += stack;
+                                var beltId = pair.Key;
-                            }
+                                ref var belt = ref cargoTraffic.beltPool[beltId];
-
+                                var cargoPath = cargoTraffic.GetCargoPath(belt.segPathId);
-                            continue;
-                        }
-                        case 600:
-                        {
-                            if (!_portalTo.TryGetValue(beltSignal.SpeedLimit, out var set)) continue;
-                            var beltId = pair.Key;
-                            ref var belt = ref cargoTraffic.beltPool[beltId];
-                            var cargoPath = cargoTraffic.GetCargoPath(belt.segPathId);
-                            if (cargoPath == null) continue;
-                            var segIndex = belt.segIndex + belt.segPivotOffset;
-                            if (!cargoPath.GetCargoAtIndex(segIndex, out var cargo, out var cargoId, out var _)) break;
-                            var itemId = cargo.item;
-                            var cargoPool = cargoPath.cargoContainer.cargoPool;
-                            var inc = cargoPool[cargoId].inc;
-                            var stack = cargoPool[cargoId].stack;
-                            foreach (var n in set)
-                            {
-                                var cargoTraffic1 = factories[(int)(n >> 32)].cargoTraffic;
-                                ref var belt1 = ref cargoTraffic1.beltPool[(int)(n & 0x7FFFFFFF)];
-                                cargoPath = cargoTraffic1.GetCargoPath(belt1.segPathId);
                                 if (cargoPath == null) continue;
-                                if (!cargoPath.TryInsertItem(belt1.segIndex + belt1.segPivotOffset, itemId, stack, inc)) continue;
+                                int itemId;
-                                cargoPath.TryPickItem(segIndex - 5, 12, out var stack1, out var inc1);
+                                if ((itemId = cargoPath.TryPickItem(belt.segIndex + belt.segPivotOffset - 5, 12, out var stack, out _)) > 0)
-                                if (inc1 != inc || stack1 != stack)
+                                {
-                                    cargoPath.TryPickItem(segIndex - 5, 12, out _, out _);
+                                    if (BeltSignalCountRemEnabled.Value) consumeRegister[itemId] += stack;
-                                break;
+                                }
-                            }
 
-                            continue;
+                                continue;
-                        }
+                            }
+                        case 600:
+                            {
+                                if (!_portalTo.TryGetValue(beltSignal.SpeedLimit, out var set)) continue;
+                                var beltId = pair.Key;
+                                ref var belt = ref cargoTraffic.beltPool[beltId];
+                                var cargoPath = cargoTraffic.GetCargoPath(belt.segPathId);
+                                if (cargoPath == null) continue;
+                                var segIndex = belt.segIndex + belt.segPivotOffset;
+                                if (!cargoPath.GetCargoAtIndex(segIndex, out var cargo, out var cargoId, out var _)) break;
+                                var itemId = cargo.item;
+                                var cargoPool = cargoPath.cargoContainer.cargoPool;
+                                var inc = cargoPool[cargoId].inc;
+                                var stack = cargoPool[cargoId].stack;
+                                foreach (var n in set)
+                                {
+                                    var cargoTraffic1 = factories[(int)(n >> 32)].cargoTraffic;
+                                    ref var belt1 = ref cargoTraffic1.beltPool[(int)(n & 0x7FFFFFFF)];
+                                    cargoPath = cargoTraffic1.GetCargoPath(belt1.segPathId);
+                                    if (cargoPath == null) continue;
+                                    if (!cargoPath.TryInsertItem(belt1.segIndex + belt1.segPivotOffset, itemId, stack, inc)) continue;
+                                    cargoPath.TryPickItem(segIndex - 5, 12, out var stack1, out var inc1);
+                                    if (inc1 != inc || stack1 != stack)
+                                        cargoPath.TryPickItem(segIndex - 5, 12, out _, out _);
+                                    break;
+                                }
+
+                                continue;
+                            }
                         case >= 1000 and < 20000:
-                        {
-                            var hasSpeedLimit = beltSignal.SpeedLimit > 0;
-                            if (hasSpeedLimit)
                             {
-                                beltSignal.Progress += beltSignal.SpeedLimit;
+                                var hasSpeedLimit = beltSignal.SpeedLimit > 0;
-                                switch (beltSignal.Progress)
+                                if (hasSpeedLimit)
                                 {
-                                    case < 3600:
+                                    beltSignal.Progress += beltSignal.SpeedLimit;
-                                        continue;
+                                    switch (beltSignal.Progress)
-                                    case > 18000:
+                                    {
-                                        beltSignal.Progress = 14400;
+                                        case < 3600:
-                                        break;
+                                            continue;
+                                        case > 18000:
+                                            beltSignal.Progress = 14400;
+                                            break;
+                                    }
                                 }
-                            }
 
-                            var beltId = pair.Key;
+                                var beltId = pair.Key;
-                            ref var belt = ref cargoTraffic.beltPool[beltId];
+                                ref var belt = ref cargoTraffic.beltPool[beltId];
-                            var cargoPath = cargoTraffic.GetCargoPath(belt.segPathId);
+                                var cargoPath = cargoTraffic.GetCargoPath(belt.segPathId);
-                            if (cargoPath == null) continue;
+                                if (cargoPath == null) continue;
-                            var stack = beltSignal.Stack;
+                                var stack = beltSignal.Stack;
-                            var inc = beltSignal.Inc;
+                                var inc = beltSignal.Inc;
-                            if (!cargoPath.TryInsertItem(belt.segIndex + belt.segPivotOffset, signalId, stack, inc)) continue;
+                                if (!cargoPath.TryInsertItem(belt.segIndex + belt.segPivotOffset, signalId, stack, inc)) continue;
-                            if (hasSpeedLimit) beltSignal.Progress -= 3600;
+                                if (hasSpeedLimit) beltSignal.Progress -= 3600;
-                            if (BeltSignalCountGenEnabled.Value) productRegister[signalId] += stack;
+                                if (BeltSignalCountGenEnabled.Value) productRegister[signalId] += stack;
-                            if (!countRecipe) continue;
+                                if (!countRecipe) continue;
-                            var sources = beltSignal.Sources;
+                                var sources = beltSignal.Sources;
-                            if (sources == null) continue;
+                                if (sources == null) continue;
-                            var progress = beltSignal.SourceProgress;
+                                var progress = beltSignal.SourceProgress;
-                            var stackf = (float)stack;
+                                var stackf = (float)stack;
-                            for (var i = sources.Length - 1; i >= 0; i--)
+                                for (var i = sources.Length - 1; i >= 0; i--)
-                            {
-                                var newCnt = progress[i] + sources[i].Item2 * stackf;
-                                if (newCnt > 0)
                                 {
-                                    var itemId = sources[i].Item1;
+                                    var newCnt = progress[i] + sources[i].Item2 * stackf;
-                                    var cnt = Mathf.CeilToInt(newCnt);
+                                    if (newCnt > 0)
-                                    productRegister[itemId] += cnt;
+                                    {
-                                    consumeRegister[itemId] += cnt;
+                                        var itemId = sources[i].Item1;
-                                    progress[i] = newCnt - cnt;
+                                        var cnt = Mathf.CeilToInt(newCnt);
+                                        productRegister[itemId] += cnt;
+                                        consumeRegister[itemId] += cnt;
+                                        progress[i] = newCnt - cnt;
+                                    }
+                                    else
+                                    {
+                                        progress[i] = newCnt;
+                                    }
                                 }
-                                else
-                                {
-                                    progress[i] = newCnt;
-                                }
-                            }
 
-                            continue;
+                                continue;
-                        }
+                            }
                     }
                 }
+                if (beltsToRemove == null) continue;
+                foreach (var beltId in beltsToRemove)
+                {
+                    belts.Remove(beltId);
+                }
             }
 
-            PerformanceMonitor.EndSample(ECpuWorkEntry.Belt);
+            DeepProfiler.EndSample(DPEntry.Belt);
         }
 
-        [HarmonyTranspiler]
+        [HarmonyPostfix]
-        [HarmonyPatch(typeof(GameData), "GameTick")]
+        [HarmonyPatch(typeof(GameLogic), nameof(GameLogic.OnFactoryFrameBegin))]
-        public static IEnumerable<CodeInstruction> GameData_GameTick_Transpiler(IEnumerable<CodeInstruction> instructions)
+        public static void GameLogic_OnFactoryFrameBegin_Postfix()
         {
-            var matcher = new CodeMatcher(instructions);
+            ProcessBeltSignals();
-            matcher.MatchForward(false,
-                new CodeMatch(OpCodes.Call, AccessTools.Method(typeof(PerformanceMonitor), nameof(PerformanceMonitor.EndSample)))
-            ).Advance(1).Insert(
-                new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(BeltSignalGenerator), nameof(ProcessBeltSignals)))
-            );
-            return matcher.InstructionEnumeration();
         }
 
-
         /* BEGIN: Item sources calculation */
-        private static readonly Dictionary<int, ItemSource> ItemSources = new();
+        private static readonly Dictionary<int, ItemSource> ItemSources = [];
         private static bool _itemSourcesInitialized;
 
         private class ItemSource
@@ -1052,7 +1205,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
                 for (var i = 0; i < len; i++)
                 {
                     if (ItemSources.ContainsKey(res[i])) continue;
-                    var rs = new ItemSource { Count = rescnt[i], From = new Dictionary<int, float>() };
+                    var rs = new ItemSource { Count = rescnt[i], From = [], Extra = null };
                     var it = recipe.Items;
                     var itcnt = recipe.ItemCounts;
                     var len2 = it.Length;
@@ -1063,7 +1216,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
 
                     if (len > 1)
                     {
-                        rs.Extra = new Dictionary<int, float>();
+                        rs.Extra = [];
                         for (var k = 0; k < len; k++)
                         {
                             if (i != k)
@@ -1093,16 +1246,12 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
                 times = count / itemSource.Count;
             }
 
-            {
+            result[itemId] = (result.TryGetValue(itemId, out var oldCount) ? oldCount : 0) + count;
-                result.TryGetValue(itemId, out var oldCount);
-                result[itemId] = oldCount + count;
-            }
             if (itemSource.Extra != null)
             {
                 foreach (var p in itemSource.Extra)
                 {
-                    extra.TryGetValue(p.Key, out var oldCount);
+                    extra[p.Key] = (extra.TryGetValue(p.Key, out oldCount) ? oldCount : 0) + times * p.Value;
-                    extra[p.Key] = oldCount + times * p.Value;
                 }
             }
 
@@ -1115,7 +1264,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         /* END: Item sources calculation */
     }
 
-    private class RemovePowerSpaceLimit: PatchImpl<RemovePowerSpaceLimit>
+    private class RemovePowerSpaceLimit : PatchImpl<RemovePowerSpaceLimit>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(BuildTool_Click), nameof(BuildTool_Click.CheckBuildConditions))]
@@ -1145,7 +1294,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    private class BoostWindPower: PatchImpl<BoostWindPower>
+    private class BoostWindPower : PatchImpl<BoostWindPower>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(PowerGeneratorComponent), nameof(PowerGeneratorComponent.EnergyCap_Wind))]
@@ -1169,8 +1318,8 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
             return matcher.InstructionEnumeration();
         }
     }
-    
+
-    private class BoostSolarPower: PatchImpl<BoostSolarPower>
+    private class BoostSolarPower : PatchImpl<BoostSolarPower>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(PowerGeneratorComponent), nameof(PowerGeneratorComponent.EnergyCap_PV))]
@@ -1194,7 +1343,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    private class BoostFuelPower: PatchImpl<BoostFuelPower>
+    private class BoostFuelPower : PatchImpl<BoostFuelPower>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(PowerGeneratorComponent), nameof(PowerGeneratorComponent.EnergyCap_Fuel))]
@@ -1235,7 +1384,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    private class BoostGeothermalPower: PatchImpl<BoostGeothermalPower>
+    private class BoostGeothermalPower : PatchImpl<BoostGeothermalPower>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(PowerGeneratorComponent), nameof(PowerGeneratorComponent.EnergyCap_GTH))]
@@ -1318,7 +1467,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    private class GreaterPowerUsageInLogistics: PatchImpl<GreaterPowerUsageInLogistics>
+    private class GreaterPowerUsageInLogistics : PatchImpl<GreaterPowerUsageInLogistics>
     {
         protected override void OnEnable()
         {
@@ -1468,7 +1617,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
         }
     }
 
-    private class ControlPanelRemoteLogistics: PatchImpl<ControlPanelRemoteLogistics>
+    private class ControlPanelRemoteLogistics : PatchImpl<ControlPanelRemoteLogistics>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UIControlPanelDispenserInspector), nameof(UIControlPanelDispenserInspector.OnItemIconMouseDown))]
@@ -1498,7 +1647,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
             );
             return matcher.InstructionEnumeration();
         }
-        
+
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UIControlPanelStationInspector), nameof(UIControlPanelStationInspector.OnShipIconClick))]
         [HarmonyPatch(typeof(UIControlPanelStationInspector), nameof(UIControlPanelStationInspector.OnWarperIconClick))]
@@ -1527,7 +1676,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
             );
             return matcher.InstructionEnumeration();
         }
-        
+
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UIControlPanelStationStorage), nameof(UIControlPanelStationStorage.OnItemIconMouseDown))]
         private static IEnumerable<CodeInstruction> UIControlPanelStationStorage_OnItemIconMouseDown_Transpiler(IEnumerable<CodeInstruction> instructions)
@@ -1554,7 +1703,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
             );
             return matcher.InstructionEnumeration();
         }
-        
+
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UIControlPanelStationStorage), nameof(UIControlPanelStationStorage.OnTakeBackButtonClick))]
         private static IEnumerable<CodeInstruction> UIControlPanelStationStorage_OnTakeBackButtonClick_Transpiler(IEnumerable<CodeInstruction> instructions)
@@ -1573,7 +1722,7 @@ public class FactoryPatch: PatchImpl<FactoryPatch>
             );
             return matcher.InstructionEnumeration();
         }
-        
+
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UIControlPanelVeinCollectorPanel), nameof(UIControlPanelVeinCollectorPanel.OnProductIconClick))]
         private static IEnumerable<CodeInstruction> UIControlPanelVeinCollectorPanel_OnProductIconClick_Transpiler(IEnumerable<CodeInstruction> instructions)

CheatEnabler/Patches/GamePatch.cs

@@ -54,7 +54,8 @@ public static class GamePatch
         protected override void OnDisable()
         {
             if (_savedDeterminators == null) return;
-            var abnormalLogic = GameMain.gameScenario.abnormalityLogic;
+            var abnormalLogic = GameMain.gameScenario?.abnormalityLogic;
+            if (abnormalLogic?.determinators == null) return;
             abnormalLogic.determinators = _savedDeterminators;
             foreach (var p in _savedDeterminators)
             {
@@ -63,19 +64,19 @@ public static class GamePatch
         }
 
         [HarmonyPrefix]
-        [HarmonyPatch(typeof(AbnormalityLogic), "NotifyBeforeGameSave")]
+        [HarmonyPatch(typeof(AbnormalityLogic), nameof(AbnormalityLogic.NotifyBeforeGameSave))]
-        [HarmonyPatch(typeof(AbnormalityLogic), "NotifyOnAssemblerRecipePick")]
+        [HarmonyPatch(typeof(AbnormalityLogic), nameof(AbnormalityLogic.NotifyOnAssemblerRecipePick))]
-        [HarmonyPatch(typeof(AbnormalityLogic), "NotifyOnGameBegin")]
+        [HarmonyPatch(typeof(AbnormalityLogic), nameof(AbnormalityLogic.NotifyOnGameBegin))]
-        [HarmonyPatch(typeof(AbnormalityLogic), "NotifyOnMechaForgeTaskComplete")]
+        [HarmonyPatch(typeof(AbnormalityLogic), nameof(AbnormalityLogic.NotifyOnMechaForgeTaskComplete))]
-        [HarmonyPatch(typeof(AbnormalityLogic), "NotifyOnUnlockTech")]
+        [HarmonyPatch(typeof(AbnormalityLogic), nameof(AbnormalityLogic.NotifyOnUnlockTech))]
-        [HarmonyPatch(typeof(AbnormalityLogic), "NotifyOnUseConsole")]
+        [HarmonyPatch(typeof(AbnormalityLogic), nameof(AbnormalityLogic.NotifyOnUseConsole))]
         private static bool DisableAbnormalLogic()
         {
             return false;
         }
 
         [HarmonyPostfix]
-        [HarmonyPatch(typeof(AbnormalityLogic), "InitDeterminators")]
+        [HarmonyPatch(typeof(AbnormalityLogic), nameof(AbnormalityLogic.InitDeterminators))]
         private static void DisableAbnormalDeterminators(AbnormalityLogic __instance)
         {
             _savedDeterminators = __instance.determinators;
@@ -186,7 +187,7 @@ public static class GamePatch
         }
     }
 
-    public class UnlockTech: PatchImpl<UnlockTech>
+    public class UnlockTech : PatchImpl<UnlockTech>
     {
         private static void UnlockTechRecursive(GameHistoryData history, [NotNull] TechProto techProto, int maxLevel = 10000)
         {
@@ -281,7 +282,7 @@ public static class GamePatch
                 }
             }
 
-            history.VarifyTechQueue();
+            history.VerifyTechQueue();
             if (history.currentTech != history.techQueue[0])
             {
                 history.currentTech = history.techQueue[0];

CheatEnabler/Patches/PlanetPatch.cs

@@ -29,7 +29,7 @@ public static class PlanetPatch
         TerraformAnyway.Enable(false);
     }
 
-    private class WaterPumperPatch: PatchImpl<WaterPumperPatch>
+    private class WaterPumperPatch : PatchImpl<WaterPumperPatch>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(BuildTool_BlueprintPaste), nameof(BuildTool_BlueprintPaste.CheckBuildConditions))]
@@ -51,7 +51,7 @@ public static class PlanetPatch
         }
     }
 
-    private class TerraformAnyway: PatchImpl<TerraformAnyway>
+    private class TerraformAnyway : PatchImpl<TerraformAnyway>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(BuildTool_Reform), nameof(BuildTool_Reform.ReformAction))]

CheatEnabler/Patches/PlayerPatch.cs

@@ -8,28 +8,42 @@ namespace CheatEnabler.Patches;
 
 public static class PlayerPatch
 {
+    public static ConfigEntry<bool> InstantHandCraftEnabled;
     public static ConfigEntry<bool> InstantTeleportEnabled;
     public static ConfigEntry<bool> WarpWithoutSpaceWarpersEnabled;
 
     public static void Init()
     {
+        InstantHandCraftEnabled.SettingChanged += (_, _) => InstantHandCraft.Enable(InstantHandCraftEnabled.Value);
         InstantTeleportEnabled.SettingChanged += (_, _) => InstantTeleport.Enable(InstantTeleportEnabled.Value);
         WarpWithoutSpaceWarpersEnabled.SettingChanged += (_, _) => WarpWithoutSpaceWarpers.Enable(WarpWithoutSpaceWarpersEnabled.Value);
     }
 
     public static void Start()
     {
+        InstantHandCraft.Enable(InstantHandCraftEnabled.Value);
         InstantTeleport.Enable(InstantTeleportEnabled.Value);
         WarpWithoutSpaceWarpers.Enable(WarpWithoutSpaceWarpersEnabled.Value);
     }
 
     public static void Uninit()
     {
+        InstantHandCraft.Enable(false);
         InstantTeleport.Enable(false);
         WarpWithoutSpaceWarpers.Enable(false);
     }
 
-    private class InstantTeleport: PatchImpl<InstantTeleport>
+    private class InstantHandCraft : PatchImpl<InstantHandCraft>
+    {
+        [HarmonyPostfix]
+        [HarmonyPatch(typeof(ForgeTask), MethodType.Constructor, typeof(int), typeof(int))]
+        private static void ForgeTask_Ctor_Postfix(ForgeTask __instance)
+        {
+            __instance.tickSpend = 0;
+        }
+    }
+
+    private class InstantTeleport : PatchImpl<InstantTeleport>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UIGlobemap), nameof(UIGlobemap._OnUpdate))]
@@ -52,7 +66,7 @@ public static class PlayerPatch
         }
     }
 
-    private class WarpWithoutSpaceWarpers: PatchImpl<WarpWithoutSpaceWarpers>
+    private class WarpWithoutSpaceWarpers : PatchImpl<WarpWithoutSpaceWarpers>
     {
         [HarmonyPrefix]
         [HarmonyPatch(typeof(Mecha), nameof(Mecha.HasWarper))]
@@ -61,7 +75,7 @@ public static class PlayerPatch
             __result = true;
             return false;
         }
-        
+
         [HarmonyPostfix]
         [HarmonyPatch(typeof(Mecha), nameof(Mecha.UseWarper))]
         private static void Mecha_UseWarper_Postfix(ref bool __result)

CheatEnabler/Patches/ResourcePatch.cs

@@ -29,61 +29,94 @@ public static class ResourcePatch
         FastMining.Enable(false);
     }
 
-    private class InfiniteResource: PatchImpl<InfiniteResource>
+    private class InfiniteResource : PatchImpl<InfiniteResource>
     {
+        static private readonly float InfiniteResourceRate = 0f;
         [HarmonyTranspiler]
-        [HarmonyPatch(typeof(FactorySystem), "GameTick", typeof(long), typeof(bool))]
+        [HarmonyPatch(typeof(FactorySystem), nameof(FactorySystem.GameTick), typeof(long), typeof(bool))]
-        [HarmonyPatch(typeof(FactorySystem), "GameTick", typeof(long), typeof(bool), typeof(int), typeof(int), typeof(int))]
+        [HarmonyPatch(typeof(GameLogic), nameof(GameLogic._miner_parallel))]
-        [HarmonyPatch(typeof(ItemProto), "GetPropValue")]
+        [HarmonyPatch(typeof(PlanetTransport), nameof(PlanetTransport.GameTick))]
-        [HarmonyPatch(typeof(PlanetTransport), "GameTick")]
+        [HarmonyPatch(typeof(UIChartAstroResource), nameof(UIChartAstroResource.CalculateMaxAmount))]
-        [HarmonyPatch(typeof(UIMinerWindow), "_OnUpdate")]
+        [HarmonyPatch(typeof(UIChartVeinGroup), nameof(UIChartVeinGroup.CalculateMaxAmount))]
-        [HarmonyPatch(typeof(UIMiningUpgradeLabel), "Update")]
+        [HarmonyPatch(typeof(UIControlPanelAdvancedMinerEntry), nameof(UIControlPanelAdvancedMinerEntry._OnUpdate))]
-        [HarmonyPatch(typeof(UIPlanetDetail), "OnPlanetDataSet")]
+        [HarmonyPatch(typeof(UIControlPanelVeinCollectorPanel), nameof(UIControlPanelVeinCollectorPanel._OnUpdate))]
-        [HarmonyPatch(typeof(UIPlanetDetail), "RefreshDynamicProperties")]
+        [HarmonyPatch(typeof(UIMinerWindow), nameof(UIMinerWindow._OnUpdate))]
-        [HarmonyPatch(typeof(UIStarDetail), "OnStarDataSet")]
+        [HarmonyPatch(typeof(UIMiningUpgradeLabel), nameof(UIMiningUpgradeLabel.Update))]
-        [HarmonyPatch(typeof(UIStarDetail), "RefreshDynamicProperties")]
+        [HarmonyPatch(typeof(UIVeinCollectorPanel), nameof(UIVeinCollectorPanel._OnUpdate))]
-        [HarmonyPatch(typeof(UIStationStorage), "RefreshValues")]
-        [HarmonyPatch(typeof(UIVeinCollectorPanel), "_OnUpdate")]
         private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
         {
             var matcher = new CodeMatcher(instructions, generator);
             matcher.MatchForward(false,
-                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.miningCostRate)))
+                new CodeMatch(ci => (ci.opcode == OpCodes.Ldfld || ci.opcode == OpCodes.Ldflda) && ci.OperandIs(AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.miningCostRate))))
             ).Repeat(codeMatcher =>
-                codeMatcher.RemoveInstruction().InsertAndAdvance(
+                {
-                    new CodeInstruction(OpCodes.Pop),
+                    if (codeMatcher.Instruction.opcode == OpCodes.Ldfld)
-                    new CodeInstruction(OpCodes.Ldc_R4, 0f)
+                    {
-                )
+                        codeMatcher.RemoveInstruction().InsertAndAdvance(
+                            new CodeInstruction(OpCodes.Pop),
+                            new CodeInstruction(OpCodes.Ldc_R4, InfiniteResourceRate)
+                        );
+                    }
+                    else
+                    {
+                        codeMatcher.RemoveInstruction().InsertAndAdvance(
+                            new CodeInstruction(OpCodes.Pop),
+                            new CodeInstruction(OpCodes.Ldsflda, AccessTools.Field(typeof(InfiniteResource), nameof(InfiniteResourceRate)))
+                        );
+                    }
+                }
             );
             return matcher.InstructionEnumeration();
         }
     }
 
-    private class FastMining: PatchImpl<FastMining>
+    private class FastMining : PatchImpl<FastMining>
     {
+        static private readonly float FastMiningSpeed = 2400f;
+
         [HarmonyTranspiler]
-        [HarmonyPatch(typeof(FactorySystem), "GameTick", typeof(long), typeof(bool))]
+        [HarmonyPatch(typeof(AstroResourceStatPlan), nameof(AstroResourceStatPlan.AddPlanetResources))]
-        [HarmonyPatch(typeof(FactorySystem), "GameTick", typeof(long), typeof(bool), typeof(int), typeof(int), typeof(int))]
+        [HarmonyPatch(typeof(BuildingGizmo), nameof(BuildingGizmo.Update))]
-        [HarmonyPatch(typeof(ItemProto), "GetPropValue")]
+        [HarmonyPatch(typeof(FactorySystem), nameof(FactorySystem.GameTick), typeof(long), typeof(bool))]
-        [HarmonyPatch(typeof(PlanetTransport), "GameTick")]
+        [HarmonyPatch(typeof(GameLogic), nameof(GameLogic._miner_parallel))]
-        [HarmonyPatch(typeof(UIMinerWindow), "_OnUpdate")]
+        [HarmonyPatch(typeof(ItemProto), nameof(ItemProto.GetPropValue))]
-        [HarmonyPatch(typeof(UIMiningUpgradeLabel), "Update")]
+        [HarmonyPatch(typeof(PlanetTransport), nameof(PlanetTransport.GameTick))]
-        [HarmonyPatch(typeof(UIPlanetDetail), "OnPlanetDataSet")]
+        [HarmonyPatch(typeof(ProductionExtraInfoCalculator), nameof(ProductionExtraInfoCalculator.CalculateFactory))]
-        [HarmonyPatch(typeof(UIPlanetDetail), "RefreshDynamicProperties")]
+        [HarmonyPatch(typeof(UIChartAstroResource), nameof(UIChartAstroResource.CalculateMaxAmount))]
-        [HarmonyPatch(typeof(UIStarDetail), "OnStarDataSet")]
+        [HarmonyPatch(typeof(UIChartVeinGroup), nameof(UIChartVeinGroup.CalculateMaxAmount))]
-        [HarmonyPatch(typeof(UIStarDetail), "RefreshDynamicProperties")]
+        [HarmonyPatch(typeof(UIControlPanelStationStorage), nameof(UIControlPanelStationStorage.RefreshValues))]
-        [HarmonyPatch(typeof(UIStationStorage), "RefreshValues")]
+        [HarmonyPatch(typeof(UIControlPanelVeinCollectorPanel), nameof(UIControlPanelVeinCollectorPanel._OnUpdate))]
-        [HarmonyPatch(typeof(UIVeinCollectorPanel), "_OnUpdate")]
+        [HarmonyPatch(typeof(UIMinerWindow), nameof(UIMinerWindow._OnUpdate))]
+        [HarmonyPatch(typeof(UIMiningUpgradeLabel), nameof(UIMiningUpgradeLabel.Update))]
+        [HarmonyPatch(typeof(UIPlanetDetail), nameof(UIPlanetDetail.OnPlanetDataSet))]
+        [HarmonyPatch(typeof(UIPlanetDetail), nameof(UIPlanetDetail.RefreshDynamicProperties))]
+        [HarmonyPatch(typeof(UIReferenceSpeedTip), nameof(UIReferenceSpeedTip.AddEntryDataWithFactory))]
+        [HarmonyPatch(typeof(UIStarDetail), nameof(UIStarDetail.OnStarDataSet))]
+        [HarmonyPatch(typeof(UIStarDetail), nameof(UIStarDetail.RefreshDynamicProperties))]
+        [HarmonyPatch(typeof(UIStationStorage), nameof(UIStationStorage.RefreshValues))]
+        [HarmonyPatch(typeof(UIVeinCollectorPanel), nameof(UIVeinCollectorPanel._OnUpdate))]
         private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
         {
             var matcher = new CodeMatcher(instructions, generator);
             matcher.MatchForward(false,
-                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.miningSpeedScale)))
+                new CodeMatch(ci => (ci.opcode == OpCodes.Ldfld || ci.opcode == OpCodes.Ldflda) && ci.OperandIs(AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.miningSpeedScale))))
             ).Repeat(codeMatcher =>
-                codeMatcher.RemoveInstruction().InsertAndAdvance(
+                {
-                    new CodeInstruction(OpCodes.Pop),
+                    if (codeMatcher.Instruction.opcode == OpCodes.Ldfld)
-                    new CodeInstruction(OpCodes.Ldc_R4, 2400f)
+                    {
-                )
+                        codeMatcher.RemoveInstruction().InsertAndAdvance(
+                            new CodeInstruction(OpCodes.Pop),
+                            new CodeInstruction(OpCodes.Ldc_R4, FastMiningSpeed)
+                        );
+                    }
+                    else
+                    {
+                        codeMatcher.RemoveInstruction().InsertAndAdvance(
+                            new CodeInstruction(OpCodes.Pop),
+                            new CodeInstruction(OpCodes.Ldsflda, AccessTools.Field(typeof(FastMining), nameof(FastMiningSpeed)))
+                        );
+                    }
+                }
             );
             return matcher.InstructionEnumeration();
         }

CheatEnabler/README.md

@@ -1,123 +1,149 @@
 # CheatEnabler
 
-#### Add various cheat functions while disabling abnormal determinants
+<details>
-#### 添加一些作弊功能，同时屏蔽异常检测
+<summary>Read me in English</summary>
+
+***Add various cheat functions while disabling abnormal determinants***
 
 ## Usage
 
 * Config panel is unified with UXAssist.
 * There are also buttons on title screen and planet minimap area to call up the config panel.
 * Features:
-  + General:
+  * General:
-    + Enable Dev Shortcuts (check config panel for usage)
+    * Enable Dev Shortcuts (check config panel for usage)
-    + Disable Abnormal Checks
+    * Disable Abnormal Checks
-    + Unlock techs with key-modifiers (Ctrl/Alt/Shift)
+    * Unlock techs with key-modifiers (Ctrl/Alt/Shift)
-    + Remove all metadata consumption records
+    * Remove all metadata consumption records
-    + Remove metadata consumption record in current game
+    * Remove metadata consumption record in current game
-    + Clear metadata flag which bans achievements
+    * Clear metadata flag which bans achievements
-    + Assign gamesave to currrnet account
+    * Assign gamesave to currrnet account
-  + Factory:
+  * Factory:
-    + Finish build immediately
+    * Finish build immediately
-    + Architect mode (Infinite buildings)
+    * Architect mode (Infinite buildings)
-    + Build without condition
+    * Build without condition
-    + No collision
+    * No collision
-    + Belt signal item generation
+    * Belt signal item generation
-      - Count generations as production in statistics
+      * Count generations as production in statistics
-      - Count removals as consumption in statistics
+      * Count removals as consumption in statistics
-      - Count all raws and intermediates in statistics
+      * Count all raws and intermediates in statistics
-      - Belt signal alt format
+      * Belt signal alt format
-    + Increase maximum power usage in Logistic Stations and Advanced Mining Machines
+    * Increase maximum power usage in Logistic Stations and Advanced Mining Machines
-      - Logistic Stations: Increased max charging power to 3GW(ILS) and 600MW(PLS) (10x of original)
+      * Logistic Stations: Increased max charging power to 3GW(ILS) and 600MW(PLS) (10x of original)
-      - Advanced Mining Machines: Increased max mining speed to 1000%
+      * Advanced Mining Machines: Increased max mining speed to 1000%
-    + Retrieve/Place items from/to remote planets on logistics control panel
+    * Retrieve/Place items from/to remote planets on logistics control panel
-    + Remove space limit between wind turbines and solar panels
+    * Remove space limit between wind turbines and solar panels
-    + Wind Turbines do global power coverage
+    * Wind Turbines do global power coverage
-    + Boost power generations for kinds of power generators
+    * Boost power generations for kinds of power generators
-  + Planet:
+  * Planet:
-    + Infinite Natural Resources
+    * Instant hand-craft
-    + Fast Mining
+    * Infinite Natural Resources
-    + Pump Anywhere
+    * Fast Mining
-    + Terraform without enought soil piles
+    * Pump Anywhere
-    + Instant teleport (like that in Sandbox mode)
+    * Terraform without enought soil piles
-  + Dyson Sphere:
+    * Instant teleport (like that in Sandbox mode)
-    + Skip bullet period
+  * Dyson Sphere:
-    + Skip absorption period
+    * Skip bullet period
-    + Quick absorb
+    * Skip absorption period
-    + Eject anyway
+    * Quick absorb
-    + Complete Dyson Sphere Shells instantly
+    * Eject anyway
-  + Mecha/Combat:
+    * Unlock Dyson Sphere max orbit radius
-    + Mecha and Drones/Fleets invicible
+    * Complete Dyson Sphere Shells instantly
-    + Buildings invicible
+    * Buttons for creating illegal Dyson Sphere Shells, you must enable `IllegalDysonShellFunctionsEnabled` of `DysonSphere` section in config to see the last 2 buttons.
-    + Enable warp without space warpers
+      * Generate an illegal dyson shell
-    + Teleport to outer space
+      * Keep max production shells and remove others
-    + Teleport to selected astronomical
+      * Duplicate shells from that with highest production
+  * Mecha/Combat:
+    * Mecha and Drones/Fleets invicible
+    * Buildings invicible
+    * Enable warp without space warpers
+    * Teleport to outer space
+    * Teleport to selected astronomical
 
 ## Notes
+
 * Please upgrade `BepInEx` 5.4.21 or later if using with [BlueprintTweaks](https://dsp.thunderstore.io/package/kremnev8/BlueprintTweaks/) to avoid possible conflicts.
-  + You can download `BepInEx` [here](https://github.com/bepinex/bepinex/releases/latest)(choose x64 edition).
+  * You can download [BepInEx here](https://github.com/bepinex/bepinex/releases/latest)(choose x64 edition).
-  + If using with r2modman, you can upgrade `BepInEx` by clicking `Settings` -> `Browse profile folder`, then extract downloaded zip to the folder and overwrite existing files.
+  * If using with r2modman, you can upgrade `BepInEx` by clicking `Settings` -> `Browse profile folder`, then extract downloaded zip to the folder and overwrite existing files.
 
 ## CREDITS
+
 * [Dyson Sphere Program](https://store.steampowered.com/app/1366540): The great game
 * [BepInEx](https://bepinex.dev/): Base modding framework
 * [Multifunction_mod](https://github.com/blacksnipebiu/Multifunction_mod): Some cheat functions
 
+</details>
+
+<details>
+<summary>中文读我</summary>
+
+***添加一些作弊功能，同时屏蔽异常检测***
 
 ## 使用说明
 
 * 配置面板复用UXAssist
 * 标题界面和行星小地图旁也有按钮呼出主面板
 * 功能：
-  + 常规：
+  * 常规：
-    + 启用开发模式快捷键(使用说明见设置面板)
+    * 启用开发模式快捷键(使用说明见设置面板)
-    + 屏蔽异常检测
+    * 屏蔽异常检测
-    + 使用组合键解锁科技（Ctrl/Alt/Shift）
+    * 使用组合键解锁科技（Ctrl/Alt/Shift）
-    + 移除所有元数据消耗记录
+    * 移除所有元数据消耗记录
-    + 移除当前存档的元数据消耗记录
+    * 移除当前存档的元数据消耗记录
-    + 解除当前存档因使用元数据导致的成就限制
+    * 解除当前存档因使用元数据导致的成就限制
-    + 将游戏存档绑定给当前账号
+    * 将游戏存档绑定给当前账号
-  + 工厂：
+  * 工厂：
-    + 建造秒完成
+    * 建造秒完成
-    + 建筑师模式(无限建筑)
+    * 建筑师模式(无限建筑)
-    + 无条件建造
+    * 无条件建造
-    + 无碰撞
+    * 无碰撞
-    + 传送带信号物品生成
+    * 传送带信号物品生成
-      - 统计信息里将生成计算为产物
+      * 统计信息里将生成计算为产物
-      - 统计信息里将移除计算为消耗
+      * 统计信息里将移除计算为消耗
-      - 统计面板中计算所有原材料和中间产物
+      * 统计面板中计算所有原材料和中间产物
-      - 传送带信号替换格式
+      * 传送带信号替换格式
-    + 提升物流塔和大型采矿机的最大功耗
+    * 提升物流塔和大型采矿机的最大功耗
-      - 物流塔：将最大充电功率提高到3GW(星际物流塔)和600MW(行星物流塔)（原来的10倍）
+      * 物流塔：将最大充电功率提高到3GW(星际物流塔)和600MW(行星物流塔)（原来的10倍）
-      - 大型采矿机：将最大采矿速度提高到1000%
+      * 大型采矿机：将最大采矿速度提高到1000%
-    + 在物流总控面板上可以从非本地行星取放物品
+    * 在物流总控面板上可以从非本地行星取放物品
-    + 风力发电机和太阳能板无间距限制
+    * 风力发电机和太阳能板无间距限制
-    + 风力涡轮机供电覆盖全球
+    * 风力涡轮机供电覆盖全球
-    + 提升各种发电设备发电量
+    * 提升各种发电设备发电量
-  + 行星：
+  * 行星：
-    + 自然资源采集不消耗
+    * 快速手动制造
-    + 高速采集
+    * 自然资源采集不消耗
-    + 平地抽水
+    * 高速采集
-    + 沙土不够时依然可以整改地形
+    * 平地抽水
-    + 快速传送(和沙盒模式一样)
+    * 沙土不够时依然可以整改地形
-  + 戴森球：
+    * 快速传送(和沙盒模式一样)
-    + 跳过子弹阶段
+  * 戴森球：
-    + 跳过吸收阶段
+    * 跳过子弹阶段
-    + 快速吸收
+    * 跳过吸收阶段
-    + 全球弹射
+    * 快速吸收
-    + 立即完成戴森壳建造
+    * 全球弹射
-  + 机甲/战斗：
+    * 解锁戴森球最大轨道半径
-    + 机甲和战斗无人机无敌
+    * 立即完成戴森壳建造
-    + 建筑无敌
+    * 用于制作仙术戴森壳的按钮，你必须在设置文件里开启`DysonSphere`分类的`IllegalDysonShellFunctionsEnabled`才能看到后面两个按钮
-    + 无需空间翘曲器即可曲速飞行
+      * 生成单层仙术戴森壳
-    + 传送到外太空
+      * 保留发电量最高的戴森壳并移除其他戴森壳
-    + 传送到选定的天体
+      * 从发电量最高的壳复制戴森壳
+  * 机甲/战斗：
+    * 机甲和战斗无人机无敌
+    * 建筑无敌
+    * 无需空间翘曲器即可曲速飞行
+    * 传送到外太空
+    * 传送到选定的天体
 
 ## 注意事项
+
 * 如果和[BlueprintTweaks](https://dsp.thunderstore.io/package/kremnev8/BlueprintTweaks/)一起使用，请升级`BepInEx`到5.4.21或更高版本，以避免可能的冲突
-  + 你可以在[这里](https://github.com/bepinex/bepinex/releases/latest)（选择x64版本）下载`BepInEx`
+  * 你可以在[这里](https://github.com/bepinex/bepinex/releases/latest)（选择x64版本）下载`BepInEx`
-  + 如果使用r2modman，你可以点击`Settings` -> `Browse profile folder`，然后将下载的zip解压到该文件夹并覆盖现有文件
+  * 如果使用r2modman，你可以点击`Settings` -> `Browse profile folder`，然后将下载的zip解压到该文件夹并覆盖现有文件
 
 ## 鸣谢
+
 * [戴森球计划](https://store.steampowered.com/app/1366540): 伟大的游戏
 * [BepInEx](https://bepinex.dev/): 基础模组框架
 * [Multifunction_mod](https://github.com/blacksnipebiu/Multifunction_mod): 一些作弊功能
+
+</details>

CheatEnabler/UIConfigWindow.cs

@@ -3,6 +3,7 @@ using CheatEnabler.Patches;
 using UnityEngine;
 using UXAssist.UI;
 using UXAssist.Common;
+using System;
 
 namespace CheatEnabler;
 
@@ -44,7 +45,7 @@ public static class UIConfigWindow
             "传送带信号物品生成数量格式：\n  默认为AAAABC\n  勾选替换为BCAAAA\nAAAA=生成速度，B=增产点数，C=堆叠数量");
         I18N.Add("Count generations as production in statistics", "Count generations as production in statistics", "统计信息里将生成计算为产物");
         I18N.Add("Count removals as consumption in statistics", "Count removals as consumption in statistics", "统计信息里将移除计算为消耗");
-        I18N.Add("Count all raws and intermediates in statistics","Count all raw materials in statistics", "统计信息里计算所有原料和中间产物");
+        I18N.Add("Count all raws and intermediates in statistics", "Count all raw materials in statistics", "统计信息里计算所有原料和中间产物");
         I18N.Add("Remove power space limit", "Remove space limit for winds and geothermals", "移除风力发电和地热发电的间距限制");
         I18N.Add("Boost wind power", "Boost wind power(x100,000)", "提升风力发电(x100,000)");
         I18N.Add("Boost solar power", "Boost solar power(x100,000)", "提升太阳能发电(x100,000)");
@@ -52,19 +53,30 @@ public static class UIConfigWindow
         I18N.Add("Boost fuel power 2", "(x20,000 for deuteron, x10,000 for antimatter)", "(氘核燃料棒x20,000，反物质燃料棒x10,000)");
         I18N.Add("Wind Turbines do global power coverage", "Wind Turbines do global power coverage", "风力涡轮机供电覆盖全球");
         I18N.Add("Boost geothermal power", "Boost geothermal power(x50,000)", "提升地热发电(x50,000)");
-        I18N.Add("Increase maximum power usage in Logistic Stations and Advanced Mining Machines", "Increase maximum power usage in Logistic Stations and Advanced Mining Machines", "提升物流塔和大型采矿机的最大功耗");
+        I18N.Add("Increase maximum power usage in Logistic Stations and Advanced Mining Machines", "Increase maximum power usage in Logistic Stations and Advanced Mining Machines",
+            "提升物流塔和大型采矿机的最大功耗");
         I18N.Add("Retrieve/Place items from/to remote planets on logistics control panel", "Retrieve/Place items from/to remote planets on logistics control panel", "在物流总控面板上可以从非本地行星取放物品");
         I18N.Add("Infinite Natural Resources", "Infinite natural resources", "自然资源采集不消耗");
         I18N.Add("Fast Mining", "Fast mining", "高速采集");
         I18N.Add("Pump Anywhere", "Pump anywhere", "平地抽水");
         I18N.Add("Skip bullet period", "Skip bullet period", "跳过子弹阶段");
+        I18N.Add("Fire all bullets at once", "Fire all bullets at once", "一次弹射所有太阳帆");
         I18N.Add("Skip absorption period", "Skip absorption period", "跳过吸收阶段");
         I18N.Add("Quick absorb", "Quick absorb", "快速吸收");
         I18N.Add("Eject anyway", "Eject anyway", "全球弹射");
         I18N.Add("Overclock Ejectors", "Overclock Ejectors (10x)", "高速弹射器(10倍射速)");
         I18N.Add("Overclock Silos", "Overclock Silos (10x)", "高速发射井(10倍射速)");
+        I18N.Add("Unlock Dyson Sphere max orbit radius", "Unlock Dyson Sphere max orbit radius", "解锁戴森球最大轨道半径");
         I18N.Add("Complete Dyson Sphere shells instantly", "Complete Dyson Sphere shells instantly", "立即完成戴森壳建造");
+        I18N.Add("Generate illegal dyson shell", "Generate an illegal dyson shell (!!All shells will be removed first!!)", "生成单层仙术戴森壳(!!会先删除全部的壳!!)");
+        I18N.Add("Keep max production shells and remove others", "Keep max production shells and remove others", "保留发电量最高的戴森壳并移除其他戴森壳");
+        I18N.Add("Duplicate shells from that with highest production", "Duplicate shells from that with highest production", "从发电量最高的壳复制戴森壳");
+        I18N.Add("Generate illegal dyson shell quickly", "Generate illegal dyson shell quickly", "快速生成仙术戴森壳");
+        I18N.Add("Shells count", "Shells count", "壳面数量");
+        I18N.Add("WARNING: This operation can be very slow, continue?", "WARNING: This operation can be very slow, continue?", "警告：此操作可能非常慢，继续吗？");
+        I18N.Add("WARNING: This operation is DANGEROUS, continue?", "WARNING: This operation is DANGEROUS, continue?", "警告：此操作非常危险，继续吗？");
         I18N.Add("Terraform without enough soil piles", "Terraform without enough soil piles", "沙土不够时依然可以整改地形");
+        I18N.Add("Instant hand-craft", "Instant hand-craft", "快速手动制造");
         I18N.Add("Instant teleport (like that in Sandbox mode)", "Instant teleport (like that in Sandbox mode)", "快速传送(和沙盒模式一样)");
         I18N.Add("Mecha and Drones/Fleets invicible", "Mecha and Drones/Fleets invicible", "机甲和战斗无人机无敌");
         I18N.Add("Buildings invicible", "Buildings invincible", "建筑无敌");
@@ -76,6 +88,57 @@ public static class UIConfigWindow
         MyConfigWindow.OnUpdateUI += UpdateUI;
     }
 
+    class MaxOrbitRadiusValueMapper : MyWindow.RangeValueMapper<float>
+    {
+        public MaxOrbitRadiusValueMapper() : base(1, 20)
+        {
+        }
+
+        public override int ValueToIndex(float value)
+        {
+            int result = Mathf.FloorToInt(value / 500_000f);
+            if (result < 1) result = 1;
+            if (result > 20) result = 20;
+            return result;
+        }
+
+        public override float IndexToValue(int index)
+        {
+            return index * 500_000f;
+        }
+    }
+
+    class ShellsCountMapper : MyWindow.RangeValueMapper<int>
+    {
+        public ShellsCountMapper() : base(1, 139)
+        {
+        }
+
+        public override int ValueToIndex(int value)
+        {
+            return value switch
+            {
+                < 4 => value,
+                < 64 => value / 4 + 3,
+                < 256 => value / 16 + 15,
+                < 4096 => value / 64 + 27,
+                _ => value / 256 + 75,
+            };
+        }
+
+        public override int IndexToValue(int index)
+        {
+            return index switch
+            {
+                < 4 => index,
+                < 19 => (index - 3) * 4,
+                < 31 => (index - 15) * 16,
+                < 91 => (index - 27) * 64,
+                _ => (index - 75) * 256,
+            };
+        }
+    }
+
     private static void CreateUI(MyConfigWindow wnd, RectTransform trans)
     {
         _windowTrans = trans;
@@ -137,12 +200,20 @@ public static class UIConfigWindow
         wnd.AddCheckBox(x, y, tab2, FactoryPatch.GreaterPowerUsageInLogisticsEnabled, "Increase maximum power usage in Logistic Stations and Advanced Mining Machines");
         y += 36f;
         wnd.AddCheckBox(x, y, tab2, FactoryPatch.ControlPanelRemoteLogisticsEnabled, "Retrieve/Place items from/to remote planets on logistics control panel");
-
-        FactoryPatch.BeltSignalGeneratorEnabled.SettingChanged += (_, _) =>
         {
-            OnBeltSignalChanged();
+            FactoryPatch.BeltSignalGeneratorEnabled.SettingChanged += OnBeltSignalChanged;
-        };
+            wnd.OnFree += () => { FactoryPatch.BeltSignalGeneratorEnabled.SettingChanged -= OnBeltSignalChanged; };
-        OnBeltSignalChanged();
+            OnBeltSignalChanged(null, null);
+            void OnBeltSignalChanged(object o, EventArgs e)
+            {
+                var on = FactoryPatch.BeltSignalGeneratorEnabled.Value;
+                cb1.gameObject.SetActive(on);
+                cb2.gameObject.SetActive(on);
+                cb3.gameObject.SetActive(on);
+                cb4.gameObject.SetActive(on);
+                tip1.gameObject.SetActive(on);
+            }
+        }
         x = 350f;
         y = 10f;
         wnd.AddCheckBox(x, y, tab2, FactoryPatch.RemovePowerSpaceLimitEnabled, "Remove power space limit");
@@ -171,6 +242,8 @@ public static class UIConfigWindow
         y += 36f;
         wnd.AddCheckBox(x, y, tab3, PlanetPatch.TerraformAnywayEnabled, "Terraform without enough soil piles");
         y += 36f;
+        wnd.AddCheckBox(x, y, tab3, PlayerPatch.InstantHandCraftEnabled, "Instant hand-craft");
+        y += 36f;
         wnd.AddCheckBox(x, y, tab3, PlayerPatch.InstantTeleportEnabled, "Instant teleport (like that in Sandbox mode)");
         x = 400f;
         y = 10f;
@@ -199,6 +272,8 @@ public static class UIConfigWindow
         x = 0f;
         y = 10f;
         wnd.AddCheckBox(x, y, tab4, DysonSpherePatch.SkipBulletEnabled, "Skip bullet period");
+        y += 26f;
+        wnd.AddCheckBox(x + 26f, y, tab4, DysonSpherePatch.FireAllBulletsEnabled, "Fire all bullets at once", 13);
         y += 36f;
         wnd.AddCheckBox(x, y, tab4, DysonSpherePatch.SkipAbsorbEnabled, "Skip absorption period");
         y += 36f;
@@ -209,9 +284,72 @@ public static class UIConfigWindow
         wnd.AddCheckBox(x, y, tab4, DysonSpherePatch.OverclockEjectorEnabled, "Overclock Ejectors");
         y += 36f;
         wnd.AddCheckBox(x, y, tab4, DysonSpherePatch.OverclockSiloEnabled, "Overclock Silos");
+        y += 36f;
+        wnd.AddCheckBox(x, y, tab4, DysonSpherePatch.UnlockMaxOrbitRadiusEnabled, "Unlock Dyson Sphere max orbit radius");
+        y += 30f;
+        {
+            var slider = wnd.AddSlider(x + 20, y, tab4, DysonSpherePatch.UnlockMaxOrbitRadiusValue, new MaxOrbitRadiusValueMapper(), "##,#m").WithSmallerHandle(-40f);
+            DysonSpherePatch.UnlockMaxOrbitRadiusEnabled.SettingChanged += UnlockMaxOrbitRadiusChanged;
+            wnd.OnFree += () => { DysonSpherePatch.UnlockMaxOrbitRadiusEnabled.SettingChanged -= UnlockMaxOrbitRadiusChanged; };
+            UnlockMaxOrbitRadiusChanged(null, null);
+
+            void UnlockMaxOrbitRadiusChanged(object o, EventArgs e)
+            {
+                slider.slider.enabled = DysonSpherePatch.UnlockMaxOrbitRadiusEnabled.Value;
+            }
+        }
         x = 300f;
         y = 10f;
         wnd.AddButton(x, y, 300f, tab4, "Complete Dyson Sphere shells instantly", 16, "button-complete-dyson-sphere-shells-instantly", DysonSphereFunctions.CompleteShellsInstantly);
+        {
+            y += 72f;
+            var originalY = y;
+            var btn1 = wnd.AddButton(x, y, 300f, tab4, "Generate illegal dyson shell", 16, "button-generate-illegal-dyson-shells", () =>
+            {
+                UIMessageBox.Show("Generate illegal dyson shell".Translate(), "WARNING: This operation can be very slow, continue?".Translate(), "取消".Translate(), "确定".Translate(), UIMessageBox.WARNING, null,
+                    () => { DysonSphereFunctions.CreateIllegalDysonShellWithMaxOutput(); });
+            });
+            y += 36f;
+            var btn2 = wnd.AddButton(x, y, 300f, tab4, "Keep max production shells and remove others", 16, "button-keep-max-production-shells", () =>
+            {
+                UIMessageBox.Show("Keep max production shells and remove others".Translate(), "WARNING: This operation is DANGEROUS, continue?".Translate(), "取消".Translate(), "确定".Translate(), UIMessageBox.WARNING, null,
+                    () => { DysonSphereFunctions.KeepMaxProductionShells(); });
+            });
+            y += 36f;
+            var btn3 = wnd.AddButton(x, y, 300f, tab4, "Duplicate shells from that with highest production", 16, "button-duplicate-shells-from-the-highest-production", () =>
+            {
+                UIMessageBox.Show("Duplicate shells from that with highest production".Translate(), "WARNING: This operation can be very slow, continue?".Translate(), "取消".Translate(), "确定".Translate(), UIMessageBox.WARNING, null,
+                    () => { DysonSphereFunctions.DuplicateShellsWithHighestProduction(); });
+            });
+            y += 30f;
+            var slider1 = wnd.AddSlider(x + 20f, y, tab4, DysonSphereFunctions.ShellsCountForFunctions, new ShellsCountMapper());
+
+            y = originalY;
+            var btn4 = wnd.AddButton(x, y, 300f, tab4, "Generate illegal dyson shell quickly", 16, "button-generate-illegal-dyson-shells-quickly", () =>
+            {
+                UIMessageBox.Show("Generate illegal dyson shell".Translate(), "WARNING: This operation can be very slow, continue?".Translate(), "取消".Translate(), "确定".Translate(), UIMessageBox.WARNING, null,
+                    () => { DysonSphereFunctions.CreateIllegalDysonShellQuickly(DysonSphereFunctions.ShellsCountForFunctions.Value); });
+            });
+            y += 30f;
+            var txt2 = wnd.AddText2(x, y, tab4, "Shells count", 15, "text-shells-count");
+            var slider2 = wnd.AddSlider(x + txt2.preferredWidth + 5f, y + 6f, tab4, DysonSphereFunctions.ShellsCountForFunctions, new ShellsCountMapper());
+
+            Functions.DysonSphereFunctions.IllegalDysonShellFunctionsEnabled.SettingChanged += onIllegalDysonShellFunctionsChanged;
+            wnd.OnFree += () => { Functions.DysonSphereFunctions.IllegalDysonShellFunctionsEnabled.SettingChanged -= onIllegalDysonShellFunctionsChanged; };
+            onIllegalDysonShellFunctionsChanged(null, null);
+            void onIllegalDysonShellFunctionsChanged(object o, EventArgs e)
+            {
+                var enabled = Functions.DysonSphereFunctions.IllegalDysonShellFunctionsEnabled.Value;
+                btn1.gameObject.SetActive(enabled);
+                btn2.gameObject.SetActive(enabled);
+                btn3.gameObject.SetActive(enabled);
+                slider1.gameObject.SetActive(enabled);
+
+                btn4.gameObject.SetActive(!enabled);
+                txt2.gameObject.SetActive(!enabled);
+                slider2.gameObject.SetActive(!enabled);
+            }
+        }
 
         var tab5 = wnd.AddTab(_windowTrans, "Mecha/Combat");
         x = 0f;
@@ -226,17 +364,6 @@ public static class UIConfigWindow
         wnd.AddButton(x, y, 200f, tab5, "Teleport to outer space", 16, "button-teleport-to-outer-space", PlayerFunctions.TeleportToOuterSpace);
         y += 36f;
         wnd.AddButton(x, y, 200f, tab5, "Teleport to selected astronomical", 16, "button-teleport-to-selected-astronomical", PlayerFunctions.TeleportToSelectedAstronomical);
-        return;
-
-        void OnBeltSignalChanged()
-        {
-            var on = FactoryPatch.BeltSignalGeneratorEnabled.Value;
-            cb1.gameObject.SetActive(on);
-            cb2.gameObject.SetActive(on);
-            cb3.gameObject.SetActive(on);
-            cb4.gameObject.SetActive(on);
-            tip1.gameObject.SetActive(on);
-        }
     }
 
     private static void UpdateUI()
@@ -253,6 +380,7 @@ public static class UIConfigWindow
         {
             _resignGameBtn.gameObject.SetActive(resignEnabled);
         }
+
         var history = data.history;
         if (history == null) return;
         var banEnabled = history.hasUsedPropertyBanAchievement;

CheatEnabler/package/manifest.json

@@ -1,10 +1,10 @@
 {
   "name": "CheatEnabler",
-  "version_number": "2.3.26",
+  "version_number": "2.4.0",
   "website_url": "https://github.com/soarqin/DSP_Mods/tree/master/CheatEnabler",
   "description": "Add various cheat functions while disabling abnormal determinants / 添加一些作弊功能，同时屏蔽异常检测",
   "dependencies": [
     "xiaoye97-BepInEx-5.4.17",
-    "soarqin-UXAssist-1.2.0"
+    "soarqin-UXAssist-1.4.0"
   ]
 }

CompressSave/README.md

@@ -1,3 +1,3 @@
 # CompressSave
 
-#### Moved [here](https://github.com/soarqin/DSP_Mods_TO/tree/master/CompressSave)
+Moved [to another repo](https://github.com/soarqin/DSP_Mods_TO/tree/master/CompressSave)

DSP_Mods.sln

@@ -1,8 +1,10 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UXAssist", "UXAssist\UXAssist.csproj", "{9C048229-6A50-4642-BC5E-02CD39D3869A}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CheatEnabler", "CheatEnabler\CheatEnabler.csproj", "{F9F16B62-D1D3-466B-BE22-E64B9EA957C2}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LogisticMiner", "LogisticMiner\LogisticMiner.csproj", "{7149D717-C913-4153-9425-38CB9D087F83}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LogisticHub", "LogisticHub\LogisticHub.csproj", "{7149D717-C913-4153-9425-38CB9D087F83}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HideTips", "HideTips\HideTips.csproj", "{4EABD71D-477F-448B-801B-48F8745A3FA7}"
 EndProject
@@ -11,8 +13,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Dustbin", "Dustbin\Dustbin.
 		{B8EB3D8D-5613-42F0-9040-EAA11A38C6AC} = {B8EB3D8D-5613-42F0-9040-EAA11A38C6AC}
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OCBatchBuild", "OCBatchBuild\OCBatchBuild.csproj", "{E8FB30A0-29BF-4CF0-8E08-9784962A8656}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UniverseGenTweaks", "UniverseGenTweaks\UniverseGenTweaks.csproj", "{9534694E-14F0-4498-852D-BBB3FCA986CD}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OverclockEverything", "OverclockEverything\OverclockEverything.csproj", "{0168941C-EEA6-49CF-9A67-E829FE06CF9B}"
@@ -30,8 +30,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DustbinPreloader", "Dustbin
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PoolOpt", "PoolOpt\PoolOpt.csproj", "{8BE61246-2C9D-4088-AA33-5AFF22C5046E}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UXAssist", "UXAssist\UXAssist.csproj", "{9C048229-6A50-4642-BC5E-02CD39D3869A}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UserCloak", "UserCloak\UserCloak.csproj", "{096D2E4B-D1CE-424D-9954-C36A23E9E279}"
 EndProject
 Global
@@ -40,6 +38,10 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Release|Any CPU.Build.0 = Release|Any CPU
 		{F9F16B62-D1D3-466B-BE22-E64B9EA957C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{F9F16B62-D1D3-466B-BE22-E64B9EA957C2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F9F16B62-D1D3-466B-BE22-E64B9EA957C2}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -56,10 +58,6 @@ Global
 		{931F0230-5941-4E49-AB19-66921AF14096}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{931F0230-5941-4E49-AB19-66921AF14096}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{931F0230-5941-4E49-AB19-66921AF14096}.Release|Any CPU.Build.0 = Release|Any CPU
-		{E8FB30A0-29BF-4CF0-8E08-9784962A8656}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{E8FB30A0-29BF-4CF0-8E08-9784962A8656}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{E8FB30A0-29BF-4CF0-8E08-9784962A8656}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{E8FB30A0-29BF-4CF0-8E08-9784962A8656}.Release|Any CPU.Build.0 = Release|Any CPU
 		{9534694E-14F0-4498-852D-BBB3FCA986CD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{9534694E-14F0-4498-852D-BBB3FCA986CD}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9534694E-14F0-4498-852D-BBB3FCA986CD}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -88,10 +86,6 @@ Global
 		{8BE61246-2C9D-4088-AA33-5AFF22C5046E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8BE61246-2C9D-4088-AA33-5AFF22C5046E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8BE61246-2C9D-4088-AA33-5AFF22C5046E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{9C048229-6A50-4642-BC5E-02CD39D3869A}.Release|Any CPU.Build.0 = Release|Any CPU
 		{096D2E4B-D1CE-424D-9954-C36A23E9E279}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{096D2E4B-D1CE-424D-9954-C36A23E9E279}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{096D2E4B-D1CE-424D-9954-C36A23E9E279}.Release|Any CPU.ActiveCfg = Release|Any CPU

Dustbin/BeltSignal.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
@@ -14,7 +13,6 @@ public static class BeltSignal
     private static HashSet<int>[] _signalBelts;
     private static int _signalBeltsCapacity;
     private static bool _initialized;
-    private static AssetBundle _bundle;
     private static Harmony _patch;
 
     public static void Enable(bool on)
@@ -33,13 +31,40 @@ public static class BeltSignal
         }
     }
 
+    private static byte[] LoadEmbeddedResource(string path, Assembly assembly = null)
+    {
+        if (assembly == null)
+        {
+            assembly = Assembly.GetCallingAssembly();
+        }
+        var info = assembly.GetName();
+        var name = info.Name;
+        using var stream = assembly.GetManifestResourceStream($"{name}.{path.Replace('/', '.')}")!;
+        var buffer = new byte[stream.Length];
+        _ = stream.Read(buffer, 0, buffer.Length);
+        return buffer;
+    }
+
+    private static Texture2D LoadEmbeddedTexture(string path, Assembly assembly = null)
+    {
+        var fileData = LoadEmbeddedResource(path, assembly);
+        var tex = new Texture2D(2, 2);
+        tex.LoadImage(fileData);
+        return tex;
+    }
+
+    private static Sprite LoadEmbeddedSprite(string path, Assembly assembly = null)
+    {
+        var tex = LoadEmbeddedTexture(path, assembly);
+        return Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(0.5f, 0.5f));
+    }
+
     [HarmonyPostfix, HarmonyPriority(Priority.Last)]
-    [HarmonyPatch(typeof(VFPreload), "InvokeOnLoadWorkEnded")]
+    [HarmonyPatch(typeof(VFPreload), nameof(VFPreload.InvokeOnLoadWorkEnded))]
     private static void VFPreload_InvokeOnLoadWorkEnded_Postfix()
     {
         if (_initialized) return;
-        var pluginfolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+        var assembly = Assembly.GetExecutingAssembly();
-        _bundle = AssetBundle.LoadFromFile($"{pluginfolder}/dustbin.assetbundle");
         var signals = LDB._signals;
         var index = signals.dataArray.Length;
         var p = new SignalProto
@@ -48,7 +73,7 @@ public static class BeltSignal
             Name = "DUSTBIN",
             GridIndex = 3110,
             IconPath = "Assets/signal-410.png",
-            _iconSprite = _bundle.LoadAsset<Sprite>("Assets/signal-410.png"),
+            _iconSprite = LoadEmbeddedSprite("assets/icon/signal-410.png", assembly),
             SID = ""
         };
         p.name = p.Name.Translate();
@@ -173,7 +198,7 @@ public static class BeltSignal
     }
 
     [HarmonyTranspiler]
-    [HarmonyPatch(typeof(GameData), "GameTick")]
+    [HarmonyPatch(typeof(GameData), nameof(GameData.GameTick))]
     public static IEnumerable<CodeInstruction> GameData_GameTick_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
     {
         var matcher = new CodeMatcher(instructions, generator);

Dustbin/CHANGELOG.md

@@ -0,0 +1,79 @@
+<details>
+<summary>Read me in English</summary>
+
+## Changelog
+
+* 1.4.0
+  * Refactorying Tank input logic codes, for better performance, and resolve a bug [#53](https://github.com/soarqin/DSP_Mods/issues/53)
+  * Remove use of AssetBundle, move the belt signal icon into `Assembly Resources`, for better flexibility.
+
+* 1.3.3
+  * Support for NebulaMultiplayerModApi 2.0.0
+
+* 1.3.2
+  * Fix a display issue that the dustbin checkbox is overlapped with the filter button in storage UI.
+
+* 1.3.1
+  * Support for game version 0.10.28.20759
+
+* 1.3.0
+  * Add a belt signal(you can find it in first tab of signal selection panel) as dustbin, which is the simplest way to destroy items.
+  * Reworked dustbin support for Tanks, to improve performance and resolve known bugs.
+    * Be note that the whole tank logic is optimized which may get a slight better performance even if you don't use them as dustbin.
+  * Config entry for soil piless gain from destroyed items are changed to a more flexible format.
+  * [Nebula Mupltiplayer Mod](https://dsp.thunderstore.io/package/nebula/NebulaMultiplayerMod/) and bug fixes from [ModFixerOne](https://dsp.thunderstore.io/package/starfi5h/ModFixerOne/) by [starfi5h](https://github.com/starfi5h/).
+
+* 1.2.1
+  * Fix dynamic array bug in codes, which causes various bugs and errors.
+
+* 1.2.0
+  * Use [DSPModSave](https://dsp.thunderstore.io/package/CommonAPI/DSPModSave/) to save dustbin specified data now, which fixes [#1](https://github.com/soarqin/DSP_Mods/issues/1).
+  * Fix issue for storages on multiple planets.
+  * Fix issue for multi-level tanks.
+  * Add a note in README for known bug on tank.
+
+* 1.1.0
+  * Rewrite whole plugin, make a checkbox on UI so that you can turn storages into dustbin by just ticking it.
+  * Can turn tank into dustbin now.
+
+</details>
+
+<details>
+<summary>中文读我</summary>
+
+## 更新日志
+
+* 1.4.0
+  * 重构储液罐的输入逻辑代码，以提高性能并解决bug [#53](https://github.com/soarqin/DSP_Mods/issues/53)
+  * 移除了AssetBundle的使用，将传送带信号图标移入`Assembly资源`，以获得更好的灵活性
+
+* 1.3.3
+  * 支持NebulaMultiplayerModApi 2.0.0
+
+* 1.3.2
+  * 修正了储物仓UI中的垃圾桶勾选框与筛选按钮重叠的显示问题
+
+* 1.3.1
+  * 支持游戏版本 0.10.28.20759
+
+* 1.3.0
+  * 添加了一个传送带信号(可以在信号选择面板的第一个页签中找到)作为垃圾桶，这是目前销毁物品最简单的方法
+  * 重写了储液罐的垃圾桶实现，以提高性能并解决已知的bug
+    * 注意：整个储液罐逻辑都被优化了，即使你不把他们作为垃圾桶使用，也可能会获得轻微的性能提升
+  * 从销毁的物品中获得沙子的配置已变为更灵活的设置项格式
+  * [Nebula Mupltiplayer Mod](https://dsp.thunderstore.io/package/nebula/NebulaMultiplayerMod/)支持和Bug修正来自[starfi5h](https://github.com/starfi5h/)的[ModFixerOne](https://dsp.thunderstore.io/package/starfi5h/ModFixerOne/)
+
+* 1.2.1
+  * 修正了代码中的动态数组Bug，该Bug可能导致各种问题
+
+* 1.2.0
+  * 现在使用[DSPModSave](https://dsp.thunderstore.io/package/CommonAPI/DSPModSave/)来保存垃圾桶的数据，修正了[#1](https://github.com/soarqin/DSP_Mods/issues/1)
+  * 修正了多星球上的储物仓问题
+  * 修正了多层储液罐的问题
+  * 在README中添加了一个已知储液罐Bug的说明
+
+* 1.1.0
+  * 重写了整个插件，现在可以在仓储类建筑的UI上勾选来将其转变为垃圾桶
+  * 现在可以将储液罐转变为垃圾桶
+
+</details>

Dustbin/Dustbin.cs

@@ -48,7 +48,7 @@ public class Dustbin : BaseUnityPlugin, IModCanSave, IMultiplayerMod
         NebulaModAPI.RegisterPackets(Assembly.GetExecutingAssembly());
         NebulaModAPI.OnPlanetLoadFinished += RequestPlanetDustbinData;
     }
-    
+
     private void OnDestroy()
     {
         TankPatch.Enable(false);
@@ -68,7 +68,7 @@ public class Dustbin : BaseUnityPlugin, IModCanSave, IMultiplayerMod
         return count;
     }
 
-    #region IModCanSave 
+    #region IModCanSave
     private const ushort ModSaveVersion = 1;
 
     public void Export(BinaryWriter w)

Dustbin/Dustbin.csproj

@@ -5,7 +5,7 @@
     <TargetFramework>net472</TargetFramework>
     <BepInExPluginGuid>org.soardev.dustbin</BepInExPluginGuid>
     <Description>DSP MOD - Dustbin</Description>
-    <Version>1.3.3</Version>
+    <Version>1.4.0</Version>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <LangVersion>latest</LangVersion>
     <PackageId>Dustbin</PackageId>
@@ -16,16 +16,19 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="DysonSphereProgram.Modding.DSPModSave" Version="1.*" />
     <PackageReference Include="DysonSphereProgram.Modding.NebulaMultiplayerModApi" Version="2.0.0" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="assets/icon/signal-410.png" />
+  </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>
-  
+
   <ItemGroup>
     <Reference Include="Assembly-CSharp">
       <HintPath>GameAssembly\Assembly-CSharp.dll</HintPath>
@@ -33,6 +36,6 @@
   </ItemGroup>
 
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
-    <Exec Command="del /F /Q package\$(ProjectName)-$(Version).zip&#xA;IF NOT EXIST package\plugins (mkdir package\plugins)&#xA;copy /y $(TargetPath) package\plugins\&#xA;cd package&#xA;powershell Compress-Archive -Force -DestinationPath '$(ProjectName)-$(Version).zip' -Path patchers, plugins, icon.png, manifest.json, ../README.md" />
+    <Exec Command="del /F /Q package\$(ProjectName)-$(Version).zip&#xA;IF NOT EXIST package\plugins (mkdir package\plugins)&#xA;copy /y $(TargetPath) package\plugins\&#xA;cd package&#xA;powershell Compress-Archive -Force -DestinationPath '$(ProjectName)-$(Version).zip' -Path patchers, plugins, icon.png, manifest.json, ../README.md, ../CHANGELOG.md" />
   </Target>
 </Project>

Dustbin/NebulaSupport/Packets.cs

@@ -61,19 +61,19 @@ namespace Dustbin.NebulaSupport
                         NebulaModAPI.MultiplayerSession.Network.SendPacket(new SyncPlanetData(Dustbin.ExportData(factory)));
                         return;
                     case < 0:
-                    {
+                        {
-                        var tankPool = factory.factoryStorage.tankPool;
+                            var tankPool = factory.factoryStorage.tankPool;
-                        tankPool[-storageId].IsDustbin = packet.Enable;
+                            tankPool[-storageId].IsDustbin = packet.Enable;
-                        TankPatch.Reset();
+                            TankPatch.Reset();
-                        return;
+                            return;
-                    }
+                        }
                     case > 0:
-                    {
+                        {
-                        var storagePool = factory.factoryStorage.storagePool;
+                            var storagePool = factory.factoryStorage.storagePool;
-                        storagePool[storageId].IsDustbin = packet.Enable;
+                            storagePool[storageId].IsDustbin = packet.Enable;
-                        StoragePatch.Reset();
+                            StoragePatch.Reset();
-                        return;
+                            return;
-                    }
+                        }
                 }
             }
         }

Dustbin/README.md

@@ -1,78 +1,29 @@
 # Dustbin
 
-#### Can turn Storages and Tanks into Dustbin(Destroy incoming items)
+<details>
-#### 储物仓和储液罐可以转变为垃圾桶(销毁送进的物品)
+<summary>Read me in English</summary>
 
-## Changelog
+***Can turn Storages and Tanks into Dustbin(Destroy incoming items)***
-* 1.3.3
-  + Support for NebulaMultiplayerModApi 2.0.0
-
-* 1.3.2
-  + Fix a display issue that the dustbin checkbox is overlapped with the filter button in storage UI.
-
-* 1.3.1
-  + Support for game version 0.10.28.20759
-
-* 1.3.0
-  + Add a belt signal(you can find it in first tab of signal selection panel) as dustbin, which is the simplest way to destroy items.
-  + Reworked dustbin support for Tanks, to improve performance and resolve known bugs.
-    - Be note that the whole tank logic is optimized which may get a slight better performance even if you don't use them as dustbin.
-  + Config entry for soil piless gain from destroyed items are changed to a more flexible format.
-  + [Nebula Mupltiplayer Mod](https://dsp.thunderstore.io/package/nebula/NebulaMultiplayerMod/) and bug fixes from [ModFixerOne](https://dsp.thunderstore.io/package/starfi5h/ModFixerOne/) by [starfi5h](https://github.com/starfi5h/).
-
-* 1.2.1
-  + Fix dynamic array bug in codes, which causes various bugs and errors.
-
-* 1.2.0
-  + Use [DSPModSave](https://dsp.thunderstore.io/package/CommonAPI/DSPModSave/) to save dustbin specified data now, which fixes [#1](https://github.com/soarqin/DSP_Mods/issues/1).
-  + Fix issue for storages on multiple planets.
-  + Fix issue for multi-level tanks.
-  + Add a note in README for known bug on tank.
-
-* 1.1.0
-  + Rewrite whole plugin, make a checkbox on UI so that you can turn storages into dustbin by just ticking it.
-  + Can turn tank into dustbin now.
 
 ## Usage
 
 * A checkbox is added to Storages and Tanks UI, which turns them into dustbins.
 * Items sent into dustbins are removed immediately.
 * Can get soil piless from destroyed items, configurable through a json encoded config entry.
-  + You can get item ID list [here](https://dsp-wiki.com/Modding:Items_IDs).
+  * You can get item ID list from [dsp-wiki](https://dsp-wiki.com/Modding:Items_IDs).
 
-## 更新日志
+</details>
-* 1.3.3
-  + 支持NebulaMultiplayerModApi 2.0.0
 
-* 1.3.2
+<details>
-  + 修正了储物仓UI中的垃圾桶勾选框与筛选按钮重叠的显示问题
+<summary>中文读我</summary>
 
-* 1.3.1
+***储物仓和储液罐可以转变为垃圾桶(销毁送进的物品)***
-  + 支持游戏版本 0.10.28.20759
-
-* 1.3.0
-  + 添加了一个传送带信号(可以在信号选择面板的第一个页签中找到)作为垃圾桶，这是目前销毁物品最简单的方法
-  + 重写了储液罐的垃圾桶实现，以提高性能并解决已知的bug
-    - 注意：整个储液罐逻辑都被优化了，即使你不把他们作为垃圾桶使用，也可能会获得轻微的性能提升
-  + 从销毁的物品中获得沙子的配置已变为更灵活的设置项格式
-  + [Nebula Mupltiplayer Mod](https://dsp.thunderstore.io/package/nebula/NebulaMultiplayerMod/)支持和Bug修正来自[starfi5h](https://github.com/starfi5h/)的[ModFixerOne](https://dsp.thunderstore.io/package/starfi5h/ModFixerOne/)
-
-* 1.2.1
-  + 修正了代码中的动态数组Bug，该Bug可能导致各种问题
-
-* 1.2.0
-  + 现在使用[DSPModSave](https://dsp.thunderstore.io/package/CommonAPI/DSPModSave/)来保存垃圾桶的数据，修正了[#1](https://github.com/soarqin/DSP_Mods/issues/1)
-  + 修正了多星球上的储物仓问题
-  + 修正了多层储液罐的问题
-  + 在README中添加了一个已知储液罐Bug的说明
-
-* 1.1.0
-  + 重写了整个插件，现在可以在仓储类建筑的UI上勾选来将其转变为垃圾桶
-  + 现在可以将储液罐转变为垃圾桶
 
 ## 使用说明
 
 * 在储物仓和储液罐上增加一个垃圾桶的勾选框。
 * 送进垃圾桶的物品会立即被移除。
 * 可以从移除的物品中获得沙子，可以通过json编码的设置项进行配置。
-  + 可以在[这里](https://dsp-wiki.com/Modding:Items_IDs)获得物品ID列表。
+  * 可以在[这里](https://dsp-wiki.com/Modding:Items_IDs)获得物品ID列表。
+
+</details>

Dustbin/StoragePatch.cs

@@ -13,7 +13,7 @@ public static class StoragePatch
     private static UI.MyCheckBox _storageDustbinCheckBox;
     private static int _lastStorageId;
     private static Harmony _patch;
-    
+
     public static void Enable(bool on)
     {
         if (on)
@@ -96,14 +96,14 @@ public static class StoragePatch
     }
 
     [HarmonyPrefix]
-    [HarmonyPatch(typeof(GameMain), "Start")]
+    [HarmonyPatch(typeof(GameMain), nameof(GameMain.Start))]
     private static void GameMain_Start_Prefix()
     {
         Reset();
     }
 
     [HarmonyPostfix]
-    [HarmonyPatch(typeof(UIStorageWindow), "_OnCreate")]
+    [HarmonyPatch(typeof(UIStorageWindow), nameof(UIStorageWindow._OnCreate))]
     private static void UIStorageWindow__OnCreate_Postfix(UIStorageWindow __instance)
     {
         _storageDustbinCheckBox = UI.MyCheckBox.CreateCheckBox(false, __instance.transform, 50f, 50f, Localization.CurrentLanguageLCID == Localization.LCID_ZHCN ? "垃圾桶" : "Dustbin");
@@ -123,7 +123,7 @@ public static class StoragePatch
     }
 
     [HarmonyPostfix]
-    [HarmonyPatch(typeof(UIStorageWindow), "_OnUpdate")]
+    [HarmonyPatch(typeof(UIStorageWindow), nameof(UIStorageWindow._OnUpdate))]
     private static void UIStorageWindow__OnUpdate_Postfix(UIStorageWindow __instance)
     {
         var storageId = __instance.storageId;
@@ -138,10 +138,10 @@ public static class StoragePatch
             _storageDustbinCheckBox.rectTrans.anchoredPosition3D = new Vector3(190, 57 - rectTrans.sizeDelta.y, 0);
         }
     }
-    
+
     /* Adopt fix from starfi5h's NebulaCompatiblilityAssist */
     [HarmonyPostfix]
-    [HarmonyPatch(typeof(UIStorageGrid), "OnStorageSizeChanged")]
+    [HarmonyPatch(typeof(UIStorageGrid), nameof(UIStorageGrid.OnStorageSizeChanged))]
     private static void UIStorageGrid_OnStorageSizeChanged_Postfix()
     {
         // Due to storage window is empty when open in client, the size will change after receiving data from host
@@ -149,8 +149,8 @@ public static class StoragePatch
     }
 
     [HarmonyTranspiler]
-    [HarmonyPatch(typeof(StorageComponent), "AddItem", new[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(bool) },
+    [HarmonyPatch(typeof(StorageComponent), nameof(StorageComponent.AddItem), [typeof(int), typeof(int), typeof(int), typeof(int), typeof(bool)],
-        new[] { ArgumentType.Normal, ArgumentType.Normal, ArgumentType.Normal, ArgumentType.Out, ArgumentType.Normal })]
+        [ArgumentType.Normal, ArgumentType.Normal, ArgumentType.Normal, ArgumentType.Out, ArgumentType.Normal])]
     private static IEnumerable<CodeInstruction> StorageComponent_AddItem_HarmonyTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
     {
         var matcher = new CodeMatcher(instructions, generator);
@@ -172,7 +172,7 @@ public static class StoragePatch
 
     /* We keep this to make MOD compatible with older version */
     [HarmonyPostfix]
-    [HarmonyPatch(typeof(StorageComponent), "Import")]
+    [HarmonyPatch(typeof(StorageComponent), nameof(StorageComponent.Import))]
     private static void StorageComponent_Import_Postfix(StorageComponent __instance)
     {
         if (__instance.bans >= 0)

Dustbin/TankPatch.cs

@@ -11,7 +11,7 @@ public static class TankPatch
     private static UI.MyCheckBox _tankDustbinCheckBox;
     private static int _lastTankId;
     private static Harmony _patch;
-    
+
     public static void Enable(bool on)
     {
         if (on)
@@ -100,14 +100,14 @@ public static class TankPatch
     }
 
     [HarmonyPrefix]
-    [HarmonyPatch(typeof(GameMain), "Start")]
+    [HarmonyPatch(typeof(GameMain), nameof(GameMain.Start))]
     private static void GameMain_Start_Prefix()
     {
         Reset();
     }
 
     [HarmonyPostfix]
-    [HarmonyPatch(typeof(UITankWindow), "_OnCreate")]
+    [HarmonyPatch(typeof(UITankWindow), nameof(UITankWindow._OnCreate))]
     private static void UITankWindow__OnCreate_Postfix(UITankWindow __instance)
     {
         _tankDustbinCheckBox = UI.MyCheckBox.CreateCheckBox(false, __instance.transform, 120f, 20f, Localization.CurrentLanguageLCID == Localization.LCID_ZHCN ? "垃圾桶" : "Dustbin");
@@ -127,7 +127,7 @@ public static class TankPatch
     }
 
     [HarmonyPostfix]
-    [HarmonyPatch(typeof(UITankWindow), "_OnUpdate")]
+    [HarmonyPatch(typeof(UITankWindow), nameof(UITankWindow._OnUpdate))]
     private static void UITankWindow__OnUpdate_Postfix(UITankWindow __instance)
     {
         var tankId = __instance.tankId;
@@ -142,7 +142,7 @@ public static class TankPatch
     }
 
     [HarmonyPrefix]
-    [HarmonyPatch(typeof(TankComponent), "GameTick")]
+    [HarmonyPatch(typeof(TankComponent), nameof(TankComponent.GameTick))]
     private static bool TankComponent_GameTick_Prefix(ref TankComponent __instance, PlanetFactory factory)
     {
         if (__instance.fluidInc < 0)
@@ -183,94 +183,68 @@ public static class TankPatch
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static void TankComponentUpdateBelt(ref TankComponent thisTank, int belt, bool isOutput, ref CargoTraffic cargoTraffic, ref TankComponent[] tankPool)
     {
-        switch (isOutput)
+        if (isOutput)
         {
-            case true when thisTank.outputSwitch:
+            if (thisTank.outputSwitch)
             {
                 if (thisTank.fluidId <= 0 || thisTank.fluidCount <= 0) return;
                 var inc = thisTank.fluidInc == 0 ? 0 : thisTank.fluidInc / thisTank.fluidCount;
                 if (!cargoTraffic.TryInsertItemAtHead(belt, thisTank.fluidId, 1, (byte)inc)) return;
                 thisTank.fluidCount--;
                 thisTank.fluidInc -= inc;
-                return;
             }
-            case false when thisTank.inputSwitch:
+        }
+        else
+        {
+            if (thisTank.inputSwitch)
             {
                 byte stack;
                 byte inc;
-                switch (thisTank.fluidId)
+                var thisFluidId = thisTank.fluidId;
+                if (thisTank.fluidCount <= 0)
                 {
-                    case > 0 when thisTank.fluidCount < thisTank.fluidCapacity && cargoTraffic.TryPickItemAtRear(belt, thisTank.fluidId, null, out stack, out inc) > 0 &&
+                    var fluidId = cargoTraffic.TryPickItemAtRear(belt, 0, ItemProto.fluids, out stack, out inc);
-                                  !thisTank.IsDustbin:
+                    if (fluidId <= 0 || thisTank.IsDustbin) return;
-                        thisTank.fluidCount += stack;
+                    thisTank.fluidId = fluidId;
-                        thisTank.fluidInc += inc;
+                    thisTank.fluidCount = stack;
-                        return;
+                    thisTank.fluidInc = inc;
-                    case 0:
+                    return;
-                    {
-                        var count = cargoTraffic.TryPickItemAtRear(belt, 0, ItemProto.fluids, out stack, out inc);
-                        if (count <= 0 || thisTank.IsDustbin) return;
-                        thisTank.fluidId = count;
-                        thisTank.fluidCount += stack;
-                        thisTank.fluidInc += inc;
-                        return;
-                    }
                 }
-
+                if (thisTank.fluidCount < thisTank.fluidCapacity || thisTank.IsDustbin)
-                if (thisTank.fluidCount < thisTank.fluidCapacity || cargoTraffic.GetItemIdAtRear(belt) != thisTank.fluidId || thisTank.nextTankId <= 0) return;
-                ref var targetTank = ref tankPool[thisTank.nextTankId];
-                while (targetTank.fluidCount >= targetTank.fluidCapacity)
                 {
-                    ref var lastTank = ref tankPool[targetTank.lastTankId];
+                    if (cargoTraffic.GetItemIdAtRear(belt) != thisFluidId || thisTank.nextTankId <= 0) return;
-                    if (targetTank.fluidId != lastTank.fluidId)
+                    if (cargoTraffic.TryPickItemAtRear(belt, thisFluidId, null, out stack, out inc) <= 0 || thisTank.IsDustbin) return;
+                    thisTank.fluidCount += stack;
+                    thisTank.fluidInc += inc;
+                    return;
+                }
+                if (thisTank.nextTankId <= 0) return;
+                ref var targetTank = ref tankPool[thisTank.nextTankId];
+                while (true)
+                {
+                    if (targetTank.fluidCount < targetTank.fluidCapacity || targetTank.IsDustbin)
                     {
-                        if (lastTank.id == thisTank.id || targetTank.fluidCount >= targetTank.fluidCapacity) return;
+                        if (!targetTank.inputSwitch) return;
-                        targetTank = ref lastTank;
+                        var targetFluidId = targetTank.fluidId;
+                        if (targetFluidId != 0 && targetFluidId != thisFluidId) return;
                         break;
                     }
-
+                    if (targetTank.nextTankId <= 0) return;
-                    if (!targetTank.inputSwitch)
-                    {
-                        if (lastTank.id == thisTank.id || targetTank.fluidCount >= targetTank.fluidCapacity) return;
-                        targetTank = ref lastTank;
-                        break;
-                    }
-
-                    if (targetTank.nextTankId <= 0)
-                    {
-                        break;
-                    }
-
                     targetTank = ref tankPool[targetTank.nextTankId];
                 }
 
-                ref var lastTank2 = ref tankPool[targetTank.lastTankId];
+                if (cargoTraffic.TryPickItemAtRear(belt, thisFluidId, null, out stack, out inc) <= 0 || targetTank.IsDustbin) return;
-                if (!targetTank.inputSwitch)
+                if (targetTank.fluidCount <= 0)
                 {
-                    targetTank = ref lastTank2;
+                    targetTank.fluidId = thisFluidId;
+                    targetTank.fluidCount = stack;
+                    targetTank.fluidInc = inc;
                 }
                 else
                 {
-                    var fluidId = targetTank.fluidId;
+                    targetTank.fluidCount += stack;
-                    if (fluidId != 0 && fluidId != lastTank2.fluidId)
+                    targetTank.fluidInc += inc;
-                    {
-                        if (lastTank2.id == thisTank.id || targetTank.fluidCount >= targetTank.fluidCapacity) return;
-                        targetTank = ref lastTank2;
-                    }
-                    else if (!lastTank2.outputSwitch)
-                    {
-                        return;
-                    }
                 }
-
-                if (cargoTraffic.TryPickItemAtRear(belt, thisTank.fluidId, null, out stack, out inc) <= 0 || targetTank.IsDustbin) return;
-                if (targetTank.fluidCount == 0)
-                {
-                    targetTank.fluidId = thisTank.fluidId;
-                }
-
-                targetTank.fluidCount += stack;
-                targetTank.fluidInc += inc;
-                return;
             }
         }
     }

Dustbin/package/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "Dustbin",
-  "version_number": "1.3.3",
+  "version_number": "1.4.0",
   "website_url": "https://github.com/soarqin/DSP_Mods/tree/master/Dustbin",
   "description": "Can turn Storages and Tanks into Dustbin(Destroy incoming items) / 储物仓和储液罐可以转变为垃圾桶(销毁送进的物品)",
   "dependencies": [

DustbinPreloader/DustbinPreloader.cs

@@ -7,7 +7,7 @@ namespace DustbinPreloader;
 
 public static class Preloader
 {
-    private static readonly ManualLogSource Logger = BepInEx.Logging.Logger.CreateLogSource("Dustbin Preloader");      
+    private static readonly ManualLogSource Logger = BepInEx.Logging.Logger.CreateLogSource("Dustbin Preloader");
     public static IEnumerable<string> TargetDLLs { get; } = new[] { "Assembly-CSharp.dll" };
 
     public static void Patch(AssemblyDefinition assembly)

DustbinPreloader/DustbinPreloader.csproj

@@ -14,14 +14,14 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>
-  
+
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
     <Exec Command="IF NOT EXIST ..\Dustbin\package\patchers (mkdir ..\Dustbin\package\patchers)&#xA;copy /y $(TargetPath) ..\Dustbin\package\patchers\" />
   </Target>

HideTips/CHANGELOG.md

@@ -0,0 +1,39 @@
+<details>
+<summary>Read me in English</summary>
+
+## Changelog
+
+* 1.0.4
+  * Remove `Disable title screen demo scene loading`, as it is buggy in recent updates.
+  * Fix a bug that when tutorials are not added to the guides panel when they are hidden by this MOD.
+* 1.0.3
+  * Add config entries to disable research completion tips/popup windows
+  * Add a note to README for mod compatibility on `Disable title screen demo scene loading`.
+* 1.0.2
+  * Add a config entry to disable title screen demo scene loading
+* 1.0.1
+  * Hide 3 more random tutorial tips popup from bottom-right panel
+* 1.0.0
+  * Initial release
+
+</details>
+
+<details>
+<summary>中文读我</summary>
+
+## 更新日志
+
+* 1.0.4
+  * 移除`关闭标题画面的演示场景加载`设置，因为在最近的更新中有较多bug。
+  * 修复了一个bug，当教程指引被这个MOD隐藏时，它们不会被添加到教程面板。
+* 1.0.3
+  * 增加设置项以关闭研究完成的提示/弹窗
+  * 在README中增加了一个关于`关闭标题画面的演示场景加载`设置的兼容性说明
+* 1.0.2
+  * 增加设置项以关闭标题画面的演示场景加载
+* 1.0.1
+  * 可屏蔽右下面板的3种随机提醒
+* 1.0.0
+  * 初始版本
+
+</details>

HideTips/HideTips.cs

@@ -152,7 +152,7 @@ public class HideTips : BaseUnityPlugin
 class HideMenuDemo
 {
     [HarmonyPriority(Priority.First), HarmonyPrefix]
-    [HarmonyPatch(typeof(DSPGame), "StartDemoGame", typeof(int))]
+    [HarmonyPatch(typeof(DSPGame), nameof(DSPGame.StartDemoGame), typeof(int))]
     private static bool DSPGame_StartDemoGame_Prefix()
     {
         if (DSPGame.Game != null)
@@ -188,7 +188,7 @@ class HideMenuDemo
     }
 
     [HarmonyPriority(Priority.First), HarmonyPrefix]
-    [HarmonyPatch(typeof(VFPreload), "IsMenuDemoLoaded")]
+    [HarmonyPatch(typeof(VFPreload), nameof(VFPreload.IsMenuDemoLoaded))]
     private static bool VFPreload_IsMenuDemoLoaded_Prefix(ref bool __result)
     {
         __result = true;
@@ -196,18 +196,18 @@ class HideMenuDemo
     }
 
     [HarmonyPriority(Priority.First), HarmonyPrefix]
-    [HarmonyPatch(typeof(DSPGame), "LateUpdate")]
+    [HarmonyPatch(typeof(DSPGame), nameof(DSPGame.LateUpdate))]
-    [HarmonyPatch(typeof(GameMain), "LateUpdate")]
+    [HarmonyPatch(typeof(GameMain), nameof(GameMain.LateUpdate))]
-    [HarmonyPatch(typeof(GameMain), "FixedUpdate")]
+    [HarmonyPatch(typeof(GameMain), nameof(GameMain.FixedUpdate))]
-    [HarmonyPatch(typeof(GameMain), "Update")]
+    [HarmonyPatch(typeof(GameMain), nameof(GameMain.Update))]
-    [HarmonyPatch(typeof(GameCamera), "LateUpdate")]
+    [HarmonyPatch(typeof(GameCamera), nameof(GameCamera.LateUpdate))]
     private static bool DSPGame_LateUpdate_Prefix()
     {
         return !DSPGame.IsMenuDemo;
     }
 
     [HarmonyPriority(Priority.First), HarmonyPrefix]
-    [HarmonyPatch(typeof(GameMain), "Begin")]
+    [HarmonyPatch(typeof(GameMain), nameof(GameMain.Begin))]
     private static bool GameMain_Begin_Prefix()
     {
         if (!DSPGame.IsMenuDemo) return true;

HideTips/HideTips.csproj

@@ -15,14 +15,14 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
-  
+
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>
-  
+
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
     <Exec Command="del /F /Q package\$(ProjectName)-$(Version).zip&#xA;powershell Compress-Archive -Force -DestinationPath 'package/$(ProjectName)-$(Version).zip' -Path '$(TargetPath)', package/icon.png, package/manifest.json, README.md" />
   </Target>

HideTips/README.md

@@ -1,42 +1,23 @@
 # HideTips
 
-#### Hide/Disable various tutorial tips/messages
+<details>
-#### 隐藏/屏蔽各种引导提示/消息
+<summary>Read me in English</summary>
 
-## Changelog
+***Hide/Disable various tutorial tips/messages***
-* 1.0.4
-  + Remove `Disable title screen demo scene loading`, as it is buggy in recent updates.
-  + Fix a bug that when tutorials are not added to the guides panel when they are hidden by this MOD.
-* 1.0.3
-  + Add config entries to disable research completion tips/popup windows
-  + Add a note to README for mod compatibility on `Disable title screen demo scene loading`.
-* 1.0.2
-  + Add a config entry to disable title screen demo scene loading
-* 1.0.1
-  + Hide 3 more random tutorial tips popup from bottom-right panel
-* 1.0.0
-  + Initial release
 
-## Usage
 * Tips/messages that can be hidden: random-reminder, tutorial, achievement/milestone card, research completion tips/popup windows.
 * Skip prologue for new game.
 * Each type of tips/messages is configurable individually.
 
-## 更新日志
+***隐藏/屏蔽各种引导提示/消息***
-* 1.0.4
+
-  + 移除`关闭标题画面的演示场景加载`设置，因为在最近的更新中有较多bug。
+</details>
-  + 修复了一个bug，当教程指引被这个MOD隐藏时，它们不会被添加到教程面板。
+
-* 1.0.3
+<details>
-  + 增加设置项以关闭研究完成的提示/弹窗
+<summary>中文读我</summary>
-  + 在README中增加了一个关于`关闭标题画面的演示场景加载`设置的兼容性说明
-* 1.0.2
-  + 增加设置项以关闭标题画面的演示场景加载
-* 1.0.1
-  + 可屏蔽右下面板的3种随机提醒
-* 1.0.0
-  + 初始版本
 
-## 使用说明
 * 可以屏蔽的消息：随机提醒，教程，成就/里程碑卡片，研究完成的提示/弹窗。
 * 跳过新游戏引导动画。
 * 各种屏蔽功能都可以在配置文件里开关。
+
+</details>

LabOpt/Functions.cs

@@ -410,30 +410,30 @@ public static class LabOptPatchFunctions
     public static void SetFunctionInternal(ref LabComponent lab, bool researchMode, int recpId, int techId, SignData[] signPool, LabComponent[] labPool)
     {
         // LabOptPatch.Logger.LogDebug($"SetFunctionInternal: id={lab.id} root={(int)RootLabIdField.GetValue(lab)} research={researchMode} recp={recpId} tech={techId}");
-		lab.replicating = false;
+        lab.replicating = false;
-		lab.time = 0;
+        lab.time = 0;
-		lab.hashBytes = 0;
+        lab.hashBytes = 0;
-		lab.extraHashBytes = 0;
+        lab.extraHashBytes = 0;
-		lab.extraTime = 0;
+        lab.extraTime = 0;
-		lab.extraSpeed = 0;
+        lab.extraSpeed = 0;
-		lab.extraPowerRatio = 0;
+        lab.extraPowerRatio = 0;
-		lab.productive = false;
+        lab.productive = false;
-		if (researchMode)
+        if (researchMode)
-		{
+        {
-			lab.forceAccMode = false;
+            lab.forceAccMode = false;
-			lab.researchMode = true;
+            lab.researchMode = true;
-			lab.recipeId = 0;
+            lab.recipeId = 0;
-			lab.techId = 0;
+            lab.techId = 0;
-			lab.timeSpend = 0;
+            lab.timeSpend = 0;
-			lab.extraTimeSpend = 0;
+            lab.extraTimeSpend = 0;
-			lab.requires = null;
+            lab.requires = null;
-			lab.requireCounts = null;
+            lab.requireCounts = null;
-			lab.served = null;
+            lab.served = null;
-			lab.incServed = null;
+            lab.incServed = null;
-			lab.products = null;
+            lab.products = null;
-			lab.productCounts = null;
+            lab.productCounts = null;
-			lab.produced = null;
+            lab.produced = null;
-			lab.productive = true;
+            lab.productive = true;
             var rootLabId = lab.pcId;
             if (rootLabId > 0)
             {
@@ -480,29 +480,29 @@ public static class LabOptPatchFunctions
                 }
             }
             signPool[lab.entityId].iconId0 = (uint)lab.techId;
-			signPool[lab.entityId].iconType = lab.techId == 0 ? 0U : 3U;
+            signPool[lab.entityId].iconType = lab.techId == 0 ? 0U : 3U;
-			return;
+            return;
-		}
+        }
-		lab.researchMode = false;
+        lab.researchMode = false;
-		lab.recipeId = 0;
+        lab.recipeId = 0;
-		lab.techId = 0;
+        lab.techId = 0;
-		lab.matrixPoints = null;
+        lab.matrixPoints = null;
-		lab.matrixServed = null;
+        lab.matrixServed = null;
-		lab.matrixIncServed = null;
+        lab.matrixIncServed = null;
-		RecipeProto recipeProto = null;
+        RecipeProto recipeProto = null;
-		if (recpId > 0)
+        if (recpId > 0)
-		{
+        {
-			recipeProto = LDB.recipes.Select(recpId);
+            recipeProto = LDB.recipes.Select(recpId);
-		}
+        }
-		if (recipeProto != null && recipeProto.Type == ERecipeType.Research)
+        if (recipeProto != null && recipeProto.Type == ERecipeType.Research)
-		{
+        {
-			lab.recipeId = recipeProto.ID;
+            lab.recipeId = recipeProto.ID;
-			lab.speed = 10000;
+            lab.speed = 10000;
-			lab.speedOverride = lab.speed;
+            lab.speedOverride = lab.speed;
-			lab.timeSpend = recipeProto.TimeSpend * 10000;
+            lab.timeSpend = recipeProto.TimeSpend * 10000;
-			lab.extraTimeSpend = recipeProto.TimeSpend * 100000;
+            lab.extraTimeSpend = recipeProto.TimeSpend * 100000;
-			lab.productive = recipeProto.productive;
+            lab.productive = recipeProto.productive;
-			lab.forceAccMode &= lab.productive;
+            lab.forceAccMode &= lab.productive;
             var rootLabId = lab.pcId;
             if (rootLabId > 0)
             {
@@ -544,26 +544,26 @@ public static class LabOptPatchFunctions
                     Array.Clear(lab.produced, 0, lab.produced.Length);
             }
         }
-		else
+        else
-		{
+        {
-			lab.forceAccMode = false;
+            lab.forceAccMode = false;
-			lab.recipeId = 0;
+            lab.recipeId = 0;
-			lab.speed = 0;
+            lab.speed = 0;
-			lab.speedOverride = 0;
+            lab.speedOverride = 0;
-			lab.timeSpend = 0;
+            lab.timeSpend = 0;
-			lab.extraTimeSpend = 0;
+            lab.extraTimeSpend = 0;
-			lab.requires = null;
+            lab.requires = null;
-			lab.requireCounts = null;
+            lab.requireCounts = null;
-			lab.served = null;
+            lab.served = null;
-			lab.incServed = null;
+            lab.incServed = null;
-			lab.needs = null;
+            lab.needs = null;
-			lab.products = null;
+            lab.products = null;
-			lab.productCounts = null;
+            lab.productCounts = null;
-			lab.produced = null;
+            lab.produced = null;
-		}
+        }
-		signPool[lab.entityId].iconId0 = (uint)lab.recipeId;
+        signPool[lab.entityId].iconId0 = (uint)lab.recipeId;
-		signPool[lab.entityId].iconType = lab.recipeId == 0 ? 0U : 2U;
+        signPool[lab.entityId].iconType = lab.recipeId == 0 ? 0U : 2U;
-	}
+    }
 
     public static int InsertIntoLab(PlanetFactory factory, int labId, int itemId, byte itemCount, byte itemInc, ref byte remainInc, int[] needs)
     {

LabOpt/LabOpt.cs

@@ -18,7 +18,7 @@ public class LabOptPatch : BaseUnityPlugin
     {
         Harmony.CreateAndPatchAll(typeof(LabOptPatch));
     }
-    
+
     // Patch LabComponent.Export() to save zero value if rootLabId > 0.
     [HarmonyTranspiler]
     [HarmonyPatch(typeof(LabComponent), nameof(LabComponent.Export))]
@@ -274,7 +274,7 @@ public class LabOptPatch : BaseUnityPlugin
         );
         return matcher.InstructionEnumeration();
     }
-    
+
     // Change locks on PlanetFactory.InsertInto(), by calling LabOptPatchFunctions.InsertIntoLab()
     [HarmonyTranspiler]
     [HarmonyPatch(typeof(PlanetFactory), nameof(PlanetFactory.InsertInto))]
@@ -332,7 +332,7 @@ public class LabOptPatch : BaseUnityPlugin
     {
         LabOptPatchFunctions.SetRootId(ref __instance, 0);
     }
-    
+
     [HarmonyTranspiler]
     [HarmonyPatch(typeof(LabOptPatchFunctions), nameof(LabOptPatchFunctions.SetRootId))]
     [HarmonyPatch(typeof(LabOptPatchFunctions), nameof(LabOptPatchFunctions.SetRootLabIdForStacking))]

LabOpt/LabOpt.csproj

@@ -15,10 +15,10 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
-  
+
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>

LabOptPreloader/LabOptPreloader.cs

@@ -7,7 +7,7 @@ namespace LabOptPreloader;
 
 public static class Preloader
 {
-    private static readonly ManualLogSource Logger = BepInEx.Logging.Logger.CreateLogSource("LabOpt Preloader");      
+    private static readonly ManualLogSource Logger = BepInEx.Logging.Logger.CreateLogSource("LabOpt Preloader");
     public static IEnumerable<string> TargetDLLs { get; } = new[] { "Assembly-CSharp.dll" };
 
     public static void Patch(AssemblyDefinition assembly)

LabOptPreloader/LabOptPreloader.csproj

@@ -14,14 +14,14 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
-  
+
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>
-  
+
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
     <Exec Command="IF NOT EXIST ..\LabOpt\package\patchers (mkdir ..\LabOpt\package\patchers)&#xA;copy /y $(TargetPath) ..\LabOpt\package\patchers\" />
   </Target>

LogisticHub/LogisticHub.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Reflection;
+using BepInEx;
+using BepInEx.Configuration;
+using HarmonyLib;
+using UXAssist.Common;
+
+namespace LogisticHub;
+
+[BepInPlugin(PluginInfo.PLUGIN_GUID, PluginInfo.PLUGIN_NAME, PluginInfo.PLUGIN_VERSION)]
+public class LogisticHub : BaseUnityPlugin
+{
+    public new static readonly BepInEx.Logging.ManualLogSource Logger =
+        BepInEx.Logging.Logger.CreateLogSource(PluginInfo.PLUGIN_NAME);
+
+    private Type[] _modules;
+
+    private void Awake()
+    {
+        Module.Miner.Enabled = Config.Bind("Miner", "Enabled", true, "enable/disable this plugin");
+        Module.Miner.OreEnergyConsume = Config.Bind("Miner", "EnergyConsumptionForOre", 2000000L,
+            "Energy consumption for each ore vein group(in 0.5W)");
+        Module.Miner.OilEnergyConsume = Config.Bind("Miner", "EnergyConsumptionForOil", 3600000L,
+            "Energy consumption for each oil seep(in 0.5W)");
+        Module.Miner.WaterEnergyConsume = Config.Bind("Miner", "EnergyConsumptionForWater", 2000000L,
+            "Energy consumption for water slot(in kW)");
+        Module.Miner.WaterSpeed = Config.Bind("Miner", "WaterMiningSpeed", 10,
+            "Water mining speed (count per second)");
+        Module.Miner.MiningScale = Config.Bind("Miner", "MiningScale", 0,
+            """
+            0 for Auto(which means having researched makes mining scale 300, otherwise 100).
+            Mining scale(in percents) for slots below half of slot limits, and the scale reduces to 100% smoothly till reach full.
+            Please note that the power consumption increases by the square of the scale which is the same as Advanced Mining Machine.
+            """);
+        Module.Miner.FuelIlsSlot = Config.Bind("Miner", "ILSFuelSlot", 4,
+            new ConfigDescription("Fuel slot for ILS, set 0 to disable.", new AcceptableValueRange<int>(0, 5)));
+        Module.Miner.FuelPlsSlot = Config.Bind("Miner", "PLSFuelSlot", 4,
+                new ConfigDescription("Fuel slot for PLS, set 0 to disable.", new AcceptableValueRange<int>(0, 4)));
+
+        _modules = Util.GetTypesFiltered(Assembly.GetExecutingAssembly(),
+            t => string.Equals(t.Namespace, "LogisticHub.Module", StringComparison.Ordinal));
+        _modules?.Do(type => type.GetMethod("Init")?.Invoke(null, null));
+        Harmony.CreateAndPatchAll(typeof(LogisticHub));
+    }
+
+    private void Start()
+    {
+        _modules?.Do(type => type.GetMethod("Start")?.Invoke(null, null));
+    }
+
+    private void OnDestroy()
+    {
+        _modules?.Do(type => type.GetMethod("Uninit")?.Invoke(null, null));
+    }
+}

LogisticHub/LogisticHub.csproj

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net472</TargetFramework>
+    <BepInExPluginGuid>org.soardev.logistichub</BepInExPluginGuid>
+    <Description>DSP MOD - LogisticHub</Description>
+    <Version>0.1.0</Version>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <LangVersion>latest</LangVersion>
+    <RestoreAdditionalProjectSources>https://nuget.bepinex.dev/v3/index.json</RestoreAdditionalProjectSources>
+    <PackageId>LogisticHub</PackageId>
+    <RootNamespace>LogisticHub</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BepInEx.Core" Version="5.*" />
+    <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
+    <PackageReference Include="UnityEngine.Modules" Version="2022.3.53" IncludeAssets="compile" />
+    <!-- <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" /> -->
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="Assembly-CSharp">
+      <HintPath>..\AssemblyFromGame\Assembly-CSharp.dll</HintPath>
+    </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>..\AssemblyFromGame\UnityEngine.UI.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\UXAssist\UXAssist.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
+  </ItemGroup>
+</Project>

LogisticHub/Module/AuxData.cs

@@ -0,0 +1,33 @@
+using System.Linq;
+
+namespace LogisticHub.Module;
+
+using UXAssist.Common;
+
+public static class AuxData
+{
+    public static (long, bool)[] Fuels;
+    
+    public static void Init()
+    {
+        GameLogic.OnDataLoaded += () =>
+        {
+            var maxId = LDB.items.dataArray.Select(data => data.ID).Prepend(0).Max();
+            Fuels = new (long, bool)[maxId + 1];
+            foreach (var data in LDB.items.dataArray)
+                Fuels[data.ID] = (data.HeatValue, data.Productive);
+        };
+    }
+
+    public static int AlignUpToPowerOf2(int n)
+    {
+        if (n < 16) return 16;
+        n--;
+        n |= n >> 1;
+        n |= n >> 2;
+        n |= n >> 4;
+        n |= n >> 8;
+        n |= n >> 16;
+        return n + 1;
+    }
+}

LogisticHub/Module/Miner.cs

@@ -0,0 +1,339 @@
+using System;
+using BepInEx.Configuration;
+using HarmonyLib;
+using UnityEngine;
+using UXAssist.Common;
+using Random = UnityEngine.Random;
+using GameLogicProc = UXAssist.Common.GameLogic;
+
+namespace LogisticHub.Module;
+
+public class Miner : PatchImpl<Miner>
+{
+    public static ConfigEntry<bool> Enabled;
+    public static ConfigEntry<long> OreEnergyConsume;
+    public static ConfigEntry<long> OilEnergyConsume;
+    public static ConfigEntry<long> WaterEnergyConsume;
+    public static ConfigEntry<int> WaterSpeed;
+    public static ConfigEntry<int> MiningScale;
+    public static ConfigEntry<int> FuelIlsSlot;
+    public static ConfigEntry<int> FuelPlsSlot;
+
+    private static float _frame;
+    private static float _miningCostRateByTech;
+    private static float _miningSpeedScaleByTech;
+    private static float _miningFrames;
+    private static long _miningSpeedScaleLong;
+    private static bool _advancedMiningMachineUnlocked;
+    private static uint _miningCostBarrier;
+    private static uint _miningCostBarrierOil;
+    private static int[] _mineIndex;
+
+    private static uint _miningSeed = (uint)Random.Range(0, int.MaxValue);
+
+    private static readonly (int, int)[] VeinList =
+    [
+        (0, 1000),
+        (1, 1001),
+        (2, 1002),
+        (3, 1003),
+        (4, 1004),
+        (5, 1005),
+        (6, 1006),
+        (7, 1007),
+        (11, 1011),
+        (12, 1012),
+        (13, 1013),
+        (14, 1014),
+        (15, 1015),
+        (16, 1016)
+    ];
+
+    public static void Init()
+    {
+        Enabled.SettingChanged += (_, _) => { Enable(Enabled.Value); };
+
+        Enable(Enabled.Value);
+    }
+
+    public static void Uninit()
+    {
+        Enable(false);
+    }
+
+    protected override void OnEnable()
+    {
+        GameLogicProc.OnGameBegin += OnGameBegin;
+    }
+
+    protected override void OnDisable()
+    {
+        GameLogicProc.OnGameBegin -= OnGameBegin;
+    }
+
+    private static void OnGameBegin()
+    {
+        VeinManager.Clear();
+        _frame = 0f;
+        UpdateMiningCostRate();
+        UpdateSpeedScale();
+        CheckRecipes();
+    }
+
+    private static int SplitIncLevel(ref int n, ref int m, int p)
+    {
+        var level = m / n;
+        var left = m - level * n;
+        n -= p;
+        left -= n;
+        m -= left > 0 ? level * p + left : level * p;
+        return level;
+    }
+
+    private static void CheckRecipes()
+    {
+        _advancedMiningMachineUnlocked = GameMain.history.recipeUnlocked.Contains(119);
+    }
+
+    private static void UpdateMiningCostRate()
+    {
+        _miningCostRateByTech = GameMain.history.miningCostRate;
+        _miningCostBarrier = (uint)(int)Math.Ceiling(2147483646.0 * _miningCostRateByTech);
+        _miningCostBarrierOil = (uint)(int)Math.Ceiling(2147483646.0 * _miningCostRateByTech * 0.401116669f / Math.Max(DSPGame.GameDesc.resourceMultiplier, 0.416666657f));
+    }
+
+    private static void UpdateSpeedScale()
+    {
+        _miningSpeedScaleByTech = GameMain.history.miningSpeedScale;
+        _miningSpeedScaleLong = (long)(_miningSpeedScaleByTech * 100);
+        _miningFrames = _miningSpeedScaleByTech * 600000f;
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(GameHistoryData), nameof(GameHistoryData.UnlockTechFunction))]
+    private static void OnUnlockTech(int func)
+    {
+        switch (func)
+        {
+            case 20:
+                UpdateMiningCostRate();
+                break;
+            case 21:
+                UpdateSpeedScale();
+                break;
+        }
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(GameLogic), nameof(GameLogic.OnFactoryFrameBegin))]
+    private static void GameLogic_OnFactoryFrameBegin_Prefix()
+    {
+        var main = GameMain.instance;
+        if (main.isMenuDemo) return;
+        if (_miningSpeedScaleLong <= 0) return;
+
+        DeepProfiler.BeginSample(DPEntry.Miner);
+        if (main.timei % 60 != 0) return;
+        _frame += _miningFrames;
+        var frameCounter = Mathf.FloorToInt(_frame / 1200000f);
+        if (frameCounter <= 0) return;
+        _frame -= frameCounter * 1200000f;
+        // LogisticHub.Logger.LogDebug($"FrameCounter: {frameCounter}");
+
+        var data = GameMain.data;
+        for (var factoryIndex = data.factoryCount - 1; factoryIndex >= 0; factoryIndex--)
+        {
+            var factory = data.factories[factoryIndex];
+            var veins = VeinManager.GetVeins(factoryIndex);
+            if (veins == null) return;
+            var stations = StationManager.GetStations(factoryIndex);
+            var planetTransport = factory.transport;
+            var factoryProductionStat = GameMain.statistics.production.factoryStatPool[factoryIndex];
+            var productRegister = factoryProductionStat?.productRegister;
+            var demands = stations.StorageIndices[1];
+            if (_mineIndex == null || factoryIndex >= _mineIndex.Length)
+                Array.Resize(ref _mineIndex, factoryIndex + 1);
+            foreach (var (itemIndex, itemId) in VeinList)
+            {
+                foreach (var storageIndex in demands[itemIndex])
+                {
+                    var station = planetTransport.stationPool[storageIndex / 100];
+                    if (station == null)
+                        continue;
+                    ref var storage = ref station.storage[storageIndex % 100];
+                    int amount;
+                    long energyConsume;
+                    var miningScale = MiningScale.Value;
+                    if (miningScale == 0)
+                    {
+                        miningScale = _advancedMiningMachineUnlocked ? 300 : 100;
+                    }
+
+                    if (miningScale > 100 && storage.count * 2 > storage.max)
+                    {
+                        miningScale = 100 + ((miningScale - 100) * (storage.max - storage.count) * 2 + storage.max - 1) / storage.max;
+                    }
+
+                    if (itemIndex > 0)
+                    {
+                        (amount, energyConsume) = Mine(factory, veins, itemId, miningScale, frameCounter, station.energy);
+                        if (amount < 0) continue;
+                    }
+                    else
+                    {
+                        energyConsume = (WaterEnergyConsume.Value * frameCounter * miningScale * miningScale + 9999L) / 10000L;
+                        if (station.energy < energyConsume) continue;
+                        amount = WaterSpeed.Value * miningScale / 100;
+                    }
+
+                    if (amount <= 0) continue;
+                    storage.count += amount;
+                    if (factoryProductionStat != null)
+                        productRegister[itemId] += amount;
+                    station.energy -= energyConsume;
+                }
+            }
+
+            for (var i = planetTransport.stationCursor - 1; i > 0; i--)
+            {
+                var stationComponent = planetTransport.stationPool[i];
+                if (stationComponent.isCollector || stationComponent.isVeinCollector || stationComponent.energy * 2 >= stationComponent.energyMax) continue;
+                var index = (stationComponent.isStellar ? FuelIlsSlot.Value : FuelPlsSlot.Value) - 1;
+                var storage = stationComponent.storage;
+                if (index < 0 || index >= storage.Length)
+                    continue;
+                var fuelCount = storage[index].count;
+                if (fuelCount == 0) continue;
+                var (heat, prod) = AuxData.Fuels[storage[index].itemId];
+                if (heat <= 0)
+                    continue;
+                /* Sprayed fuels */
+                int pretendIncLevel;
+                if (prod && (pretendIncLevel = storage[index].inc / storage[index].count) > 0)
+                {
+                    var count = (int)((stationComponent.energyMax - stationComponent.energy) * 1000L / Cargo.incTable[pretendIncLevel] / 7L);
+                    if (count > fuelCount)
+                        count = fuelCount;
+                    var incLevel = SplitIncLevel(ref storage[index].count, ref storage[index].inc, count);
+                    if (incLevel > 10)
+                        incLevel = 10;
+                    stationComponent.energy += heat * count * (1000L + Cargo.incTable[incLevel]) / 1000L;
+                }
+                else
+                {
+                    var count = (int)((stationComponent.energyMax - stationComponent.energy) / heat);
+                    if (count > fuelCount)
+                        count = fuelCount;
+                    SplitIncLevel(ref storage[index].count, ref storage[index].inc, count);
+                    stationComponent.energy += heat * count;
+                }
+            }
+        }
+
+        DeepProfiler.EndSample(DPEntry.Miner);
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(GameHistoryData), nameof(GameHistoryData.UnlockRecipe))]
+    private static void OnUnlockRecipe(int recipeId)
+    {
+        if (recipeId == 119)
+        {
+            CheckRecipes();
+        }
+    }
+
+    private static (int, long) Mine(PlanetFactory factory, ProductVeinData[] allVeins, int productId, int percent, int counter, long energyMax)
+    {
+        var veins = allVeins[productId - 1000];
+        if (veins == null)
+            return (-1, -1L);
+
+        var veinIndices = veins.VeinIndices;
+        uint barrier;
+        int limit;
+        int count;
+        long energy;
+        var length = veinIndices.Count - 1;
+        /* if is Oil */
+        if (productId == 1007)
+        {
+            energy = (OilEnergyConsume.Value * length * percent * percent + 9999L) / 10000L;
+            if (energy > energyMax)
+                return (-1, -1L);
+            var countf = 0f;
+            var veinsPool = factory.veinPool;
+            for (var i = length; i > 0; i--)
+            {
+                countf += veinsPool[veinIndices[i]].amount * 4 * VeinData.oilSpeedMultiplier;
+            }
+
+            count = ((int)countf * counter * percent + 99) / 100;
+            if (count == 0)
+                return (-1, -1L);
+            barrier = _miningCostBarrierOil;
+            limit = 2500;
+        }
+        else
+        {
+            count = (length * counter * percent + 99) / 100;
+            if (count == 0)
+                return (-1, -1L);
+            energy = (OreEnergyConsume.Value * veins.GroupCount * percent * percent + 9999L) / 10000L;
+            if (energy > energyMax)
+                return (-1, -1L);
+            barrier = _miningCostBarrier;
+            limit = 0;
+        }
+
+        var veinsData = factory.veinPool;
+        var total = 0;
+        var factoryIndex = factory.index;
+        var mineIndex = _mineIndex[factoryIndex];
+        for (; count > 0; count--)
+        {
+            mineIndex = mineIndex % length + 1;
+            var index = veinIndices[mineIndex];
+            ref var vd = ref veinsData[index];
+            int groupIndex;
+
+            if (vd.amount <= 0)
+            {
+                groupIndex = vd.groupIndex;
+                factory.veinGroups[groupIndex].count--;
+                factory.RemoveVeinWithComponents(index);
+                factory.RecalculateVeinGroup(groupIndex);
+                length = veinIndices.Count - 1;
+                if (length <= 0) break;
+                continue;
+            }
+
+            total++;
+
+            if (vd.amount <= limit) continue;
+            var consume = true;
+            if (barrier < 2147483646u)
+            {
+                _miningSeed = (uint)((int)((ulong)((_miningSeed % 2147483646u + 1) * 48271L) % 2147483647uL) - 1);
+                consume = _miningSeed < barrier;
+            }
+
+            if (!consume) continue;
+
+            vd.amount--;
+            groupIndex = vd.groupIndex;
+            factory.veinGroups[groupIndex].amount--;
+
+            if (vd.amount > 0) continue;
+            factory.veinGroups[groupIndex].count--;
+            factory.RemoveVeinWithComponents(index);
+            factory.RecalculateVeinGroup(groupIndex);
+            length = veinIndices.Count - 1;
+            if (length <= 0) break;
+        }
+
+        _mineIndex[factoryIndex] = mineIndex;
+
+        return (total, energy);
+    }
+}

LogisticHub/Module/StationManager.cs

@@ -0,0 +1,321 @@
+using System;
+using System.Collections.Generic;
+using HarmonyLib;
+using UXAssist.Common;
+using GameLogicProc = UXAssist.Common.GameLogic;
+
+namespace LogisticHub.Module;
+
+public class PlanetStations
+{
+    public readonly List<int>[][] StorageIndices = [null, null];
+
+    public void AddStationStorage(bool demand, int id, int stationId, int storageIdx)
+    {
+        var stations = StorageIndices[demand ? 1 : 0];
+        if (stations == null || id >= stations.Length)
+        {
+            Array.Resize(ref stations, AuxData.AlignUpToPowerOf2(id + 1));
+            StorageIndices[demand ? 1 : 0] = stations;
+        }
+
+        var list = stations[id];
+        if (list == null)
+        {
+            list = [];
+            stations[id] = list;
+        }
+
+        var value = stationId * 100 + storageIdx;
+        var index = list.BinarySearch(value);
+        if (index < 0)
+            list.Insert(~index, value);
+    }
+
+    public void RemoveStationStorage(bool demand, int id, int stationId, int storageIdx)
+    {
+        var stations = StorageIndices[demand ? 1 : 0];
+        if (stations == null || id >= stations.Length)
+            return;
+        var list = stations[id];
+        if (list == null)
+            return;
+
+        var value = stationId * 100 + storageIdx;
+        var index = list.BinarySearch(value);
+        if (index >= 0)
+            list.RemoveAt(index);
+    }
+}
+
+public class StationManager : PatchImpl<StationManager>
+{
+    private static PlanetStations[] _stations;
+
+    public static void Init()
+    {
+        GameLogicProc.OnGameBegin += () =>
+        {
+            _stations = null;
+            var data = GameMain.data;
+            for (var index = data.factoryCount - 1; index >= 0; index--)
+            {
+                var factory = data.factories[index];
+                if (factory == null || factory.index != index) continue;
+                var planetIndex = factory.index;
+                var stations = StationsByPlanet(planetIndex);
+                var transport = factory.transport;
+                var pool = transport.stationPool;
+                for (var i = transport.stationCursor - 1; i > 0; i--)
+                {
+                    var station = pool[i];
+                    if (station == null || station.id != i || station.isCollector || station.isVeinCollector) continue;
+                    UpdateStationInfo(stations, station);
+                }
+            }
+        };
+        Enable(true);
+    }
+
+    public static void Uninit()
+    {
+        Enable(false);
+    }
+
+    private static int ItemIdToIndex(int itemId)
+    {
+        return itemId switch
+        {
+            >= 1000 and < 2000 => itemId - 1000,
+            >= 5000 and < 5050 => itemId - 5000 + 900,
+            >= 6000 and < 6050 => itemId - 6000 + 950,
+            _ => -1
+        };
+    }
+
+    public static int IndexToItemId(int index)
+    {
+        return index switch
+        {
+            < 900 => index + 1000,
+            < 950 => index - 900 + 5000,
+            < 1000 => index - 950 + 6000,
+            _ => -1
+        };
+    }
+
+    public static PlanetStations GetStations(int planetIndex)
+    {
+        return _stations != null && planetIndex < _stations.Length ? _stations[planetIndex] : null;
+    }
+
+    private static PlanetStations StationsByPlanet(int planetIndex)
+    {
+        if (_stations == null || _stations.Length <= planetIndex)
+            Array.Resize(ref _stations, AuxData.AlignUpToPowerOf2(planetIndex + 1));
+        var stations = _stations[planetIndex];
+        if (stations != null) return stations;
+        stations = new PlanetStations();
+        _stations[planetIndex] = stations;
+        return stations;
+    }
+
+    private static void DebugLog()
+    {
+        for (var idx = 0; idx < _stations.Length; idx++)
+        {
+            var stations = _stations[idx];
+            if (stations == null) continue;
+            LogisticHub.Logger.LogDebug($"Planet {idx}:");
+            for (var i = 0; i < 2; i++)
+            {
+                var storage = stations.StorageIndices[i];
+                if (storage == null) continue;
+                LogisticHub.Logger.LogDebug(i == 1 ? "  Demand:" : "  Supply:");
+                for (var j = 0; j < storage.Length; j++)
+                {
+                    var list = storage[j];
+                    if (list == null) continue;
+                    var count = list.Count;
+                    if (count <= 0) continue;
+                    var itemId = IndexToItemId(j);
+                    LogisticHub.Logger.LogDebug($"    {itemId}: {string.Join(", ", list)}");
+                }
+            }
+        }
+    }
+
+    private static void UpdateStationInfo(PlanetStations stations, StationComponent station, int storageIdx = -1)
+    {
+        var storage = station.storage;
+        var stationId = station.id;
+        if (storageIdx >= 0)
+        {
+            if (storageIdx >= storage.Length) return;
+            var itemId = ItemIdToIndex(storage[storageIdx].itemId);
+            if (itemId <= 0) return;
+            var logic = storage[storageIdx].localLogic;
+            switch (logic)
+            {
+                case ELogisticStorage.Demand:
+                    stations.AddStationStorage(true, itemId, stationId, storageIdx);
+                    break;
+                case ELogisticStorage.Supply:
+                    stations.AddStationStorage(false, itemId, stationId, storageIdx);
+                    break;
+                case ELogisticStorage.None:
+                default:
+                    break;
+            }
+
+            return;
+        }
+
+        for (var i = storage.Length - 1; i >= 0; i--)
+        {
+            var itemId = ItemIdToIndex(storage[i].itemId);
+            if (itemId <= 0) continue;
+            var logic = storage[i].localLogic;
+            switch (logic)
+            {
+                case ELogisticStorage.Demand:
+                    stations.AddStationStorage(true, itemId, stationId, i);
+                    break;
+                case ELogisticStorage.Supply:
+                    stations.AddStationStorage(false, itemId, stationId, i);
+                    break;
+                case ELogisticStorage.None:
+                default:
+                    break;
+            }
+        }
+    }
+
+    private static void RemoveStationInfo(PlanetStations stations, StationComponent station, int storageIdx = -1)
+    {
+        var storage = station.storage;
+        var stationId = station.id;
+        if (storageIdx >= 0)
+        {
+            var itemId = ItemIdToIndex(storage[storageIdx].itemId);
+            if (itemId <= 0) return;
+            var logic = storage[storageIdx].localLogic;
+            switch (logic)
+            {
+                case ELogisticStorage.Demand:
+                    stations.RemoveStationStorage(true, itemId, stationId, storageIdx);
+                    break;
+                case ELogisticStorage.Supply:
+                    stations.RemoveStationStorage(false, itemId, stationId, storageIdx);
+                    break;
+                case ELogisticStorage.None:
+                default:
+                    break;
+            }
+
+            return;
+        }
+
+        for (var i = storage.Length - 1; i >= 0; i--)
+        {
+            var itemId = ItemIdToIndex(storage[i].itemId);
+            if (itemId <= 0) continue;
+            var logic = storage[i].localLogic;
+            switch (logic)
+            {
+                case ELogisticStorage.Demand:
+                    stations.RemoveStationStorage(true, itemId, stationId, i);
+                    break;
+                case ELogisticStorage.Supply:
+                    stations.RemoveStationStorage(false, itemId, stationId, i);
+                    break;
+                case ELogisticStorage.None:
+                default:
+                    break;
+            }
+        }
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(PlanetTransport), nameof(PlanetTransport.Init))]
+    private static void PlanetTransport_Init_Postfix(PlanetTransport __instance)
+    {
+        var factory = __instance.factory;
+        var planetIndex = factory.index;
+
+        if (_stations == null || _stations.Length <= planetIndex)
+            Array.Resize(ref _stations, AuxData.AlignUpToPowerOf2(planetIndex + 1));
+        var stations = new PlanetStations();
+        _stations[planetIndex] = stations;
+
+        var pool = __instance.stationPool;
+        for (var i = __instance.stationCursor - 1; i > 0; i--)
+        {
+            var station = pool[i];
+            if (station == null || station.id != i || station.isCollector || station.isVeinCollector) continue;
+            UpdateStationInfo(stations, station);
+        }
+        // DebugLog();
+    }
+    
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(BuildingParameters), nameof(BuildingParameters.ApplyPrebuildParametersToEntity))]
+    private static void BuildingParameters_ApplyPrebuildParametersToEntity_Postfix(int entityId, PlanetFactory factory)
+    {
+        if (entityId <= 0) return;
+        ref var entity = ref factory.entityPool[entityId];
+        var stationId = entity.stationId;
+        if (stationId <= 0) return;
+        var station = factory.transport.stationPool[stationId];
+        if (station == null || station.id != stationId || station.isCollector || station.isVeinCollector) return;
+        UpdateStationInfo(StationsByPlanet(factory.index), station);
+        // DebugLog();
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(PlanetTransport), nameof(PlanetTransport.RemoveStationComponent))]
+    private static void PlanetTransport_RemoveStationComponent_Prefix(PlanetTransport __instance, int id)
+    {
+        if (id <= 0) return;
+        var station = __instance.stationPool[id];
+        if (station == null || station.id != id || station.isCollector || station.isVeinCollector) return;
+        RemoveStationInfo(StationsByPlanet(__instance.factory.index), station);
+        // DebugLog();
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(PlanetTransport), nameof(PlanetTransport.SetStationStorage))]
+    private static void PlanetTransport_SetStationStorage_Prefix(PlanetTransport __instance, int stationId, int storageIdx, int itemId, ELogisticStorage localLogic, out bool __state)
+    {
+        var station = __instance.stationPool[stationId];
+        if (station == null || station.id != stationId || station.isCollector || station.isVeinCollector || storageIdx < 0 || storageIdx >= station.storage.Length)
+        {
+            __state = false;
+            return;
+        }
+
+        ref var storage = ref station.storage[storageIdx];
+        var oldItemId = storage.itemId;
+        var oldLocalLogic = storage.localLogic;
+        if (localLogic == oldLocalLogic && itemId == oldItemId)
+        {
+            __state = false;
+            return;
+        }
+
+        if (oldItemId > 0 && oldLocalLogic != ELogisticStorage.None)
+            RemoveStationInfo(StationsByPlanet(__instance.factory.index), station, storageIdx);
+        __state = localLogic != ELogisticStorage.None;
+        // if (!__state) DebugLog();
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(PlanetTransport), nameof(PlanetTransport.SetStationStorage))]
+    private static void PlanetTransport_SetStationStorage_Postfix(PlanetTransport __instance, int stationId, int storageIdx, bool __state)
+    {
+        if (!__state) return;
+        var station = __instance.stationPool[stationId];
+        UpdateStationInfo(StationsByPlanet(__instance.factory.index), station, storageIdx);
+        // DebugLog();
+    }
+}

LogisticHub/Module/VeinManager.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using HarmonyLib;
+using UXAssist.Common;
+
+namespace LogisticHub.Module;
+
+public class ProductVeinData
+{
+    public readonly List<int> VeinIndices = [];
+    public readonly HashSet<int> GroupIndices = [];
+    public int GroupCount = 0;
+}
+
+public class VeinManager : PatchImpl<VeinManager>
+{
+    private static ProductVeinData[][] _veins;
+
+    public static void Init()
+    {
+        Enable(true);
+    }
+
+    public static void Uninit()
+    {
+        Enable(false);
+    }
+
+    public static void Clear()
+    {
+        _veins = null;
+    }
+
+    public static ProductVeinData[] GetVeins(int planetIndex)
+    {
+        if (_veins == null || _veins.Length <= planetIndex)
+            return null;
+        return _veins[planetIndex];
+    }
+
+    private static ProductVeinData[] GetOrCreateVeins(int planetIndex)
+    {
+        if (_veins == null || _veins.Length <= planetIndex)
+            Array.Resize(ref _veins, AuxData.AlignUpToPowerOf2(planetIndex + 1));
+        var veins = _veins[planetIndex];
+        if (veins != null) return veins;
+        veins = new ProductVeinData[20];
+        _veins[planetIndex] = veins;
+        return veins;
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(PlanetFactory), nameof(PlanetFactory.Init))]
+    [HarmonyPatch(typeof(PlanetFactory), nameof(PlanetFactory.RecalculateVeinGroup))]
+    [HarmonyPatch(typeof(PlanetFactory), nameof(PlanetFactory.RecalculateAllVeinGroups))]
+    private static void PlanetFactory_RecalculateAllVeinGroups_Postfix(PlanetFactory __instance)
+    {
+        RecalcVeins(__instance);
+    }
+
+    private static void DebugLog()
+    {
+        foreach (var veins in _veins)
+        {
+            if (veins == null) continue;
+            for (var i = 0; i < veins.Length; i++)
+            {
+                var pvd = veins[i];
+                if (pvd == null) continue;
+                LogisticHub.Logger.LogInfo($"Product {i} VeinTypeCount={pvd.VeinIndices.Count} GroupCount={pvd.GroupCount}");
+            }
+        }
+    }
+
+    private static void RecalcVeins(PlanetFactory factory)
+    {
+        var planetIndex = factory.index;
+        var veins = GetOrCreateVeins(planetIndex);
+        var veinPool = factory.veinPool;
+
+        foreach (var pvd in veins)
+        {
+            if (pvd == null) continue;
+            pvd.VeinIndices.Clear();
+            pvd.GroupIndices.Clear();
+            pvd.GroupCount = 0;
+        }
+
+        for (var i = factory.veinCursor - 1; i > 0; i--)
+        {
+            if (veinPool[i].id != i || veinPool[i].amount <= 0 || veinPool[i].type == EVeinType.None) continue;
+            var productId = veinPool[i].productId - 1000;
+            if (productId is < 0 or >= 20) continue;
+            var pvd = veins[productId];
+            if (pvd == null)
+            {
+                pvd = new ProductVeinData();
+                veins[productId] = pvd;
+            }
+
+            pvd.VeinIndices.Add(i);
+            pvd.GroupIndices.Add(veinPool[i].groupIndex);
+        }
+
+        foreach (var pvd in veins)
+        {
+            if (pvd == null) continue;
+            pvd.GroupCount = pvd.GroupIndices.Count;
+        }
+
+        // DebugLog();
+    }
+}

LogisticHub/README.md

@@ -0,0 +1,47 @@
+# LogisticHub
+
+#### Cheat functions for Logistic Storages, make them mine resources on the planet and exchange items from certain buildings
+#### 物流塔作弊功能，使其可以在星球上采矿并与特定建筑物交换物品
+
+## Usage
+
+* Miner(and fuel burning) functions
+  +Inspired by [PlanetMiner](https://dsp.thunderstore.io/package/blacksnipebiu/PlanetMiner)([github](https://github.com/blacksnipebiu/PlanetMiner))  
+    But it is heavily optimized to resolve performance, accuracy and other issues in PlanetMiner.
+  + (Optimization to PlanetMiner) Only recalculate count of veins when vein chunks are changed (added/removed by foundations/Sandbox-Mode, or exhausted), so this removes Dictionary allocation on each planet for every frame.
+  + (Optimization to PlanetMiner) More accurate frame counting by use float number.
+  + (Optimization to PlanetMiner) Does not increase power consumptions on `Veins Utilization` upgrades.
+  + (Optimization to PlanetMiner) Separate power consumptions for veins, oil seeps and water.
+  + (Optimization to PlanetMiner) Power consumptions are counted by groups of veins and count of oil seeps, which is more sensible.
+  + Can burn fuels in certain slot when energy below half of max.
+    - (Optimization to PlanetMiner) Sprayed fuels generates extra energy as normal.
+  + (Optimization to PlanetMiner) All used parameters are configurable:
+    - LogisticHub has the same speed as normal Mining Machine for normal ores by default.  
+      But you can set mining scale in configuration, which makes LogisticHub working like Advance Mining Machines:  
+      power consumption increases by the square of the scale, and gradually decrease mining speed over half of the maximum count.  
+      This applies to all of veins, oils and water.  
+      Mining scale can be set to 0(by default), which means it is automatically set by tech unlocks, set to 300 when you reaches Advanced Mining Machine, otherwise 100.
+    - 100/s for water by default.
+    - Energy costs: 1MW/vein-group & 10MW/water-slot & 1.8MW/oil-seep(configurable)
+    - Fuels burning slot. Default: 4th for ILS and PLS. Set to 0 to disable it.
+
+## 使用说明
+
+* 采矿(和燃料燃烧)功能
+  + 创意来自 [PlanetMiner](https://dsp.thunderstore.io/package/blacksnipebiu/PlanetMiner)([github](https://github.com/blacksnipebiu/PlanetMiner))  
+    对性能重度优化，并解决了PlanetMiner的精度等问题。
+  + (对PlanetMiner的优化) 仅当矿堆发生变化(填埋/恢复/采完)时重新计算矿堆数据，解决每行星每计算帧要重建字典的性能问题。
+  + (对PlanetMiner的优化) 用浮点数保证更精确的帧计算。
+  + (对PlanetMiner的优化) 升级`矿物利用`不会提升能耗。
+  + (对PlanetMiner的优化) 分开矿物，油井和水的采集能耗。
+  + (对PlanetMiner的优化) 采集能耗以矿物组，油井为单位，相对更加合理。
+  + 剩余电量少于一半时可以燃烧指定格子的燃料补充。
+    - (对PlanetMiner的优化) 喷涂了增产剂的燃料按照正常的计算方式提供更多的能量(除了原本就不增加能量输出的反物质燃料棒)。
+  + (对PlanetMiner的优化) 所有参数都可以在设置文件内配置:
+    - 物流塔枢纽和普通矿机采矿速度一样(等同于同时采集所有对应矿物)。  
+      你可以设置采矿倍率改变物流塔枢纽采矿速度，和高级采矿机相同地，能耗和倍率的平方成正比，并且在存储矿物量多于一半时逐渐降低采矿倍率。  
+      此倍率对各种矿物，油井和水的采集都生效。  
+      倍率可以设置为0(默认)，此时倍率会随科技解锁而变化，默认是100%，解锁高级采矿机后变为300%。
+    - 水的采集速度默认为100/s。
+    - 能耗：每矿物组 1MW，单格水 10MW，每油井 1.8MW。
+    - 燃料格位置。默认：星际物流塔和行星内物流塔第4格。设为0则关闭燃料补充能量功能。

LogisticHub/package/manifest.json

@@ -0,0 +1,10 @@
+{
+  "name": "LogisticHub",
+  "version_number": "0.1.0",
+  "website_url": "https://github.com/soarqin/DSP_Mods/tree/master/LogisticHub",
+  "description": "Cheat functions to Logistic Storages which make them miner and items hub / 物流塔作弊功能，使其成为矿机和物品枢纽",
+  "dependencies": [
+    "xiaoye97-BepInEx-5.4.17",
+    "soarqin-UXAssist-1.2.0"
+  ]
+}

LogisticMiner/LogisticMiner.cs

@@ -1,485 +0,0 @@
-using System;
-using System.Collections.Generic;
-using BepInEx;
-using BepInEx.Configuration;
-using HarmonyLib;
-using Random = UnityEngine.Random;
-
-namespace LogisticMiner;
-
-[BepInPlugin(PluginInfo.PLUGIN_GUID, PluginInfo.PLUGIN_NAME, PluginInfo.PLUGIN_VERSION)]
-public class LogisticMiner : BaseUnityPlugin
-{
-    private new static readonly BepInEx.Logging.ManualLogSource Logger =
-        BepInEx.Logging.Logger.CreateLogSource(PluginInfo.PLUGIN_NAME);
-
-    private static long _oreEnergyConsume = 2000000;
-    private static long _oilEnergyConsume = 3600000;
-    private static long _waterEnergyConsume = 20000000;
-    private static int _waterSpeed = 100;
-    private static int _miningScale;
-    private static int _fuelIlsSlot = 3;
-    private static int _fuelPlsSlot = 2;
-
-    private static float _frame;
-    private static float _miningCostRateByTech;
-    private static float _miningSpeedScaleByTech;
-    private static float _miningFrames;
-    private static long _miningSpeedScaleLong;
-    private static bool _advancedMiningMachineUnlocked;
-    private static uint _miningCostBarrier;
-    private static uint _miningCostBarrierOil;
-
-    private static uint _seed = (uint)Random.Range(int.MinValue, int.MaxValue);
-    private static readonly Dictionary<int, VeinCacheData> PlanetVeinCacheData = new();
-    private static readonly Dictionary<int, (long, bool)> Fuels = new();
-
-    private bool _cfgEnabled = true;
-
-    private void Awake()
-    {
-        _cfgEnabled = Config.Bind("General", "Enabled", _cfgEnabled, "enable/disable this plugin").Value;
-        _oreEnergyConsume = Config.Bind("General", "EnergyConsumptionForOre", _oreEnergyConsume / 2000,
-            "Energy consumption for each ore vein group(in kW)").Value * 2000;
-        _oilEnergyConsume = Config.Bind("General", "EnergyConsumptionForOil", _oilEnergyConsume / 2000,
-            "Energy consumption for each oil seep(in kW)").Value * 2000;
-        _waterEnergyConsume = Config.Bind("General", "EnergyConsumptionForWater", _waterEnergyConsume / 2000,
-            "Energy consumption for water slot(in kW)").Value * 2000;
-        _waterSpeed = Config.Bind("General", "WaterMiningSpeed", _waterSpeed,
-            "Water mining speed (count per second)").Value;
-        _miningScale = Config.Bind("General", "MiningScale", _miningScale,
-                "0 for Auto(which means having researched makes mining scale 300, otherwise 100). Mining scale(in percents) for slots below half of slot limits, and the scale reduces to 100% smoothly till reach full. Please note that the power consumption increases by the square of the scale which is the same as Advanced Mining Machine")
-            .Value;
-        _fuelIlsSlot = Config.Bind("General", "ILSFuelSlot", _fuelIlsSlot + 1,
-                new ConfigDescription("Fuel slot for ILS, set to 0 to disable",
-                    new AcceptableValueRange<int>(0, 5), Array.Empty<object>()))
-            .Value - 1;
-        _fuelPlsSlot = Config.Bind("General", "PLSFuelSlot", _fuelPlsSlot + 1,
-                new ConfigDescription("Fuel slot for PLS, set to 0 to disable",
-                    new AcceptableValueRange<int>(0, 4), Array.Empty<object>()))
-            .Value - 1;
-        if (!_cfgEnabled) return;
-
-        Harmony.CreateAndPatchAll(typeof(LogisticMiner));
-    }
-
-    private static int SplitIncLevel(ref int n, ref int m, int p)
-    {
-        var level = m / n;
-        var left = m - level * n;
-        n -= p;
-        left -= n;
-        m -= left > 0 ? level * p + left : level * p;
-        return level;
-    }
-
-    private static void CheckRecipes()
-    {
-        _advancedMiningMachineUnlocked = GameMain.history.recipeUnlocked.Contains(119);
-    }
-
-    private static void UpdateMiningCostRate()
-    {
-        _miningCostRateByTech = GameMain.history.miningCostRate;
-        _miningCostBarrier = (uint)(int)Math.Ceiling(2147483646.0 * _miningCostRateByTech);
-        _miningCostBarrierOil =
-            (uint)(int)Math.Ceiling(2147483646.0 * _miningCostRateByTech * 0.401116669f /
-                                    DSPGame.GameDesc.resourceMultiplier);
-    }
-
-    private static void UpdateSpeedScale()
-    {
-        _miningSpeedScaleByTech = GameMain.history.miningSpeedScale;
-        _miningSpeedScaleLong = (long)(_miningSpeedScaleByTech * 100);
-        lock (PlanetVeinCacheData)
-        {
-            _miningFrames = 120f / _miningSpeedScaleByTech;
-        }
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(DSPGame), "StartGame", typeof(GameDesc))]
-    [HarmonyPatch(typeof(DSPGame), "StartGame", typeof(string))]
-    private static void OnGameStart()
-    {
-        Logger.LogInfo("Game Start");
-        PlanetVeinCacheData.Clear();
-        Fuels.Clear();
-        foreach (var data in LDB.items.dataArray)
-        {
-            if (data.HeatValue > 0)
-            {
-                Fuels.Add(data.ID, (data.HeatValue, data.Productive));
-            }
-        }
-        /* Thinking: storage max may affect mining scale?
-        _localStationMax = LDB.items.Select(2103).prefabDesc.stationMaxItemCount;
-        _remoteStationMax = LDB.items.Select(2104).prefabDesc.stationMaxItemCount;
-        */
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(GameMain), "Start")]
-    private static void OnGameLoaded()
-    {
-        _frame = 0f;
-
-        UpdateMiningCostRate();
-        UpdateSpeedScale();
-        CheckRecipes();
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(GameHistoryData), "UnlockTechFunction")]
-    private static void OnUnlockTech(int func)
-    {
-        switch (func)
-        {
-            case 20:
-                UpdateMiningCostRate();
-                break;
-            case 21:
-                UpdateSpeedScale();
-                break;
-        }
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(GameData), "GameTick")]
-    private static void FrameTick()
-    {
-        var main = GameMain.instance;
-        if (main.isMenuDemo)
-        {
-            return;
-        }
-
-        _frame++;
-        if (_frame <= 1000000f) return;
-        /* keep precision of floats by limiting them <= 1000000f */
-        _frame -= 1000000f;
-        foreach (var pair in PlanetVeinCacheData)
-        {
-            pair.Value.FrameNext -= 1000000f;
-        }
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(GameHistoryData), "UnlockRecipe")]
-    private static void OnUnlockRecipe(int recipeId)
-    {
-        if (recipeId == 119)
-        {
-            CheckRecipes();
-        }
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(PlanetFactory), "Init")]
-    [HarmonyPatch(typeof(PlanetFactory), "RecalculateVeinGroup")]
-    [HarmonyPatch(typeof(PlanetFactory), "RecalculateAllVeinGroups")]
-    private static void NeedRecalcVeins(PlanetFactory __instance)
-    {
-        RecalcVeins(__instance);
-    }
-
-    private static void RecalcVeins(PlanetFactory factory)
-    {
-        var planetId = factory.planetId;
-        lock (PlanetVeinCacheData)
-        {
-            /* remove planet veins from dict */
-            if (PlanetVeinCacheData.TryGetValue(planetId, out var vcd))
-            {
-                vcd.GenVeins(factory);
-            }
-            else
-            {
-                vcd = new VeinCacheData();
-                vcd.GenVeins(factory);
-                vcd.FrameNext = _frame + _miningFrames;
-                PlanetVeinCacheData.Add(planetId, vcd);
-            }
-        }
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(FactorySystem), "CheckBeforeGameTick")]
-    private static void FactorySystemLogisticMiner(FactorySystem __instance)
-    {
-        if (_miningSpeedScaleLong <= 0)
-            return;
-        var factory = __instance.factory;
-        var planetId = factory.planetId;
-        lock (PlanetVeinCacheData)
-        {
-            if (PlanetVeinCacheData.TryGetValue(planetId, out var vcd))
-            {
-                if (vcd.FrameNext > _frame)
-                    return;
-            }
-            else
-            {
-                PlanetVeinCacheData[planetId] = new VeinCacheData
-                {
-                    FrameNext = _frame + _miningFrames
-                };
-                return;
-            }
-
-            var planetTransport = __instance.planet.factory.transport;
-            var factoryProductionStat =
-                GameMain.statistics.production.factoryStatPool[__instance.factory.index];
-            var productRegister = factoryProductionStat?.productRegister;
-            PerformanceMonitor.BeginSample(ECpuWorkEntry.Miner);
-            do
-            {
-                for (var j = 1; j < planetTransport.stationCursor; j++)
-                {
-                    var stationComponent = planetTransport.stationPool[j];
-                    if (stationComponent == null) continue;
-                    /* skip Orbital Collectors and Advanced Mining Machines */
-                    if (stationComponent.isCollector || stationComponent.isVeinCollector) continue;
-                    var storage = stationComponent.storage;
-                    if (storage == null) continue;
-                    var isCollecting = false;
-                    for (var k = 0; k < stationComponent.storage.Length; k++)
-                    {
-                        ref var stationStore = ref storage[k];
-                        if (stationStore.localLogic != ELogisticStorage.Demand ||
-                            stationStore.max <= stationStore.count)
-                            continue;
-
-                        var isVein = vcd.HasVein(stationStore.itemId);
-                        var isVeinOrWater = isVein || stationStore.itemId == __instance.planet.waterItemId;
-                        if (!isVeinOrWater) continue;
-                        int amount;
-                        long energyConsume;
-                        isCollecting = true;
-                        var miningScale = _miningScale;
-                        if (miningScale == 0)
-                        {
-                            miningScale = _advancedMiningMachineUnlocked ? 300 : 100;
-                        }
-
-                        if (miningScale > 100 && stationStore.count * 2 > stationStore.max)
-                        {
-                            miningScale = 100 +
-                                          ((miningScale - 100) * (stationStore.max - stationStore.count) * 2 +
-                                              stationStore.max - 1) / stationStore.max;
-                        }
-
-                        if (isVein)
-                        {
-                            (amount, energyConsume) = vcd.Mine(factory, stationStore.itemId, miningScale,
-                                _miningSpeedScaleLong,
-                                stationComponent.energy);
-                            if (amount < 0)
-                            {
-                                k = int.MaxValue - 1;
-                                continue;
-                            }
-                        }
-                        else
-                        {
-                            energyConsume = (_waterEnergyConsume * miningScale * miningScale + 9999L) / 100L /
-                                            _miningSpeedScaleLong;
-                            if (stationComponent.energy < energyConsume)
-                            {
-                                k = int.MaxValue - 1;
-                                continue;
-                            }
-
-                            amount = _waterSpeed * miningScale / 100;
-                        }
-
-                        if (amount <= 0) continue;
-                        stationStore.count += amount;
-                        if (factoryProductionStat != null)
-                            productRegister[stationStore.itemId] += amount;
-                        stationComponent.energy -= energyConsume;
-                    }
-
-                    if (!isCollecting || stationComponent.energy * 2 >= stationComponent.energyMax) continue;
-                    var index = stationComponent.isStellar ? _fuelIlsSlot : _fuelPlsSlot;
-                    if (index < 0 || index >= storage.Length)
-                        continue;
-                    var fuelCount = storage[index].count;
-                    if (fuelCount == 0) continue;
-                    if (!Fuels.TryGetValue(storage[index].itemId, out var val) || val.Item1 <= 0)
-                        continue;
-                    /* Sprayed fuels */
-                    int pretendIncLevel;
-                    if (val.Item2 && (pretendIncLevel = storage[index].inc / storage[index].count) > 0)
-                    {
-                        var count = (int)((stationComponent.energyMax - stationComponent.energy) * 1000L /
-                                          Cargo.incTable[pretendIncLevel] / 7L);
-                        if (count > fuelCount)
-                            count = fuelCount;
-                        var incLevel = SplitIncLevel(ref storage[index].count, ref storage[index].inc, count);
-                        if (incLevel > 10)
-                            incLevel = 10;
-                        stationComponent.energy += val.Item1 * count * (1000L + Cargo.incTable[incLevel]) / 1000L;
-                    }
-                    else
-                    {
-                        var count = (int)((stationComponent.energyMax - stationComponent.energy) / val.Item1);
-                        if (count > fuelCount)
-                            count = fuelCount;
-                        SplitIncLevel(ref storage[index].count, ref storage[index].inc, count);
-                        stationComponent.energy += val.Item1 * count;
-                    }
-                }
-
-                vcd.FrameNext += _miningFrames;
-            } while (vcd.FrameNext <= _frame);
-
-            PerformanceMonitor.EndSample(ECpuWorkEntry.Miner);
-        }
-    }
-
-    private class VeinCacheData
-    {
-        public float FrameNext;
-
-        /* stores list of indices to veinData, with an extra INT which indicates cout of veinGroups at last */
-        private Dictionary<int, List<int>> _veins = new();
-        private int _mineIndex = -1;
-
-        public bool HasVein(int productId)
-        {
-            return _veins.ContainsKey(productId);
-        }
-
-        public void GenVeins(PlanetFactory factory)
-        {
-            _veins = new Dictionary<int, List<int>>();
-            var veinPool = factory.veinPool;
-            var vg = new Dictionary<int, HashSet<int>>();
-            for (var i = 0; i < veinPool.Length; i++)
-            {
-                if (veinPool[i].amount <= 0 || veinPool[i].type == EVeinType.None) continue;
-                var productId = veinPool[i].productId;
-                if (_veins.TryGetValue(productId, out var l))
-                {
-                    l.Add(i);
-                }
-                else
-                {
-                    _veins.Add(productId, [i]);
-                }
-
-                if (vg.TryGetValue(productId, out var hs))
-                {
-                    hs.Add(veinPool[i].groupIndex);
-                }
-                else
-                {
-                    vg.Add(productId, [veinPool[i].groupIndex]);
-                }
-            }
-
-            foreach (var pair in vg)
-            {
-                _veins[pair.Key].Add(pair.Value.Count);
-            }
-        }
-
-        public (int, long) Mine(PlanetFactory factory, int productId, int percent, long miningSpeedScale,
-            long energyMax)
-        {
-            if (!_veins.TryGetValue(productId, out var veins))
-            {
-                return (-1, -1L);
-            }
-
-            uint barrier;
-            int limit;
-            int count;
-            long energy;
-            var length = veins.Count - 1;
-            /* if is Oil */
-            if (productId == 1007)
-            {
-                energy = (_oilEnergyConsume * length * percent * percent + 9999L) / 100L / miningSpeedScale;
-                if (energy > energyMax)
-                    return (-1, -1L);
-                float countf = 0f;
-                var veinsPool = factory.veinPool;
-                for (var i = 0; i < length; i++)
-                {
-                    ref var vd = ref veinsPool[veins[i]];
-                    countf += vd.amount * 4 * VeinData.oilSpeedMultiplier;
-                }
-
-                count = ((int)countf * percent + 99) / 100;
-                if (count == 0)
-                    return (-1, -1L);
-                barrier = _miningCostBarrierOil;
-                limit = 2500;
-            }
-            else
-            {
-                count = (length * percent + 99) / 100;
-                if (count == 0)
-                    return (-1, -1L);
-                energy = (_oreEnergyConsume * veins[length] * percent * percent + 9999L) / 100L / miningSpeedScale;
-                if (energy > energyMax)
-                    return (-1, -1L);
-                barrier = _miningCostBarrier;
-                limit = 0;
-            }
-
-            var veinsData = factory.veinPool;
-            var total = 0;
-            for (; count > 0; count--)
-            {
-                _mineIndex = (_mineIndex + 1) % length;
-                var index = veins[_mineIndex];
-                ref var vd = ref veinsData[index];
-                int groupIndex;
-                if (vd.amount > 0)
-                {
-                    total++;
-                    if (vd.amount > limit)
-                    {
-                        var consume = true;
-                        if (barrier < 2147483646u)
-                        {
-                            _seed = (uint)((int)((ulong)((_seed % 2147483646u + 1) * 48271L) % 2147483647uL) - 1);
-                            consume = _seed < barrier;
-                        }
-
-                        if (consume)
-                        {
-                            vd.amount--;
-                            groupIndex = vd.groupIndex;
-                            factory.veinGroups[groupIndex].amount--;
-                            if (vd.amount <= 0)
-                            {
-                                factory.veinGroups[groupIndex].count--;
-                                factory.RemoveVeinWithComponents(index);
-                                factory.RecalculateVeinGroup(groupIndex);
-                                if (!_veins.TryGetValue(productId, out veins))
-                                    break;
-                                length = veins.Count - 1;
-                            }
-                        }
-                    }
-
-                    continue;
-                }
-
-                groupIndex = vd.groupIndex;
-                factory.veinGroups[groupIndex].count--;
-                factory.RemoveVeinWithComponents(index);
-                factory.RecalculateVeinGroup(groupIndex);
-                if (!_veins.TryGetValue(productId, out veins))
-                    break;
-                length = veins.Count - 1;
-            }
-
-            return (total, energy);
-        }
-    }
-}

LogisticMiner/LogisticMiner.csproj

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net472</TargetFramework>
-    <AssemblyName>LogisticMiner</AssemblyName>
-    <BepInExPluginGuid>org.soardev.logisticminer</BepInExPluginGuid>
-    <Description>DSP MOD - LogisticMiner</Description>
-    <Version>0.1.0</Version>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>latest</LangVersion>
-    <RestoreAdditionalProjectSources>https://nuget.bepinex.dev/v3/index.json</RestoreAdditionalProjectSources>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="BepInEx.Core" Version="5.*" />
-    <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
-    <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
-  </ItemGroup>
-</Project>

LogisticMiner/README.md

@@ -1,50 +0,0 @@
-# LogisticMiner
-
-#### Logistic Storages can mine all ores/water on current planet
-#### 物流塔可以采集当前星球的全部矿产(以及水)
-
-## Usage
-
-* Inspired
-  by [PlanetMiner](https://dsp.thunderstore.io/package/blacksnipebiu/PlanetMiner)([github](https://github.com/blacksnipebiu/PlanetMiner))  
-  But it is heavily optimized to resolve performance, accuracy and other issues in PlanetMiner.
-* (Optimization to PlanetMiner) Only recalculate count of veins when vein chunks are changed (added/removed by foundations/Sandbox-Mode, or
-  exhausted), so this removes Dictionary allocation on each planet for every frame.
-* (Optimization to PlanetMiner) More accurate frame counting by use float number.
-* (Optimization to PlanetMiner) Does not increase power consumptions on `Veins Utilization` upgrades.
-* (Optimization to PlanetMiner) Separate power consumptions for veins, oil seeps and water.
-* (Optimization to PlanetMiner) Power consumptions are counted by groups of veins and count of oil seeps, which is more sensible.
-* Can burn fuels in certain slot when energy below half of max.
-    * (Optimization to PlanetMiner) Sprayed fuels generates extra energy as normal.
-* (Optimization to PlanetMiner) All used parameters are configurable:
-    * Logistic Miner has the same speed as normal Mining Machine for normal ores by default.  
-      But you can set mining scale in configuration, which makes Logistic Miner working like Advance Mining Machines:  
-      power
-      consumption increases by the square of the scale, and gradually decrease mining speed over half of the maximum
-      count.  
-      This applies to all of veins, oils and water.  
-      Mining scale can be set to 0(by default), which means it is automatically set by tech unlocks, set to 300 when you
-      reaches Advanced Mining Machine, otherwise 100.
-    * 100/s for water by default.
-    * Energy costs: 1MW/vein-group & 10MW/water-slot & 1.8MW/oil-seep(configurable)
-    * Fuels burning slot. Default: 4th for ILS, 3rd for PLS. Set to 0 to disable it.
-
-## 使用说明
-
-* 创意来自 [PlanetMiner](https://dsp.thunderstore.io/package/blacksnipebiu/PlanetMiner)([github](https://github.com/blacksnipebiu/PlanetMiner))  
-  对性能重度优化，并解决了PlanetMiner的精度等问题。
-* (对PlanetMiner的优化) 仅当矿堆发生变化(填埋/恢复/采完)时重新计算矿堆数据，解决每行星每计算帧要重建字典的性能问题。
-* (对PlanetMiner的优化) 用浮点数保证更精确的帧计算。
-* (对PlanetMiner的优化) 升级`矿物利用`不会提升能耗。
-* (对PlanetMiner的优化) 分开矿物，油井和水的采集能耗。
-* (对PlanetMiner的优化) 采集能耗以矿物组，油井为单位，相对更加合理。
-* 剩余电量少于一半时可以燃烧指定格子的燃料补充。
-    * (对PlanetMiner的优化) 喷涂了增产剂的燃料按照正常的计算方式提供更多的能量(除了原本就不增加能量输出的反物质燃料棒)。
-* (对PlanetMiner的优化) 所有参数都可以在设置文件内配置:
-    * 物流塔矿机和普通矿机采矿速度一样(等同于同时采集所有对应矿物)。  
-      你可以设置采矿倍率改变物流塔矿机采矿速度，和高级采矿机相同地，能耗和倍率的平方成正比，并且在存储矿物量多于一半时逐渐降低采矿倍率。  
-      此倍率对各种矿物，油井和水的采集都生效。  
-      倍率可以设置为0(默认)，此时倍率会随科技解锁而变化，默认是100%，解锁高级采矿机后变为300%。
-    * 水的采集速度默认为100/s。
-    * 能耗：每矿物组 1MW，单格水 10MW，每油井 1.8MW。
-    * 燃料格位置。默认：星际物流塔第4格，行星内物流塔第3格。设为0则关闭燃料补充能量功能。

LogisticMiner/package/manifest.json

@@ -1,9 +0,0 @@
-{
-  "name": "LogisticMiner",
-  "version_number": "0.1.0",
-  "website_url": "https://github.com/soarqin/DSP_Mods/tree/master/LogisticMiner",
-  "description": "Logistic Storages can mine all ores/water on current planet / 物流塔可以采集当前星球的全部矿产(以及水)",
-  "dependencies": [
-    "xiaoye97-BepInEx-5.4.17"
-  ]
-}

MechaDronesTweaks/CHANGELOG.md

@@ -0,0 +1,45 @@
+<details>
+<summary>Read me in English</summary>
+
+## Changelog
+
+* 1.1.4
+  * Fixed support for game version 0.10.29
+
+* 1.1.3
+  * Support for game version 0.10.28.20759+
+  * Fixed a minor bug that `RemoveSpeedLimitForStage1` not working while `UseFixedSpeed` set to false and `SpeedMultiplier` set to 1
+
+* 1.1.2
+  * `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` and `LargerAreaForTerraform` are moved to [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)
+
+* 1.1.1
+  * Fixed crash in `LargeAreaForTerraform` functions.
+
+* 1.1.0
+  * Added `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` and `LargerAreaForTerraform` options (Check Usage for details).
+
+</details>
+
+<details>
+<summary>中文读我</summary>
+
+## 更新日志
+
+* 1.1.4
+  * 修复了对游戏版本0.10.29的支持
+
+* 1.1.3
+  * 支持游戏版本0.10.28.20759+
+  * 修复了当`UseFixedSpeed`设置为false且`SpeedMultiplier`设置为1时`RemoveSpeedLimitForStage1`无效的问题
+
+* 1.1.2
+  * `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` 和 `LargerAreaForTerraform` 移动到了 MOD [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) 中
+
+* 1.1.1
+  * 修复了 `LargeAreaForTerraform` 功能可能导致崩溃的问题。
+
+* 1.1.0
+  * 添加了 `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` 和 `LargerAreaForTerraform` 选项 (详情见使用说明)。
+
+</details>

MechaDronesTweaks/MechaDronesTweaks.csproj

@@ -15,7 +15,7 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
 

MechaDronesTweaks/README.md

@@ -1,26 +1,30 @@
 # MechaDronesTweaks
 
-#### Some tweaks for mecha drones(Successor to FastDrones MOD)
+<details>
-#### 机甲建设机调整(FastDrones MOD的后继者)
+<summary>Read me in English</summary>
+
+***Some tweaks for mecha drones(Successor to FastDrones MOD)***
 
 ## Updates
+
 * 1.1.4
-  + Fixed support for game version 0.10.29
+  * Fixed support for game version 0.10.29
 
 * 1.1.3
-  + Support for game version 0.10.28.20759+
+  * Support for game version 0.10.28.20759+
-  + Fixed a minor bug that `RemoveSpeedLimitForStage1` not working while `UseFixedSpeed` set to false and `SpeedMultiplier` set to 1
+  * Fixed a minor bug that `RemoveSpeedLimitForStage1` not working while `UseFixedSpeed` set to false and `SpeedMultiplier` set to 1
 
 * 1.1.2
-  + `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` and `LargerAreaForTerraform` are moved to [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)
+  * `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` and `LargerAreaForTerraform` are moved to [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist)
 
 * 1.1.1
-  + Fixed crash in `LargeAreaForTerraform` functions.
+  * Fixed crash in `LargeAreaForTerraform` functions.
 
 * 1.1.0
-  + Added `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` and `LargerAreaForTerraform` options (Check Usage for details).
+  * Added `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` and `LargerAreaForTerraform` options (Check Usage for details).
 
 ## Usage
+
 * Inspired by [FastDrones](https://dsp.thunderstore.io/package/dkoppstein/FastDrones/), but patching IL codes, consuming less CPU to reduce lags on massive builds especially blueprints' put.
 * Does not affect current game-saves, which means:
   * All values are patched in memory but written to game-saves so that you can play with normal mecha drone parameters while disabling this MOD.
@@ -37,24 +41,15 @@
     * `EnergyMultiplier` [Default Value: 0.1]: Energy consumption multiplier for mecha drones.
 * Note: This MOD will disable `FastDrones` if the MOD is installed, to avoid conflict in functions.
 
-## 更新日志
+</details>
-* 1.1.4
-  + 修复了对游戏版本0.10.29的支持
 
-* 1.1.3
+<details>
-  + 支持游戏版本0.10.28.20759+
+<summary>中文读我</summary>
-  + 修复了当`UseFixedSpeed`设置为false且`SpeedMultiplier`设置为1时`RemoveSpeedLimitForStage1`无效的问题
 
-* 1.1.2
+***机甲建设机调整(FastDrones MOD的后继者)***
-  + `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` 和 `LargerAreaForTerraform` 移动到了 MOD [UXAssist](https://dsp.thunderstore.io/package/soarqin/UXAssist) 中
-
-* 1.1.1
-  + 修复了 `LargeAreaForTerraform` 功能可能导致崩溃的问题。
-
-* 1.1.0
-  + 添加了 `RemoveBuildRangeLimit`, `LargerAreaForUpgradeAndDismantle` 和 `LargerAreaForTerraform` 选项 (详情见使用说明)。
 
 ## 使用说明
+
 * 功能参考 [FastDrones](https://dsp.thunderstore.io/package/dkoppstein/FastDrones/)，但主要对IL代码进行Patch因此消耗更少的CPU，尤其在大规模建造比如放置蓝图的时候可以大大减少卡顿。
 * 不影响当前游戏存档:
   * 所有修改参数都在内存中Patch不会写入存档，禁用此MOD后可恢复正常建设机参数。
@@ -70,3 +65,5 @@
     * `SpeedMultiplier` [默认值: 4]: 速度倍数。
     * `EnergyMultiplier` [默认值: 0.1]: 能量消耗倍数。
 * 说明: 如果安装了`FastDrones`本MOD会将其禁用避免功能冲突。
+
+</details>

OCBatchBuild/OCBatchBuild.csproj

@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net472</TargetFramework>
-    <AssemblyName>OCBatchBuild</AssemblyName>
-    <BepInExPluginGuid>org.soardev.ocbatchbuild</BepInExPluginGuid>
-    <Description>DSP MOD - OCBatchBuild</Description>
-    <Version>1.2.0</Version>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>latest</LangVersion>
-    <RestoreAdditionalProjectSources>https://nuget.bepinex.dev/v3/index.json</RestoreAdditionalProjectSources>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="BepInEx.Core" Version="5.*" />
-    <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
-    <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
-  </ItemGroup>
-
-  <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
-    <Exec Command="del /F /Q package\$(ProjectName)-$(Version).zip&#xA;powershell Compress-Archive -Force -DestinationPath 'package/$(ProjectName)-$(Version).zip' -Path '$(TargetPath)', package/icon.png, package/manifest.json, README.md" />
-  </Target>
-</Project>

OCBatchBuild/OrbitalCollectorBatchBuild.cs

@@ -1,129 +0,0 @@
-using System;
-using System.Collections.Generic;
-using BepInEx;
-using HarmonyLib;
-
-namespace OCBatchBuild;
-
-[BepInPlugin(PluginInfo.PLUGIN_GUID, PluginInfo.PLUGIN_NAME, PluginInfo.PLUGIN_VERSION)]
-public class OrbitalCollectorBatchBuild : BaseUnityPlugin
-{
-    private new static readonly BepInEx.Logging.ManualLogSource Logger =
-        BepInEx.Logging.Logger.CreateLogSource(PluginInfo.PLUGIN_NAME);
-
-    private bool _cfgEnabled = true;
-    private static int _maxBuildCount;
-    private static bool _instantBuild;
-
-    private void Awake()
-    {
-        _cfgEnabled = Config.Bind("General", "Enabled", _cfgEnabled, "enable/disable this plugin").Value;
-        _maxBuildCount = Config.Bind("General", "MaxBuildCount", _maxBuildCount, "Maximum Orbital Collectors to build once, set to 0 to build as many as possible").Value;
-        _instantBuild = Config.Bind("General", "InstantBuild", _instantBuild, "Enable to make Orbital Collectors built instantly. This is thought to be game logic breaking.").Value;
-        Harmony.CreateAndPatchAll(typeof(OrbitalCollectorBatchBuild));
-    }
-
-    [HarmonyPostfix]
-    [HarmonyPatch(typeof(BuildTool_Click), "CreatePrebuilds")]
-    private static void CreatePrebuilds(BuildTool_Click __instance)
-    {
-        /* Check Gas Planet */
-        if (__instance.planet.type != EPlanetType.Gas) return;
-        if (__instance.buildPreviews.Count == 0) return;
-
-        var buildPreview = __instance.buildPreviews[0];
-        /* Check if is collector station */
-        if (!buildPreview.desc.isCollectStation) return;
-
-        var factory = __instance.factory;
-        var stationPool = factory.transport.stationPool;
-        var entityPool = factory.entityPool;
-        var stationCursor = factory.transport.stationCursor;
-        var pos = buildPreview.lpos;
-        var pos2 = buildPreview.lpos2;
-        var itemId = buildPreview.item.ID;
-        var countToBuild = _maxBuildCount - 1;
-        if (countToBuild == 0) return;
-        var prebuilds = new List<int> {-buildPreview.objId};
-        var player = __instance.player;
-        var firstPos = pos;
-        var cellCount = PlanetGrid.DetermineLongitudeSegmentCount(0, factory.planet.aux.mainGrid.segment) * 5;
-        var cellRad = Math.PI / cellCount;
-        var distRadCount = 0;
-        for (var i = 1; i <= cellCount; i++)
-        {
-            pos = Maths.RotateLF(0.0, 1.0, 0.0, cellRad, pos);
-            if ((firstPos - pos).sqrMagnitude < 14297f) continue;
-            distRadCount = i;
-            break;
-        }
-
-        if (distRadCount == 0) return;
-        pos = firstPos;
-        /* rotate for a minimal distance for next OC on sphere */
-        pos = Maths.RotateLF(0.0, 1.0, 0.0, cellRad * distRadCount, pos);
-        pos2 = Maths.RotateLF(0.0, 1.0, 0.0, cellRad * distRadCount, pos2);
-        for (var i = distRadCount; i < cellCount && countToBuild != 0;)
-        {
-            /* Check for collision */
-            var collide = false;
-            for (var j = 1; j < stationCursor; j++)
-            {
-                if (stationPool[j] == null || stationPool[j].id != j) continue;
-                if ((entityPool[stationPool[j].entityId].pos - pos).sqrMagnitude >= 14297f) continue;
-                collide = true;
-                break;
-            }
-            if (collide)
-            {
-                /* rotate for a small cell on sphere */
-                pos = Maths.RotateLF(0.0, 1.0, 0.0, cellRad, pos);
-                pos2 = Maths.RotateLF(0.0, 1.0, 0.0, cellRad, pos2);
-                i++;
-                continue;
-            }
-
-            if (player.inhandItemId == itemId && player.inhandItemCount > 0)
-            {
-                player.UseHandItems(1, out var _);
-            }
-            else
-            {
-                var count = 1;
-                player.package.TakeTailItems(ref itemId, ref count, out var _);
-                if (count == 0) break;
-            }
-
-            var rot = Maths.SphericalRotation(pos, 0f);
-            var rot2 = Maths.SphericalRotation(pos2, 0f);
-            var prebuild = default(PrebuildData);
-            prebuild.protoId = (short)buildPreview.item.ID;
-            prebuild.modelIndex = (short)buildPreview.desc.modelIndex;
-            prebuild.pos = pos;
-            prebuild.pos2 = pos2;
-            prebuild.rot = rot;
-            prebuild.rot2 = rot2;
-            prebuild.pickOffset = (short)buildPreview.inputOffset;
-            prebuild.insertOffset = (short)buildPreview.outputOffset;
-            prebuild.recipeId = buildPreview.recipeId;
-            prebuild.filterId = buildPreview.filterId;
-            prebuild.InitParametersArray(buildPreview.paramCount);
-            for (var j = 0; j < buildPreview.paramCount; j++)
-            {
-                prebuild.parameters[j] = buildPreview.parameters[j];
-            }
-            prebuilds.Add(factory.AddPrebuildDataWithComponents(prebuild));
-            countToBuild--;
-            /* rotate for minimal distance for next OC on sphere */
-            pos = Maths.RotateLF(0.0, 1.0, 0.0, cellRad * distRadCount, pos);
-            pos2 = Maths.RotateLF(0.0, 1.0, 0.0, cellRad * distRadCount, pos2);
-            i += distRadCount;
-        }
-
-        if (!_instantBuild) return;
-        foreach (var id in prebuilds)
-        {
-            factory.BuildFinally(player, id);
-        }
-    }
-}

OCBatchBuild/README.md

@@ -1,24 +0,0 @@
-# OrbitalCollectorBatchBuild
-
-#### Batch build Orbital Collectors
-#### 轨道采集器快速批量建造
-
-## Updates
-### 1.2.0
-* Support for mods that change default radius of Gas Planets, e.g. `GalacticScale`.
-* Remove maximum build count limit in config.
-
-### 1.1.0
-* Add `InstantBuild` to config
-
-## Usage
-* Build any orbital collector on a Gas Giant to trigger building all placable orbital collectors.
-* Can set maximum orbital collectors to build once in config.
-* Note: Collectors are placed as prebuilt status, you still need to fly around the Gas Giant to complete building. This is designed not to break much game logic.  
-  You can set `InstantBuild` to `true` in config to make them built instantly.
-
-## 使用说明
-* 在气态星球上建造任何一个轨道采集器触发所有可建造采集器的放置。
-* 可以在设置文件中配置一次批量建造的最大轨道采集器数量。
-* 提示：轨道采集器会处于待建造状态，你仍然需要绕行气态行星一圈以完成建造。这个机制是为了尽可能减少对原有游戏逻辑的破坏。  
-  在配置文件里设置`InstantBuild`为`true`可以使采集器的建造立即完成。

OCBatchBuild/package/manifest.json

@@ -1,9 +0,0 @@
-{
-  "name": "OrbitalCollectorBatchBuild",
-  "version_number": "1.2.0",
-  "website_url": "https://github.com/soarqin/DSP_Mods/tree/master/OCBatchBuild",
-  "description": "Batch build Orbital Collectors / 轨道采集器快速批量建造",
-  "dependencies": [
-    "xiaoye97-BepInEx-5.4.17"
-  ]
-}

OverclockEverything/OverclockEverything.csproj

@@ -16,15 +16,15 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="DysonSphereProgram.Modding.DSPModSave" Version="1.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
-  
+
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>
-  
+
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
     <Exec Command="del /F /Q package\$(ProjectName)-$(Version).zip&#xA;powershell Compress-Archive -Force -DestinationPath 'package/$(ProjectName)-$(Version).zip' -Path '$(TargetPath)', package/icon.png, package/manifest.json, README.md" />
   </Target>

OverclockEverything/README.md

@@ -1,12 +1,9 @@
 # OverclockEverything
 
-#### Boost nearly all structures
+***Boost nearly all structures***
-#### 加速几乎所有建筑功能
-
-## Usage
 
 * Boost power generation, assembling speed, belt and sorter speed.
 
-## 使用说明
+***加速几乎所有建筑功能***
 
 * 加快发电，制造，传送带和分拣器速度。

PoolOpt/PoolOpt.csproj

@@ -15,14 +15,14 @@
   <ItemGroup>
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
-    <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.GameLibs" Version="0.10.32.*-r.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
-  
+
   <ItemGroup Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'">
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="all" />
   </ItemGroup>
-  
+
   <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(Configuration)' == 'Release'">
     <Exec Command="del /F /Q package\$(ProjectName)-$(Version).zip&#xA;powershell Compress-Archive -Force -DestinationPath 'package/$(ProjectName)-$(Version).zip' -Path '$(TargetPath)', package/icon.png, package/manifest.json, README.md" />
   </Target>

README.md

@@ -1,67 +1,62 @@
-## DSP Mods by Soar Qin
+# DSP Mods by Soar Qin
 
-# [CheatEnabler](CheatEnabler)
+## [CheatEnabler](CheatEnabler)
 
-Add various cheat functions while disabling abnormal determinants  
+Add various cheat functions while disabling abnormal determinants
 添加一些作弊功能，同时屏蔽异常检测
 
-# [CompressSave](CompressSave)
+## [CompressSave](CompressSave)
 
-Moved [here](https://github.com/soarqin/DSP_Mods_TO/tree/master/CompressSave)
+Moved [to another repo](https://github.com/soarqin/DSP_Mods_TO/tree/master/CompressSave)
 
-# [LogisticMiner](LogisticMiner)
+## [LogisticHub](LogisticHub)
 
-Logistic Storages can mine all ores/water on current planet  
+Cheat functions for Logistic Storages, make them mine resources on the planet and exchange items from certain buildings
-物流塔可以采集当前星球的全部矿产(以及水)
+物流塔作弊功能，使其可以在星球上采矿并与特定建筑物交换物品
 
-# [HideTips](HideTips)
+## [HideTips](HideTips)
 
-Hide/Disable various tutorial tips/messages  
+Hide/Disable various tutorial tips/messages
 隐藏/屏蔽各种引导提示/消息
 
-# [Dustbin](Dustbin)
+## [Dustbin](Dustbin)
 
-Can turn Storages and Tanks into Dustbin(Destroy incoming items)  
+Can turn Storages and Tanks into Dustbin(Destroy incoming items)
 储物仓和储液罐可以转变为垃圾桶(销毁送进的物品)
 
-# [OverclockEverything](OverclockEverything)
+## [OverclockEverything](OverclockEverything)
 
 Boost nearly all structures
 加速几乎所有建筑功能
 
-# [OrbitalCollectorBatchBuild](OCBatchBuild)
+## [UniverseGenTweaks](UniverseGenTweaks)
 
-Batch build Orbital Collectors  
+Universe Generator Tweak
-轨道采集器快速批量建造
-
-# [UniverseGenTweaks](UniverseGenTweaks)
-
-Universe Generator Tweak  
 宇宙生成参数调节
 
-# [MechaDronesTweaks](MechaDronesTweaks)
+## [MechaDronesTweaks](MechaDronesTweaks)
 
-Some tweaks for mecha drones and build functions(Successor to FastDrones MOD)    
+Some tweaks for mecha drones and build functions(Successor to FastDrones MOD)
 机甲建设机和建设功能调整(FastDrones MOD的后继者)
 
-# [LabOpt](LabOpt)
+## [LabOpt](LabOpt)
 
-Performance optimizations for Matrix Labs  
+Performance optimizations for Matrix Labs
 Marked as obsoleted temporarily, needs more investigation about LabComponent's mechanism
 优化研究站性能
 暂时标识为过期，需要更多关于LabComponent机制的研究
 
-# [PoolOpt](PoolOpt)
+## [PoolOpt](PoolOpt)
 
-Optimize memory pools on loading gamesaves  
+Optimize memory pools on loading gamesaves
 加载游戏存档时优化内存池的使用
 
-# [UserCloak](UserCloak)
+## [UserCloak](UserCloak)
 
-Cloak(Fake) user account info  
+Cloak(Fake) user account info
 隐匿(伪装)用户账号信息
 
-# [UXAssist](UXAssist)
+## [UXAssist](UXAssist)
 
-Some functions and patches for better user experience  
+Some functions and patches for better user experience
-一些提升用户体验的功能和补丁
+一些提升用户体验的功能和补丁

UXAssist/Common/GameLogic.cs

@@ -3,12 +3,12 @@ using HarmonyLib;
 
 namespace UXAssist.Common;
 
-public class GameLogic: PatchImpl<GameLogic>
+public class GameLogic : PatchImpl<GameLogic>
 {
     public static Action OnDataLoaded;
     public static Action OnGameBegin;
     public static Action OnGameEnd;
-    
+
     [HarmonyPostfix]
     [HarmonyPatch(typeof(VFPreload), nameof(VFPreload.InvokeOnLoadWorkEnded))]
     public static void VFPreload_InvokeOnLoadWorkEnded_Postfix()

UXAssist/Common/I18N.cs

@@ -122,14 +122,14 @@ public static class I18N
         _initialized = true;
         Apply();
     }
-    
+
     [HarmonyPostfix, HarmonyPriority(Priority.Last), HarmonyPatch(typeof(Localization), nameof(Localization.LoadLanguage))]
     private static void Localization_LoadLanguage_Postfix(int index)
     {
         if (!_initialized) return;
         ApplyLanguage(index);
     }
-    
+
     [HarmonyPostfix, HarmonyPriority(Priority.Last), HarmonyPatch(typeof(Localization), nameof(Localization.NotifyLanguageChange))]
     private static void Localization_NotifyLanguageChange_Postfix()
     {

UXAssist/Common/KeyBindings.cs

@@ -29,4 +29,11 @@ public static class KeyBindings
 
         return new CombineKey((int)shortcut.MainKey, mod, ECombineKeyAction.OnceClick, false);
     }
+
+    public static bool IsKeyPressing(this PressKeyBind keyBind)
+    {
+        var defBind = keyBind.defaultBind;
+        var overrideKey = VFInput.override_keys[defBind.id];
+        return overrideKey.IsNull() ? defBind.key.GetKey() : overrideKey.GetKey();
+    }
 }

UXAssist/Common/PatchImpl.cs

@@ -13,9 +13,9 @@ public class PatchGuidAttribute(string guid) : Attribute
 
 public enum PatchCallbackFlag
 {
-    // OnEnable() is called After patch is applied by default, set this flag to call it before patch is applied
+    // By default, OnEnable() is called After patch applied, set this flag to call it before patch is applied
     CallOnEnableBeforePatch,
-    // OnDisable() is called Before patch is removed by default, set this flag to call it after patch is removed
+    // By default, OnDisable() is called Before patch removed, set this flag to call it after patch is removed
     CallOnDisableAfterUnpatch,
 }
 
@@ -27,25 +27,27 @@ public class PatchSetCallbackFlagAttribute(PatchCallbackFlag flag) : Attribute
 
 public class PatchImpl<T> where T : PatchImpl<T>, new()
 {
-    private static T Instance { get; } = new();
+    protected static T Instance { get; } = new();
-    
+
-    private Harmony _patch;
+    protected Harmony _patch;
 
     public static void Enable(bool enable)
     {
         var thisInstance = Instance;
         if (enable)
         {
+            if (thisInstance._patch != null) return;
             var guid = typeof(T).GetCustomAttribute<PatchGuidAttribute>()?.Guid ?? $"PatchImpl.{typeof(T).FullName ?? typeof(T).ToString()}";
             var callOnEnableBefore = typeof(T).GetCustomAttributes<PatchSetCallbackFlagAttribute>().Any(n => n.Flag == PatchCallbackFlag.CallOnEnableBeforePatch);
             if (callOnEnableBefore) thisInstance.OnEnable();
-            thisInstance._patch ??= Harmony.CreateAndPatchAll(typeof(T), guid);
+            thisInstance._patch = Harmony.CreateAndPatchAll(typeof(T), guid);
             if (!callOnEnableBefore) thisInstance.OnEnable();
             return;
         }
+        if (thisInstance._patch == null) return;
         var callOnDisableAfter = typeof(T).GetCustomAttributes<PatchSetCallbackFlagAttribute>().Any(n => n.Flag == PatchCallbackFlag.CallOnDisableAfterUnpatch);
         if (!callOnDisableAfter) thisInstance.OnDisable();
-        thisInstance._patch?.UnpatchSelf();
+        thisInstance._patch.UnpatchSelf();
         thisInstance._patch = null;
         if (callOnDisableAfter) thisInstance.OnDisable();
     }

UXAssist/Common/Util.cs

@@ -36,13 +36,13 @@ public static class Util
         tex.LoadImage(fileData);
         return tex;
     }
-    
+
     public static Sprite LoadSprite(string path)
     {
         var tex = LoadTexture(path);
         return Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(0.5f, 0.5f));
     }
-    
+
     public static Texture2D LoadEmbeddedTexture(string path, Assembly assembly = null)
     {
         var fileData = LoadEmbeddedResource(path, assembly);
@@ -50,12 +50,12 @@ public static class Util
         tex.LoadImage(fileData);
         return tex;
     }
-    
+
     public static Sprite LoadEmbeddedSprite(string path, Assembly assembly = null)
     {
         var tex = LoadEmbeddedTexture(path, assembly);
         return Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), new Vector2(0.5f, 0.5f));
     }
-    
+
     public static string PluginFolder(Assembly assembly = null) => Path.GetDirectoryName((assembly == null ? Assembly.GetCallingAssembly() : assembly).Location);
 }

UXAssist/Common/WinApi.cs

@@ -128,8 +128,8 @@ public static class WinApi
     [DllImport("user32", ExactSpelling = true)]
     public static extern bool MoveWindow(IntPtr hWnd, int x, int y, int nWidth, int nHeight, bool bRepaint);
 
-    [DllImport("kernel32", ExactSpelling = true, SetLastError = true)]
+    [DllImport("user32", ExactSpelling = true)]
-    public static extern bool GetProcessAffinityMask(IntPtr hProcess, out ulong lpProcessAffinityMask, out ulong lpSystemAffinityMask);
+    public static extern IntPtr MonitorFromRect([In] ref Rect lpRect, uint dwFlags);
 
     [DllImport("kernel32", ExactSpelling = true, SetLastError = true)]
     public static extern IntPtr GetCurrentProcess();
@@ -140,9 +140,6 @@ public static class WinApi
     [DllImport("kernel32", ExactSpelling = true)]
     public static extern IntPtr GetConsoleWindow();
 
-    [DllImport("kernel32", ExactSpelling = true, SetLastError = true)]
-    public static extern bool SetProcessAffinityMask(IntPtr hProcess, ulong dwProcessAffinityMask);
-
     // GetPriorityClass and SetPriorityClass
     [DllImport("kernel32", ExactSpelling = true, SetLastError = true)]
     public static extern int GetPriorityClass(IntPtr hProcess);
@@ -157,126 +154,4 @@ public static class WinApi
     public static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam);
 
     #endregion
-
-    #region GetLogicalProcessorInformationEx
-
-    [Flags]
-    private enum LOGICAL_PROCESSOR_RELATIONSHIP
-    {
-        RelationProcessorCore,
-        RelationNumaNode,
-        RelationCache,
-        RelationProcessorPackage,
-        RelationGroup,
-        RelationAll = 0xffff
-    }
-
-    [StructLayout(LayoutKind.Sequential, Pack = 4)]
-    private struct GROUP_AFFINITY
-    {
-        public nuint Mask;
-        public ushort Group;
-        public ushort Reserved0;
-        public ushort Reserved1;
-        public ushort Reserved3;
-    }
-    
-    [StructLayout(LayoutKind.Sequential, Pack = 4)]
-    private struct PROCESSOR_RELATIONSHIP
-    {
-        public byte Flags;
-        public byte EfficiencyClass;
-        public ushort Reserved0;
-        public uint Reserved1;
-        public uint Reserved2;
-        public uint Reserved3;
-        public uint Reserved4;
-        public ushort Reserved5;
-        public ushort GroupCount;
-        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
-        public GROUP_AFFINITY[] GroupMask;
-    }
-
-    [StructLayout(LayoutKind.Sequential)]
-    private struct SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX
-    {
-        public LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
-        public uint Size;
-        public PROCESSOR_RELATIONSHIP Processor;
-    }
-    
-    [DllImport("kernel32", SetLastError = true)]
-    private static extern bool GetLogicalProcessorInformationEx(
-        LOGICAL_PROCESSOR_RELATIONSHIP relationshipType,
-        IntPtr buffer,
-        ref uint returnLength
-    );
-
-    public struct LogicalProcessorDetails
-    {
-        public int CoreCount;
-        public int ThreadCount;
-        public int PerformanceCoreCount;
-        public int EfficiencyCoreCount;
-        public ulong PerformanceCoreMask;
-        public ulong EfficiencyCoreMask;
-        public bool HybridArchitecture => PerformanceCoreCount > 0 && EfficiencyCoreCount > 0;
-    }
-
-    public static LogicalProcessorDetails GetLogicalProcessorDetails()
-    {
-        uint returnLength = 0;
-        GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore, IntPtr.Zero, ref returnLength);
-        var result = new LogicalProcessorDetails();
-        if (Marshal.GetLastWin32Error() != ERROR_INSUFFICIENT_BUFFER) return result;
-        var ptr = Marshal.AllocHGlobal((int)returnLength);
-        try
-        {
-            if (!GetLogicalProcessorInformationEx(LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore, ptr, ref returnLength))
-                return result;
-            uint offset = 0;
-            var item = ptr;
-            while (offset < returnLength)
-            {
-                var buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX)Marshal.PtrToStructure(item, typeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX));
-                offset += buffer.Size;
-                item += (int)buffer.Size;
-                if (buffer.Relationship != LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore) continue;
-                result.CoreCount++;
-                var mask = buffer.Processor.GroupMask[0].Mask;
-                var tcount = CountBitsSet(mask);
-                result.ThreadCount += tcount;
-                if (buffer.Processor.EfficiencyClass > 0)
-                {
-                    result.PerformanceCoreCount++;
-                    result.PerformanceCoreMask |= mask;
-                }
-                else
-                {
-                    result.EfficiencyCoreCount++;
-                    result.EfficiencyCoreMask |= mask;
-                }
-            }
-        }
-        finally
-        {
-            Marshal.FreeHGlobal(ptr);
-        }
-
-        return result;
-
-        int CountBitsSet(ulong mask)
-        {
-            var count = 0;
-            while (mask != 0)
-            {
-                mask &= mask - 1;
-                count++;
-            }
-
-            return count;
-        }
-    }
-
-    #endregion
 }

UXAssist/Functions/DysonSphereFunctions.cs

@@ -1,6 +1,4 @@
-using System.Linq;
+namespace UXAssist.Functions;
-
-namespace UXAssist.Functions;
 
 public static class DysonSphereFunctions
 {

UXAssist/Functions/FactoryFunctions.cs

@@ -0,0 +1,253 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UXAssist.Functions;
+
+public static class FactoryFunctions
+{
+    public static void CutConveyorBelt(CargoTraffic cargoTraffic, int beltId)
+    {
+        ref var belt = ref cargoTraffic.beltPool[beltId];
+        if (belt.id != beltId || belt.outputId <= 0) return;
+
+        // Clear entity connection
+        var factory = cargoTraffic.factory;
+        factory.ReadObjectConn(belt.entityId, 0, out var isOutput, out var otherObjId, out var otherSlot);
+        if (isOutput && factory.entityPool[otherObjId].beltId == belt.outputId)
+        {
+            factory.ClearObjectConnDirect(belt.entityId, 0);
+            factory.ClearObjectConnDirect(otherObjId, otherSlot);
+        }
+        // Alter belt connections
+        var (i0, i1, i2) = (belt.rightInputId, belt.backInputId, belt.leftInputId);
+        cargoTraffic._arrInputs(ref i0, ref i1, ref i2);
+        cargoTraffic.AlterBeltConnections(beltId, 0, i0, i1, i2);
+    }
+
+    public static void DismantleBlueprintSelectedBuildings()
+    {
+        var player = GameMain.mainPlayer;
+        var build = player?.controller?.actionBuild;
+        if (build == null) return;
+        var blueprintCopyTool = build.blueprintCopyTool;
+        if (blueprintCopyTool == null || !blueprintCopyTool.active) return;
+        var factory = build.factory;
+        List<int> buildPreviewsToRemove = [];
+        foreach (var buildPreview in blueprintCopyTool.bpPool)
+        {
+            if (buildPreview?.item == null) continue;
+            var objId = buildPreview.objId;
+            if (objId == 0) continue;
+            int index;
+            if ((index = buildPreviewsToRemove.BinarySearch(objId)) < 0)
+                buildPreviewsToRemove.Insert(~index, objId);
+            var isBelt = buildPreview.desc.isBelt;
+            var isInserter = buildPreview.desc.isInserter;
+            if (isInserter) continue;
+            if (isBelt)
+            {
+                var needCheck = false;
+                for (var j = 0; j < 2; j++)
+                {
+                    factory.ReadObjectConn(objId, j, out _, out var connObjId, out _);
+                    if (connObjId == 0 || factory.ObjectIsBelt(connObjId) || blueprintCopyTool.ObjectIsInserter(connObjId)) continue;
+                    needCheck = true;
+                    break;
+                }
+                if (needCheck)
+                {
+                    for (var k = 0; k < 16; k++)
+                    {
+                        factory.ReadObjectConn(objId, k, out _, out var connObjId, out _);
+                        if (connObjId != 0 && (index = buildPreviewsToRemove.BinarySearch(connObjId)) < 0 && (factory.ObjectIsBelt(connObjId) || blueprintCopyTool.ObjectIsInserter(connObjId)))
+                            buildPreviewsToRemove.Insert(~index, connObjId);
+                    }
+                }
+                for (var m = 0; m < 4; m++)
+                {
+                    factory.ReadObjectConn(objId, m, out _, out var connObjId, out _);
+                    if (connObjId == 0 || !factory.ObjectIsBelt(connObjId) || buildPreviewsToRemove.BinarySearch(connObjId) >= 0) continue;
+                    for (var j = 0; j < 2; j++)
+                    {
+                        factory.ReadObjectConn(connObjId, j, out _, out var connObjId2, out _);
+                        if (connObjId2 == 0 || (index = buildPreviewsToRemove.BinarySearch(connObjId2)) >= 0 || factory.ObjectIsBelt(connObjId2) || blueprintCopyTool.ObjectIsInserter(connObjId2)) continue;
+                        buildPreviewsToRemove.Insert(~index, connObjId);
+                        break;
+                    }
+                }
+                continue;
+            }
+            if (buildPreview.desc.addonType == EAddonType.Belt) continue;
+            for (var j = 0; j < 16; j++)
+            {
+                factory.ReadObjectConn(objId, j, out _, out var connObjId, out _);
+                if (connObjId != 0 && (index = buildPreviewsToRemove.BinarySearch(connObjId)) < 0 && (factory.ObjectIsBelt(connObjId) || blueprintCopyTool.ObjectIsInserter(connObjId)))
+                    buildPreviewsToRemove.Insert(~index, connObjId);
+            }
+        }
+        var entityPool = factory.entityPool;
+        var stationPool = factory.transport.stationPool;
+        foreach (var objId in buildPreviewsToRemove)
+        {
+            if (objId > 0)
+            {
+                int stationId = entityPool[objId].stationId;
+                if (stationId > 0)
+                {
+                    StationComponent sc = stationPool[stationId];
+                    if (sc.id != stationId) continue;
+                    for (int i = 0; i < sc.storage.Length; i++)
+                    {
+                        int package = player.TryAddItemToPackage(sc.storage[i].itemId, sc.storage[i].count, sc.storage[i].inc, true, objId);
+                        UIItemup.Up(sc.storage[i].itemId, package);
+                    }
+                    sc.storage = new StationStore[sc.storage.Length];
+                    sc.needs = new int[sc.needs.Length];
+                }
+            }
+            build.DoDismantleObject(objId);
+        }
+        blueprintCopyTool.ClearSelection();
+        blueprintCopyTool.ClearPreSelection();
+        blueprintCopyTool.ResetBlueprint();
+        blueprintCopyTool.ResetBuildPreviews();
+        blueprintCopyTool.RefreshBlueprintData();
+    }
+
+    public static void SelectAllBuildingsInBlueprintCopy()
+    {
+        var localFactory = GameMain.localPlanet?.factory;
+        if (localFactory == null) return;
+        var blueprintCopyTool = GameMain.mainPlayer?.controller?.actionBuild?.blueprintCopyTool;
+        if (blueprintCopyTool == null || !blueprintCopyTool.active) return;
+        var entityPool = localFactory.entityPool;
+        foreach (var entity in entityPool)
+        {
+            if (entity.id == 0) continue;
+            blueprintCopyTool.preSelectObjIds.Add(entity.id);
+            blueprintCopyTool.selectedObjIds.Add(entity.id);
+        }
+        var prebuildPool = localFactory.prebuildPool;
+        foreach (var prebuild in prebuildPool)
+        {
+            if (prebuild.id == 0) continue;
+            blueprintCopyTool.preSelectObjIds.Add(-prebuild.id);
+            blueprintCopyTool.selectedObjIds.Add(-prebuild.id);
+        }
+        blueprintCopyTool.RefreshBlueprintData();
+        blueprintCopyTool.DeterminePreviews();
+    }
+
+    private struct BPBuildingData
+    {
+        public BlueprintBuilding building;
+        public int itemType;
+        public double offset;
+    }
+
+    private struct BPBeltData
+    {
+        public BlueprintBuilding building;
+        public double offset;
+    }
+
+    private static HashSet<int> _itemIsBelt = null;
+    private static Dictionary<int, int> _upgradeTypes = null;
+
+    public static void SortBlueprintData(BlueprintData blueprintData)
+    {
+        // Initialize itemIsBelt and upgradeTypes
+        if (_itemIsBelt == null)
+        {
+            _itemIsBelt = [];
+            _upgradeTypes = [];
+            foreach (var proto in LDB.items.dataArray)
+            {
+                if (proto.prefabDesc?.isBelt ?? false)
+                {
+                    _itemIsBelt.Add(proto.ID);
+                    continue;
+                }
+                if (proto.Upgrades != null && proto.Upgrades.Length > 0)
+                {
+                    var minUpgrade = proto.Upgrades.Min(u => u);
+                    if (minUpgrade != 0 && minUpgrade != proto.ID)
+                    {
+                        _upgradeTypes.Add(proto.ID, minUpgrade);
+                    }
+                }
+            }
+        }
+
+        // Separate belt and non-belt buildings
+        List<BPBuildingData> bpBuildings = [];
+        Dictionary<BlueprintBuilding, BPBeltData> bpBelts = [];
+        foreach (var building in blueprintData.buildings)
+        {
+            var offset = building.areaIndex * 1073741824.0 + building.localOffset_y * 262144.0 + building.localOffset_x * 1024.0 + building.localOffset_z;
+            if (_itemIsBelt.Contains(building.itemId))
+            {
+                bpBelts.Add(building, new BPBeltData { building = building, offset = offset });
+            }
+            else
+            {
+                var itemType = _upgradeTypes.TryGetValue(building.itemId, out var upgradeType) ? upgradeType : building.itemId;
+                bpBuildings.Add(new BPBuildingData { building = building, itemType = itemType, offset = offset });
+            }
+        }
+        HashSet<BlueprintBuilding> beltsWithInput = [.. bpBelts.Select(pair => pair.Value.building.outputObj)];
+        var beltHeads = bpBelts.Where(pair => !beltsWithInput.Contains(pair.Value.building)).ToDictionary(pair => pair.Key, pair => pair.Value);
+        // Sort belt buildings
+        List<BlueprintBuilding> sortedBpBelts = [];
+        // Deal with non-cycle belt paths
+        foreach (var pair in beltHeads.OrderByDescending(pair => pair.Value.offset))
+        {
+            var building = pair.Key;
+            while (building != null)
+            {
+                if (!bpBelts.Remove(building)) break;
+                sortedBpBelts.Add(building);
+                building = building.outputObj;
+            }
+        }
+        // Deal with cycle belt paths
+        foreach (var pair in bpBelts.OrderByDescending(pair => pair.Value.offset))
+        {
+            var building = pair.Key;
+            while (building != null)
+            {
+                if (!bpBelts.Remove(building)) break;
+                sortedBpBelts.Add(building);
+                building = building.outputObj;
+            }
+        }
+
+        // Sort non-belt buildings
+        bpBuildings.Sort((a, b) =>
+        {
+            var sign = b.itemType.CompareTo(a.itemType);
+            if (sign != 0) return sign;
+
+            sign = b.building.modelIndex.CompareTo(a.building.modelIndex);
+            if (sign != 0) return sign;
+
+            sign = b.building.recipeId.CompareTo(a.building.recipeId);
+            if (sign != 0) return sign;
+
+            sign = a.building.areaIndex.CompareTo(b.building.areaIndex);
+            if (sign != 0) return sign;
+
+            return b.offset.CompareTo(a.offset);
+        });
+
+        // Concatenate sorted belts and non-belt buildings
+        sortedBpBelts.Reverse();
+        blueprintData.buildings = [.. bpBuildings.Select(b => b.building), .. sortedBpBelts];
+        var buildings = blueprintData.buildings;
+
+        for (var i = buildings.Length - 1; i >= 0; i--)
+        {
+            buildings[i].index = i;
+        }
+    }
+}

UXAssist/Functions/PlanetFunctions.cs

@@ -93,6 +93,28 @@ public static class PlanetFunctions
             planet.audio?.RemoveAudioData(ed.audioId);
         }
 
+        var hives = GameMain.spaceSector?.dfHives;
+        if (hives != null)
+        {
+            var hive = hives[planet.star.index];
+            var relays = hive?.relays?.buffer;
+            if (relays != null)
+            {
+                var astroId = planet.astroId;
+                for (var i = relays.Length - 1; i >= 0; i--)
+                {
+                    var relay = relays[i];
+                    if (relay == null || relay.id != i) continue;
+                    if (relay.targetAstroId != astroId && relay.searchAstroId != astroId) continue;
+                    relay.targetAstroId = 0;
+                    relay.searchAstroId = 0;
+                    if (relay.baseId > 0)
+                        hive.relayNeutralizedCounter++;
+                    relay.LeaveBase();
+                }
+            }
+        }
+
         if (planet.factory.enemyPool != null)
         {
             for (var i = planet.factory.enemyCursor - 1; i > 0; i--)
@@ -102,7 +124,7 @@ public static class PlanetFunctions
                 var combatStatId = enemyData.combatStatId;
                 planet.factory.skillSystem.OnRemovingSkillTarget(combatStatId, planet.factory.skillSystem.combatStats.buffer[combatStatId].originAstroId, ETargetType.CombatStat);
                 planet.factory.skillSystem.combatStats.Remove(combatStatId);
-                planet.factory.KillEnemyFinally(player, i, ref CombatStat.empty);
+                planet.factory.KillEnemyFinally(i, ref CombatStat.empty);
             }
             planet.factory.enemySystem.Free();
             UIRoot.instance.uiGame.dfAssaultTip.ClearAllSpots();
@@ -121,6 +143,7 @@ public static class PlanetFunctions
             }
         }
 
+        var planetId = planet.id;
         var gameScenario = GameMain.gameScenario;
         if (gameScenario != null)
         {
@@ -131,8 +154,8 @@ public static class PlanetFunctions
                 {
                     if (pgc.id <= 0) continue;
                     int protoId = factory.entityPool[pgc.entityId].protoId;
-                    gameScenario.achievementLogic.NotifyBeforeDismantleEntity(planet.id, protoId, pgc.entityId);
+                    gameScenario.achievementLogic.NotifyBeforeDismantleEntity(planetId, protoId, pgc.entityId);
-                    gameScenario.NotifyOnDismantleEntity(planet.id, protoId, pgc.entityId);
+                    gameScenario.NotifyOnDismantleEntity(planetId, protoId, pgc.entityId);
                 }
             }
         }
@@ -146,10 +169,23 @@ public static class PlanetFunctions
         var index = factory.index;
         var warningSystem = GameMain.data.warningSystem;
         var warningPool = warningSystem.warningPool;
-        for (var i = warningSystem.warningCursor - 1; i > 0; i--)
+        for (var i = warningSystem.warningCursor - 1; i >= 0; i--)
         {
-            if (warningPool[i].id == i && warningPool[i].factoryId == index)
+            ref var warning = ref warningPool[i];
-                warningSystem.RemoveWarningData(warningPool[i].id);
+            if (warning.id != i) continue;
+            switch (warning.factoryId)
+            {
+                case -4:
+                    if (warning.astroId == planetId)
+                        warningSystem.RemoveWarningData(i);
+                    break;
+                case >= 0:
+                    if (warning.factoryId == index)
+                        warningSystem.RemoveWarningData(i);
+                    break;
+                default:
+                    break;
+            }
         }
         var isCombatMode = factory.gameData.gameDesc.isCombatMode;
         factory.entityCursor = 1;

UXAssist/Functions/TechFunctions.cs

@@ -0,0 +1,313 @@
+namespace UXAssist.Functions;
+
+using System;
+using System.Collections.Generic;
+using Common;
+using UnityEngine;
+
+public static class TechFunctions
+{
+    public static void Init()
+    {
+        I18N.Add("Do you want to use metadata to buyout the following tech?", "Do you want to use metadata to buyout the following tech?", "要使用元数据买断以下科技吗？");
+        I18N.Add("The following is the required metadata for buyout:", "The following is the required metadata for buyout:", "以下是买断所需元数据：");
+        I18N.Add("Batch buyout tech", "Batch buyout tech", "批量买断科技");
+    }
+
+    public static void GenerateTechListWithPrerequisites(GameHistoryData history, int techId, List<int> techIdList)
+    {
+        var techProto = LDB.techs.Select(techId);
+        if (techProto == null || !techProto.Published) return;
+        var flag = true;
+        for (var i = 0; i < 2; i++)
+        {
+            foreach (var preTechId in (i == 1 ? techProto.PreTechsImplicit : techProto.PreTechs))
+            {
+                if (!history.techStates.ContainsKey(preTechId) || history.techStates[preTechId].unlocked) continue;
+                if (history.techStates[preTechId].maxLevel > history.techStates[preTechId].curLevel)
+                {
+                    flag = false;
+                }
+                GenerateTechListWithPrerequisites(history, preTechId, techIdList);
+            }
+        }
+        if (history.techStates.ContainsKey(techId) && !history.techStates[techId].unlocked && flag)
+        {
+            techIdList.Add(techId);
+        }
+    }
+
+    private static void CheckTechUnlockProperties(GameHistoryData history, TechProto techProto, SortedList<int, int> properties, List<Tuple<TechProto, int, int>> techList, int maxLevel = 10000, bool withPrerequisites = true)
+    {
+        var techStates = history.techStates;
+        var techID = techProto.ID;
+        if (techStates == null || !techStates.TryGetValue(techID, out var value)) return;
+        if (value.unlocked) return;
+
+        var maxLvl = Math.Min(maxLevel < 0 ? value.curLevel - maxLevel - 1 : maxLevel, value.maxLevel);
+        if (withPrerequisites)
+        {
+            foreach (var preid in techProto.PreTechs)
+            {
+                var preProto = LDB.techs.Select(preid);
+                if (preProto != null)
+                    CheckTechUnlockProperties(history, preProto, properties, techList, techProto.PreTechsMax ? 10000 : preProto.Level, true);
+            }
+            foreach (var preid in techProto.PreTechsImplicit)
+            {
+                var preProto = LDB.techs.Select(preid);
+                if (preProto != null)
+                    CheckTechUnlockProperties(history, preProto, properties, techList, techProto.PreTechsMax ? 10000 : preProto.Level, true);
+            }
+        }
+
+        if (value.curLevel < techProto.Level) value.curLevel = techProto.Level;
+        techList.Add(new Tuple<TechProto, int, int>(techProto, value.curLevel, techProto.Level));
+        while (value.curLevel <= maxLvl)
+        {
+            if (techProto.PropertyOverrideItemArray != null)
+            {
+                var propertyOverrideItemArray = techProto.PropertyOverrideItemArray;
+                for (var i = 0; i < propertyOverrideItemArray.Length; i++)
+                {
+                    var id = propertyOverrideItemArray[i].id;
+                    var count = (float)propertyOverrideItemArray[i].count;
+                    var ratio = Mathf.Clamp01((float)((double)value.hashUploaded / value.hashNeeded));
+                    var consume = Mathf.CeilToInt(count * (1f - ratio));
+                    if (properties.TryGetValue(id, out var existingCount))
+                        properties[id] = existingCount + consume;
+                    else
+                        properties.Add(id, consume);
+                }
+            }
+            else
+            {
+                for (var i = 0; i < techProto.itemArray.Length; i++)
+                {
+                    var id = techProto.itemArray[i].ID;
+                    var consume = (int)(techProto.ItemPoints[i] * (value.hashNeeded - value.hashUploaded) / 3600L);
+                    if (properties.TryGetValue(id, out var existingCount))
+                        properties[id] = existingCount + consume;
+                    else
+                        properties.Add(id, consume);
+                }
+            }
+            value.curLevel++;
+            value.hashUploaded = 0;
+            value.hashNeeded = techProto.GetHashNeeded(value.curLevel);
+        }
+    }
+
+    private static int UnlockTechImpl(GameHistoryData history, TechProto techProto, int maxLevel = 10000, bool withPrerequisites = true)
+    {
+        var techStates = history.techStates;
+        var techID = techProto.ID;
+        if (techStates == null || !techStates.TryGetValue(techID, out var value))
+        {
+            return -1;
+        }
+
+        if (value.unlocked)
+        {
+            return -1;
+        }
+
+        var maxLvl = Math.Min(maxLevel < 0 ? value.curLevel - maxLevel - 1 : maxLevel, value.maxLevel);
+
+        if (withPrerequisites)
+        {
+            foreach (var preid in techProto.PreTechs)
+            {
+                var preProto = LDB.techs.Select(preid);
+                if (preProto != null)
+                    UnlockTechImpl(history, preProto, techProto.PreTechsMax ? 10000 : preProto.Level, true);
+            }
+            foreach (var preid in techProto.PreTechsImplicit)
+            {
+                var preProto = LDB.techs.Select(preid);
+                if (preProto != null)
+                    UnlockTechImpl(history, preProto, techProto.PreTechsMax ? 10000 : preProto.Level, true);
+            }
+        }
+
+        if (value.curLevel < techProto.Level) value.curLevel = techProto.Level;
+        while (value.curLevel <= maxLvl)
+        {
+            if (value.curLevel == 0)
+            {
+                foreach (var recipe in techProto.UnlockRecipes)
+                {
+                    history.UnlockRecipe(recipe);
+                }
+            }
+
+            for (var j = 0; j < techProto.UnlockFunctions.Length; j++)
+            {
+                history.UnlockTechFunction(techProto.UnlockFunctions[j], techProto.UnlockValues[j], value.curLevel);
+            }
+
+            for (var k = 0; k < techProto.AddItems.Length; k++)
+            {
+                history.GainTechAwards(techProto.AddItems[k], techProto.AddItemCounts[k]);
+            }
+
+            value.curLevel++;
+        }
+
+        value.unlocked = maxLvl >= value.maxLevel;
+        value.curLevel = value.unlocked ? maxLvl : maxLvl + 1;
+        value.hashNeeded = techProto.GetHashNeeded(value.curLevel);
+        value.hashUploaded = value.unlocked ? value.hashNeeded : 0;
+        techStates[techID] = value;
+        return maxLvl;
+    }
+
+    private static bool UnlockTechImmediately(TechProto techProto, int maxLevel = 10000, bool withPrerequisites = true)
+    {
+        if (techProto == null) return false;
+        var history = GameMain.history;
+        var ulvl = UnlockTechImpl(history, techProto, maxLevel, withPrerequisites);
+        if (ulvl < 0) return false;
+        history.RegFeatureKey(1000100);
+        history.NotifyTechUnlock(techProto.ID, ulvl);
+        return true;
+    }
+
+    public static void UnlockAllProtoWithMetadataAndPrompt()
+    {
+        var history = GameMain.history;
+        List<TechProto> techProtos = [];
+        foreach (var techProto in LDB.techs.dataArray)
+        {
+            if (techProto.Published && !techProto.IsObsolete && !techProto.IsHiddenTech && !history.TechUnlocked(techProto.ID) && (techProto.MaxLevel <= techProto.Level || techProto.MaxLevel <= 16) && (techProto.ID is (< 3301 or > 3309) and (< 3601 or > 3609) and (< 3901 or > 3909)) && techProto.ID != 1508)
+            {
+                techProtos.Add(techProto);
+            }
+        }
+        UnlockProtoWithMetadataAndPrompt([.. techProtos], 16, false);
+    }
+
+    public static void UnlockProtoWithMetadataAndPrompt(TechProto[] techProtos, int toLevel, bool withPrerequisites = true)
+    {
+        var techList = new List<Tuple<TechProto, int, int>>();
+        var properties = new SortedList<int, int>();
+        var history = GameMain.history;
+        foreach (var techProto in techProtos)
+        {
+            CheckTechUnlockProperties(history, techProto, properties, techList, toLevel, withPrerequisites);
+        }
+        var propertySystem = DSPGame.propertySystem;
+        var clusterSeedKey = history.gameData.GetClusterSeedKey();
+        var enough = true;
+        foreach (var consumption in properties)
+        {
+            if (propertySystem.GetItemAvaliableProperty(clusterSeedKey, consumption.Key) >= consumption.Value) continue;
+            enough = false;
+            break;
+        }
+        if (!enough)
+        {
+            UIMessageBox.Show("元数据".Translate(), "元数据不足".Translate(), "确定".Translate(), UIMessageBox.ERROR);
+            return;
+        }
+
+        if (!history.hasUsedPropertyBanAchievement)
+        {
+            UIMessageBox.Show("初次使用元数据标题".Translate(), "初次使用元数据描述".Translate(), "取消".Translate(), "确定".Translate(), UIMessageBox.QUESTION, null, DoUnlockCalculatedTechs);
+            return;
+        }
+
+        DoUnlockCalculatedTechs();
+        return;
+
+        void DoUnlockCalculatedTechs()
+        {
+            if (techList.Count <= 1)
+            {
+                UnlockWithPropertiesImmediately();
+                return;
+            }
+            var msg = "Do you want to use metadata to buyout the following tech?".Translate();
+
+            if (techList.Count <= 10)
+            {
+                foreach (var tuple in techList)
+                {
+                    AddToMsg(ref msg, tuple);
+                }
+            }
+            else
+            {
+                for (var i = 0; i < 5; i++)
+                {
+                    AddToMsg(ref msg, techList[i]);
+                }
+                msg += "\n  ...";
+                for (var i = techList.Count - 5; i < techList.Count; i++)
+                {
+                    AddToMsg(ref msg, techList[i]);
+                }
+            }
+
+            msg += "\n\n";
+            msg += "The following is the required metadata for buyout:".Translate();
+            foreach (var consumption in properties)
+            {
+                if (consumption.Value <= 0) continue;
+                msg += $"\n  {LDB.items.Select(consumption.Key).propertyName}x{consumption.Value}";
+            }
+            UIMessageBox.Show("Batch buyout tech".Translate(), msg, "取消".Translate(), "确定".Translate(), UIMessageBox.QUESTION, null, UnlockWithPropertiesImmediately);
+            return;
+
+            void AddToMsg(ref string str, Tuple<TechProto, int, int> tuple)
+            {
+                if (tuple.Item2 == tuple.Item3)
+                {
+                    if (tuple.Item2 <= 0)
+                        str += $"\n  {tuple.Item1.name}";
+                    else
+                        str += $"\n  {tuple.Item1.name}{"杠等级".Translate()}{tuple.Item2}";
+                }
+                else
+                    str += $"\n  {tuple.Item1.name}{"杠等级".Translate()}{tuple.Item2}->{tuple.Item3}";
+            }
+        }
+
+        void UnlockWithPropertiesImmediately()
+        {
+            var mainPlayer = GameMain.mainPlayer;
+            foreach (var consumption in properties)
+            {
+                if (consumption.Value <= 0) continue;
+                propertySystem.AddItemConsumption(clusterSeedKey, consumption.Key, consumption.Value);
+                history.AddPropertyItemConsumption(consumption.Key, consumption.Value, true);
+                mainPlayer.mecha.AddProductionStat(consumption.Key, consumption.Value, mainPlayer.nearestFactory);
+                mainPlayer.mecha.AddConsumptionStat(consumption.Key, consumption.Value, mainPlayer.nearestFactory);
+            }
+            foreach (var techProto in techProtos)
+            {
+                UnlockTechImmediately(techProto, toLevel, withPrerequisites);
+            }
+            history.VerifyTechQueue();
+            if (history.currentTech != history.techQueue[0])
+            {
+                history.currentTech = history.techQueue[0];
+            }
+        }
+    }
+
+    public static void RemoveCargoStackingTechs()
+    {
+        var history = GameMain.data?.history;
+        if (history == null) return;
+        history.inserterStackCountObsolete = 1;
+        for (var id = 3301; id <= 3305; id++)
+        {
+            history.techStates.TryGetValue(id, out var state);
+            if (!state.unlocked) continue;
+            state.unlocked = false;
+            state.hashUploaded = 0;
+            history.techStates[id] = state;
+        }
+    }
+}

UXAssist/Functions/UIFunctions.cs

@@ -0,0 +1,722 @@
+using CommonAPI.Systems;
+using UnityEngine;
+using UnityEngine.UI;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using UXAssist.UI;
+using UXAssist.Common;
+using GameLogicProc = UXAssist.Common.GameLogic;
+
+namespace UXAssist.Functions;
+
+public static class UIFunctions
+{
+    private static bool _initialized;
+    private static PressKeyBind _toggleKey;
+    private static bool _configWinInitialized;
+    private static MyConfigWindow _configWin;
+    private static GameObject _buttonOnPlanetGlobe;
+
+    public static void Init()
+    {
+        _toggleKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
+        {
+            key = new CombineKey((int)KeyCode.BackQuote, CombineKey.ALT_COMB, ECombineKeyAction.OnceClick, false),
+            conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
+            name = "OpenUXAssistConfigWindow",
+            canOverride = true
+        });
+        I18N.Add("KEYOpenUXAssistConfigWindow", "[UXA] Open UXAssist Config Window", "[UXA] 打开UX助手设置面板");
+
+        I18N.Add("Enable auto-cruise", "Enable auto-cruise", "启用自动巡航");
+        I18N.Add("Disable auto-cruise", "Disable auto-cruise", "禁用自动巡航");
+        I18N.Add("High yield", "High yield", "高产");
+        I18N.Add("Perfect", "Perfect", "完美");
+        I18N.Add("Union results", "Union results", "结果取并集");
+        I18N.Add("All 6 Basic Ores", "All 6 Basic Ores", "六种基础矿物齐全");
+        I18N.Add("Show original name", "Show original name", "显示原始名称");
+        I18N.Add("Show distance", "Show distance", "显示距离");
+        I18N.Add("Show planet count", "Show planet count", "显示行星数");
+        I18N.Add("Show all information", "Show all information", "显示全部信息");
+        I18N.OnInitialized += RecreateConfigWindow;
+    }
+
+    public static void OnInputUpdate()
+    {
+        if (_toggleKey.keyValue)
+        {
+            ToggleConfigWindow();
+        }
+    }
+
+    #region ConfigWindow
+    public static void ToggleConfigWindow()
+    {
+        if (!_configWinInitialized)
+        {
+            if (!I18N.Initialized()) return;
+            _configWinInitialized = true;
+            _configWin = MyConfigWindow.CreateInstance();
+        }
+
+        if (_configWin.active)
+        {
+            _configWin._Close();
+        }
+        else
+        {
+            _configWin.Open();
+        }
+    }
+
+    public static void InitMenuButtons()
+    {
+        if (_initialized) return;
+        var uiRoot = UIRoot.instance;
+        if (!uiRoot) return;
+        {
+            var mainMenu = uiRoot.uiMainMenu;
+            var src = mainMenu.newGameButton;
+            var parent = src.transform.parent;
+            var btn = GameObject.Instantiate(src, parent);
+            btn.name = "button-uxassist-config";
+            var l = btn.text.GetComponent<Localizer>();
+            if (l != null)
+            {
+                l.stringKey = "UXAssist Config";
+                l.translation = "UXAssist Config".Translate();
+            }
+
+            btn.text.text = "UXAssist Config".Translate();
+            btn.text.fontSize = btn.text.fontSize * 7 / 8;
+            I18N.OnInitialized += () => { btn.text.text = "UXAssist Config".Translate(); };
+            var vec = ((RectTransform)mainMenu.exitButton.transform).anchoredPosition3D;
+            var vec2 = ((RectTransform)mainMenu.creditsButton.transform).anchoredPosition3D;
+            var transform1 = (RectTransform)btn.transform;
+            transform1.anchoredPosition3D = new Vector3(vec.x, vec.y + (vec.y - vec2.y) * 2, vec.z);
+            btn.button.onClick.RemoveAllListeners();
+            btn.button.onClick.AddListener(Functions.UIFunctions.ToggleConfigWindow);
+        }
+        {
+            var panel = uiRoot.uiGame.planetGlobe;
+            var src = panel.button2;
+            var sandboxMenu = uiRoot.uiGame.sandboxMenu;
+            var icon = sandboxMenu.categoryButtons[6].transform.Find("icon")?.GetComponent<Image>()?.sprite;
+            var b = GameObject.Instantiate(src, src.transform.parent);
+            _buttonOnPlanetGlobe = b.gameObject;
+            var rect = (RectTransform)_buttonOnPlanetGlobe.transform;
+            var btn = _buttonOnPlanetGlobe.GetComponent<UIButton>();
+            var img = _buttonOnPlanetGlobe.transform.Find("button-2/icon")?.GetComponent<Image>();
+            if (img != null)
+            {
+                img.sprite = icon;
+            }
+
+            if (_buttonOnPlanetGlobe != null && btn != null)
+            {
+                _buttonOnPlanetGlobe.name = "open-uxassist-config";
+                rect.localScale = new Vector3(0.6f, 0.6f, 0.6f);
+                rect.anchoredPosition3D = new Vector3(64f, -5f, 0f);
+                b.onClick.RemoveAllListeners();
+                btn.onClick += _ => { Functions.UIFunctions.ToggleConfigWindow(); };
+                btn.tips.tipTitle = "UXAssist Config";
+                I18N.OnInitialized += () => { btn.tips.tipTitle = "UXAssist Config".Translate(); };
+                btn.tips.tipText = null;
+                btn.tips.corner = 9;
+                btn.tips.offset = new Vector2(-20f, -20f);
+                _buttonOnPlanetGlobe.SetActive(true);
+            }
+        }
+        InitToggleAutoCruiseCheckButton();
+        InitStarmapButtons();
+        _initialized = true;
+    }
+
+    public static void RecreateConfigWindow()
+    {
+        if (!_configWinInitialized) return;
+        var wasActive = _configWin.active;
+        if (wasActive) _configWin._Close();
+        MyConfigWindow.DestroyInstance(_configWin);
+        _configWinInitialized = false;
+        if (wasActive) ToggleConfigWindow();
+    }
+
+    public static void UpdateGlobeButtonPosition(UIPlanetGlobe planetGlobe)
+    {
+        if (_buttonOnPlanetGlobe == null) return;
+        var rect = (RectTransform)_buttonOnPlanetGlobe.transform;
+        if (planetGlobe.dysonSphereSystemUnlocked || planetGlobe.logisticsSystemUnlocked)
+        {
+            rect.anchoredPosition3D = new Vector3(64f, -5f, 0f);
+        }
+        else
+        {
+            rect.anchoredPosition3D = new Vector3(128f, -100f, 0f);
+        }
+    }
+    #endregion
+
+    #region ToggleAutoCruiseCheckButton
+    public static UI.MyCheckButton ToggleAutoCruise;
+
+    public static void InitToggleAutoCruiseCheckButton()
+    {
+        var lowGroup = GameObject.Find("UI Root/Overlay Canvas/In Game/Low Group");
+        ToggleAutoCruise = MyCheckButton.CreateCheckButton(0, 0, lowGroup.GetComponent<RectTransform>(), Patches.PlayerPatch.AutoCruiseEnabled).WithSize(120f, 40f);
+        UpdateToggleAutoCruiseCheckButtonVisiblility();
+        ToggleAutoCruiseChecked();
+        ToggleAutoCruise.OnChecked += ToggleAutoCruiseChecked;
+        var rectTrans = ToggleAutoCruise.rectTrans;
+        rectTrans.anchorMax = new Vector2(0.5f, 0f);
+        rectTrans.anchorMin = new Vector2(0.5f, 0f);
+        rectTrans.pivot = new Vector2(0.5f, 0f);
+        rectTrans.anchoredPosition3D = new Vector3(0f, 185f, 0f);
+        static void ToggleAutoCruiseChecked()
+        {
+            if (ToggleAutoCruise.Checked)
+            {
+                ToggleAutoCruise.SetLabelText("Disable auto-cruise");
+            }
+            else
+            {
+                ToggleAutoCruise.SetLabelText("Enable auto-cruise");
+            }
+        }
+    }
+
+    public static void UpdateToggleAutoCruiseCheckButtonVisiblility()
+    {
+        if (ToggleAutoCruise == null) return;
+        var active = Patches.PlayerPatch.AutoNavigationEnabled.Value && Patches.PlayerPatch.AutoNavigation.IndicatorAstroId > 0;
+        ToggleAutoCruise.gameObject.SetActive(active);
+    }
+    #endregion
+
+    #region StarMapButtons
+    private static int _cornerComboBoxIndex;
+    private static string[] _starOrderNames;
+    private static bool _starmapFilterInitialized;
+    private static ulong[] _starmapStarFilterValues;
+    private static bool _starFilterEnabled;
+    public static UI.MyCheckButton StarmapFilterToggler;
+    public static bool[] ShowStarName;
+
+    private static readonly Sprite[] PlanetIcons = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/07.png"),
+        null,
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/09.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/10.png"),
+        null,
+        null,
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/13.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/14.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/15.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/16.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/17.png"),
+        null,
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/19.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/20.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/21.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/22.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/23.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/24.png"),
+        Common.Util.LoadEmbeddedSprite("assets/planet_icon/25.png")
+    ];
+
+    private static readonly (int, int)[] FilterVeinIds = [(9, 0), (10, 0), (11, 0), (12, 0), (13, 0), (14, 0), (7, 0), (0, 1116), (0, 1000), (8, 1011), (0, 1120), (0, 1121)];
+    private static readonly int[] FilterPlanetThemes = [16, 23, 15, 22, 25, 21, 14, 17, 19, 7, 10, 20, 24, 9, 13];
+    private static readonly Dictionary<int, int> ItemToVeinBitFlagMap = new()
+    {
+        {1011, 8},
+        {1120, 20},
+        {1121, 21},
+        {1116, 22},
+        {1000, 23},
+    };
+
+    public static void InitStarmapButtons()
+    {
+        var uiRoot = UIRoot.instance;
+        if (!uiRoot) return;
+
+        var rect = uiRoot.uiGame.starmap.transform as RectTransform;
+        var panel = new GameObject("uxassist-starmap-panel");
+        var rtrans = panel.AddComponent<RectTransform>();
+        panel.transform.SetParent(rect);
+        rtrans.sizeDelta = new Vector2(0f, 0f);
+        rtrans.localScale = new Vector3(1f, 1f, 1f);
+        rtrans.anchorMax = new Vector2(1f, 1f);
+        rtrans.anchorMin = new Vector2(0f, 0f);
+        rtrans.pivot = new Vector2(0f, 1f);
+        rtrans.anchoredPosition3D = new Vector3(0, 0, 0f);
+
+        var cornerComboBox = UI.MyCornerComboBox.CreateComboBox(135, 0, rtrans, true).WithItems("Show original name".Translate(), "Show distance".Translate(), "Show planet count".Translate(), "Show all information".Translate());
+        cornerComboBox.SetIndex(Functions.UIFunctions.CornerComboBoxIndex);
+        cornerComboBox.OnSelChanged += (index) =>
+        {
+            Functions.UIFunctions.CornerComboBoxIndex = index;
+        };
+        StarmapFilterToggler = UI.MyCheckButton.CreateCheckButton(0, 0, rtrans, false, ">>").WithSize(24, 24);
+        MyCheckButton[] buttons = [
+            UI.MyCheckButton.CreateCheckButton(24, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Kimberlite
+            UI.MyCheckButton.CreateCheckButton(48, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Fractal Silicon
+            UI.MyCheckButton.CreateCheckButton(72, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Organic Crystal
+            UI.MyCheckButton.CreateCheckButton(96, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Grating Crystal
+            UI.MyCheckButton.CreateCheckButton(120, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Stalagmite Crystal
+            UI.MyCheckButton.CreateCheckButton(144, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Unipolar Magnet
+            UI.MyCheckButton.CreateCheckButton(168, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Crude Oil
+            UI.MyCheckButton.CreateCheckButton(192, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Fire Ice
+            UI.MyCheckButton.CreateCheckButton(216, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Sulfuric Acid
+            UI.MyCheckButton.CreateCheckButton(240, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Water
+            UI.MyCheckButton.CreateCheckButton(264, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Hydrogen
+            UI.MyCheckButton.CreateCheckButton(288, 0, rtrans, false).WithIcon().WithSize(24, 24).WithIconWidth(24), // Deuterium
+
+            UI.MyCheckButton.CreateCheckButton(24, 24, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 48, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 72, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 96, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 120, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 144, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 168, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+
+            UI.MyCheckButton.CreateCheckButton(24, 210, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 234, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 258, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 282, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 306, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 330, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 354, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+            UI.MyCheckButton.CreateCheckButton(24, 378, rtrans, false).WithIcon().WithSize(150, 24).WithIconWidth(24),
+        ];
+        var unionCheckBox = UI.MyCheckBox.CreateCheckBox(312, 0, rtrans, false, "Union results".Translate(), 15).WithSmallerBox(24f);
+        unionCheckBox.gameObject.SetActive(false);
+        unionCheckBox.OnChecked += () =>
+        {
+            UpdateStarmapStarFilters();
+        };
+        var allOresText = MyWindow.AddText(20, 190, rtrans, "All 6 Basic Ores".Translate(), 12);
+        allOresText.gameObject.SetActive(false);
+        StarmapFilterToggler.OnChecked += UpdateButtons;
+        foreach (var button in buttons)
+        {
+            button.OnChecked += () =>
+            {
+                if (button.Checked && !VFInput.shift && !VFInput.control)
+                {
+                    foreach (var b in buttons)
+                    {
+                        if (b != button) b.Checked = false;
+                    }
+                }
+                UpdateStarmapStarFilters();
+            };
+        }
+
+        I18N.OnInitialized += UpdateI18N;
+        GameLogicProc.OnDataLoaded += () =>
+        {
+            VeinProto veinProto;
+            ItemProto itemProto;
+            for (int i = 0; i < 12; i++)
+            {
+                var (veinProtoId, itemProtoId) = FilterVeinIds[i];
+                if (itemProtoId != 0)
+                {
+                    itemProto = LDB.items.Select(itemProtoId);
+                    buttons[i].SetIcon(itemProto.iconSprite);
+                }
+                else if (veinProtoId != 0)
+                {
+                    veinProto = LDB.veins.Select(veinProtoId);
+                    buttons[i].SetIcon(veinProto.iconSprite);
+                }
+            }
+
+            for (int i = 0; i < FilterPlanetThemes.Length; i++)
+            {
+                buttons[12 + i].SetIcon(PlanetIcons[FilterPlanetThemes[i]]);
+            }
+            UpdateI18N();
+        };
+
+        GameLogicProc.OnGameBegin += () =>
+        {
+            if (DSPGame.IsMenuDemo) return;
+
+            var galaxy = GameMain.data.galaxy;
+            ShowStarName = new bool[galaxy.starCount];
+            _starOrderNames = new string[galaxy.starCount];
+            _starmapStarFilterValues = new ulong[galaxy.starCount];
+            StarData[] stars = [.. galaxy.stars.Where(star => star != null)];
+            Array.Sort(stars, (a, b) =>
+            {
+                int res = a.position.sqrMagnitude.CompareTo(b.position.sqrMagnitude);
+                if (res != 0) return res;
+                return a.index.CompareTo(b.index);
+            });
+            for (int i = 0; i < stars.Length; i++)
+            {
+                var star = stars[i];
+                _starOrderNames[star.index] = star.displayName;
+            }
+            int[] spectrCount = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+            for (int i = 0; i < stars.Length; i++)
+            {
+                var star = stars[i];
+                var index = star.index;
+                switch (star.type)
+                {
+                    case EStarType.MainSeqStar:
+                        switch (star.spectr)
+                        {
+                            case ESpectrType.M:
+                                _starOrderNames[index] = String.Format("M{0}", ++spectrCount[0]);
+                                break;
+                            case ESpectrType.K:
+                                _starOrderNames[index] = String.Format("K{0}", ++spectrCount[1]);
+                                break;
+                            case ESpectrType.G:
+                                _starOrderNames[index] = String.Format("G{0}", ++spectrCount[2]);
+                                break;
+                            case ESpectrType.F:
+                                _starOrderNames[index] = String.Format("F{0}", ++spectrCount[3]);
+                                break;
+                            case ESpectrType.A:
+                                _starOrderNames[index] = String.Format("A{0}", ++spectrCount[4]);
+                                break;
+                            case ESpectrType.B:
+                                _starOrderNames[index] = String.Format("B{0}", ++spectrCount[5]);
+                                break;
+                            case ESpectrType.O:
+                                _starOrderNames[index] = String.Format("O{0}", ++spectrCount[6]);
+                                break;
+                        }
+                        break;
+                    case EStarType.GiantStar:
+                        _starOrderNames[index] = String.Format("GS{0}", ++spectrCount[7]);
+                        break;
+                    case EStarType.WhiteDwarf:
+                        _starOrderNames[index] = String.Format("WD{0}", ++spectrCount[8]);
+                        break;
+                    case EStarType.NeutronStar:
+                        _starOrderNames[index] = String.Format("NS{0}", ++spectrCount[9]);
+                        break;
+                    case EStarType.BlackHole:
+                        _starOrderNames[index] = String.Format("BH{0}", ++spectrCount[10]);
+                        break;
+                }
+            }
+            StarmapFilterToggler.gameObject.SetActive(false);
+            StarmapFilterToggler.Checked = false;
+            UpdateButtons();
+            SetStarFilterEnabled(false);
+            foreach (var star in galaxy.stars)
+            {
+                if (star != null) PlanetModelingManager.RequestScanStar(star);
+            }
+            _starmapFilterInitialized = true;
+            if (PlanetModelingManager.scnPlanetReqList.Count == 0)
+            {
+                OnPlanetScanEnded();
+            }
+        };
+        GameLogicProc.OnGameEnd += () =>
+        {
+            _starOrderNames = null;
+            ShowStarName = null;
+            _starmapStarFilterValues = null;
+            _starmapFilterInitialized = false;
+        };
+        void UpdateI18N()
+        {
+            if (cornerComboBox != null)
+            {
+                var items = cornerComboBox.Items;
+                cornerComboBox.UpdateLabelText();
+                items[0] = "Show original name".Translate();
+                items[1] = "Show distance".Translate();
+                items[2] = "Show planet count".Translate();
+                items[3] = "Show all information".Translate();
+            }
+            if (buttons != null)
+            {
+                VeinProto veinProto;
+                ItemProto itemProto;
+                for (int i = 0; i < 12; i++)
+                {
+                    var (veinProtoId, itemProtoId) = FilterVeinIds[i];
+                    if (itemProtoId != 0)
+                    {
+                        itemProto = LDB.items.Select(itemProtoId);
+                        buttons[i].WithTip(itemProto.Name);
+                    }
+                    else if (veinProtoId != 0)
+                    {
+                        veinProto = LDB.veins.Select(veinProtoId);
+                        buttons[i].WithTip(veinProto.Name);
+                    }
+                }
+                for (int i = 0; i < FilterPlanetThemes.Length; i++)
+                {
+                    var theme = FilterPlanetThemes[i];
+                    var themeProto = LDB.themes.Select(theme);
+                    switch (i)
+                    {
+                        case 5:
+                            buttons[12 + i].SetLabelText($"{themeProto.DisplayName.Translate()} ({"High yield".Translate()})");
+                            break;
+                        case 6:
+                            buttons[12 + i].SetLabelText($"{themeProto.DisplayName.Translate()} ({"Perfect".Translate()})");
+                            break;
+                        default:
+                            buttons[12 + i].SetLabelText(themeProto.DisplayName.Translate());
+                            break;
+                    }
+                }
+            }
+            if (allOresText != null) allOresText.text = "All 6 Basic Ores".Translate();
+        }
+        void UpdateButtons()
+        {
+            var chk = StarmapFilterToggler.Checked;
+            foreach (var button in buttons)
+            {
+                if (chk)
+                    button.gameObject.SetActive(true);
+                else
+                {
+                    button.gameObject.SetActive(false);
+                    button.Checked = false;
+                }
+            }
+            unionCheckBox.gameObject.SetActive(chk);
+            allOresText.gameObject.SetActive(chk);
+            StarmapFilterToggler.SetLabelText(chk ? "X" : ">>");
+            if (!chk)
+            {
+                UpdateStarmapStarFilters();
+            }
+            UIRoot.instance.uiGame.dfMonitor.transform.parent.gameObject.SetActive(!chk);
+        }
+        void UpdateStarmapStarFilters()
+        {
+            var filterValue = 0UL;
+            var union = unionCheckBox.Checked;
+            if (StarmapFilterToggler.Checked)
+            {
+                for (int i = 0; i < 12; i++)
+                {
+                    if (buttons[i].Checked)
+                    {
+                        var (veinProtoId, itemProtoId) = FilterVeinIds[i];
+                        if (veinProtoId != 0)
+                        {
+                            filterValue |= 1UL << veinProtoId;
+                        }
+                        else if (itemProtoId != 0)
+                        {
+                            filterValue |= 1UL << ItemToVeinBitFlagMap[itemProtoId];
+                        }
+                    }
+                }
+                for (int i = 0; i < FilterPlanetThemes.Length; i++)
+                {
+                    if (buttons[12 + i].Checked)
+                    {
+                        filterValue |= 1UL << (30 + FilterPlanetThemes[i]);
+                    }
+                }
+            }
+            if (filterValue == 0UL)
+            {
+                for (int i = 0; i < ShowStarName.Length; i++)
+                {
+                    ShowStarName[i] = false;
+                }
+                SetStarFilterEnabled(false);
+                return;
+            }
+            for (int i = _starmapStarFilterValues.Length - 1; i >= 0; i--)
+            {
+                ShowStarName[i] = union ? (_starmapStarFilterValues[i] & filterValue) != 0 : (_starmapStarFilterValues[i] & filterValue) == filterValue;
+            }
+            SetStarFilterEnabled(true);
+        }
+    }
+
+    public static void OnPlanetScanEnded()
+    {
+        if (!_starmapFilterInitialized || StarmapFilterToggler == null || StarmapFilterToggler.gameObject.activeSelf) return;
+        StarmapUpdateFilterValues();
+        StarmapFilterToggler.gameObject.SetActive(true);
+    }
+
+    private static void StarmapUpdateFilterValues()
+    {
+        var galaxy = GameMain.data.galaxy;
+        var stars = galaxy.stars;
+        for (int i = 0; i < galaxy.starCount; i++)
+        {
+            var star = stars[i];
+            if (star == null) continue;
+            var value = 0UL;
+            foreach (var planet in star.planets)
+            {
+                if (planet == null) continue;
+                if (!planet.scanned)
+                {
+                    PlanetModelingManager.RequestScanPlanet(planet);
+                    continue;
+                }
+                var planetValue = 0UL;
+                if (planet.type == EPlanetType.Gas)
+                {
+                    foreach (var n in planet.gasItems)
+                    {
+                        if (ItemToVeinBitFlagMap.TryGetValue(n, out var bitFlag))
+                        {
+                            planetValue |= 1UL << bitFlag;
+                        }
+                    }
+                }
+                else
+                {
+                    if (planet.runtimeVeinGroups != null)
+                    {
+                        foreach (var group in planet.runtimeVeinGroups)
+                        {
+                            if (group.amount > 0)
+                            {
+                                planetValue |= 1UL << (int)group.type;
+                            }
+                        }
+                    }
+                    if (ItemToVeinBitFlagMap.TryGetValue(planet.waterItemId, out var bitFlag))
+                    {
+                        planetValue |= 1UL << bitFlag;
+                    }
+                }
+                if ((value & (1UL << (30 + planet.theme))) == 0)
+                {
+                    switch (planet.theme)
+                    {
+                        case 7:
+                        case 9:
+                        case 10:
+                        case 13:
+                        case 17:
+                        case 19:
+                        case 20:
+                        case 24:
+                            {
+                                const ulong needed = 0x7EUL;
+                                if ((planetValue & needed) == needed)
+                                {
+                                    value |= 1UL << (30 + planet.theme);
+                                }
+                                break;
+                            }
+                        case 14:
+                            {
+                                const ulong needed = 0x2200UL;
+                                if ((planetValue & needed) == needed)
+                                {
+                                    value |= 1UL << (30 + planet.theme);
+                                }
+                                break;
+                            }
+                        case 15:
+                        case 16:
+                        case 21:
+                        case 22:
+                        case 23:
+                        case 25:
+                            value |= 1UL << (30 + planet.theme);
+                            break;
+                    }
+                }
+                value |= planetValue;
+            }
+            _starmapStarFilterValues[i] = value;
+        }
+    }
+
+    public static int CornerComboBoxIndex
+    {
+        get => _cornerComboBoxIndex;
+        set
+        {
+            _cornerComboBoxIndex = value;
+            Patches.PlayerPatch.ShortcutKeysForStarsName.ForceShowAllStarsNameExternal = _cornerComboBoxIndex != 0 && !_starFilterEnabled;
+            UpdateStarmapStarNames();
+        }
+    }
+
+    private static void SetStarFilterEnabled(bool enabled)
+    {
+        if (_starFilterEnabled == enabled) return;
+        _starFilterEnabled = enabled;
+        if (!enabled) Patches.PlayerPatch.ShortcutKeysForStarsName.ShowAllStarsNameStatus = 0;
+        Patches.PlayerPatch.ShortcutKeysForStarsName.ForceShowAllStarsNameExternal = _cornerComboBoxIndex != 0 && !_starFilterEnabled;
+        UpdateStarmapStarNames();
+    }
+
+    private static void UpdateStarmapStarNames()
+    {
+        foreach (var starUI in UIRoot.instance.uiGame.starmap.starUIs)
+        {
+            var star = starUI?.star;
+            if (star == null) continue;
+            switch (_cornerComboBoxIndex)
+            {
+                case 1:
+                    starUI.nameText.text = String.Format("{0:00}-{1}-{2:0.00}", star.index + 1, _starOrderNames[star.index], GetStarDist(star));
+                    break;
+                case 2:
+                    {
+                        var (nongas, total) = GetStarPlanetCount(star);
+                        starUI.nameText.text = String.Format("{0:00}-{1}-{2}-{3}", star.index + 1, _starOrderNames[star.index], nongas, total);
+                        break;
+                    }
+                case 3:
+                    {
+                        var (nongas, total) = GetStarPlanetCount(star);
+                        starUI.nameText.text = String.Format("{0:00}-{1}-{2:0.00}-{3}-{4}", star.index + 1, _starOrderNames[star.index], GetStarDist(star), nongas, total);
+                        break;
+                    }
+                default:
+                    starUI.nameText.text = star.displayName;
+                    break;
+            }
+        }
+        return;
+
+        double GetStarDist(StarData star)
+        {
+            return star.position.magnitude;
+        }
+
+        (int, int) GetStarPlanetCount(StarData star)
+        {
+            int total = 0;
+            int nongas = 0;
+            foreach (var planet in star.planets)
+            {
+                if (planet == null) continue;
+                if (planet.type != EPlanetType.Gas) nongas++;
+                total++;
+            }
+            return (nongas, total);
+        }
+    }
+    #endregion
+}

UXAssist/Functions/WindowFunctions.cs

@@ -1,14 +1,13 @@
 using System;
 using System.Runtime.InteropServices;
 using BepInEx.Configuration;
-using UnityEngine;
 using UXAssist.Common;
-using UXAssist.Patches;
 
 namespace UXAssist.Functions;
 
 public static class WindowFunctions
 {
+    private static bool _initialized;
     public static string ProfileName { get; private set; }
 
     private const string GameWindowClass = "UnityWndClass";
@@ -17,11 +16,7 @@ public static class WindowFunctions
     private static IntPtr _oldWndProc = IntPtr.Zero;
     private static IntPtr _gameWindowHandle = IntPtr.Zero;
 
-    private static bool _gameLoaded;
-    public static WinApi.LogicalProcessorDetails ProcessorDetails { get; private set; }
-
     public static ConfigEntry<int> ProcessPriority;
-    public static ConfigEntry<int> ProcessAffinity;
 
     private static readonly int[] ProrityFlags =
     [
@@ -34,18 +29,13 @@ public static class WindowFunctions
 
     public static void Init()
     {
-        I18N.Add("Cores: {0}\nThreads: {1}", "Cores: {0}\nThreads: {1}", "核心数: {0}\n线程数: {1}");
+        if (_initialized) return;
-        I18N.Add("\nP-Cores: {0}\nE-Cores: {1}", "\nP-Cores: {0}\nE-Cores: {1}", "\n性能核心: {0}\n能效核心: {1}");
+        _initialized = true;
-        I18N.Add("\nPriority: {0}", "\nProcess priority: {0}", "\n进程优先级: {0}");
-        I18N.Add("\nEnabled CPUs: ", "\nEnabled CPUs: ", "\n使用的CPU: ");
-        I18N.Add("Unknown", "Unknown", "未知");
-        ProcessorDetails = WinApi.GetLogicalProcessorDetails();
         SetWindowTitle();
     }
 
     public static void Start()
     {
-        GameLogic.OnDataLoaded += OnDataLoaded;
         var wndProc = new WinApi.WndProc(GameWndProc);
         var gameWnd = FindGameWindow();
         if (gameWnd != IntPtr.Zero)
@@ -53,52 +43,8 @@ public static class WindowFunctions
             _oldWndProc = WinApi.SetWindowLongPtr(gameWnd, WinApi.GWLP_WNDPROC, Marshal.GetFunctionPointerForDelegate(wndProc));
         }
 
-        if (GamePatch.LoadLastWindowRectEnabled.Value)
-            GamePatch.LoadLastWindowRect.MoveWindowPosition(true);
-
         ProcessPriority.SettingChanged += (_, _) => WinApi.SetPriorityClass(WinApi.GetCurrentProcess(), ProrityFlags[ProcessPriority.Value]);
         WinApi.SetPriorityClass(WinApi.GetCurrentProcess(), ProrityFlags[ProcessPriority.Value]);
-        ProcessAffinity.SettingChanged += (_, _) => UpdateAffinity();
-        UpdateAffinity();
-        return;
-
-        void UpdateAffinity()
-        {
-            var process = WinApi.GetCurrentProcess();
-            if (!WinApi.GetProcessAffinityMask(process, out _, out var systemMask))
-            {
-                systemMask = ulong.MaxValue;
-            }
-
-            switch (ProcessAffinity.Value)
-            {
-                case 0:
-                    WinApi.SetProcessAffinityMask(process, systemMask);
-                    break;
-                case 1:
-                    WinApi.SetProcessAffinityMask(process, systemMask & ((1UL << (ProcessorDetails.ThreadCount / 2)) - 1UL));
-                    break;
-                case 2:
-                    WinApi.SetProcessAffinityMask(process, systemMask & (ProcessorDetails.ThreadCount > 16 ? 0xFFUL : 1UL));
-                    break;
-                case 3:
-                    WinApi.SetProcessAffinityMask(process, systemMask & ProcessorDetails.PerformanceCoreMask);
-                    break;
-                case 4:
-                    WinApi.SetProcessAffinityMask(process, systemMask & ProcessorDetails.EfficiencyCoreMask);
-                    break;
-            }
-        }
-    }
-
-    public static void Uninit()
-    {
-        GameLogic.OnDataLoaded -= OnDataLoaded;
-    }
-
-    private static void OnDataLoaded()
-    {
-        _gameLoaded = true;
     }
 
     private static IntPtr GameWndProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam)
@@ -113,42 +59,6 @@ public static class WindowFunctions
                 {
                     WinApi.SetWindowLongPtr(_gameWindowHandle, WinApi.GWLP_WNDPROC, _oldWndProc);
                 }
-
-                break;
-            case WinApi.WM_SYSCOMMAND:
-                switch ((long)wParam & 0xFFF0L)
-                {
-                    case WinApi.SC_MOVE:
-                        if (GamePatch.LoadLastWindowRectEnabled.Value && !_gameLoaded) return (IntPtr)1L;
-                        break;
-                }
-
-                break;
-            case WinApi.WM_MOVING:
-                if (!GamePatch.LoadLastWindowRectEnabled.Value || _gameLoaded) break;
-                var rect = GamePatch.LastWindowRect.Value;
-                if (rect is { z: 0f, w: 0f }) break;
-                var x = Mathf.RoundToInt(rect.x);
-                var y = Mathf.RoundToInt(rect.y);
-                var rect2 = Marshal.PtrToStructure<WinApi.Rect>(lParam);
-                rect2.Left = x;
-                rect2.Top = y;
-                Marshal.StructureToPtr(rect2, lParam, false);
-                break;
-            case WinApi.WM_SIZING:
-                if (!GamePatch.LoadLastWindowRectEnabled.Value || _gameLoaded) break;
-                rect = GamePatch.LastWindowRect.Value;
-                if (rect is { z: 0f, w: 0f }) break;
-                x = Mathf.RoundToInt(rect.x);
-                y = Mathf.RoundToInt(rect.y);
-                var w = Mathf.RoundToInt(rect.z);
-                var h = Mathf.RoundToInt(rect.w);
-                rect2 = Marshal.PtrToStructure<WinApi.Rect>(lParam);
-                rect2.Left = x;
-                rect2.Top = y;
-                rect2.Right = x + w;
-                rect2.Bottom = y + h;
-                Marshal.StructureToPtr(rect2, lParam, false);
                 break;
         }
 
@@ -168,71 +78,36 @@ public static class WindowFunctions
         };
     }
 
-    public static void ShowCPUInfo()
-    {
-        var details = ProcessorDetails;
-        var msg = string.Format("Cores: {0}\nThreads: {1}".Translate(), details.CoreCount, details.ThreadCount);
-        var hybrid = details.HybridArchitecture;
-        if (hybrid)
-        {
-            msg += string.Format("\nP-Cores: {0}\nE-Cores: {1}".Translate(), details.PerformanceCoreCount, details.EfficiencyCoreCount);
-        }
-
-        var handle = WinApi.GetCurrentProcess();
-        var prio = GetPriorityName(WinApi.GetPriorityClass(handle));
-        msg += string.Format("\nPriority: {0}".Translate(), prio);
-
-        var aff = 0UL;
-        if (WinApi.GetProcessAffinityMask(handle, out var processMask, out var systemMask))
-            aff = processMask & systemMask;
-
-        msg += "\nEnabled CPUs: ".Translate();
-        var first = true;
-        for (var i = 0; aff != 0UL; i++)
-        {
-            if ((aff & 1UL) != 0)
-            {
-                if (first)
-                    first = false;
-                else
-                    msg += ",";
-                msg += i;
-                if (hybrid)
-                {
-                    if ((details.PerformanceCoreMask & (1UL << i)) != 0)
-                        msg += "(P)";
-                    else if ((details.EfficiencyCoreMask & (1UL << i)) != 0)
-                        msg += "(E)";
-                }
-            }
-
-            aff >>= 1;
-        }
-
-        UIMessageBox.Show("CPU Info".Translate(), msg, "确定".Translate(), -1);
-    }
-
     public static void SetWindowTitle()
     {
         // Get profile name from command line arguments, and set window title accordingly
         var args = Environment.GetCommandLineArgs();
-        for (var i = 0; i < args.Length - 1; i++)
+        for (var i = args.Length - 2; i >= 0; i--)
         {
-            if (args[i] != "--doorstop-target") continue;
+            if (args[i] == "--gale-profile")
-            var arg = args[i + 1];
+            {
-            const string doorstopPathSuffix = @"\BepInEx\core\BepInEx.Preloader.dll";
+                // We use gale profile name directly
-            if (!arg.EndsWith(doorstopPathSuffix, StringComparison.OrdinalIgnoreCase))
+                ProfileName = args[i + 1];
-                break;
+            }
-            arg = arg.Substring(0, arg.Length - doorstopPathSuffix.Length);
+            else
-            const string profileSuffix = @"\profiles\";
+            {
-            var index = arg.LastIndexOf(profileSuffix, StringComparison.OrdinalIgnoreCase);
+                // Doorstop 3.x and 4.x use different arguments to pass the target assembly path
-            if (index < 0)
+                if (args[i] != "--doorstop-target" && args[i] != "--doorstop-target-assembly") continue;
-                break;
+                var arg = args[i + 1];
-            arg = arg.Substring(index + profileSuffix.Length);
+                const string doorstopPathSuffix = @"\BepInEx\core\BepInEx.Preloader.dll";
+                if (!arg.EndsWith(doorstopPathSuffix, StringComparison.OrdinalIgnoreCase))
+                    break;
+                arg = arg.Substring(0, arg.Length - doorstopPathSuffix.Length);
+                const string profileSuffix = @"\profiles\";
+                var index = arg.LastIndexOf(profileSuffix, StringComparison.OrdinalIgnoreCase);
+                if (index < 0)
+                    break;
+                arg = arg.Substring(index + profileSuffix.Length);
+                ProfileName = arg;
+            }
             var wnd = FindGameWindow();
             if (wnd == IntPtr.Zero) return;
-            ProfileName = arg;
+            _gameWindowTitle = $"Dyson Sphere Program - {ProfileName}";
-            _gameWindowTitle = $"Dyson Sphere Program - {arg}";
             WinApi.SetWindowText(wnd, _gameWindowTitle);
             break;
         }

UXAssist/ModsCompat/PlanetVeinUtilization.cs

@@ -0,0 +1,23 @@
+using HarmonyLib;
+
+namespace UXAssist.ModsCompat;
+
+class PlanetVeinUtilization
+{
+    public const string PlanetVeinUtilizationGuid = "testpostpleaseignore.dsp.planet_vein_utilization";
+
+    public static bool Run(Harmony harmony)
+    {
+        if (!BepInEx.Bootstrap.Chainloader.PluginInfos.TryGetValue(PlanetVeinUtilizationGuid, out var pluginInfo)) return false;
+        var assembly = pluginInfo.Instance.GetType().Assembly;
+        var classType = assembly.GetType("PlanetVeinUtilization.PlanetVeinUtilization");
+        harmony.Patch(AccessTools.Method(classType, "Awake"),
+            new HarmonyMethod(typeof(PlanetVeinUtilization).GetMethod("PatchPlanetVeinUtilizationAwake")));
+        return true;
+    }
+
+    public static bool PatchPlanetVeinUtilizationAwake()
+    {
+        return false;
+    }
+}

UXAssist/Patches/DysonSpherePatch.cs

@@ -5,10 +5,11 @@ using BepInEx.Configuration;
 using HarmonyLib;
 using UnityEngine.UI;
 using UXAssist.Common;
+using GameLogicProc = UXAssist.Common.GameLogic;
 
 namespace UXAssist.Patches;
 
-public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
+public class DysonSpherePatch : PatchImpl<DysonSpherePatch>
 {
     public static ConfigEntry<bool> StopEjectOnNodeCompleteEnabled;
     public static ConfigEntry<bool> OnlyConstructNodesEnabled;
@@ -173,7 +174,7 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                     {
                         lock (productRegister)
                         {
-                            productRegister[11902] += todoCount - count;
+                            productRegister[ProductionStatistics.DYSON_STRUCTURE_ID] += todoCount - count;
                         }
                     }
                 }
@@ -213,8 +214,8 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                     {
                         lock (productRegister)
                         {
-                            productRegister[11901] += solarSailCount;
+                            productRegister[ProductionStatistics.SOLAR_SAIL_ID] += solarSailCount;
-                            productRegister[11903] += solarSailCount;
+                            productRegister[ProductionStatistics.DYSON_CELL_ID] += solarSailCount;
                         }
                     }
                     var consumeRegister = __instance.consumeRegister;
@@ -222,7 +223,7 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
                     {
                         lock (consumeRegister)
                         {
-                            consumeRegister[11901] += solarSailCount;
+                            consumeRegister[ProductionStatistics.SOLAR_SAIL_ID] += solarSailCount;
                         }
                     }
                 }
@@ -260,7 +261,7 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         return matcher.InstructionEnumeration();
     }
 
-    private class StopEjectOnNodeComplete: PatchImpl<StopEjectOnNodeComplete>
+    private class StopEjectOnNodeComplete : PatchImpl<StopEjectOnNodeComplete>
     {
         private static HashSet<int>[] _nodeForAbsorb;
         private static bool _initialized;
@@ -268,14 +269,14 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         protected override void OnEnable()
         {
             InitNodeForAbsorb();
-            GameLogic.OnGameBegin += GameMain_Begin_Postfix;
+            GameLogicProc.OnGameBegin += GameMain_Begin_Postfix;
-            GameLogic.OnGameEnd += GameMain_End_Postfix;
+            GameLogicProc.OnGameEnd += GameMain_End_Postfix;
         }
 
         protected override void OnDisable()
         {
-            GameLogic.OnGameEnd -= GameMain_End_Postfix;
+            GameLogicProc.OnGameEnd -= GameMain_End_Postfix;
-            GameLogic.OnGameBegin -= GameMain_Begin_Postfix;
+            GameLogicProc.OnGameBegin -= GameMain_Begin_Postfix;
             _initialized = false;
             _nodeForAbsorb = null;
         }
@@ -389,20 +390,36 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
         {
             var matcher = new CodeMatcher(instructions, generator);
             matcher.MatchForward(false,
-                // if (this.orbitId == 0
+                // if (this.runtimeOrbitId == 0
                 new CodeMatch(OpCodes.Ldarg_0),
-                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.orbitId))),
+                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.runtimeOrbitId))),
                 new CodeMatch(OpCodes.Brtrue)
-            ).Advance(2).Insert(
+            ).Advance(2).InsertAndAdvance(
                 // || !StopEjectOnNodeComplete.AnyNodeForAbsorb(this.starData.index))
                 new CodeInstruction(OpCodes.Ldc_I4_0),
                 new CodeInstruction(OpCodes.Cgt),
-                new CodeInstruction(OpCodes.Ldarg_2),
+                new CodeInstruction(OpCodes.Ldarg_3),
                 new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(DysonSwarm), nameof(DysonSwarm.starData))),
                 new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(StarData), nameof(StarData.index))),
                 new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(StopEjectOnNodeComplete), nameof(AnyNodeForAbsorb))),
                 new CodeInstruction(OpCodes.And)
             );
+
+            // Do not search for next orbit if runtimeOrbitId is not 0 (which means nodes are completed)
+            Label? jmpTarget = null;
+            matcher.MatchForward(false,
+                new CodeMatch(OpCodes.Ldarg_0),
+                new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.autoOrbit))),
+                new CodeMatch(ci => ci.Branches(out jmpTarget))
+            );
+            if (jmpTarget == null) return matcher.InstructionEnumeration();
+            var labels = matcher.Labels;
+            matcher.Labels = null;
+            matcher.Insert(
+                new CodeInstruction(OpCodes.Ldarg_0).WithLabels(labels),
+                new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(EjectorComponent), nameof(EjectorComponent.runtimeOrbitId))),
+                new CodeInstruction(OpCodes.Brtrue, jmpTarget.Value)
+            );
             return matcher.InstructionEnumeration();
         }
 
@@ -475,13 +492,13 @@ public class DysonSpherePatch: PatchImpl<DysonSpherePatch>
     }
 
     [PatchSetCallbackFlag(PatchCallbackFlag.CallOnDisableAfterUnpatch)]
-    private class OnlyConstructNodes: PatchImpl<OnlyConstructNodes>
+    private class OnlyConstructNodes : PatchImpl<OnlyConstructNodes>
     {
         protected override void OnEnable()
         {
             RecheckDysonSphereAutoNodes();
         }
-        
+
         protected override void OnDisable()
         {
             RecheckDysonSphereAutoNodes();

UXAssist/Patches/GamePatch.cs

@@ -1,7 +1,10 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection.Emit;
+using System.Xml;
+using BepInEx;
 using BepInEx.Configuration;
 using CommonAPI.Systems;
 using HarmonyLib;
@@ -16,12 +19,11 @@ public class GamePatch : PatchImpl<GamePatch>
     public static ConfigEntry<bool> EnableWindowResizeEnabled;
     public static ConfigEntry<bool> LoadLastWindowRectEnabled;
 
-    public static ConfigEntry<int> MouseCursorScaleUpMultiplier;
-
     // public static ConfigEntry<bool> AutoSaveOptEnabled;
     public static ConfigEntry<bool> ConvertSavesFromPeaceEnabled;
     public static ConfigEntry<Vector4> LastWindowRect;
     public static ConfigEntry<bool> ProfileBasedSaveFolderEnabled;
+    public static ConfigEntry<bool> ProfileBasedOptionEnabled;
     public static ConfigEntry<string> DefaultProfileName;
     public static ConfigEntry<double> GameUpsFactor;
 
@@ -56,35 +58,37 @@ public class GamePatch : PatchImpl<GamePatch>
     public static void Init()
     {
         _speedDownKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
-            {
+        {
-                key = new CombineKey((int)KeyCode.Minus, CombineKey.CTRL_COMB, ECombineKeyAction.OnceClick, false),
+            key = new CombineKey((int)KeyCode.Minus, CombineKey.CTRL_COMB, ECombineKeyAction.OnceClick, false),
-                conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
+            conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
-                name = "UPSSpeedDown",
+            name = "UPSSpeedDown",
-                canOverride = true
+            canOverride = true
-            }
+        }
         );
-        I18N.Add("KEYUPSSpeedDown", "Decrease logical frame rate", "降低逻辑帧率");
+        I18N.Add("KEYUPSSpeedDown", "[UXA] Decrease logical frame rate", "[UXA] 降低逻辑帧率");
         _speedUpKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
-            {
+        {
-                key = new CombineKey((int)KeyCode.Equals, CombineKey.CTRL_COMB, ECombineKeyAction.OnceClick, false),
+            key = new CombineKey((int)KeyCode.Equals, CombineKey.CTRL_COMB, ECombineKeyAction.OnceClick, false),
-                conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.UI | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
+            conflictGroup = KeyBindConflict.MOVEMENT | KeyBindConflict.UI | KeyBindConflict.FLYING | KeyBindConflict.SAILING | KeyBindConflict.BUILD_MODE_1 | KeyBindConflict.KEYBOARD_KEYBIND,
-                name = "UPSSpeedUp",
+            name = "UPSSpeedUp",
-                canOverride = true
+            canOverride = true
-            }
+        }
         );
-        I18N.Add("KEYUPSSpeedUp", "Increase logical frame rate", "提升逻辑帧率");
+        I18N.Add("KEYUPSSpeedUp", "[UXA] Increase logical frame rate", "[UXA] 提升逻辑帧率");
-        I18N.Add("Logical frame rate: {0}x", "Logical frame rate: {0}x", "逻辑帧速率: {0}x");
+        I18N.Add("Logical frame rate: {0}x", "[UXA] Logical frame rate: {0}x", "[UXA] 逻辑帧速率: {0}x");
 
         EnableWindowResizeEnabled.SettingChanged += (_, _) => EnableWindowResize.Enable(EnableWindowResizeEnabled.Value);
-        LoadLastWindowRectEnabled.SettingChanged += (_, _) => LoadLastWindowRect.Enable(LoadLastWindowRectEnabled.Value);
+        LoadLastWindowRectEnabled.SettingChanged += (_, _) =>
-        MouseCursorScaleUpMultiplier.SettingChanged += (_, _) =>
         {
-            MouseCursorScaleUp.NeedReloadCursors = true;
+            if (LoadLastWindowRectEnabled.Value)
-            MouseCursorScaleUp.Enable(MouseCursorScaleUpMultiplier.Value > 1);
+            {
+                FixLastWindowRect();
+            }
         };
         // AutoSaveOptEnabled.SettingChanged += (_, _) => AutoSaveOpt.Enable(AutoSaveOptEnabled.Value);
         ConvertSavesFromPeaceEnabled.SettingChanged += (_, _) => ConvertSavesFromPeace.Enable(ConvertSavesFromPeaceEnabled.Value);
         ProfileBasedSaveFolderEnabled.SettingChanged += (_, _) => RefreshSavePath();
+        ProfileBasedOptionEnabled.SettingChanged += (_, _) => ProfileBasedOption.Enable(ProfileBasedOptionEnabled.Value);
         DefaultProfileName.SettingChanged += (_, _) => RefreshSavePath();
         GameUpsFactor.SettingChanged += (_, _) =>
         {
@@ -97,31 +101,37 @@ public class GamePatch : PatchImpl<GamePatch>
 
             FPSController.SetFixUPS(GameMain.tickPerSec * GameUpsFactor.Value);
         };
+        ProfileBasedOption.Enable(ProfileBasedOptionEnabled.Value);
     }
 
     public static void Start()
     {
+        if (LoadLastWindowRectEnabled.Value)
+        {
+            FixLastWindowRect();
+            var wnd = WindowFunctions.FindGameWindow();
+            if (wnd != IntPtr.Zero)
+            {
+                ThreadingHelper.Instance.StartCoroutine(SetWindowPositionCoroutine(wnd, (int)LastWindowRect.Value.x, (int)LastWindowRect.Value.y));
+            }
+        }
         EnableWindowResize.Enable(EnableWindowResizeEnabled.Value);
-        LoadLastWindowRect.Enable(LoadLastWindowRectEnabled.Value);
-        MouseCursorScaleUp.NeedReloadCursors = false;
-        MouseCursorScaleUp.Enable(MouseCursorScaleUpMultiplier.Value > 1);
         // AutoSaveOpt.Enable(AutoSaveOptEnabled.Value);
         ConvertSavesFromPeace.Enable(ConvertSavesFromPeaceEnabled.Value);
         Enable(true);
+
+        RefreshSavePath();
     }
 
     public static void Uninit()
     {
         Enable(false);
-        LoadLastWindowRect.Enable(false);
         EnableWindowResize.Enable(false);
-        MouseCursorScaleUp.NeedReloadCursors = false;
-        MouseCursorScaleUp.Enable(false);
         // AutoSaveOpt.Enable(false);
         ConvertSavesFromPeace.Enable(false);
     }
 
-    public static void OnUpdate()
+    public static void OnInputUpdate()
     {
         if (!_enableGameUpsFactor) return;
         if (_speedDownKey.keyValue)
@@ -137,41 +147,128 @@ public class GamePatch : PatchImpl<GamePatch>
         }
     }
 
+    [HarmonyPostfix]
+    [HarmonyPriority(Priority.First)]
+    [HarmonyPatch(typeof(GameConfig), nameof(GameConfig.gameSaveFolder), MethodType.Getter)]
+    public static void GameConfig_gameSaveFolder_Postfix(ref string __result)
+    {
+        if (!ProfileBasedSaveFolderEnabled.Value || string.IsNullOrEmpty(WindowFunctions.ProfileName)) return;
+        __result = $"{__result}{WindowFunctions.ProfileName}/";
+    }
+
     private static void RefreshSavePath()
     {
-        var profileName = WindowFunctions.ProfileName;
+        var gameSaveFolder = GameConfig.gameSaveFolder;
-        if (profileName == null) return;
+        if (!Directory.Exists(gameSaveFolder))
-
+            Directory.CreateDirectory(gameSaveFolder);
-        if (UIRoot.instance.loadGameWindow.gameObject.activeSelf)
+        if (UIRoot.instance?.loadGameWindow?.active == true) UIRoot.instance.loadGameWindow.RefreshList();
-        {
+        if (UIRoot.instance?.saveGameWindow?.active == true) UIRoot.instance.saveGameWindow.RefreshList();
-            UIRoot.instance.loadGameWindow._Close();
-        }
-
-        if (UIRoot.instance.saveGameWindow.gameObject.activeSelf)
-        {
-            UIRoot.instance.saveGameWindow._Close();
-        }
-
-        string gameSavePath;
-        if (ProfileBasedSaveFolderEnabled.Value && string.Compare(DefaultProfileName.Value, profileName, StringComparison.OrdinalIgnoreCase) != 0)
-            gameSavePath = $"{GameConfig.overrideDocumentFolder}{GameConfig.gameName}/Save/{profileName}/";
-        else
-            gameSavePath = $"{GameConfig.overrideDocumentFolder}{GameConfig.gameName}/Save/";
-        if (string.Compare(GameConfig.gameSavePath, gameSavePath, StringComparison.OrdinalIgnoreCase) == 0) return;
-        GameConfig.gameSavePath = gameSavePath;
-        if (!Directory.Exists(GameConfig.gameSavePath))
-        {
-            Directory.CreateDirectory(GameConfig.gameSavePath);
-        }
     }
 
     [HarmonyPrefix, HarmonyPatch(typeof(GameMain), nameof(GameMain.HandleApplicationQuit))]
     private static void GameMain_HandleApplicationQuit_Prefix()
     {
+        if (!LoadLastWindowRectEnabled.Value) return;
         var wnd = WindowFunctions.FindGameWindow();
         if (wnd == IntPtr.Zero) return;
         WinApi.GetWindowRect(wnd, out var rect);
-        LastWindowRect.Value = new Vector4(rect.Left < 20 - Screen.width ? 0 : rect.Left, rect.Top < 20 - Screen.height ? 0 : rect.Top, Screen.width, Screen.height);
+        LastWindowRect.Value = new Vector4(rect.Left, rect.Top, Screen.width, Screen.height);
+    }
+    private static void FixLastWindowRect()
+    {
+        if (Screen.fullScreenMode is not (FullScreenMode.ExclusiveFullScreen or FullScreenMode.FullScreenWindow or FullScreenMode.MaximizedWindow))
+        {
+            var rect = LastWindowRect.Value;
+            var x = Mathf.RoundToInt(rect.x);
+            var y = Mathf.RoundToInt(rect.y);
+            var w = Mathf.RoundToInt(rect.z);
+            var h = Mathf.RoundToInt(rect.w);
+            var needFix = false;
+            if (w < 100)
+            {
+                w = 1280;
+                needFix = true;
+            }
+
+            if (h < 100)
+            {
+                h = 720;
+                needFix = true;
+            }
+
+            var rc = new WinApi.Rect { Left = x, Top = y, Right = x + w, Bottom = y + h };
+            if (WinApi.MonitorFromRect(ref rc, 0) == IntPtr.Zero)
+            {
+                x = 0;
+                y = 0;
+                w = 1280;
+                h = 720;
+                needFix = true;
+            }
+            if (needFix)
+            {
+                LastWindowRect.Value = new Vector4(x, y, w, h);
+            }
+        }
+    }
+
+    public static IEnumerator SetWindowPositionCoroutine(IntPtr wnd, int x, int y)
+    {
+        yield return new WaitForEndOfFrame();
+        yield return new WaitForEndOfFrame();
+        WinApi.SetWindowPos(wnd, IntPtr.Zero, x, y, 0, 0, 0x0235);
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(Screen), nameof(Screen.SetResolution), typeof(int), typeof(int), typeof(FullScreenMode), typeof(RefreshRate))]
+    private static void Screen_SetResolution_Prefix(ref int width, ref int height, FullScreenMode fullscreenMode, ref Vector2Int __state)
+    {
+        if (fullscreenMode is FullScreenMode.ExclusiveFullScreen or FullScreenMode.FullScreenWindow or FullScreenMode.MaximizedWindow) return;
+        if (GameMain.isRunning)
+        {
+            var wnd = WindowFunctions.FindGameWindow();
+            if (wnd == IntPtr.Zero) return;
+            WinApi.GetWindowRect(wnd, out var rc);
+            __state = new Vector2Int(rc.Left, rc.Top);
+            return;
+        }
+        else if (!LoadLastWindowRectEnabled.Value) return;
+        int x = 0, y = 0, w = 0, h = 0;
+        var rect = LastWindowRect.Value;
+        if (rect is not { z: 0f, w: 0f })
+        {
+            x = Mathf.RoundToInt(rect.x);
+            y = Mathf.RoundToInt(rect.y);
+            w = Mathf.RoundToInt(rect.z);
+            h = Mathf.RoundToInt(rect.w);
+        }
+        width = w;
+        height = h;
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(Screen), nameof(Screen.SetResolution), typeof(int), typeof(int), typeof(FullScreenMode), typeof(RefreshRate))]
+    private static void Screen_SetResolution_Postfix(FullScreenMode fullscreenMode, Vector2Int __state)
+    {
+        if (fullscreenMode is FullScreenMode.ExclusiveFullScreen or FullScreenMode.FullScreenWindow or FullScreenMode.MaximizedWindow) return;
+        var gameRunning = GameMain.isRunning;
+        if (!LoadLastWindowRectEnabled.Value && !gameRunning) return;
+        var wnd = WindowFunctions.FindGameWindow();
+        if (wnd == IntPtr.Zero) return;
+        int x, y;
+        if (gameRunning)
+        {
+            x = __state.x;
+            y = __state.y;
+        }
+        else
+        {
+            var rect = LastWindowRect.Value;
+            if (rect is { z: 0f, w: 0f }) return;
+            x = Mathf.RoundToInt(rect.x);
+            y = Mathf.RoundToInt(rect.y);
+        }
+        ThreadingHelper.Instance.StartCoroutine(SetWindowPositionCoroutine(wnd, x, y));
     }
 
     private class EnableWindowResize : PatchImpl<EnableWindowResize>
@@ -218,162 +315,6 @@ public class GamePatch : PatchImpl<GamePatch>
         }
     }
 
-    public class LoadLastWindowRect : PatchImpl<LoadLastWindowRect>
-    {
-        private static bool _loaded;
-
-        protected override void OnEnable()
-        {
-            GameLogic.OnDataLoaded += VFPreload_InvokeOnLoadWorkEnded_Postfix;
-            if (Screen.fullScreenMode is not (FullScreenMode.ExclusiveFullScreen or FullScreenMode.FullScreenWindow or FullScreenMode.MaximizedWindow))
-            {
-                var rect = LastWindowRect.Value;
-                var x = Mathf.RoundToInt(rect.x);
-                var y = Mathf.RoundToInt(rect.y);
-                var w = Mathf.RoundToInt(rect.z);
-                var h = Mathf.RoundToInt(rect.w);
-                var needFix = false;
-                if (w < 100)
-                {
-                    w = 1280;
-                    needFix = true;
-                }
-
-                if (h < 100)
-                {
-                    h = 720;
-                    needFix = true;
-                }
-
-                var sw = Screen.currentResolution.width;
-                var sh = Screen.currentResolution.height;
-                if (x + w > sw)
-                {
-                    x = sw - w;
-                    needFix = true;
-                }
-
-                if (y + h > sh)
-                {
-                    y = sh - h;
-                    needFix = true;
-                }
-
-                if (x < 0)
-                {
-                    x = 0;
-                    needFix = true;
-                }
-
-                if (y < 0)
-                {
-                    y = 0;
-                    needFix = true;
-                }
-
-                if (needFix)
-                {
-                    LastWindowRect.Value = new Vector4(x, y, w, h);
-                }
-            }
-
-            MoveWindowPosition();
-        }
-
-        protected override void OnDisable()
-        {
-            GameLogic.OnDataLoaded -= VFPreload_InvokeOnLoadWorkEnded_Postfix;
-        }
-
-        public static void MoveWindowPosition(bool setResolution = false)
-        {
-            if (Screen.fullScreenMode is FullScreenMode.ExclusiveFullScreen or FullScreenMode.FullScreenWindow or FullScreenMode.MaximizedWindow || GameMain.isRunning) return;
-            var wnd = WindowFunctions.FindGameWindow();
-            if (wnd == IntPtr.Zero) return;
-            var rect = LastWindowRect.Value;
-            if (rect is { z: 0f, w: 0f }) return;
-            var x = Mathf.RoundToInt(rect.x);
-            var y = Mathf.RoundToInt(rect.y);
-            if (setResolution)
-            {
-                var w = Mathf.RoundToInt(rect.z);
-                var h = Mathf.RoundToInt(rect.w);
-                Screen.SetResolution(w, h, false);
-            }
-
-            WinApi.SetWindowPos(wnd, IntPtr.Zero, x, y, 0, 0, 0x0235);
-        }
-
-        [HarmonyPrefix]
-        [HarmonyPatch(typeof(Screen), nameof(Screen.SetResolution), typeof(int), typeof(int), typeof(FullScreenMode), typeof(int))]
-        private static void Screen_SetResolution_Prefix(ref int width, ref int height, FullScreenMode fullscreenMode)
-        {
-            if (fullscreenMode is FullScreenMode.ExclusiveFullScreen or FullScreenMode.FullScreenWindow or FullScreenMode.MaximizedWindow || GameMain.isRunning) return;
-            var rect = LastWindowRect.Value;
-            if (rect is { z: 0f, w: 0f }) return;
-            var w = Mathf.RoundToInt(rect.z);
-            var h = Mathf.RoundToInt(rect.w);
-            width = w;
-            height = h;
-        }
-
-        [HarmonyPostfix]
-        [HarmonyPatch(typeof(Screen), nameof(Screen.SetResolution), typeof(int), typeof(int), typeof(FullScreenMode), typeof(int))]
-        private static void Screen_SetResolution_Postfix(FullScreenMode fullscreenMode)
-        {
-            MoveWindowPosition();
-        }
-
-        private static void VFPreload_InvokeOnLoadWorkEnded_Postfix()
-        {
-            if (_loaded || Screen.fullScreenMode is FullScreenMode.ExclusiveFullScreen or FullScreenMode.FullScreenWindow or FullScreenMode.MaximizedWindow) return;
-            _loaded = true;
-            var wnd = WindowFunctions.FindGameWindow();
-            if (wnd == IntPtr.Zero) return;
-            var rect = LastWindowRect.Value;
-            if (rect is { z: 0f, w: 0f }) return;
-            var x = Mathf.RoundToInt(rect.x);
-            var y = Mathf.RoundToInt(rect.y);
-            var w = Mathf.RoundToInt(rect.z);
-            var h = Mathf.RoundToInt(rect.w);
-            Screen.SetResolution(w, h, false);
-            WinApi.SetWindowPos(wnd, IntPtr.Zero, x, y, 0, 0, 0x0235);
-            if (EnableWindowResizeEnabled.Value)
-                WinApi.SetWindowLong(wnd, WinApi.GWL_STYLE,
-                    WinApi.GetWindowLong(wnd, WinApi.GWL_STYLE) | WinApi.WS_THICKFRAME | WinApi.WS_MAXIMIZEBOX);
-        }
-
-        private static GameOption _gameOption;
-
-        [HarmonyPostfix]
-        [HarmonyPatch(typeof(UIOptionWindow), nameof(UIOptionWindow._OnOpen))]
-        private static void UIOptionWindow__OnOpen_Postfix()
-        {
-            _gameOption = DSPGame.globalOption;
-        }
-
-        [HarmonyTranspiler]
-        [HarmonyPatch(typeof(GameOption), nameof(GameOption.Apply))]
-        private static IEnumerable<CodeInstruction> UIOptionWindow_ApplyOptions_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
-        {
-            var matcher = new CodeMatcher(instructions, generator);
-            var label1 = generator.DefineLabel();
-            matcher.MatchForward(false,
-                new CodeMatch(OpCodes.Call, AccessTools.Method(typeof(Screen), nameof(Screen.SetResolution), [typeof(int), typeof(int), typeof(bool), typeof(int)]))
-            ).Advance(1).Labels.Add(label1);
-            matcher.Start().Insert(
-                Transpilers.EmitDelegate(() =>
-                    _gameOption.fullscreen == DSPGame.globalOption.fullscreen &&
-                    _gameOption.resolution.width == DSPGame.globalOption.resolution.width &&
-                    _gameOption.resolution.height == DSPGame.globalOption.resolution.height &&
-                    _gameOption.resolution.refreshRate == DSPGame.globalOption.resolution.refreshRate
-                ),
-                new CodeInstruction(OpCodes.Brtrue, label1)
-            );
-            return matcher.InstructionEnumeration();
-        }
-    }
-
     /*
     private class AutoSaveOpt: PatchImpl<AutoSaveOpt>
     {
@@ -547,130 +488,76 @@ public class GamePatch : PatchImpl<GamePatch>
         }
     }
 
-    [PatchSetCallbackFlag(PatchCallbackFlag.CallOnDisableAfterUnpatch)]
+    private class ProfileBasedOption : PatchImpl<ProfileBasedOption>
-    private class MouseCursorScaleUp : PatchImpl<MouseCursorScaleUp>
     {
-        public static bool NeedReloadCursors;
+        [HarmonyPrefix]
-
+        [HarmonyPatch(typeof(GameOption), nameof(GameOption.LoadGlobal))]
-        protected override void OnEnable()
+        private static bool GameOption_LoadGlobal_Prefix(ref GameOption __instance)
         {
-            if (!NeedReloadCursors) return;
+            var profileName = WindowFunctions.ProfileName;
-            if (!UICursor.loaded) return;
+            if (profileName == null)
-            UICursor.loaded = false;
-            UICursor.LoadCursors();
-        }
-
-        protected override void OnDisable()
-        {
-            if (!NeedReloadCursors) return;
-            if (!UICursor.loaded) return;
-            UICursor.loaded = false;
-            UICursor.LoadCursors();
-        }
-
-        [HarmonyTranspiler]
-        [HarmonyPatch(typeof(UICursor), nameof(UICursor.LoadCursors))]
-        private static IEnumerable<CodeInstruction> UICursor_LoadCursors_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
-        {
-            var matcher = new CodeMatcher(instructions, generator);
-            /*
-            matcher.MatchForward(false,
-                new CodeMatch(OpCodes.Ldc_I4_S),
-                new CodeMatch(OpCodes.Newarr)
-            );
-            var startPos = matcher.Pos;
-            matcher.Advance(2).MatchForward(false,
-                new CodeMatch(OpCodes.Stsfld, AccessTools.Field(typeof(UICursor), nameof(UICursor.cursorTexs)))
-            );
-            var endPos = matcher.Pos + 1;
-            matcher.Start().Advance(startPos).RemoveInstructions(endPos - startPos);
-            matcher.InsertAndAdvance(
-                Transpilers.EmitDelegate(() =>
-                {
-                    var pluginfolder = Util.PluginFolder;
-                    UICursor.cursorTexs =
-                    [
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-transfer.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-target-in.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-target-out.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-target-a.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-target-b.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-ban.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-delete.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-reform.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-dyson-node-create.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-painter.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-eyedropper.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-eraser.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-upgrade.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-downgrade.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-blank.png"),
-                        Util.LoadTexture($"{pluginfolder}/assets/cursor/cursor-remove.png")
-                    ];
-                })
-            );
-            */
-            matcher.MatchForward(false,
-                new CodeMatch(OpCodes.Stsfld, AccessTools.Field(typeof(UICursor), nameof(UICursor.cursorHots))),
-                new CodeMatch(OpCodes.Ldc_I4_1),
-                new CodeMatch(OpCodes.Stsfld, AccessTools.Field(typeof(UICursor), nameof(UICursor.loaded)))
-            ).Advance(1).InsertAndAdvance(
-                Transpilers.EmitDelegate(() =>
-                {
-                    var multiplier = MouseCursorScaleUpMultiplier.Value;
-                    for (var i = 0; i < UICursor.cursorTexs.Length; i++)
-                    {
-                        var cursor = UICursor.cursorTexs[i];
-                        if (cursor == null) continue;
-                        var newWidth = 32 * multiplier;
-                        var newHeight = 32 * multiplier;
-                        if (cursor.width == newWidth && cursor.height == newHeight) continue;
-                        UICursor.cursorTexs[i] = ResizeTexture2D(cursor, newWidth, newHeight);
-                    }
-
-                    if (multiplier <= 1) return;
-                    for (var i = UICursor.cursorHots.Length - 1; i >= 0; i--)
-                    {
-                        UICursor.cursorHots[i] = new Vector2(UICursor.cursorHots[i].x * multiplier, UICursor.cursorHots[i].y * multiplier);
-                    }
-                })
-            ).MatchForward(false,
-                new CodeMatch(OpCodes.Ldc_I4_0),
-                new CodeMatch(OpCodes.Call, AccessTools.Method(typeof(Cursor), nameof(Cursor.SetCursor), [typeof(Texture2D), typeof(Vector2), typeof(CursorMode)]))
-            ).SetInstruction(new CodeInstruction(OpCodes.Ldc_I4_1));
-            return matcher.InstructionEnumeration();
-
-            Texture2D ResizeTexture2D(Texture2D texture2D, int targetWidth, int targetHeight)
             {
-                var oldActive = RenderTexture.active;
+                // We should initialize WindowFunctions before using WindowFunctions.ProfileName
-                var rt = new RenderTexture(targetWidth, targetHeight, 32)
+                WindowFunctions.Init();
-                {
+                profileName = WindowFunctions.ProfileName;
-                    antiAliasing = 8
+                if (profileName == null) return true;
-                };
-                RenderTexture.active = rt;
-                Graphics.Blit(texture2D, rt);
-                rt.ResolveAntiAliasedSurface();
-                var result = new Texture2D(targetWidth, targetHeight, texture2D.format, false);
-                result.ReadPixels(new Rect(0, 0, targetWidth, targetHeight), 0, 0);
-                result.filterMode = FilterMode.Trilinear;
-                result.Apply();
-                RenderTexture.active = oldActive;
-                rt.Release();
-                return result;
             }
+            if (string.Compare(DefaultProfileName.Value, profileName, StringComparison.OrdinalIgnoreCase) == 0) return true;
+            var optionPath = $"{GameConfig.gameDocumentFolder}Option/{profileName}.xml";
+            if (File.Exists(optionPath))
+            {
+                try
+                {
+                    __instance.ImportXML(optionPath);
+                    return false;
+                }
+                catch
+                {
+                }
+            }
+            var gameXMLOptionPath = GameConfig.gameXMLOptionPath;
+            if (File.Exists(gameXMLOptionPath))
+            {
+                try
+                {
+                    __instance.ImportXML(gameXMLOptionPath);
+                    return false;
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogException(ex);
+                }
+            }
+            GameOption.newlyCreated = true;
+            __instance.SetDefault();
+            return false;
         }
 
-        [HarmonyTranspiler]
+        [HarmonyPrefix]
-        [HarmonyPatch(typeof(UICursor), nameof(UICursor.cursorIndexApply), MethodType.Setter)]
+        [HarmonyPatch(typeof(GameOption), nameof(GameOption.SaveGlobal))]
-        private static IEnumerable<CodeInstruction> UICursor_set_cursorIndexApply_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+        private static bool GameOption_SaveGlobal_Prefix(ref GameOption __instance)
         {
-            var matcher = new CodeMatcher(instructions, generator);
+            var profileName = WindowFunctions.ProfileName;
-            matcher.Start().MatchForward(false,
+            if (profileName == null) return true;
-                new CodeMatch(OpCodes.Ldc_I4_0),
+            if (string.Compare(DefaultProfileName.Value, profileName, StringComparison.OrdinalIgnoreCase) == 0) return true;
-                new CodeMatch(OpCodes.Call, AccessTools.Method(typeof(Cursor), nameof(Cursor.SetCursor), [typeof(Texture2D), typeof(Vector2), typeof(CursorMode)]))
+            var path = $"{GameConfig.gameDocumentFolder}Option";
-            ).SetInstruction(new CodeInstruction(OpCodes.Ldc_I4_1));
+            if (!Directory.Exists(path))
-            return matcher.InstructionEnumeration();
+            {
+                Directory.CreateDirectory(path);
+            }
+            try
+            {
+                using FileStream fileStream = new($"{path}/{profileName}.xml", FileMode.Create, FileAccess.Write, FileShare.None);
+                using XmlTextWriter xmlTextWriter = new(fileStream, Console.OutputEncoding);
+                xmlTextWriter.Formatting = Formatting.Indented;
+                __instance.ExportXML(xmlTextWriter);
+                xmlTextWriter.Close();
+            }
+            catch (Exception ex)
+            {
+                Debug.LogException(ex);
+            }
+            return false;
         }
     }
 }

UXAssist/Patches/PersistPatch.cs

@@ -1,5 +1,4 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
 using System.Reflection.Emit;
 using HarmonyLib;
 using UnityEngine;
@@ -39,29 +38,6 @@ public class PersistPatch : PatchImpl<PersistPatch>
         return matcher.InstructionEnumeration();
     }
 
-    // Patch to fix the issue that warning popup on VeinUtil upgraded to level 8000+
-    [HarmonyTranspiler]
-    [HarmonyPatch(typeof(ABN_VeinsUtil), nameof(ABN_VeinsUtil.CheckValue))]
-    private static IEnumerable<CodeInstruction> ABN_VeinsUtil_CheckValue_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
-    {
-        var matcher = new CodeMatcher(instructions, generator);
-        matcher.MatchForward(false,
-            new CodeMatch(OpCodes.Ldelem_R8),
-            new CodeMatch(OpCodes.Conv_R4),
-            new CodeMatch(OpCodes.Add),
-            new CodeMatch(OpCodes.Stloc_1)
-        );
-        // loc1 = Mathf.Round(n * 1000f) / 1000f;
-        matcher.Advance(3).Insert(
-            new CodeInstruction(OpCodes.Ldc_R4, 1000f),
-            new CodeInstruction(OpCodes.Mul),
-            new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(Mathf), nameof(Mathf.Round))),
-            new CodeInstruction(OpCodes.Ldc_R4, 1000f),
-            new CodeInstruction(OpCodes.Div)
-        );
-        return matcher.InstructionEnumeration();
-    }
-
     // Bring popup tip window to top layer
     [HarmonyTranspiler]
     [HarmonyPatch(typeof(UIButton), nameof(UIButton.LateUpdate))]
@@ -86,36 +62,30 @@ public class PersistPatch : PatchImpl<PersistPatch>
         return matcher.InstructionEnumeration();
     }
 
-    // Sort blueprint structures by item id, model index, recipe id, area index, and position before saving
+    // Sort blueprint data when pasting
-    [HarmonyPostfix]
+    [HarmonyTranspiler]
-    [HarmonyPatch(typeof(BlueprintUtils), nameof(BlueprintUtils.GenerateBlueprintData))]
+    [HarmonyPatch(typeof(BuildTool_BlueprintCopy), nameof(BuildTool_BlueprintCopy.UseToPasteNow))]
-    private static void BlueprintUtils_GenerateBlueprintData_Postfix(BlueprintData _blueprintData)
+    private static IEnumerable<CodeInstruction> BuildTool_BlueprintCopy_UseToPasteNow_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
     {
-        var buildings = _blueprintData.buildings;
+        var matcher = new CodeMatcher(instructions, generator);
-        Array.Sort(buildings, (a, b) =>
+        matcher.MatchForward(false,
-        {
+            new CodeMatch(OpCodes.Ldarg_0),
-            var tmpItemId = a.itemId - b.itemId;
+            new CodeMatch(OpCodes.Call, AccessTools.Method(typeof(BuildTool_BlueprintCopy), nameof(BuildTool_BlueprintCopy.RefreshBlueprintData)))
-            if (tmpItemId != 0) return tmpItemId;
+        ).Advance(2).Insert(
+            new CodeInstruction(OpCodes.Ldarg_0),
+            new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(BuildTool_BlueprintCopy), nameof(BuildTool_BlueprintCopy.blueprint))),
+            new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(Functions.FactoryFunctions), nameof(Functions.FactoryFunctions.SortBlueprintData)))
+        );
+        return matcher.InstructionEnumeration();
+    }
 
-            var tmpModelIndex = a.modelIndex - b.modelIndex;
+    // Sort blueprint data when saving
-            if (tmpModelIndex != 0) return tmpModelIndex;
+    [HarmonyPrefix]
-
+    [HarmonyPatch(typeof(BlueprintData), nameof(BlueprintData.SaveBlueprintData))]
-            var tmpRecipeId = a.recipeId - b.recipeId;
+    private static void BlueprintData_SaveBlueprintData_Prefix(BlueprintData __instance)
-            if (tmpRecipeId != 0) return tmpRecipeId;
+    {
-
+        if (!__instance.isValid) return;
-            var tmpAreaIndex = a.areaIndex - b.areaIndex;
+        Functions.FactoryFunctions.SortBlueprintData(__instance);
-            if (tmpAreaIndex != 0) return tmpAreaIndex;
-
-            var sign = Math.Sign(b.localOffset_y - a.localOffset_y);
-            if (sign != 0) return sign;
-
-            sign = Math.Sign(b.localOffset_x - a.localOffset_x);
-            return sign != 0 ? sign : Math.Sign(b.localOffset_z - a.localOffset_z);
-        });
-        for (var i = buildings.Length - 1; i >= 0; i--)
-        {
-            buildings[i].index = i;
-        }
     }
 
     // Increase maximum value of property realizing, 2000 -> 20000

UXAssist/Patches/PlanetPatch.cs

@@ -24,7 +24,7 @@ public static class PlanetPatch
         PlayerActionsInGlobeView.Enable(false);
     }
 
-    public class PlayerActionsInGlobeView: PatchImpl<PlayerActionsInGlobeView>
+    public class PlayerActionsInGlobeView : PatchImpl<PlayerActionsInGlobeView>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(VFInput), nameof(VFInput.UpdateGameStates))]
@@ -48,7 +48,7 @@ public static class PlanetPatch
             });
             return matcher.InstructionEnumeration();
         }
-        
+
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(PlayerController), nameof(PlayerController.GetInput))]
         private static IEnumerable<CodeInstruction> PlayerController_GetInput_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)

UXAssist/Patches/PlayerPatch.cs

@@ -8,18 +8,41 @@ using UXAssist.Common;
 
 namespace UXAssist.Patches;
 
-public static class PlayerPatch
+public class PlayerPatch : PatchImpl<PlayerPatch>
 {
     public static ConfigEntry<bool> EnhancedMechaForgeCountControlEnabled;
     public static ConfigEntry<bool> HideTipsForSandsChangesEnabled;
+    public static ConfigEntry<bool> ShortcutKeysForStarsNameEnabled;
     public static ConfigEntry<bool> AutoNavigationEnabled;
     public static ConfigEntry<bool> AutoCruiseEnabled;
     public static ConfigEntry<bool> AutoBoostEnabled;
     public static ConfigEntry<double> DistanceToWarp;
+    private static PressKeyBind _showAllStarsNameKey;
+    private static PressKeyBind _toggleAllStarsNameKey;
     private static PressKeyBind _autoDriveKey;
-    
+
     public static void Init()
     {
+        _showAllStarsNameKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
+        {
+            key = new CombineKey(0, CombineKey.ALT_COMB, ECombineKeyAction.OnceClick, false),
+            conflictGroup = KeyBindConflict.UI | KeyBindConflict.KEYBOARD_KEYBIND,
+            name = "ShowAllStarsName",
+            canOverride = true
+        }
+        );
+        I18N.Add("KEYShowAllStarsName", "[UXA] Keep pressing to show all Stars' name", "[UXA] 按住显示所有星系名称");
+
+        _toggleAllStarsNameKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
+        {
+            key = new CombineKey((int)KeyCode.Tab, 0, ECombineKeyAction.OnceClick, false),
+            conflictGroup = KeyBindConflict.UI | KeyBindConflict.KEYBOARD_KEYBIND,
+            name = "ToggleAllStarsName",
+            canOverride = true
+        }
+        );
+        I18N.Add("KEYToggleAllStarsName", "[UXA] Toggle display of all Stars' name", "[UXA] 切换所有星系名称显示状态");
+
         _autoDriveKey = KeyBindings.RegisterKeyBinding(new BuiltinKey
         {
             key = new CombineKey(0, 0, ECombineKeyAction.OnceClick, true),
@@ -27,36 +50,87 @@ public static class PlayerPatch
             name = "ToggleAutoCruise",
             canOverride = true
         });
+        I18N.Add("KEYToggleAutoCruise", "[UXA] Toggle auto-cruise", "[UXA] 切换自动巡航");
         I18N.Add("AutoCruiseOn", "Auto-cruise enabled", "已启用自动巡航");
         I18N.Add("AutoCruiseOff", "Auto-cruise disabled", "已禁用自动巡航");
+
         EnhancedMechaForgeCountControlEnabled.SettingChanged += (_, _) => EnhancedMechaForgeCountControl.Enable(EnhancedMechaForgeCountControlEnabled.Value);
         HideTipsForSandsChangesEnabled.SettingChanged += (_, _) => HideTipsForSandsChanges.Enable(HideTipsForSandsChangesEnabled.Value);
+        ShortcutKeysForStarsNameEnabled.SettingChanged += (_, _) => ShortcutKeysForStarsName.Enable(ShortcutKeysForStarsNameEnabled.Value);
         AutoNavigationEnabled.SettingChanged += (_, _) => AutoNavigation.Enable(AutoNavigationEnabled.Value);
+        AutoNavigationEnabled.SettingChanged += (_, _) => Functions.UIFunctions.UpdateToggleAutoCruiseCheckButtonVisiblility();
+        AutoCruiseEnabled.SettingChanged += (_, _) => Functions.UIFunctions.UpdateToggleAutoCruiseCheckButtonVisiblility();
     }
 
     public static void Start()
     {
         EnhancedMechaForgeCountControl.Enable(EnhancedMechaForgeCountControlEnabled.Value);
         HideTipsForSandsChanges.Enable(HideTipsForSandsChangesEnabled.Value);
+        ShortcutKeysForStarsName.Enable(ShortcutKeysForStarsNameEnabled.Value);
         AutoNavigation.Enable(AutoNavigationEnabled.Value);
+        Enable(true);
     }
 
-    public static void OnUpdate()
+    public static void OnInputUpdate()
     {
+        ShortcutKeysForStarsName.OnInputUpdate();
         if (_autoDriveKey.keyValue)
         {
             AutoNavigation.ToggleAutoCruise();
         }
     }
-    
+
     public static void Uninit()
     {
+        Enable(false);
         EnhancedMechaForgeCountControl.Enable(false);
         HideTipsForSandsChanges.Enable(false);
+        ShortcutKeysForStarsName.Enable(false);
         AutoNavigation.Enable(false);
     }
 
-    private class EnhancedMechaForgeCountControl: PatchImpl<EnhancedMechaForgeCountControl>
+
+    [HarmonyTranspiler]
+    [HarmonyPatch(typeof(UIStarmapStar), nameof(UIStarmapStar._OnLateUpdate))]
+    private static IEnumerable<CodeInstruction> UIStarmapStar__OnLateUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+    {
+        var matcher = new CodeMatcher(instructions, generator);
+        Label? jumpPos = null;
+        matcher.MatchForward(false,
+            new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(UIStarmapStar), nameof(UIStarmapStar.projectedCoord))),
+            new CodeMatch(ci => ci.IsLdloc()),
+            new CodeMatch(ci => ci.Branches(out jumpPos))
+        );
+        matcher.Advance(3);
+        var labels = matcher.Labels;
+        matcher.Labels = [];
+        matcher.CreateLabel(out var jumpPos2);
+        matcher.InsertAndAdvance(
+            new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(ShortcutKeysForStarsName.ShowAllStarsNameStatus))).WithLabels(labels),
+            new CodeInstruction(OpCodes.Ldc_I4_1),
+            new CodeInstruction(OpCodes.Ceq),
+            new CodeInstruction(OpCodes.Brtrue, jumpPos.Value),
+            new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(PlayerPatch.ShortcutKeysForStarsName), nameof(ShortcutKeysForStarsName.ForceShowAllStarsName))),
+            new CodeInstruction(OpCodes.Brtrue, jumpPos.Value),
+            new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(Functions.UIFunctions), nameof(Functions.UIFunctions.ShowStarName))),
+            new CodeInstruction(OpCodes.Ldarg_0),
+            new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapStar), nameof(UIStarmapStar.star))),
+            new CodeInstruction(OpCodes.Ldfld, AccessTools.Field(typeof(StarData), nameof(StarData.index))),
+            new CodeInstruction(OpCodes.Ldelem_I1),
+            new CodeInstruction(OpCodes.Brtrue, jumpPos.Value),
+            new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(ShortcutKeysForStarsName.ShowAllStarsNameStatus))),
+            new CodeInstruction(OpCodes.Ldc_I4_2),
+            new CodeInstruction(OpCodes.Ceq),
+            new CodeInstruction(OpCodes.Brfalse, jumpPos2),
+            new CodeInstruction(OpCodes.Ldc_I4_0),
+            new CodeInstruction(OpCodes.Stloc_1),
+            new CodeInstruction(OpCodes.Br, jumpPos.Value)
+        );
+        return matcher.InstructionEnumeration();
+    }
+
+
+    private class EnhancedMechaForgeCountControl : PatchImpl<EnhancedMechaForgeCountControl>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UIReplicatorWindow), nameof(UIReplicatorWindow.OnOkButtonClick))]
@@ -107,7 +181,7 @@ public static class PlayerPatch
         }
     }
 
-    private class HideTipsForSandsChanges: PatchImpl<HideTipsForSandsChanges>
+    private class HideTipsForSandsChanges : PatchImpl<HideTipsForSandsChanges>
     {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(Player), nameof(Player.SetSandCount))]
@@ -121,13 +195,149 @@ public static class PlayerPatch
         }
     }
 
-    public class AutoNavigation: PatchImpl<AutoNavigation>
+    public class ShortcutKeysForStarsName : PatchImpl<ShortcutKeysForStarsName>
+    {
+        public static int ShowAllStarsNameStatus;
+        public static bool ForceShowAllStarsName;
+        public static bool ForceShowAllStarsNameExternal;
+
+        public static void ToggleAllStarsName()
+        {
+            ShowAllStarsNameStatus = (ShowAllStarsNameStatus + 1) % 3;
+        }
+
+        public static void OnInputUpdate()
+        {
+            if (!UIRoot.instance.uiGame.starmap.active) return;
+            var enabled = ShortcutKeysForStarsNameEnabled.Value;
+            if (!enabled)
+            {
+                ForceShowAllStarsName = ForceShowAllStarsNameExternal;
+                return;
+            }
+            if (_toggleAllStarsNameKey.keyValue)
+            {
+                ToggleAllStarsName();
+            }
+            ForceShowAllStarsName = ForceShowAllStarsNameExternal || _showAllStarsNameKey.IsKeyPressing();
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch(typeof(UIStarmap), nameof(UIStarmap._OnOpen))]
+        private static void UIStarmap__OnOpen_Prefix()
+        {
+            ShowAllStarsNameStatus = 0;
+        }
+        /*
+                [HarmonyTranspiler]
+                [HarmonyPatch(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet._OnLateUpdate))]
+                private static IEnumerable<CodeInstruction> UIStarmapPlanet__OnLateUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+                {
+                    var matcher = new CodeMatcher(instructions, generator);
+                    matcher.MatchForward(false,
+                        new CodeMatch(OpCodes.Ldarg_0),
+                        new CodeMatch(OpCodes.Ldloc_3),
+                        new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet.projected)))
+                    );
+                    matcher.Advance(3);
+                    matcher.CreateLabel(out var jumpPos1);
+                    matcher.InsertAndAdvance(
+                        new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))),
+                        new CodeInstruction(OpCodes.Ldc_I4_2),
+                        new CodeInstruction(OpCodes.Ceq),
+                        new CodeInstruction(OpCodes.Brfalse, jumpPos1),
+                        new CodeInstruction(OpCodes.Ldc_I4_0),
+                        new CodeInstruction(OpCodes.Stloc_3)
+                    );
+                    matcher.MatchForward(false,
+                        new CodeMatch(OpCodes.Ldarg_0),
+                        new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet.gameHistory))),
+                        new CodeMatch(OpCodes.Ldarg_0),
+                        new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapPlanet), nameof(UIStarmapPlanet.planet))),
+                        new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(PlanetData), nameof(PlanetData.id))),
+                        new CodeMatch(OpCodes.Callvirt, AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.GetPlanetPin))),
+                        new CodeMatch(OpCodes.Ldc_I4_1),
+                        new CodeMatch(ci => ci.Branches(out _)),
+                        new CodeMatch(OpCodes.Ldc_I4_1),
+                        new CodeMatch(ci => ci.IsStloc()),
+                        new CodeMatch(ci => ci.Branches(out _))
+                    );
+                    matcher.CreateLabelAt(matcher.Pos + 8, out var jumpPos);
+                    var labels = matcher.Labels;
+                    matcher.Labels = null;
+                    matcher.InsertAndAdvance(
+                        new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))).WithLabels(labels),
+                        new CodeInstruction(OpCodes.Ldc_I4_1),
+                        new CodeInstruction(OpCodes.Ceq),
+                        new CodeInstruction(OpCodes.Brtrue, jumpPos),
+                        new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(PlayerPatch), nameof(_showAllStarsNameKey))),
+                        new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(KeyBindings), nameof(KeyBindings.IsKeyPressing))),
+                        new CodeInstruction(OpCodes.Brtrue, jumpPos)
+                    );
+                    return matcher.InstructionEnumeration();
+                }
+
+                [HarmonyTranspiler]
+                [HarmonyPatch(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive._OnLateUpdate))]
+                private static IEnumerable<CodeInstruction> UIStarmapDFHive__OnLateUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+                {
+                    var matcher = new CodeMatcher(instructions, generator);
+                    matcher.MatchForward(false,
+                        new CodeMatch(OpCodes.Ldarg_0),
+                        new CodeMatch(ci => ci.IsLdloc()),
+                        new CodeMatch(OpCodes.Stfld, AccessTools.Field(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive.projected)))
+                    );
+                    matcher.Advance(3);
+                    matcher.CreateLabel(out var jumpPos1);
+                    matcher.InsertAndAdvance(
+                        new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))),
+                        new CodeInstruction(OpCodes.Ldc_I4_2),
+                        new CodeInstruction(OpCodes.Ceq),
+                        new CodeInstruction(OpCodes.Brfalse, jumpPos1),
+                        new CodeInstruction(OpCodes.Ldc_I4_0),
+                        new CodeInstruction(OpCodes.Stloc_S, 4)
+                    );
+                    matcher.MatchForward(false,
+                        new CodeMatch(OpCodes.Ldarg_0),
+                        new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive.gameHistory))),
+                        new CodeMatch(OpCodes.Ldarg_0),
+                        new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(UIStarmapDFHive), nameof(UIStarmapDFHive.hive))),
+                        new CodeMatch(OpCodes.Ldfld, AccessTools.Field(typeof(EnemyDFHiveSystem), nameof(EnemyDFHiveSystem.hiveStarId))),
+                        new CodeMatch(OpCodes.Ldc_I4, 1000000),
+                        new CodeMatch(OpCodes.Sub),
+                        new CodeMatch(OpCodes.Callvirt, AccessTools.Field(typeof(GameHistoryData), nameof(GameHistoryData.GetHivePin))),
+                        new CodeMatch(OpCodes.Ldc_I4_1),
+                        new CodeMatch(ci => ci.Branches(out _)),
+                        new CodeMatch(OpCodes.Ldc_I4_1),
+                        new CodeMatch(ci => ci.IsStloc()),
+                        new CodeMatch(ci => ci.Branches(out _))
+                    );
+                    matcher.CreateLabelAt(matcher.Pos + 10, out var jumpPos);
+                    var labels = matcher.Labels;
+                    matcher.Labels = null;
+                    matcher.InsertAndAdvance(
+                        new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(ShortcutKeysForStarsName), nameof(_showAllStarsNameStatus))).WithLabels(labels),
+                        new CodeInstruction(OpCodes.Ldc_I4_1),
+                        new CodeInstruction(OpCodes.Ceq),
+                        new CodeInstruction(OpCodes.Brtrue, jumpPos),
+                        new CodeInstruction(OpCodes.Ldsfld, AccessTools.Field(typeof(PlayerPatch), nameof(_showAllStarsNameKey))),
+                        new CodeInstruction(OpCodes.Call, AccessTools.Method(typeof(KeyBindings), nameof(KeyBindings.IsKeyPressing))),
+                        new CodeInstruction(OpCodes.Brtrue, jumpPos)
+                    );
+                    return matcher.InstructionEnumeration();
+                }
+        */
+    }
+
+    public class AutoNavigation : PatchImpl<AutoNavigation>
     {
         private static bool _canUseWarper;
         private static int _indicatorAstroId;
         private static bool _speedUp;
         private static Vector3 _direction;
 
+        public static int IndicatorAstroId => _indicatorAstroId;
+
         public static void ToggleAutoCruise()
         {
             AutoCruiseEnabled.Value = !AutoCruiseEnabled.Value;
@@ -155,9 +365,9 @@ public static class PlayerPatch
                     if (navi.indicatorAstroId != _indicatorAstroId)
                     {
                         _indicatorAstroId = navi.indicatorAstroId;
-                        if (_indicatorAstroId == 0) return;
+                        Functions.UIFunctions.UpdateToggleAutoCruiseCheckButtonVisiblility();
                     }
-                    else if (_indicatorAstroId == 0) return;
+                    if (_indicatorAstroId == 0) return;
                     switch (controller.movementStateInFrame)
                     {
                         case EMovementState.Walk:
@@ -184,12 +394,12 @@ public static class PlayerPatch
                             var astroVec = astro.uPos - playerPos;
                             var distance = astroVec.magnitude;
                             if (distance < astro.type switch
-                                {
+                            {
-                                    EAstroType.Planet => 800.0 + astro.uRadius,
+                                EAstroType.Planet => 800.0 + astro.uRadius,
-                                    EAstroType.Star => 4000.0 + astro.uRadius,
+                                EAstroType.Star => 4000.0 + astro.uRadius,
-                                    EAstroType.EnemyHive => 400.0,
+                                EAstroType.EnemyHive => 800.0,
-                                    _ => 2000.0 + astro.uRadius
+                                _ => 2000.0 + astro.uRadius
-                                })
+                            })
                             {
                                 if (isHive)
                                 {
@@ -204,7 +414,7 @@ public static class PlayerPatch
 
                                 /* Check nearest astroes, try to bypass them */
                                 var localStar = GameMain.localStar;
-                                _canUseWarper = autoCruise && !player.warping && player.mecha.warpStorage.GetItemCount(1210) > 0;
+                                _canUseWarper = autoCruise && player.mecha.thrusterLevel >= 3 && !player.warping && player.mecha.HasWarper();
                                 if (localStar != null)
                                 {
                                     var nearestRange = (playerPos - localStar.uPosition).sqrMagnitude;
@@ -228,9 +438,9 @@ public static class PlayerPatch
                                             if (hiveSys.realized && hiveSys.hiveAstroId > 1000000)
                                             {
                                                 ref var hiveAstro = ref GameMain.spaceSector.astros[hiveSys.hiveAstroId - 1000000];
-                                                /* Divide by 4, so that the real range is 2 times of the calculated range,
+                                                /* Divide by 36, so that the real range is 6 times of the calculated range,
-                                                   which means the minimal range allowed is 4000 */
+                                                   which means the minimal range allowed is 12000 */
-                                                var range = (playerPos - hiveAstro.uPos).sqrMagnitude / 4.0;
+                                                var range = (playerPos - hiveAstro.uPos).sqrMagnitude / 36.0;
                                                 if (range < nearestRange)
                                                 {
                                                     nearestRange = range;
@@ -272,12 +482,12 @@ public static class PlayerPatch
                                     if (distance < GalaxyData.LY * 1.5)
                                     {
                                         if (distance < actionSail.currentWarpSpeed * distance switch
-                                            {
+                                        {
-                                                > GalaxyData.LY * 0.6 => 0.33,
+                                            > GalaxyData.LY * 0.6 => 0.33,
-                                                > GalaxyData.LY * 0.3 => 0.5,
+                                            > GalaxyData.LY * 0.3 => 0.5,
-                                                > GalaxyData.LY * 0.1 => 0.66,
+                                            > GalaxyData.LY * 0.1 => 0.66,
-                                                _ => 1.0
+                                            _ => 1.0
-                                            })
+                                        })
                                         {
                                             controller.input0.y = -1f;
                                         }
@@ -319,7 +529,7 @@ public static class PlayerPatch
             );
             return matcher.InstructionEnumeration();
         }
-        
+
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(VFInput), nameof(VFInput._sailSpeedUp), MethodType.Getter)]
         private static IEnumerable<CodeInstruction> VFInput_sailSpeedUp_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
@@ -335,7 +545,7 @@ public static class PlayerPatch
             return matcher.InstructionEnumeration();
         }
 
-        /* Disable Lock Cursor Mode on entering sail panel 
+        /* Disable Lock Cursor Mode on entering sail panel
         [HarmonyPrefix]
         [HarmonyPatch(typeof(UISailPanel), nameof(UISailPanel._OnOpen))]
         public static void OnOpen_Prefix()

UXAssist/Patches/TechPatch.cs

@@ -1,57 +1,65 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
+using System.Linq;
 using System.Reflection.Emit;
 using BepInEx.Configuration;
 using HarmonyLib;
-using UnityEngine;
+using UnityEngine.UI;
 using UXAssist.Common;
+using GameLogicProc = UXAssist.Common.GameLogic;
 
 namespace UXAssist.Patches;
 
 public static class TechPatch
 {
     public static ConfigEntry<bool> SorterCargoStackingEnabled;
+    public static ConfigEntry<bool> DisableBattleRelatedTechsInPeaceModeEnabled;
     public static ConfigEntry<bool> BatchBuyoutTechEnabled;
-    
+
     public static void Init()
     {
         I18N.Add("分拣器运货量", "Sorter Mk.III cargo stacking : ", "极速分拣器每次可运送 ");
         SorterCargoStackingEnabled.SettingChanged += (_, _) => SorterCargoStacking.Enable(SorterCargoStackingEnabled.Value);
+        DisableBattleRelatedTechsInPeaceModeEnabled.SettingChanged += (_, _) => DisableBattleRelatedTechsInPeaceMode.Enable(DisableBattleRelatedTechsInPeaceModeEnabled.Value);
         BatchBuyoutTechEnabled.SettingChanged += (_, _) => BatchBuyoutTech.Enable(BatchBuyoutTechEnabled.Value);
     }
 
     public static void Start()
     {
         SorterCargoStacking.Enable(SorterCargoStackingEnabled.Value);
+        DisableBattleRelatedTechsInPeaceMode.Enable(DisableBattleRelatedTechsInPeaceModeEnabled.Value);
         BatchBuyoutTech.Enable(BatchBuyoutTechEnabled.Value);
     }
 
     public static void Uninit()
     {
         BatchBuyoutTech.Enable(false);
+        DisableBattleRelatedTechsInPeaceMode.Enable(false);
         SorterCargoStacking.Enable(false);
     }
-    
+
-    private class SorterCargoStacking: PatchImpl<SorterCargoStacking>
+    private class SorterCargoStacking
     {
         private static bool _protoPatched;
-        
+
-        protected override void OnEnable()
+        public static void Enable(bool enable)
         {
-            TryPatchProto(true);
+            if (enable)
-            GameLogic.OnDataLoaded += VFPreload_InvokeOnLoadWorkEnded_Postfix;
+            {
-        }
+                TryPatchProto(true);
-        
+                GameLogicProc.OnDataLoaded += VFPreload_InvokeOnLoadWorkEnded_Postfix;
-        protected override void OnDisable()
+            }
-        {
+            else
-            GameLogic.OnDataLoaded -= VFPreload_InvokeOnLoadWorkEnded_Postfix;
+            {
-            TryPatchProto(false);
+                GameLogicProc.OnDataLoaded -= VFPreload_InvokeOnLoadWorkEnded_Postfix;
+                TryPatchProto(false);
+            }
         }
 
         private static void TryPatchProto(bool on)
         {
+            if (DSPGame.IsMenuDemo) return;
             var techs = LDB.techs;
-            if (techs == null || techs.dataArray == null || techs.dataArray.Length == 0) return;
+            if (techs == null || techs?.dataArray == null || techs.dataArray.Length == 0) return;
             if (on)
             {
                 var delim = -26.0f;
@@ -114,162 +122,173 @@ public static class TechPatch
         }
     }
 
-    private class BatchBuyoutTech: PatchImpl<BatchBuyoutTech>
+    private static class DisableBattleRelatedTechsInPeaceMode
     {
-        private static void GenerateTechList(GameHistoryData history, int techId, List<int> techIdList)
+        private static bool _protoPatched;
+        private static HashSet<int> _techsToDisableSet;
+        private static Dictionary<int, TechProto[]> _originTechPosts = [];
+
+        public static void Enable(bool enable)
         {
-            var techProto = LDB.techs.Select(techId);
+            if (_techsToDisableSet == null)
-            if (techProto == null || !techProto.Published) return;
-            var flag = true;
-            for (var i = 0; i < 2; i++)
             {
-                var array = techProto.PreTechs;
+                (int, int)[] techListToDisable =
-                if (i == 1)
+                [
-                {
+                    // Explosive Unit, Crystal Explosive Unit
-                    array = techProto.PreTechsImplicit;
+                    // 爆破单元，晶石爆破单元
-                }
+                    (1803, 1804),
-                for (var j = 0; j < array.Length; j++)
+                    // Implosion Cannon
-                {
+                    // 聚爆加农炮
-                    if (!history.techStates.ContainsKey(array[j]) || history.techStates[array[j]].unlocked) continue;
+                    (1807, 1807),
-                    if (history.techStates[array[j]].maxLevel > history.techStates[array[j]].curLevel)
+                    // Signal Tower, Planetary Defense System, Jammer Tower, Plasma Turret, Titanium Ammo Box, Superalloy Ammo Box, High-Explosive Shell Set, Supersonic Missile Set, Crystal Shell Set, Gravity Missile Set, Antimatter Capsule, Precision Drone, Prototype, Attack Drone, Corvette, Destroyer, Suppressing Capsule, EM Capsule Mk.III
-                    {
+                    // 信号塔, 行星防御系统, 干扰塔, 磁化电浆炮, 钛化弹箱, 超合金弹箱, 高爆炮弹组, 超音速导弹组, 晶石炮弹组, 引力导弹组, 反物质胶囊, 地面战斗机-A型, 地面战斗机-E型, 地面战斗机-F型, 太空战斗机-A型, 太空战斗机-F型, 电磁胶囊II, 电磁胶囊III
-                        flag = false;
+                    (1809, 1825),
-                    }
+                    // Auto Reconstruction Marking
-                    GenerateTechList(history, array[j], techIdList);
+                    // 自动标记重建
-                }
+                    (2951, 2956),
+                    // Energy Shield
+                    // 能量护盾
+                    (2801, 2807),
+                    // Kinetic Weapon Damage
+                    // 动能武器伤害
+                    (5001, 5006),
+                    // Energy Weapon Damage
+                    // 能量武器伤害
+                    (5101, 5106),
+                    // Explosive Weapon Damage
+                    // 爆炸武器伤害
+                    (5201, 5206),
+                    // Combat Drone Damage
+                    // 战斗无人机伤害
+                    (5301, 5305),
+                    // Combat Drone Attack Speed
+                    // 战斗无人机攻击速度
+                    (5401, 5405),
+                    // Combat Drone Engine
+                    // 战斗无人机引擎
+                    (5601, 5605),
+                    // Combat Drone Durability
+                    // 战斗无人机耐久
+                    (5701, 5705),
+                    // Ground Squadron Expansion
+                    // 地面编队扩容
+                    (5801, 5807),
+                    // Space Fleet Expansion
+                    // 太空编队扩容
+                    (5901, 5907),
+                    // Enhanced Structure
+                    // 结构强化
+                    (6001, 6006),
+                    // Planetary Shield
+                    // 行星护盾
+                    (6101, 6106),
+                ];
+                _techsToDisableSet = [.. techListToDisable.SelectMany(t => Enumerable.Range(t.Item1, t.Item2 - t.Item1 + 1))];
             }
-            if (history.techStates.ContainsKey(techId) && !history.techStates[techId].unlocked && flag)
+            if (enable)
             {
-                techIdList.Add(techId);
+                if (DSPGame.GameDesc != null)
+                    TryPatchProto(DSPGame.GameDesc.isPeaceMode);
+                GameLogicProc.OnGameBegin += OnGameBegin;
+            }
+            else
+            {
+                GameLogicProc.OnGameBegin -= OnGameBegin;
+                TryPatchProto(false);
             }
         }
 
-        
+        private static void OnGameBegin()
-        private static void CheckTechUnlockProperties(GameHistoryData history, TechProto techProto, int[] properties, List<Tuple<TechProto, int, int>> techList, int maxLevel = 10000)
         {
-            var techStates = history.techStates;
+            TryPatchProto(DSPGame.GameDesc.isPeaceMode);
-            var techID = techProto.ID;
-            if (techStates == null || !techStates.TryGetValue(techID, out var value)) return;
-            if (value.unlocked) return;
-
-            var maxLvl = Math.Min(maxLevel < 0 ? value.curLevel - maxLevel - 1 : maxLevel, value.maxLevel);
-
-            foreach (var preid in techProto.PreTechs)
-            {
-                var preProto = LDB.techs.Select(preid);
-                if (preProto != null)
-                    CheckTechUnlockProperties(history, preProto, properties, techList, techProto.PreTechsMax ? 10000 : preProto.Level);
-            }
-            foreach (var preid in techProto.PreTechsImplicit)
-            {
-                var preProto = LDB.techs.Select(preid);
-                if (preProto != null)
-                    CheckTechUnlockProperties(history, preProto, properties, techList, techProto.PreTechsMax ? 10000 : preProto.Level);
-            }
-
-            if (value.curLevel < techProto.Level) value.curLevel = techProto.Level;
-            techList.Add(new Tuple<TechProto, int, int>(techProto, value.curLevel, techProto.Level));
-            while (value.curLevel <= maxLvl)
-            {
-                if (techProto.PropertyOverrideItemArray != null)
-                {
-                    var propertyOverrideItemArray = techProto.PropertyOverrideItemArray;
-                    for (var i = 0; i < propertyOverrideItemArray.Length; i++)
-                    {
-                        var id = propertyOverrideItemArray[i].id;
-                        var count = (float)propertyOverrideItemArray[i].count;
-                        var ratio = Mathf.Clamp01((float)((double)value.hashUploaded / value.hashNeeded));
-                        var consume = Mathf.CeilToInt(count * (1f - ratio));
-                        properties[id - 6001] += consume;
-                    }
-                }
-                else
-                {
-                    for (var j = 0; j < techProto.itemArray.Length; j++)
-                    {
-                        var id = techProto.itemArray[j].ID;
-                        var consume = (int)(techProto.ItemPoints[j] * (value.hashNeeded - value.hashUploaded) / 3600L);
-                        properties[id - 6001] += consume;
-                    }
-                }
-                value.curLevel++;
-                value.hashUploaded = 0;
-                value.hashNeeded = techProto.GetHashNeeded(value.curLevel);
-            }
         }
 
-        private static int UnlockTechRecursiveImpl(GameHistoryData history, TechProto techProto, int maxLevel = 10000)
+        private static void TryPatchProto(bool on)
         {
-            var techStates = history.techStates;
+            if (DSPGame.IsMenuDemo || on == _protoPatched) return;
-            var techID = techProto.ID;
+            var techs = LDB.techs;
-            if (techStates == null || !techStates.TryGetValue(techID, out var value))
+            if (techs?.dataArray == null || techs.dataArray.Length == 0) return;
+            if (on)
             {
-                return -1;
+                foreach (var tp in techs.dataArray)
-            }
-
-            if (value.unlocked)
-            {
-                return -1;
-            }
-
-            var maxLvl = Math.Min(maxLevel < 0 ? value.curLevel - maxLevel - 1 : maxLevel, value.maxLevel);
-
-            foreach (var preid in techProto.PreTechs)
-            {
-                var preProto = LDB.techs.Select(preid);
-                if (preProto != null)
-                    UnlockTechRecursiveImpl(history, preProto, techProto.PreTechsMax ? 10000 : preProto.Level);
-            }
-            foreach (var preid in techProto.PreTechsImplicit)
-            {
-                var preProto = LDB.techs.Select(preid);
-                if (preProto != null)
-                    UnlockTechRecursiveImpl(history, preProto, techProto.PreTechsMax ? 10000 : preProto.Level);
-            }
-
-            if (value.curLevel < techProto.Level) value.curLevel = techProto.Level;
-            while (value.curLevel <= maxLvl)
-            {
-                if (value.curLevel == 0)
                 {
-                    foreach (var recipe in techProto.UnlockRecipes)
+                    if (_techsToDisableSet.Contains(tp.ID))
                     {
-                        history.UnlockRecipe(recipe);
+                        tp.IsObsolete = true;
+                    }
+                    var postTechs = tp.postTechArray;
+                    for (var i = postTechs.Length - 1; i >= 0; i--)
+                    {
+                        if (_techsToDisableSet.Contains(postTechs[i].ID))
+                        {
+                            _originTechPosts[tp.ID] = postTechs;
+                            tp.postTechArray = [.. postTechs.Where(p => !_techsToDisableSet.Contains(p.ID))];
+                            break;
+                        }
                     }
                 }
-
+                _protoPatched = true;
-                for (var j = 0; j < techProto.UnlockFunctions.Length; j++)
-                {
-                    history.UnlockTechFunction(techProto.UnlockFunctions[j], techProto.UnlockValues[j], value.curLevel);
-                }
-
-                for (var k = 0; k < techProto.AddItems.Length; k++)
-                {
-                    history.GainTechAwards(techProto.AddItems[k], techProto.AddItemCounts[k]);
-                }
-
-                value.curLevel++;
             }
-
+            else
-            value.unlocked = maxLvl >= value.maxLevel;
+            {
-            value.curLevel = value.unlocked ? maxLvl : maxLvl + 1;
+                foreach (var tp in techs.dataArray)
-            value.hashNeeded = techProto.GetHashNeeded(value.curLevel);
+                {
-            value.hashUploaded = value.unlocked ? value.hashNeeded : 0;
+                    if (_techsToDisableSet.Contains(tp.ID))
-            techStates[techID] = value;
+                    {
-            return maxLvl;
+                        tp.IsObsolete = false;
-        }
+                    }
-
+                    if (_originTechPosts.TryGetValue(tp.ID, out var postTechs))
-        private static bool UnlockTechRecursive(TechProto techProto, int maxLevel = 10000)
+                    {
-        {
+                        tp.postTechArray = postTechs;
-            if (techProto == null) return false;
+                    }
+                }
+                _originTechPosts.Clear();
+                _protoPatched = false;
+            }
+            var nodes = UIRoot.instance.uiGame.techTree.nodes;
             var history = GameMain.history;
-            var ulvl = UnlockTechRecursiveImpl(history, techProto, maxLevel);
+            foreach (var item in nodes)
-            if (ulvl < 0) return false;
+            {
-            history.RegFeatureKey(1000100);
+                var node = item.Value;
-            history.NotifyTechUnlock(techProto.ID, ulvl);
+                foreach (var arrow in node.arrows)
-            return true;
+                {
+                    arrow.gameObject.SetActive(false);
+                }
+                var postTechArray = node.techProto.postTechArray;
+                var active = postTechArray.Length > 0;
+                node.connGroup.gameObject.SetActive(active);
+                node.connImages = active ? node.connGroup.GetComponentsInChildren<Image>(true) : [];
+                if (!active) continue;
+                bool onlyOneOutput = postTechArray.Length == 1;
+                for (var i = 0; i < postTechArray.Length; i++)
+                {
+                    var postTech = postTechArray[i];
+                    if (!nodes.ContainsKey(postTech.ID)) continue;
+                    bool itemUnlocked = true;
+                    for (var n = 0; n < postTech.PreItem.Length; n++)
+                    {
+                        if (history.ItemUnlocked(postTech.PreItem[n])) continue;
+                        itemUnlocked = false;
+                        break;
+                    }
+                    bool techUnlocked = history.TechUnlocked(postTech.ID);
+                    node.arrows[i].gameObject.SetActive(itemUnlocked || techUnlocked);
+                    if (onlyOneOutput && !itemUnlocked && !techUnlocked)
+                    {
+                        node.outputArrow.enabled = false;
+                        node.outputLine.gameObject.SetActive(false);
+                    }
+                    else
+                    {
+                        node.outputLine.gameObject.SetActive(true);
+                    }
+                }
+            }
         }
-        
+    }
+
+    private class BatchBuyoutTech : PatchImpl<BatchBuyoutTech>
+    {
         [HarmonyTranspiler]
         [HarmonyPatch(typeof(UITechNode), nameof(UITechNode.UpdateInfoDynamic))]
         private static IEnumerable<CodeInstruction> UITechNode_UpdateInfoDynamic_Transpiler(IEnumerable<CodeInstruction> instructions)
@@ -285,7 +304,7 @@ public static class TechPatch
             );
             return matcher.InstructionEnumeration();
         }
-        
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(UITechNode), nameof(UITechNode.OnBuyoutButtonClick))]
         private static bool UITechNode_OnBuyoutButtonClick_Prefix(UITechNode __instance)
@@ -296,109 +315,8 @@ public static class TechPatch
             }
             var techProto = __instance.techProto;
             if (techProto == null) return false;
-            var properties = new int[6];
+            Functions.TechFunctions.UnlockProtoWithMetadataAndPrompt([techProto], -1, true);
-            List<Tuple<TechProto, int, int>> techList = new();
-            var history = GameMain.history;
-            var maxLevel = -1;
-            CheckTechUnlockProperties(history, techProto, properties, techList, maxLevel);
-            var propertySystem = DSPGame.propertySystem;
-            var clusterSeedKey = history.gameData.GetClusterSeedKey();
-            var enough = true;
-            for (var i = 0; i < 6; i++)
-            {
-                if (propertySystem.GetItemAvaliableProperty(clusterSeedKey, 6001 + i) >= properties[i]) continue;
-                enough = false;
-                break;
-            }
-            if (!enough)
-            {
-                UIRealtimeTip.Popup("元数据不足".Translate());
-                return false;
-            }
-
-            if (!history.hasUsedPropertyBanAchievement)
-            {
-                UIMessageBox.Show("初次使用元数据标题".Translate(), "初次使用元数据描述".Translate(), "取消".Translate(), "确定".Translate(), 2, null, DoUnlockFunc);
-                return false;
-            }
-
-            DoUnlockFunc();
             return false;
-
-            void DoUnlockFunc()
-            {
-                if (techList.Count <= 1)
-                {
-                    DoUnlockFuncInternal();
-                    return;
-                }
-                var msg = "要使用元数据买断以下科技吗？";
-
-                if (techList.Count <= 10)
-                {
-                    foreach (var tuple in techList)
-                    {
-                        AddToMsg(ref msg, tuple);
-                    }
-                }
-                else
-                {
-                    for (var i = 0; i < 5; i++)
-                    {
-                        AddToMsg(ref msg, techList[i]);
-                    }
-                    msg += "  ...\n";
-                    for (var i = techList.Count - 5; i < techList.Count; i++)
-                    {
-                        AddToMsg(ref msg, techList[i]);
-                    }
-                }
-
-                msg += "\n\n";
-                msg += "以下是买断所需元数据：";
-                for (var i = 0; i < 6; i++)
-                {
-                    var itemCount = properties[i];
-                    if (itemCount <= 0) continue;
-                    msg += $"\n  {LDB.items.Select(6001 + i).propertyName}x{itemCount}";
-                }
-                UIMessageBox.Show("批量买断科技", msg, "取消".Translate(), "确定".Translate(), 2, null, DoUnlockFuncInternal);
-                return;
-            
-                void AddToMsg(ref string str, Tuple<TechProto, int, int> tuple)
-                {
-                    if (tuple.Item2 == tuple.Item3)
-                    {
-                        if (tuple.Item2 <= 0)
-                            str += $"\n  {tuple.Item1.name}";
-                        else
-                            str += $"\n  {tuple.Item1.name}{"杠等级".Translate()}{tuple.Item2}";
-                    }
-                    else
-                        str += $"\n  {tuple.Item1.name}{"杠等级".Translate()}{tuple.Item2}->{tuple.Item3}";
-                }
-            }
-
-            void DoUnlockFuncInternal()
-            {
-                var mainPlayer = GameMain.mainPlayer;
-                for (var i = 0; i < 6; i++)
-                {
-                    var itemCount = properties[i];
-                    if (itemCount <= 0) continue;
-                    var itemId = 6001 + i;
-                    propertySystem.AddItemConsumption(clusterSeedKey, itemId, itemCount);
-                    history.AddPropertyItemConsumption(itemId, itemCount, true);
-                    mainPlayer.mecha.AddProductionStat(itemId, itemCount, mainPlayer.nearestFactory);
-                    mainPlayer.mecha.AddConsumptionStat(itemId, itemCount, mainPlayer.nearestFactory);
-                }
-                UnlockTechRecursive(__instance.techProto, maxLevel);
-                history.VarifyTechQueue();
-                if (history.currentTech != history.techQueue[0])
-                {
-                    history.currentTech = history.techQueue[0];
-                }
-            }
         }
     }
 }

UXAssist/Patches/UIPatch.cs

@@ -0,0 +1,396 @@
+namespace UXAssist.Patches;
+
+using System.Linq;
+using HarmonyLib;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using BepInEx.Configuration;
+using Common;
+using GameLogicProc = Common.GameLogic;
+
+[PatchGuid(PluginInfo.PLUGIN_GUID)]
+public class UIPatch : PatchImpl<UIPatch>
+{
+    public static ConfigEntry<bool> PlanetVeinUtilizationEnabled;
+
+    public static void Init()
+    {
+        PlanetVeinUtilizationEnabled.SettingChanged += (_, _) => PlanetVeinUtilization.Enable(PlanetVeinUtilizationEnabled.Value);
+    }
+
+    public static void Start()
+    {
+        GameLogicProc.OnGameBegin += PlanetVeinUtilization.OnGameBegin;
+        Enable(true);
+        Functions.UIFunctions.InitMenuButtons();
+        PlanetVeinUtilization.Enable(PlanetVeinUtilizationEnabled.Value);
+    }
+
+    public static void Uninit()
+    {
+        PlanetVeinUtilization.Enable(false);
+        Enable(false);
+        GameLogicProc.OnGameBegin -= PlanetVeinUtilization.OnGameBegin;
+    }
+
+    private class PlanetVeinUtilization : PatchImpl<PlanetVeinUtilization>
+    {
+        private static VeinTypeInfo[] planetVeinCount = null;
+        private static VeinTypeInfo[] starVeinCount = null;
+        private static readonly Dictionary<int, bool> tmpGroups = [];
+
+        public static void OnGameBegin()
+        {
+            if (planetVeinCount != null)
+            {
+                foreach (VeinTypeInfo vti in planetVeinCount)
+                {
+                    if (vti.textCtrl != null)
+                    {
+                        Object.Destroy(vti.textCtrl.gameObject);
+                    }
+                }
+                planetVeinCount = null;
+            }
+            if (starVeinCount != null)
+            {
+                foreach (VeinTypeInfo vti in starVeinCount)
+                {
+                    if (vti.textCtrl != null)
+                    {
+                        Object.Destroy(vti.textCtrl.gameObject);
+                    }
+                }
+                starVeinCount = null;
+            }
+            var maxVeinId = LDB.veins.dataArray.Max(vein => vein.ID);
+            planetVeinCount = new VeinTypeInfo[maxVeinId + 1];
+            starVeinCount = new VeinTypeInfo[maxVeinId + 1];
+            InitializeVeinCountArray(planetVeinCount);
+            InitializeVeinCountArray(starVeinCount);
+        }
+
+        protected override void OnEnable()
+        {
+            if (planetVeinCount != null)
+            {
+                foreach (VeinTypeInfo vti in planetVeinCount)
+                {
+                    vti.Reset();
+                    vti.textCtrl?.gameObject.SetActive(true);
+                }
+                UIPlanetDetail_RefreshDynamicProperties_Postfix(UIRoot.instance.uiGame.planetDetail);
+            }
+            if (starVeinCount != null)
+            {
+                foreach (VeinTypeInfo vti in starVeinCount)
+                {
+                    vti.Reset();
+                    vti.textCtrl?.gameObject.SetActive(true);
+                }
+                UIStarDetail_RefreshDynamicProperties_Postfix(UIRoot.instance.uiGame.starDetail);
+            }
+        }
+
+        private static Vector2 GetAdjustedSizeDelta(Vector2 origSizeDelta)
+        {
+            return new Vector2(origSizeDelta.x + 40f, origSizeDelta.y);
+        }
+
+        protected override void OnDisable()
+        {
+            if (planetVeinCount != null)
+            {
+                foreach (VeinTypeInfo vti in planetVeinCount)
+                {
+                    vti.Reset();
+                    vti.textCtrl?.gameObject.SetActive(false);
+                }
+            }
+            if (starVeinCount != null)
+            {
+                foreach (VeinTypeInfo vti in starVeinCount)
+                {
+                    vti.Reset();
+                    vti.textCtrl?.gameObject.SetActive(false);
+                }
+            }
+        }
+
+        #region Helper functions
+        private static void ProcessVeinData(VeinTypeInfo[] veinCount, VeinData[] veinPool)
+        {
+            lock (veinPool)
+            {
+                foreach (VeinData veinData in veinPool)
+                {
+                    if (veinData.groupIndex == 0 || veinData.amount == 0) continue;
+                    if (tmpGroups.TryGetValue(veinData.groupIndex, out bool hasMiner))
+                    {
+                        if (hasMiner) continue;
+                        hasMiner = veinData.minerCount > 0;
+                        if (!hasMiner) continue;
+                        tmpGroups[veinData.groupIndex] = true;
+                        VeinTypeInfo vti = veinCount[(int)veinData.type];
+                        vti.numVeinGroupsWithCollector++;
+                    }
+                    else
+                    {
+                        hasMiner = veinData.minerCount > 0;
+                        tmpGroups.Add(veinData.groupIndex, hasMiner);
+                        VeinTypeInfo vti = veinCount[(int)veinData.type];
+                        vti.numVeinGroups++;
+                        if (hasMiner)
+                        {
+                            vti.numVeinGroupsWithCollector++;
+                        }
+                    }
+                }
+            }
+            tmpGroups.Clear();
+        }
+
+        private static void FormatResource(int refId, UIResAmountEntry uiresAmountEntry, VeinTypeInfo vt)
+        {
+            if (vt.textCtrl == null)
+            {
+                var parent = uiresAmountEntry.labelText.transform.parent;
+                vt.textCtrl = Object.Instantiate(uiresAmountEntry.valueText, parent);
+                vt.textCtrl.font = uiresAmountEntry.labelText.font;
+                RectTransform trans = vt.textCtrl.rectTransform;
+                var pos = uiresAmountEntry.rectTrans.localPosition;
+                pos.x = pos.x + uiresAmountEntry.iconImage.rectTransform.localPosition.x - 25f;
+                trans.localPosition = pos;
+                Vector2 size = trans.sizeDelta;
+                size.x = 40f;
+                trans.sizeDelta = size;
+            }
+            else
+            {
+                RectTransform trans = vt.textCtrl.rectTransform;
+                Vector3 pos = trans.localPosition;
+                pos.y = uiresAmountEntry.rectTrans.localPosition.y;
+                trans.localPosition = pos;
+            }
+            vt.textCtrl.text = $"{vt.numVeinGroupsWithCollector}/{vt.numVeinGroups}";
+        }
+
+        private static void InitializeVeinCountArray(VeinTypeInfo[] veinCountArray)
+        {
+            for (int i = 0; i < veinCountArray.Length; i++)
+            {
+                veinCountArray[i] = new VeinTypeInfo();
+            }
+        }
+        #endregion
+
+        #region UIPlanetDetail patches
+        [HarmonyPrefix, HarmonyPatch(typeof(UIPlanetDetail), nameof(UIPlanetDetail.OnPlanetDataSet))]
+        public static void UIPlanetDetail_OnPlanetDataSet_Prefix(UIPlanetDetail __instance)
+        {
+            foreach (VeinTypeInfo vti in planetVeinCount)
+            {
+                vti.Reset();
+            }
+        }
+
+        [HarmonyPostfix, HarmonyPatch(typeof(UIPlanetDetail), nameof(UIPlanetDetail.RefreshDynamicProperties))]
+        public static void UIPlanetDetail_RefreshDynamicProperties_Postfix(UIPlanetDetail __instance)
+        {
+            PlanetData planet = __instance.planet;
+            if (planet == null || planet.runtimeVeinGroups == null || __instance.tabIndex != 0) { return; }
+
+            int observeLevelCheck = __instance.planet == GameMain.localPlanet ? 1 : 2;
+            if (GameMain.history.universeObserveLevel < observeLevelCheck) { return; }
+
+            foreach (VeinTypeInfo vti in planetVeinCount)
+            {
+                vti.numVeinGroups = 0;
+                vti.numVeinGroupsWithCollector = 0;
+            }
+            // count up the total number of vein groups per resource type, as well as the total number of groups that have a miner attached
+            PlanetFactory factory = planet.factory;
+            if (factory != null)
+            {
+                ProcessVeinData(planetVeinCount, factory.veinPool);
+            }
+            else
+            {
+                VeinGroup[] veinGroups = planet.runtimeVeinGroups;
+                lock (planet.veinGroupsLock)
+                {
+                    for (int i = 1; i < veinGroups.Length; i++)
+                    {
+                        planetVeinCount[(int)veinGroups[i].type].numVeinGroups++;
+                    }
+                }
+            }
+
+            // update each resource to show the following vein group info:
+            //     Iron:  <number of vein groups with miners> / <total number of vein groups>
+            foreach (UIResAmountEntry uiresAmountEntry in __instance.entries)
+            {
+                int refId = uiresAmountEntry.refId;
+                if (refId > 0 && refId < (int)EVeinType.Max)
+                {
+                    var vt = planetVeinCount[refId];
+                    if (vt.numVeinGroups > 0)
+                    {
+                        FormatResource(refId, uiresAmountEntry, vt);
+                    }
+                    else if (vt.textCtrl != null)
+                    {
+                        vt.textCtrl.text = "";
+                    }
+                }
+            }
+        }
+        #endregion
+
+        #region UIStarDetail patches
+        [HarmonyPrefix, HarmonyPatch(typeof(UIStarDetail), nameof(UIStarDetail.OnStarDataSet))]
+        public static void UIStaretail_OnStarDataSet_Prefix(UIStarDetail __instance)
+        {
+            foreach (VeinTypeInfo vti in starVeinCount)
+            {
+                vti.Reset();
+            }
+        }
+
+        [HarmonyPostfix, HarmonyPatch(typeof(UIStarDetail), nameof(UIStarDetail.RefreshDynamicProperties))]
+        public static void UIStarDetail_RefreshDynamicProperties_Postfix(UIStarDetail __instance)
+        {
+            if (__instance.star == null || __instance.tabIndex != 0) { return; }
+            if (GameMain.history.universeObserveLevel < 2) { return; }
+
+            foreach (VeinTypeInfo vti in starVeinCount)
+            {
+                vti.numVeinGroups = 0;
+                vti.numVeinGroupsWithCollector = 0;
+            }
+            foreach (PlanetData planet in __instance.star.planets)
+            {
+                if (planet.runtimeVeinGroups == null) { continue; }
+                PlanetFactory factory = planet.factory;
+                if (factory != null)
+                {
+                    ProcessVeinData(starVeinCount, factory.veinPool);
+                }
+                else
+                {
+                    VeinGroup[] veinGroups = planet.runtimeVeinGroups;
+                    lock (planet.veinGroupsLock)
+                    {
+                        for (int i = 1; i < veinGroups.Length; i++)
+                        {
+                            starVeinCount[(int)veinGroups[i].type].numVeinGroups++;
+                        }
+                    }
+                }
+            }
+            // update each resource to show the following vein group info:
+            //     Iron:  <number of vein groups with miners> / <total number of vein groups>
+            foreach (UIResAmountEntry uiresAmountEntry in __instance.entries)
+            {
+                int refId = uiresAmountEntry.refId;
+                if (refId > 0 && refId < (int)EVeinType.Max)
+                {
+                    var vt = starVeinCount[refId];
+                    if (vt.numVeinGroups > 0)
+                    {
+                        FormatResource(refId, uiresAmountEntry, vt);
+                    }
+                    else if (vt.textCtrl != null)
+                    {
+                        vt.textCtrl.text = "";
+                    }
+                }
+            }
+        }
+        #endregion
+    }
+
+    public class VeinTypeInfo
+    {
+        public int numVeinGroups;
+        public int numVeinGroupsWithCollector;
+        public Text textCtrl;
+
+        public void Reset()
+        {
+            numVeinGroups = 0;
+            numVeinGroupsWithCollector = 0;
+            if (textCtrl != null)
+            {
+                textCtrl.text = "";
+            }
+        }
+    }
+
+    // Add config button to main menu
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(UIRoot), nameof(UIRoot._OnOpen))]
+    public static void UIRoot__OnOpen_Postfix()
+    {
+        Functions.UIFunctions.InitMenuButtons();
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(PlanetData), nameof(PlanetData.NotifyScanEnded))]
+    private static void PlanetData_NotifyScanEnded_Postfix(PlanetData __instance)
+    {
+        if (PlanetModelingManager.scnPlanetReqList.Count > 0) return;
+        BepInEx.ThreadingHelper.Instance.StartSyncInvoke(Functions.UIFunctions.OnPlanetScanEnded);
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(UIPlanetGlobe), nameof(UIPlanetGlobe.DistributeButtons))]
+    private static void UIPlanetGlobe_DistributeButtons_Postfix(UIPlanetGlobe __instance)
+    {
+        Functions.UIFunctions.UpdateGlobeButtonPosition(__instance);
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(UIStarmapStar), nameof(UIStarmapStar.OnStarDisplayNameChange))]
+    private static bool UIStarmapStar_OnStarDisplayNameChange_Prefix()
+    {
+        return Functions.UIFunctions.CornerComboBoxIndex == 0;
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPatch(typeof(UIStarmapStar), nameof(UIStarmapStar._OnClose))]
+    private static void UIStarmapStar__OnClose_Postfix(UIStarmapStar __instance)
+    {
+        Functions.UIFunctions.StarmapFilterToggler?.SetCheckedWithEvent(false);
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(UIMechaLab), nameof(UIMechaLab.DetermineVisible))]
+    private static bool UIMechaLab_DetermineVisible_Prefix(UIMechaLab __instance, ref bool __result)
+    {
+        if (!UIRoot.instance.uiGame.starmap.active || !Functions.UIFunctions.StarmapFilterToggler.Checked)
+        {
+            return true;
+        }
+        __instance._Close();
+        __result = false;
+        return false;
+    }
+
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(UIGoalPanel), nameof(UIGoalPanel.DetermineVisiable))]
+    private static bool UIGoalPanel_DetermineVisiable_Prefix(UIGoalPanel __instance)
+    {
+        if (!UIRoot.instance.uiGame.starmap.active || !Functions.UIFunctions.StarmapFilterToggler.Checked)
+        {
+            return true;
+        }
+        __instance.isUseOverwrittenState = true;
+        if (__instance.stateOverwritten == EUIGoalPanelState.None)
+        {
+            __instance.stateOverwritten = EUIGoalPanelState.Collapse;
+        }
+        return false;
+    }
+}

UXAssist/README.md

@@ -1,118 +1,146 @@
 # UXAssist
 
-#### Some functions and patches for better user experience
+<details>
+<summary>Read me in English</summary>
 
-#### 一些提升用户体验的功能和补丁
+***Some functions and patches for better user experience***
 
 ## Usage
 
 * Press `` Alt+`(BackQuote) `` to call up the config panel. You can change the shortcut on the panel.
 * There are also buttons on title screen and planet minimap area to call up the config panel.
 * Patches:
-  + 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
-  + 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)
-  + Enable `Hide UI` function(`F11` by default) while on Star Map view
+  * Enable `Hide UI` function(`F11` by default) while on Star Map view
-  + Append mod profile name to game window title, if using mod managers (`Thunderstore Mod Manager` or `r2modman`).
+  * Append mod profile name to game window title, if using mod managers (`Thunderstore Mod Manager` or `r2modman`).
 * Features:
-  + General
+  * General
-    - Enable game window resize
+    * Enable game window resize
-    - Remember window position and size on last exit
+    * Remember window position and size on last exit
-    - Convert Peace-Mode saves to Combat-Mode on loading
+    * Convert Peace-Mode saves to Combat-Mode on loading
-    - Scale up mouse cursor
+    * Mod manager profile based save folder
-      - Note: This will enable software cursor mode, which may cause mouse movement lag on heavy load.
+      * Save files are stored in `Save\<ProfileName>` folder.
-    - Mod manager profile based save folder
+      * Will use original save location if matching default profile name.
-      - Save files are stored in `Save\<ProfileName>` folder.
+    * Mod manager profile based option
-      - Will use original save location if matching default profile name.
+      * Option file is stored as `Options\<ProfileName>.xml`.
-    - Logical Frame Rate
+    * Logical Frame Rate
-      - This will change game running speed, down to 0.1x slower and up to 10x faster.
+      * This will change game running speed, down to 0.1x slower and up to 10x faster.
-      - A pair of shortcut keys (`-` and `+`) to change the logical frame rate by -0.5x and +0.5x.
+      * A pair of shortcut keys (`-` and `+`) to change the logical frame rate by -0.5x and +0.5x.
-      - Note:
+      * Note:
-        - High logical frame rate is not guaranteed to be stable, especially when factories are under heavy load.
+        * High logical frame rate is not guaranteed to be stable, especially when factories are under heavy load.
-        - This will not affect some game animations.
+        * This will not affect some game animations.
-        - When set game speed in mod `Auxilaryfunction`, this feature will be disabled.
+        * When set game speed in mod `Auxilaryfunction`, this feature will be disabled.
-        - When mod `BulletTime` is installed, this feature will be hidden, but patch `BulletTime`'s speed control, to make its maximum speed 10x.
+        * When mod `BulletTime` is installed, this feature will be hidden, but patch `BulletTime`'s speed control, to make its maximum speed 10x.
-    - Set process priority
+    * Set process priority
-    - Set enabled CPU threads
+    * 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)
+  * Factory
-  + Planet/Factory
+    * Sunlight at night
-    - Sunlight at night
+    * Remove some build conditions
-    - Remove some build conditions
+    * Remove build count and range limit
-    - Remove build count and range limit
+    * Larger area for upgrade and dismantle(30x30 at max)
-    - Larger area for upgrade and dismantle(30x30 at max)
+    * Larger area for terraform(30x30 at max)
-    - Larger area for terraform(30x30 at max)
+    * Off-grid building and stepped rotation
-    - Off-grid building and stepped rotation
+    * Cut conveyor belt
-    - Treat stack items as single in monitor components
+      * Press shortcut key to cut conveyor belt under cursor.
-    - Enhanced control for logistic storage limits
+      * The default shortcut key is Alt+X, you can set it in system options panel.
-      - Logistic storage limits are not scaled on upgrading `Logistics Carrier Capacity`, if they are not set to maximum capacity.
+    * Treat stack items as single in monitor components
-      - You can use arrow keys to adjust logistic storage limits gracefully.
+    * Quick build and dismantle stacking labs/storages/tanks
-    - Quick build and dismantle stacking labs/storages/tanks
+    * Fast fill in to and take out from tanks
-    - Fast fill in to and take out from tanks
+      * You can set multiplier for tanks' operation speed
-      - You can set multiplier for tanks' operation speed
+      * This affects manually fill in to and/or take out from tanks, as well as transfer from upper to lower level.
-      - This affects manually fill in to and/or take out from tanks, as well as transfer from upper to lower level.
+    * Protect veins from exhaustion
-    - Protect veins from exhaustion
+      * By default, the vein amount is protected at 100, and oil speed is protected at 1.0/s, you can set them yourself in config file.
-      - By default, the vein amount is protected at 100, and oil speed is protected at 1.0/s, you can set them yourself in config file.
+      * When reach the protection value, veins/oils steeps will not be mined/extracted any longer.
-      - When reach the protection value, veins/oils steeps will not be mined/extracted any longer.
+      * Close this function to resume mining and pumping, usually when you have enough level on `Veins Utilization`
-      - Close this function to resume mining and pumping, usually when you have enough level on `Veins Utilization`
+    * Do not render factory entities (except belts and sorters)
-    - Do not render factory entities (except belts and sorters)
+      * This also makes players click though factory entities but belts and sorters
-      - This also makes players click though factory entities but belts and sorters
+    * Drag building power poles in maximum connection range
-    - Drag building power poles in maximum connection range
+    * Dismantle blueprint selected buildings
-    - Allow overflow for Logistic Stations and Advanced Mining Machines
+      * Press shortcut key in blueprint copy mode to dismantle selected buildings.
-      - Allow overflow when trying to insert in-hand items
+      * The default shortcut key is Ctrl+X, you can set it in system options panel.
-      - Allow `Enhanced control for logistic storage limits` to exceed tech capacity limits
+    * Re-intialize planet (without reseting veins)
-      - Remove logistic strorage limit check on loading game
+    * Quick dismantle all buildings (without drops)
-    - Logistics Control Panel Improvement
+    * Quick build Orbital Collectors
-      - Auto apply filter with item under mouse cursor while opening the panel
+    * Belt signals for buy out dark fog items automatically
-      - Quick-set item filter while right-clicking item icons in storage list on the panel
+      * 6 belt signals are added to the signal panel, which can be used to buy out dark fog items automatically.
-    - Real-time logistic stations info panel
+      * Generated items are stacked in 4 items.
-    - Re-intialize planet (without reseting veins)
+      * Exchange ratio is following the original game design, aka:
-    - Quick dismantle all buildings (without drops)
+        * 1 Metaverse = 20 Dark Fog Matrices
-    - Quick build Orbital Collectors
+        * 1 Metaverse = 60 Engery Shards
-    - Belt signals for buy out dark fog items automatically
+        * 1 Metaverse = 30 Silicon-based Neurons
-      - 6 belt signals are added to the signal panel, which can be used to buy out dark fog items automatically.
+        * 1 Metaverse = 30 Negentropy Singularities
-      - Generated items are stacked in 4 items.
+        * 1 Metaverse = 30 Matter Recombinators
-      - Exchange ratio is following the original game design, aka:
+        * 1 Metaverse = 10 Core Elements
-        - 1 Metaverse = 20 Dark Fog Matrices
+    * Tweak building buffer
-        - 1 Metaverse = 60 Engery Shards
+      * Factory recipe buffer formula: take the larger value between `Assembler buffer time multiplier(in seconds) * items needed per second` and `Assembler buffer minimum multiplier * items needed per recipe`
-        - 1 Metaverse = 30 Silicon-based Neurons
+        * `Assembler buffer time multiplier(in seconds)`: Range 2-10, default is 4 (same as game)
-        - 1 Metaverse = 30 Negentropy Singularities
+        * `Assembler buffer minimum multiplier`: Range 2-10, default is 2 (same as game)
-        - 1 Metaverse = 30 Matter Recombinators
+      * Matrix Lab assembly mode formula: Default buffer is `Buffer count for assembling in labs`, when using Self-evolution Lab, if recipe's original production time is not greater than 9 seconds, add `Extra buffer count for Self-evolution Labs` * (`Lab speed` - 1)
-        - 1 Metaverse = 10 Core Elements
+        * `Buffer count for assembling in labs`: Range 2-20, default is 6 (same as game)
-  + Player/Mecha
+        * `Extra buffer count for Self-evolution Labs`: Range 1-10, default is 3 (same as game)
-    - Unlimited interactive range
+      * `Buffer count for researching in labs`: Range 2-20, default is 10 (same as game)
-    - Enable player actions in globe view
+      * `Ray Receiver Graviton Lens buffer count`: Range 1-20, default is 1 (game default is 20)
-    - Hide tips for soil piles changes
+      * `Ejector Solar Sails buffer count`: Range 5-400 (step by 5), default is 20 (same as game)
-    - Enhanced count control for hand-make
+      * `Silo Rockets buffer count`: Range 1-20, default is 20 (same as game)
-    - Auto navigation on sailings
+  * Logistics
-      - It keeps Icarus on course to the target planet
+    * Enhanced control for logistic storage capacities
-      - It will try to bypass any obstacles(planets, stars or dark-fog hives) on the way
+      * Logistic storage capacities are not scaled on upgrading `Logistics Carrier Capacity`, if they are not set to maximum capacity or already greater than maximum capacity.
-      - Furthermore, you can set a shortcut key in the system options window, which is used to toggle `Auto-cruise` that enables flying to targeted planets fully automatically.
+      * You can use arrow keys to adjust logistic storage capacities gracefully.
-        - Auto-cruise will start when you select a planet as target
+    * Logistics Control Panel Improvement
-        - It will use warper to fly to the target planet if the planet is too far away, the range can be configured.
+      * Auto apply filter with item under mouse cursor while opening the panel
-        - It will speed down when approaching the target planet, to avoid overshooting
+      * Quick-set item filter while right-clicking item icons in storage list on the panel
-  + Dyson Sphere
+    * Allow overflow for Logistic Stations and Advanced Mining Machines
-    - Stop ejectors when available nodes are all filled up
+      * Allow overflow when trying to insert in-hand items
-    - Construct only structure points but frames
+      * Allow `Enhanced control for logistic storage capacities` to exceed tech capacity limits
-    - Re-initialize Dyson Spheres
+      * Remove logistic strorage capacity limit check on loading game
-    - Quick dismantle Dyson Shells
+    * Real-time logistic stations info panel
-    - Dyson Sphere "Auto Fast Build" speed multiplier
+    * Auto-config logistic stations
-      - Note: this only applies to `Dyson Sphere "Auto Fast Build"` in sandbox mode
+      * Auto-config buildings include: Logistics Distributor, PLS, ILS, Advanced Mining Machine
-  + Tech
+  * Player/Mecha
-    - Restore upgrades of `Sorter Cargo Stacking` on panel
+    * Unlimited interactive range
-    - Set `Sorter Cargo Stacking` to unresearched state
+    * Enable player actions in globe view
-    - Buy out techs with their prerequisites
+    * Hide tips for soil piles changes
-      - This enables batch buying out techs with their prerequisites. Buy-out button is shown for all locked techs/upgrads.
+    * Enhanced count control for hand-make
-  + Combat
+    * Auto navigation on sailings
-    - Open Dark Fog Communicator anywhere
+      * It keeps Icarus on course to the target planet
+      * It will try to bypass any obstacles(planets, stars or dark-fog hives) on the way
+      * Furthermore, you can set a shortcut key in the system options window, which is used to toggle `Auto-cruise` that enables flying to targeted planets fully automatically.
+        * Auto-cruise will start when you select a planet as target
+        * It will use warper to fly to the target planet if the planet is too far away, the range can be configured.
+        * It will speed down when approaching the target planet, to avoid overshooting
+  * Dyson Sphere
+    * Stop ejectors when available nodes are all filled up
+    * Construct only structure points but frames
+    * Re-initialize Dyson Spheres
+    * Quick dismantle Dyson Shells
+    * Dyson Sphere "Auto Fast Build" speed multiplier
+      * Note: this only applies to `Dyson Sphere "Auto Fast Build"` in sandbox mode
+  * Tech
+    * Restore upgrades of `Sorter Cargo Stacking` on panel
+    * Set `Sorter Cargo Stacking` to unresearched state
+    * Buy out techs with their prerequisites
+      * This enables batch buying out techs with their prerequisites. Buy-out button is shown for all locked techs/upgrads.
+  * Combat
+    * Open Dark Fog Communicator anywhere
+  * UI
+    * Embedded [Planet Vein Untilization](https://thunderstore.io/c/dyson-sphere-program/p/testpushpleaseignore/Planet_Vein_Utilization/) due to its lack of maintainance, with minor bug fixes.
+    * Shortcut keys for showing stars' name
+      * Add a shortcut key to always show all star names in starmap when holding, default is `Alt`
+      * Add a shortcut key to toggle between three star name display states in starmap: `Original state`, `Show all names`, `Hide all names`, default is `Tab`, will restore to original state when closing starmap
+    * Starmap view:
+      * Add a star name filter, you can filter displayed star names by ores or planet types now.
+      * Add a dropdown box to show all stars' distance and/or planet count.
 
 ## Notes
 
 * Please upgrade `BepInEx` 5.4.21 or later if using with [BlueprintTweaks](https://dsp.thunderstore.io/package/kremnev8/BlueprintTweaks/) to avoid possible conflicts.
-  + You can download `BepInEx` [here](https://github.com/bepinex/bepinex/releases/latest)(choose x64 edition).
+  * You can download [BepInEx here](https://github.com/bepinex/bepinex/releases/latest)(choose x64 edition).
-  + If using with r2modman, you can upgrade `BepInEx` by clicking `Settings` -> `Browse profile folder`, then extract downloaded zip to the folder and overwrite existing files.
+  * If using with r2modman, you can upgrade `BepInEx` by clicking `Settings` -> `Browse profile folder`, then extract downloaded zip to the folder and overwrite existing files.
 
 ## CREDITS
 
@@ -121,117 +149,156 @@
 * [LSTM](https://github.com/hetima/DSP_LSTM) & [PlanetFinder](https://github.com/hetima/DSP_PlanetFinder): UI implementations
 * [OffGridConstruction](https://github.com/Velociraptor115-DSPModding/OffGridConstruction): Off-grid building & stepped rotation implementations
 * [CruiseAssist](https://dsp.thunderstore.io/package/tanu/CruiseAssist/) and its extension [AutoPilot](https://dsp.thunderstore.io/package/tanu/AutoPilot/): `Auto navigation on sailings` and `Auto-cruise` implementations
+* [Planet Vein Untilization](https://thunderstore.io/c/dyson-sphere-program/p/testpushpleaseignore/Planet_Vein_Utilization/)
+
+</details>
+
+<details>
+<summary>中文读我</summary>
+
+***一些提升用户体验的功能和补丁***
+
+## Bug反馈
+
+* QQ群：372754090
 
 ## 使用说明
 
 * 按 `` Alt+`(反引号) `` 键呼出主面板，可以在面板上修改快捷键。
 * 标题界面和行星小地图旁也有按钮呼出主面板。
 * 补丁：
-  + 更严格的建造菜单热键检测，因此在按住Ctrl/Alt/Shift时不再会触发建造热键(0~9, F1~F10, X, U)
+  * 更严格的建造菜单热键检测，因此在按住Ctrl/Alt/Shift时不再会触发建造热键(0~9, F1~F10, X, U)
-  + 修复了`矿物利用`升级到8000级以上时弹出警告的bug
+  * 修复了`矿物利用`升级到8000级以上时弹出警告的bug
-  + 保存蓝图前对建筑进行排序，以减少生成的蓝图数据大小
+  * 保存蓝图前对建筑进行排序，以减少生成的蓝图数据大小
-  + 将元数据提取的最大数量增加到20000(原来为2000)
+  * 将元数据提取的最大数量增加到20000(原来为2000)
-  + 将玩家指令队列的容量增加到128(原来为16)
+  * 将玩家指令队列的容量增加到128(原来为16)
-  + 在星图视图中启用`隐藏UI`功能(默认按键为`F11`)
+  * 在星图视图中启用`隐藏UI`功能(默认按键为`F11`)
-  + 如果使用mod管理器(`Thunderstore Mod Manager`或`r2modman`)启动游戏，在游戏窗口标题中追加mod配置档案名
+  * 如果使用mod管理器(`Thunderstore Mod Manager`或`r2modman`)启动游戏，在游戏窗口标题中追加mod配置档案名
 * 功能：
-  + 通用
+  * 通用
-    - 可调整游戏窗口大小(可最大化和拖动边框)
+    * 可调整游戏窗口大小(可最大化和拖动边框)
-    - 记住上次退出时的窗口位置和大小
+    * 记住上次退出时的窗口位置和大小
-    - 在加载和平模式存档时将其转换为战斗模式
+    * 在加载和平模式存档时将其转换为战斗模式
-    - 放大鼠标指针
+    * 基于mod管理器配置档案名的存档文件夹
-      - 注意：这将启用软件指针模式，可能会在CPU负载较重时导致鼠标移动延迟
+      * 存档文件会存储在`Save\<ProfileName>`文件夹中
-    - 基于mod管理器配置档案名的存档文件夹
+      * 如果匹配默认配置档案名则使用原始存档位置
-      - 存档文件会存储在`Save\<ProfileName>`文件夹中
+    * 基于mod管理器配置档案名的选项文件
-      - 如果匹配默认配置档案名则使用原始存档位置
+      * 选项文件存储为`Options\<ProfileName>.xml`
-    - 逻辑帧倍率
+    * 逻辑帧倍率
-      - 这将改变游戏运行速度，最慢0.1倍，最快10倍
+      * 这将改变游戏运行速度，最慢0.1倍，最快10倍
-      - 设置了一对快捷键(`-`和`+`)，可以-/+0.5倍改变逻辑帧倍率
+      * 设置了一对快捷键(`-`和`+`)，可以-/+0.5倍改变逻辑帧倍率
-      - 注意：
+      * 注意：
-        - 高逻辑帧倍率不能保证稳定性，特别是在工厂负载较重时
+        * 高逻辑帧倍率不能保证稳定性，特别是在工厂负载较重时
-        - 这不会影响一些游戏动画
+        * 这不会影响一些游戏动画
-        - 当在`Auxilaryfunction`mod中设置游戏速度时，此功能将被禁用
+        * 当在`Auxilaryfunction`mod中设置游戏速度时，此功能将被禁用
-        - 当安装了`BulletTime`mod时，此功能将被隐藏，但会对`BulletTime`的速度控制打补丁，使其最大速度变为10倍
+        * 当安装了`BulletTime`mod时，此功能将被隐藏，但会对`BulletTime`的速度控制打补丁，使其最大速度变为10倍
-    - 设置进程优先级
+    * 设置进程优先级
-    - 设置使用的CPU线程
+    * 将元数据提取的最大数量增加到20000(原来为2000)
-    - 将元数据提取的最大数量增加到20000(原来为2000)
+    * 将玩家指令队列的容量增加到128(原来为16)
-    - 将玩家指令队列的容量增加到128(原来为16)
+  * 工厂
-  + 行星/工厂
+    * 夜间日光灯
-    - 夜间日光灯
+    * 移除部分不影响游戏逻辑的建造条件
-    - 移除部分不影响游戏逻辑的建造条件
+    * 范围升级和拆除的最大区域扩大(最大30x30)
-    - 范围升级和拆除的最大区域扩大(最大30x30)
+    * 范围铺设地基的最大区域扩大(最大30x30)
-    - 范围铺设地基的最大区域扩大(最大30x30)
+    * 脱离网格建造以及小角度旋转
-    - 脱离网格建造以及小角度旋转
+    * 切割传送带
-    - 在流速计中将堆叠物品视为单个物品
+      * 按快捷键切割光标位置的传送带
-    - 物流塔存储数量限制控制改进
+      * 默认快捷键是Alt+X，可以在系统选项面板中设置
-      - 当升级`运输机舱扩容`时，不会对各种物流塔的存储限制按比例提升，除非设置为最大允许容量。
+    * 在流速计中将堆叠物品视为单个物品
-      - 你可以使用方向键微调物流塔存储限制
+    * 快速建造和拆除堆叠研究站/储物仓/储液罐
-    - 快速建造和拆除堆叠研究站/储物仓/储液罐
+    * 储液罐快速注入和抽取液体
-    - 储液罐快速注入和抽取液体
+      * 你可以设置储液罐操作速度的倍率
-      - 你可以设置储液罐操作速度的倍率
+      * 影响手动注入和抽取，以及从储液罐上层传输到下层的速度
-      - 影响手动注入和抽取，以及从储液罐上层传输到下层的速度
+    * 保护矿脉不会耗尽
-    - 保护矿脉不会耗尽
+      * 默认矿脉数量保护在100，采油速保护在1.0/s，你可以在配置文件中自行设置。
-      - 默认矿脉数量保护在100，采油速保护在1.0/s，你可以在配置文件中自行设置。
+      * 当达到保护值时，矿脉和油井将不再被开采。
-      - 当达到保护值时，矿脉和油井将不再被开采。
+      * 关闭此功能以恢复开采，一般是当你在`矿物利用`上有足够的等级时。
-      - 关闭此功能以恢复开采，一般是当你在`矿物利用`上有足够的等级时。
+    * 不渲染工厂建筑实体(除了传送带和分拣器)
-    - 不渲染工厂建筑实体(除了传送带和分拣器)
+      * 这也使玩家可以点穿工厂实体直接点到传送带和分拣器
-      - 这也使玩家可以点穿工厂实体直接点到传送带和分拣器
+    * 拖动建造电线杆时自动使用最大连接距离间隔
-    - 拖动建造电线杆时自动使用最大连接距离间隔
+    * 拆除蓝图选中的建筑
-    - 允许物流塔和大型采矿机物品溢出
+      * 在蓝图复制模式下按快捷键拆除选中的建筑
-      - 当尝试塞入手中物品时允许溢出
+      * 默认快捷键是Ctrl+X，可以在系统选项面板中设置
-      - 允许`物流塔存储数量限制控制改进`超过科技容量限制
+    * 初始化本行星（不重置矿脉）
-      - 在加载游戏时移除物流塔容量限制检查
+    * 快速拆除所有建筑（不掉落）
-    - 物流控制面板改进
+    * 快速建造轨道采集器
-      - 打开面板时自动将鼠标指向物品设为筛选条件
+    * 用于自动购买黑雾物品的传送带信号
-      - 在控制面板物流塔列表中右键点击物品图标快速设置为筛选条件
+      * 在信号面板上添加了6个传送带信号，可以用于自动购买黑雾道具。
-    - 物流运输站实时信息面板
+      * 生成的物品堆叠数为4。
-      - 注意：如果你启用了`Auxilaryfunction`中的`展示物流站信息`，此功能将被隐藏
+      * 兑换比率遵循原始游戏设计，即：
-    - 初始化本行星（不重置矿脉）
+        * 1个元宇宙 = 20个黑雾矩阵
-    - 快速拆除所有建筑（不掉落）
+        * 1个元宇宙 = 60个能量碎片
-    - 快速建造轨道采集器
+        * 1个元宇宙 = 30个硅基神经元
-    - 用于自动购买黑雾物品的传送带信号
+        * 1个元宇宙 = 30个负熵奇点
-      - 在信号面板上添加了6个传送带信号，可以用于自动购买黑雾道具。
+        * 1个元宇宙 = 30个物质重组器
-      - 生成的物品堆叠数为4。
+        * 1个元宇宙 = 10个核心素
-      - 兑换比率遵循原始游戏设计，即：
+    * 调整建筑输入缓冲
-        - 1个元宇宙 = 20个黑雾矩阵
+      * 工厂配方计算公式，在`工厂配方缓冲时间倍率秒数x每秒需要的原料数量`和`工厂配方缓冲最小倍率x每生产一次配方需要的原料数量`中取更大的那个值
-        - 1个元宇宙 = 60个能量碎片
+        * `工厂配方缓冲时间倍率(秒)`：范围2-10，默认为4(同游戏)
-        - 1个元宇宙 = 30个硅基神经元
+        * `工厂配方缓冲最小倍率`：范围2-10，默认为2(同游戏)
-        - 1个元宇宙 = 30个负熵奇点
+      * 研究站矩阵合成模式计算公式，默认缓存`研究站矩阵合成模式缓存数量`个，当使用自演化研究站时，如果配方的原始生产时间不大于9秒，则增加`自演化研究站矩阵额外缓冲数量`*(`研究站速度倍率`-1)
-        - 1个元宇宙 = 30个物质重组器
+        * `研究站矩阵合成模式缓存数量`：范围2-20，默认为6(同游戏)
-        - 1个元宇宙 = 10个核心素
+        * `自演化研究站矩阵额外缓冲数量`：范围1-10，默认为3(同游戏)
-  + 玩家/机甲
+      * `研究站科研模式缓存数量`：范围2-20，默认为10(同游戏)
-    - 无限交互距离
+      * `射线接收器透镜缓冲数量`：范围1-20，默认为1(游戏默认为20)
-    - 移除建造数量和范围限制
+      * `弹射太阳帆缓冲区数量`：范围5-400（步进值为5），默认值为20（与游戏相同）
-    - 在行星视图中允许玩家操作
+      * `发射井火箭缓冲区数量`：范围1-20，默认值为20（与游戏相同）
-    - 隐藏沙土数量变动的提示
+  * 物流
-    - 手动制造物品的数量控制改进
+    * 物流塔存储数量限制控制改进
-    - 航行时自动导航
+      * 当升级`运输机舱扩容`时，不会对各种物流塔的存储限制按比例提升，除非设置为最大允许容量或者已经超过升级后的最大容量。
-      - 它会保持伊卡洛斯飞向目标星球
+      * 你可以使用方向键微调物流塔存储限制
-      - 它会尝试绕过途中的任何障碍物(行星、恒星或黑雾巢穴)
+    * 物流控制面板改进
-      - 此外，可以在系统选项窗口中设置快捷键，用于切换`自动巡航`，实现完全自动化的飞行至目标星球。
+      * 打开面板时自动将鼠标指向物品设为筛选条件
-        - 当你选择目标星球后，自动巡航就会开始
+      * 在控制面板物流塔列表中右键点击物品图标快速设置为筛选条件
-        - 如果目标星球距离过远会自动使用曲速(超过5AU)，你可以在面板上更改这个值。
+    * 允许物流塔和大型采矿机物品溢出
-        - 它会在接近目标星球时减速，以避免发生越过目标的情况
+      * 当尝试塞入手中物品时允许溢出
-  + 戴森球
+      * 允许`物流塔存储数量限制控制改进`超过科技容量限制
-    - 可用节点全部造完时停止弹射
+      * 在加载游戏时移除物流塔容量限制检查
-    - 只建造节点不建造框架
+    * 物流运输站实时信息面板
-    - 初始化戴森球
+      * 注意：如果你启用了`Auxilaryfunction`中的`展示物流站信息`，此功能将被隐藏
-    - 快速拆除戴森壳
+    * 自动配置物流站
-    - 戴森球自动快速建造速度倍率
+      * 自动配置的建筑包括：物流配送器、行星物流站、星际物流站、高级采矿机
-      - 注意：这仅适用于沙盒模式下的`戴森球自动快速建造`功能
+  * 玩家/机甲
-  + 科研
+    * 无限交互距离
-    - 在升级面板上恢复`分拣器货物堆叠`的升级
+    * 移除建造数量和范围限制
-    - 将`分拣器货物堆叠`设为未研究状态
+    * 在行星视图中允许玩家操作
-    - 买断科技也同时买断所有前置科技
+    * 隐藏沙土数量变动的提示
-      - 这使得可以批量买断科技及其所有前置科技。所有未解锁的科技/升级都会显示买断按钮。
+    * 手动制造物品的数量控制改进
-  + 战斗
+    * 航行时自动导航
-    - 在任意位置打开黑雾通讯器
+      * 它会保持伊卡洛斯飞向目标星球
+      * 它会尝试绕过途中的任何障碍物(行星、恒星或黑雾巢穴)
+      * 此外，可以在系统选项窗口中设置快捷键，用于切换`自动巡航`，实现完全自动化的飞行至目标星球。
+        * 当你选择目标星球后，自动巡航就会开始
+        * 如果目标星球距离过远会自动使用曲速(超过5AU)，你可以在面板上更改这个值。
+        * 它会在接近目标星球时减速，以避免发生越过目标的情况
+  * 戴森球
+    * 可用节点全部造完时停止弹射
+    * 只建造节点不建造框架
+    * 初始化戴森球
+    * 快速拆除戴森壳
+    * 戴森球自动快速建造速度倍率
+      * 注意：这仅适用于沙盒模式下的`戴森球自动快速建造`功能
+  * 科研
+    * 在升级面板上恢复`分拣器货物堆叠`的升级
+    * 将`分拣器货物堆叠`设为未研究状态
+    * 买断科技也同时买断所有前置科技
+      * 这使得可以批量买断科技及其所有前置科技。所有未解锁的科技/升级都会显示买断按钮。
+  * 战斗
+    * 在任意位置打开黑雾通讯器
+  * UI
+    * 启用显示所有星系名称的快捷键
+      * 新增一个快捷键，按住后始终在星图显示所有星系名称，默认为`Alt`
+      * 新增一个快捷键，在星图视图切换三种星系名称显示状态：`原始显示状态`，`显示所有名称`，`隐藏所有名称`，默认为`Tab`，关闭星图时会恢复到原始状态
+    * 星图：
+      * 添加星系名过滤器，现在可以按矿物或行星类型过滤显示的星系名
+      * 添加了一个下拉框用以切换显示所有星系的距离和/或行星数量
+    * 由于缺乏维护，整合内置了[Planet Vein Untilization](https://thunderstore.io/c/dyson-sphere-program/p/testpushpleaseignore/Planet_Vein_Utilization/)，并修复了一些小错误。
 
 ## 注意事项
 
 * 如果和[BlueprintTweaks](https://dsp.thunderstore.io/package/kremnev8/BlueprintTweaks/)一起使用，请升级`BepInEx`到5.4.21或更高版本，以避免可能的冲突。
-  + 你可以在[这里](https://github.com/bepinex/bepinex/releases/latest)（选择x64版本）下载`BepInEx`。
+  * 你可以在[这里](https://github.com/bepinex/bepinex/releases/latest)（选择x64版本）下载`BepInEx`。
-  + 如果使用r2modman，你可以点击`Settings` -> `Browse profile folder`，然后将下载的zip解压到该文件夹并覆盖现有文件。
+  * 如果使用r2modman，你可以点击`Settings` -> `Browse profile folder`，然后将下载的zip解压到该文件夹并覆盖现有文件。
 
 ## 鸣谢
 
@@ -239,4 +306,7 @@
 * [BepInEx](https://bepinex.dev/): 基础模组框架
 * [LSTM](https://github.com/hetima/DSP_LSTM) & [PlanetFinder](https://github.com/hetima/DSP_PlanetFinder): UI实现
 * [OffGridConstruction](https://github.com/Velociraptor115-DSPModding/OffGridConstruction): 脱离网格建造以及小角度旋转的实现
-* [CruiseAssist](https://dsp.thunderstore.io/package/tanu/CruiseAssist/)及其扩展[AutoPilot](https://dsp.thunderstore.io/package/tanu/AutoPilot/): `航行时自动导航`和`自动巡航`的实现
+* [CruiseAssist](https://dsp.thunderstore.io/package/tanu/CruiseAssist/)及其扩展[AutoPilot](https://dsp.thunderstore.io/package/tanu/AutoPilot/): `航行时自动导航`和`自动巡航`的实现
+* [Planet Vein Untilization](https://thunderstore.io/c/dyson-sphere-program/p/testpushpleaseignore/Planet_Vein_Utilization/)
+
+</details>

UXAssist/UI/MyCheckButton.cs

@@ -0,0 +1,266 @@
+using System;
+using BepInEx.Configuration;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace UXAssist.UI;
+
+public class MyCheckButton : MonoBehaviour
+{
+    public RectTransform rectTrans;
+    public UIButton uiButton;
+    public Image icon;
+    public Text labelText;
+    public event Action OnChecked;
+    private bool _checked;
+    private float _iconWidth = 28f;
+
+    private static GameObject _baseObject;
+
+    private static Color openMouseOverColor;
+    private static Color openPressColor;
+    private static Color openNormalColor;
+    private static Color closeMouseOverColor;
+    private static Color closePressColor;
+    private static Color closeNormalColor;
+
+    public static void InitBaseObject()
+    {
+        if (_baseObject) return;
+        var tankWindow = UIRoot.instance.uiGame.tankWindow;
+        openMouseOverColor = tankWindow.openMouseOverColor;
+        openPressColor = tankWindow.openPressColor;
+        openNormalColor = tankWindow.openNormalColor;
+        closeMouseOverColor = tankWindow.closeMouseOverColor;
+        closePressColor = tankWindow.closePressColor;
+        closeNormalColor = tankWindow.closeNormalColor;
+
+        var go = Instantiate(UIRoot.instance.uiGame.beltWindow.reverseButton.gameObject);
+        go.name = "my-checkbutton";
+        go.SetActive(false);
+        var comp = go.transform.Find("text");
+        if (comp)
+        {
+            var txt = comp.GetComponent<Text>();
+            if (txt)
+            {
+                txt.text = "";
+                txt.alignment = TextAnchor.MiddleCenter;
+                txt.rectTransform.anchorMax = new Vector2(0f, 1f);
+                txt.rectTransform.anchorMin = new Vector2(0f, 1f);
+                txt.rectTransform.pivot = new Vector2(0f, 1f);
+                txt.rectTransform.localPosition = new Vector3(0f, 0f, 0f);
+            }
+            var localizer = comp.GetComponent<Localizer>();
+            if (localizer) DestroyImmediate(localizer);
+        }
+        _baseObject = go;
+    }
+
+    protected void OnDestroy()
+    {
+        if (_config != null) _config.SettingChanged -= _configChanged;
+    }
+
+    public static MyCheckButton CreateCheckButton(float x, float y, RectTransform parent, ConfigEntry<bool> config, string label = "", int fontSize = 15)
+    {
+        return CreateCheckButton(x, y, parent, config.Value, label, fontSize).WithConfigEntry(config);
+    }
+
+    public static MyCheckButton CreateCheckButton(float x, float y, RectTransform parent, bool check, string label = "", int fontSize = 15)
+    {
+        return CreateCheckButton(x, y, parent, fontSize).WithCheck(check).WithLabelText(label);
+    }
+
+    public static MyCheckButton CreateCheckButton(float x, float y, RectTransform parent, int fontSize = 15)
+    {
+        var go = Instantiate(_baseObject);
+        go.name = "my-checkbutton";
+        go.SetActive(true);
+        var cb = go.AddComponent<MyCheckButton>();
+        var rect = Util.NormalizeRectWithTopLeft(cb, x, y, parent);
+
+        cb.rectTrans = rect;
+        cb.uiButton = go.GetComponent<UIButton>();
+
+        var child = go.transform.Find("text");
+        if (child != null)
+        {
+            cb.labelText = child.GetComponent<Text>();
+            if (cb.labelText)
+            {
+                cb.labelText.text = "";
+                cb.labelText.fontSize = fontSize;
+            }
+        }
+
+        cb._iconWidth = Mathf.Min(cb._iconWidth > 0f ? cb._iconWidth : 32f, rect.sizeDelta.y);
+        cb.UpdateCheckColor();
+        cb.uiButton.onClick += cb.OnClick;
+        cb.UpdateSize();
+        return cb;
+    }
+
+    public bool Checked
+    {
+        get => _checked;
+        set
+        {
+            _checked = value;
+            UpdateCheckColor();
+        }
+    }
+
+    public void SetCheckedWithEvent(bool check)
+    {
+        if (_checked == check) return;
+        Checked = check;
+        OnChecked?.Invoke();
+    }
+
+    public void SetLabelText(string val)
+    {
+        if (labelText != null)
+        {
+            labelText.text = val.Translate();
+        }
+    }
+
+    private EventHandler _configChanged;
+    private Action _checkedChanged;
+    private ConfigEntry<bool> _config;
+    public void SetConfigEntry(ConfigEntry<bool> config)
+    {
+        if (_checkedChanged != null) OnChecked -= _checkedChanged;
+        if (_configChanged != null) config.SettingChanged -= _configChanged;
+
+        _config = config;
+        _checkedChanged = () => config.Value = !config.Value;
+        OnChecked += _checkedChanged;
+        _configChanged = (_, _) => Checked = config.Value;
+        config.SettingChanged += _configChanged;
+    }
+
+    public MyCheckButton WithLabelText(string val)
+    {
+        SetLabelText(val);
+        return this;
+    }
+
+    private void UpdateSize()
+    {
+        var width = rectTrans.sizeDelta.x;
+        var height = rectTrans.sizeDelta.y;
+        labelText.rectTransform.localPosition = new Vector3(icon != null ? _iconWidth : 0f, 0f, 0f);
+        labelText.rectTransform.sizeDelta = new Vector2(icon != null ? width - _iconWidth : width, height);
+        if (icon != null)
+        {
+            icon.rectTransform.sizeDelta = new Vector2(_iconWidth, _iconWidth);
+            icon.rectTransform.localPosition = new Vector3(0f, -height * 0.5f, 0f);
+        }
+    }
+
+    public MyCheckButton WithSize(float width, float height)
+    {
+        rectTrans.sizeDelta = new Vector2(width, height);
+        if (height < _iconWidth) _iconWidth = height;
+        UpdateSize();
+        return this;
+    }
+
+    public MyCheckButton WithIconWidth(float width)
+    {
+        if (_iconWidth == width) return this;
+        var height = rectTrans.sizeDelta.y;
+        if (width > height)
+        {
+            width = height;
+            if (_iconWidth == width) return this;
+        }
+        _iconWidth = width;
+        if (icon != null) UpdateSize();
+        return this;
+    }
+
+    public MyCheckButton WithIcon(Sprite sprite = null)
+    {
+        if (icon == null)
+        {
+            var iconGo = new GameObject("icon");
+            var rect = iconGo.AddComponent<RectTransform>();
+            (icon = iconGo.AddComponent<Image>()).sprite = sprite;
+            iconGo.transform.SetParent(rectTrans);
+            rect.sizeDelta = new Vector2(_iconWidth, _iconWidth);
+            rect.localScale = new Vector3(1f, 1f, 1f);
+            rect.anchorMax = new Vector2(0f, 1f);
+            rect.anchorMin = new Vector2(0f, 1f);
+            rect.pivot = new Vector2(0f, 0.5f);
+            var height = rectTrans.sizeDelta.y;
+            rect.localPosition = new Vector3(0f, -height * 0.5f, 0f);
+            iconGo.SetActive(sprite != null);
+            UpdateSize();
+        }
+        else
+        {
+            SetIcon(sprite);
+        }
+        return this;
+    }
+
+    public MyCheckButton WithTip(string tip, float delay = 1f)
+    {
+        uiButton.tips.type = UIButton.ItemTipType.Other;
+        uiButton.tips.topLevel = true;
+        uiButton.tips.tipTitle = tip;
+        uiButton.tips.tipText = null;
+        uiButton.tips.delay = delay;
+        uiButton.tips.corner = 2;
+        uiButton.UpdateTip();
+        return this;
+    }
+
+    public void SetIcon(Sprite sprite = null)
+    {
+        icon.sprite = sprite;
+        icon.gameObject.SetActive(sprite != null);
+    }
+
+    public MyCheckButton WithCheck(bool check)
+    {
+        Checked = check;
+        return this;
+    }
+
+    public MyCheckButton WithConfigEntry(ConfigEntry<bool> config)
+    {
+        SetConfigEntry(config);
+        return this;
+    }
+
+    public void OnClick(int obj)
+    {
+        _checked = !_checked;
+        UpdateCheckColor();
+        OnChecked?.Invoke();
+    }
+
+    public float Width => rectTrans.sizeDelta.x + labelText.rectTransform.sizeDelta.x;
+    public float Height => Math.Max(rectTrans.sizeDelta.y, labelText.rectTransform.sizeDelta.y);
+
+    private void UpdateCheckColor()
+    {
+        if (_checked)
+        {
+            uiButton.transitions[0].mouseoverColor = openMouseOverColor;
+            uiButton.transitions[0].pressedColor = openPressColor;
+            uiButton.transitions[0].normalColor = openNormalColor;
+        }
+        else
+        {
+            uiButton.transitions[0].mouseoverColor = closeMouseOverColor;
+            uiButton.transitions[0].pressedColor = closePressColor;
+            uiButton.transitions[0].normalColor = new Color(0.6557f, 0.9145f, 1f, 0.0627f);
+        }
+        uiButton.RefreshTransitionsImmediately();
+    }
+}

UXAssist/UI/MyCheckbox.cs

@@ -18,10 +18,10 @@ public class MyCheckBox : MonoBehaviour
 
     private static GameObject _baseObject;
 
-    private static readonly Color BoxColor = new Color(1f, 1f, 1f, 100f / 255f);
+    private static readonly Color BoxColor = new(1f, 1f, 1f, 100f / 255f);
-    private static readonly Color CheckColor = new Color(1f, 1f, 1f, 1f);
+    private static readonly Color CheckColor = new(1f, 1f, 1f, 1f);
-    private static readonly Color TextColor = new Color(178f / 255f, 178f / 255f, 178f / 255f, 168f / 255f);
+    private static readonly Color TextColor = new(178f / 255f, 178f / 255f, 178f / 255f, 168f / 255f);
-    
+
     public static void InitBaseObject()
     {
         if (_baseObject) return;
@@ -41,7 +41,7 @@ public class MyCheckBox : MonoBehaviour
 
     protected void OnDestroy()
     {
-        _config.SettingChanged -= _configChanged;
+        if (_config != null) _config.SettingChanged -= _configChanged;
     }
 
     public static MyCheckBox CreateCheckBox(float x, float y, RectTransform parent, ConfigEntry<bool> config, string label = "", int fontSize = 15)
@@ -66,6 +66,7 @@ public class MyCheckBox : MonoBehaviour
         cb.uiButton = go.GetComponent<UIButton>();
         cb.boxImage = go.transform.GetComponent<Image>();
         cb.checkImage = go.transform.Find("checked")?.GetComponent<Image>();
+        Util.NormalizeRectWithTopLeft(cb.checkImage, 0f, 0f);
 
         var child = go.transform.Find("text");
         if (child != null)
@@ -82,7 +83,7 @@ public class MyCheckBox : MonoBehaviour
         cb.uiButton.onClick += cb.OnClick;
         return cb;
     }
-    
+
     private void UpdateLabelTextWidth()
     {
         if (labelText) labelText.rectTransform.sizeDelta = new Vector2(labelText.preferredWidth, labelText.rectTransform.sizeDelta.y);
@@ -150,7 +151,17 @@ public class MyCheckBox : MonoBehaviour
         Checked = check;
         return this;
     }
-    
+
+    public MyCheckBox WithSmallerBox(float boxSize = 20f)
+    {
+        var oldWidth = rectTrans.sizeDelta.x;
+        rectTrans.sizeDelta = new Vector2(boxSize, boxSize);
+        checkImage.rectTransform.sizeDelta = new Vector2(boxSize, boxSize);
+        labelText.rectTransform.sizeDelta = new Vector2(labelText.rectTransform.sizeDelta.x, boxSize);
+        labelText.rectTransform.localPosition = new Vector3(labelText.rectTransform.localPosition.x + boxSize - oldWidth, labelText.rectTransform.localPosition.y, labelText.rectTransform.localPosition.z);
+        return this;
+    }
+
     public MyCheckBox WithEnable(bool on)
     {
         SetEnable(on);

UXAssist/UI/MyComboBox.cs

@@ -34,7 +34,7 @@ public class MyComboBox : MonoBehaviour
         }
         var localizer = go.GetComponent<Localizer>();
         if (localizer) DestroyImmediate(localizer);
-        
+
         var rect = (RectTransform)go.transform;
         var cbctrl = rect.transform.Find("ComboBox").GetComponent<UIComboBox>();
         foreach (var button in cbctrl.ItemButtons)
@@ -93,7 +93,7 @@ public class MyComboBox : MonoBehaviour
         var oldPosition = rtrans.localPosition;
         var pwidth = _text.preferredWidth;
         rtrans.localPosition = new Vector3(pwidth + 5f, oldPosition.y, oldPosition.z);
-        _rectTrans.sizeDelta = new Vector2(rtrans.localPosition.x + rtrans.sizeDelta.x, _rectTrans.sizeDelta.y);
+        _rectTrans.sizeDelta = new Vector2(rtrans.localPosition.x + 5f + rtrans.sizeDelta.x, _rectTrans.sizeDelta.y);
     }
 
     public void SetPrompt(string prompt)
@@ -112,7 +112,12 @@ public class MyComboBox : MonoBehaviour
         UpdateComboBoxPosition();
     }
 
-    public void SetItems(params string[] items) => _comboBox.Items = items.Select(s => s.Translate()).ToList();
+    public void SetItems(params string[] items)
+    {
+        _comboBox.Items = [.. items.Select(s => s.Translate())];
+        _comboBox.StartItemIndex = 0;
+        _comboBox.DropDownCount = Math.Min(items.Length, 8);
+    }
 
     public void SetIndex(int index) => _comboBox.itemIndex = index;
 
@@ -146,7 +151,7 @@ public class MyComboBox : MonoBehaviour
         SetPrompt(prompt);
         return this;
     }
-    
+
     public MyComboBox WithFontSize(int size)
     {
         SetFontSize(size);
@@ -158,7 +163,7 @@ public class MyComboBox : MonoBehaviour
         SetItems(items);
         return this;
     }
-    
+
     public MyComboBox WithIndex(int index)
     {
         SetIndex(index);

UXAssist/UI/MyConfigWindow.cs

@@ -14,7 +14,7 @@ public class MyConfigWindow : MyWindowWithTabs
     {
         return MyWindowManager.CreateWindow<MyConfigWindow>("UXAConfigWindow", "UXAssist Config");
     }
-    
+
     public static void DestroyInstance(MyConfigWindow win)
     {
         MyWindowManager.DestroyWindow(win);

UXAssist/UI/MyCornerComboBox.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using BepInEx.Configuration;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace UXAssist.UI;
+
+public class MyCornerComboBox : MonoBehaviour
+{
+    private RectTransform _rectTrans;
+    private UIComboBox _comboBox;
+    public Action<int> OnSelChanged;
+
+    private static GameObject _baseObject;
+
+    public static void InitBaseObject()
+    {
+        if (_baseObject) return;
+        var go = Instantiate(UIRoot.instance.uiGame.starDetail.displayCombo.gameObject);
+        go.name = "my-small-combobox";
+        go.SetActive(false);
+
+        var cbctrl = go.transform.GetComponent<UIComboBox>();
+        cbctrl.onSubmit.RemoveAllListeners();
+        cbctrl.onItemIndexChange.RemoveAllListeners();
+        foreach (var button in cbctrl.ItemButtons)
+        {
+            Destroy(button.gameObject);
+        }
+        cbctrl.Items.Clear();
+        cbctrl.ItemButtons.Clear();
+        _baseObject = go;
+    }
+
+    public static MyCornerComboBox CreateComboBox(float x, float y, RectTransform parent, bool topRight = false)
+    {
+        var gameObject = Instantiate(_baseObject);
+        gameObject.name = "my-combobox";
+        gameObject.SetActive(true);
+        var cb = gameObject.AddComponent<MyCornerComboBox>();
+        RectTransform rtrans;
+        if (topRight)
+        {
+            rtrans = Util.NormalizeRectWithTopRight(cb, x, y, parent);
+        }
+        else
+        {
+            rtrans = Util.NormalizeRectWithTopLeft(cb, x, y, parent);
+        }
+        cb._rectTrans = rtrans;
+        var box = rtrans.GetComponent<UIComboBox>();
+        cb._comboBox = box;
+        box.onItemIndexChange.AddListener(() => { cb.OnSelChanged?.Invoke(box.itemIndex); });
+
+        return cb;
+    }
+
+    protected void OnDestroy()
+    {
+        if (_config != null && _configChanged != null)
+            _config.SettingChanged -= _configChanged;
+    }
+
+    public void SetFontSize(int size)
+    {
+        var textComp = _comboBox.transform.Find("Main Button")?.GetComponentInChildren<Text>();
+        if (textComp) textComp.fontSize = size;
+        _comboBox.ItemButtons.ForEach(b => b.GetComponentInChildren<Text>().fontSize = size);
+        _comboBox.m_ListItemRes.GetComponentInChildren<Text>().fontSize = size;
+    }
+
+    public void SetItems(params string[] items)
+    {
+        _comboBox.Items = [.. items.Select(s => s.Translate())];
+        _comboBox.StartItemIndex = 0;
+        _comboBox.DropDownCount = items.Length;
+    }
+
+    public List<string> Items => _comboBox.Items;
+
+    public void UpdateLabelText()
+    {
+        var textComp = _comboBox.transform.Find("Main Button")?.GetComponentInChildren<Text>();
+        if (textComp) textComp.text = _comboBox.Items[_comboBox.itemIndex];
+    }
+
+    public void SetIndex(int index) => _comboBox.itemIndex = index;
+
+    public void SetSize(float width, float height)
+    {
+        _rectTrans.sizeDelta = new Vector2(width > 0f ? width : _rectTrans.sizeDelta.x, height > 0f ? height : _rectTrans.sizeDelta.y);
+    }
+
+    public void AddOnSelChanged(Action<int> action) => OnSelChanged += action;
+
+    private EventHandler _configChanged;
+    private Action<int> _selChanged;
+    private ConfigEntry<int> _config;
+    public void SetConfigEntry(ConfigEntry<int> config)
+    {
+        if (_selChanged != null) OnSelChanged -= _selChanged;
+        if (_configChanged != null) config.SettingChanged -= _configChanged;
+
+        _comboBox.itemIndex = config.Value;
+        _config = config;
+        _selChanged = value => config.Value = value;
+        OnSelChanged += _selChanged;
+        _configChanged = (_, _) => SetIndex(config.Value);
+        config.SettingChanged += _configChanged;
+    }
+
+    public MyCornerComboBox WithFontSize(int size)
+    {
+        SetFontSize(size);
+        return this;
+    }
+
+    public MyCornerComboBox WithItems(params string[] items)
+    {
+        SetItems(items);
+        return this;
+    }
+
+    public MyCornerComboBox WithIndex(int index)
+    {
+        SetIndex(index);
+        return this;
+    }
+
+    public MyCornerComboBox WithSize(float width, float height)
+    {
+        SetSize(width, height);
+        return this;
+    }
+
+    public MyCornerComboBox WithOnSelChanged(params Action<int>[] action)
+    {
+        foreach (var act in action)
+            AddOnSelChanged(act);
+        return this;
+    }
+
+    public MyCornerComboBox WithConfigEntry(ConfigEntry<int> config)
+    {
+        SetConfigEntry(config);
+        return this;
+    }
+
+    public float Width => _rectTrans.sizeDelta.x;
+    public float Height => _rectTrans.sizeDelta.y;
+}

UXAssist/UI/MyFlatButton.cs

@@ -0,0 +1,95 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace UXAssist.UI;
+
+public class MyFlatButton : MonoBehaviour
+{
+    public RectTransform rectTrans;
+    public UIButton uiButton;
+    public Text labelText;
+
+    private static GameObject _baseObject;
+
+    public static void InitBaseObject()
+    {
+        if (_baseObject) return;
+        var panel = UIRoot.instance.uiGame.dysonEditor.controlPanel.hierarchy.layerPanel;
+        var go = Instantiate(panel.layerButtons[0].gameObject);
+        var btn = go.GetComponent<UIButton>();
+        go.GetComponent<Image>().sprite = panel.buttonDefaultSprite;
+        btn.gameObject.name = "my-flatbutton";
+        btn.highlighted = false;
+        var img = btn.GetComponent<Image>();
+        if (img != null)
+        {
+            img.sprite = panel.buttonDefaultSprite;
+            img.color = new Color(img.color.r, img.color.g, img.color.b, 13f / 255f);
+        }
+
+        img = btn.gameObject.transform.Find("frame")?.GetComponent<Image>();
+        if (img != null)
+        {
+            img.color = new Color(img.color.r, img.color.g, img.color.b, 0f);
+        }
+
+        btn.button.onClick.RemoveAllListeners();
+        _baseObject = go;
+    }
+
+    public static MyFlatButton CreateFlatButton(float x, float y, RectTransform parent, string label = "", int fontSize = 15, Action<int> onClick = null)
+    {
+        return CreateFlatButton(x, y, parent, fontSize, onClick).WithLabelText(label);
+    }
+
+    public static MyFlatButton CreateFlatButton(float x, float y, RectTransform parent, int fontSize = 15, Action<int> onClick = null)
+    {
+        var go = Instantiate(_baseObject);
+        go.name = "my-flatbutton";
+        go.SetActive(true);
+        var cb = go.AddComponent<MyFlatButton>();
+        var rect = Util.NormalizeRectWithTopLeft(cb, x, y, parent);
+
+        cb.rectTrans = rect;
+        cb.uiButton = go.GetComponent<UIButton>();
+
+        cb.labelText = go.transform.Find("Text")?.GetComponent<Text>();
+        cb.uiButton.onClick += onClick;
+        return cb;
+    }
+
+    public void SetLabelText(string val)
+    {
+        if (labelText != null)
+        {
+            labelText.text = val.Translate();
+        }
+    }
+
+    public MyFlatButton WithLabelText(string val)
+    {
+        SetLabelText(val);
+        return this;
+    }
+
+    public MyFlatButton WithSize(float width, float height)
+    {
+        rectTrans.sizeDelta = new Vector2(width, height);
+        return this;
+    }
+
+    public MyFlatButton WithTip(string tip, float delay = 1f)
+    {
+        uiButton.tips.type = UIButton.ItemTipType.Other;
+        uiButton.tips.topLevel = true;
+        uiButton.tips.tipTitle = tip;
+        uiButton.tips.tipText = null;
+        uiButton.tips.delay = delay;
+        uiButton.tips.corner = 2;
+        uiButton.UpdateTip();
+        return this;
+    }
+    public float Width => rectTrans.sizeDelta.x + labelText.rectTransform.sizeDelta.x;
+    public float Height => Math.Max(rectTrans.sizeDelta.y, labelText.rectTransform.sizeDelta.y);
+}

UXAssist/UI/MyKeyBinder.cs

@@ -43,7 +43,7 @@ public class MyKeyBinder : MonoBehaviour
     public UIButton setNoneKeyUIButton;
 
     private bool _nextNotOn;
-    
+
     protected void OnDestroy()
     {
         OnFree?.Invoke();

UXAssist/UI/MySideSlider.cs

@@ -0,0 +1,166 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace UXAssist.UI;
+
+// MySlider modified from LSTM: https://github.com/hetima/DSP_LSTM/blob/main/LSTM/MySlider.cs
+
+public class MySideSlider : MonoBehaviour
+{
+    public RectTransform rectTrans;
+    public Slider slider;
+    public Text labelText;
+    public string labelFormat;
+    public event Action OnValueChanged;
+
+    public static MySideSlider CreateSlider(float x, float y, RectTransform parent, float value, float minValue, float maxValue, string format = "G", float width = 0f, float textWidth = 0f)
+    {
+        return CreateSlider(x, y, parent, width, textWidth).WithLabelFormat(format).WithMinMaxValue(minValue, maxValue).WithValue(value);
+    }
+
+    public static MySideSlider CreateSlider(float x, float y, RectTransform parent, float width = 0f, float textWidth = 0f)
+    {
+        var go = Instantiate(UIRoot.instance.uiGame.stationWindow.maxMiningSpeedGroup.gameObject);
+        //sizeDelta = 240, 20
+        go.name = "my-side-slider";
+        Destroy(go.transform.Find("label").gameObject);
+        Destroy(go.GetComponent<UIButton>());
+        go.SetActive(true);
+        var sl = go.AddComponent<MySideSlider>();
+        var rect = Util.NormalizeRectWithTopLeft(sl, x, y, parent);
+        sl.rectTrans = rect;
+
+        sl.slider = go.transform.Find("slider").GetComponent<Slider>();
+        sl.slider.minValue = 0f;
+        sl.slider.maxValue = 100f;
+        sl.slider.onValueChanged.RemoveAllListeners();
+        sl.slider.onValueChanged.AddListener(sl.SliderChanged);
+        if (width == 0) width = 160f;
+        if (sl.slider.transform is RectTransform rectTrans)
+        {
+            rectTrans.localPosition = new Vector3(width, rectTrans.localPosition.y, rectTrans.localPosition.z);
+            rectTrans.sizeDelta = new Vector2(width, rectTrans.sizeDelta.y);
+        }
+        sl.Value = 0f;
+
+        sl.labelText = go.transform.Find("value").GetComponent<Text>();
+        sl.labelText.alignment = textWidth <= 0f ? TextAnchor.MiddleLeft : TextAnchor.MiddleRight;
+        if (sl.labelText.transform is RectTransform rectTrans2)
+        {
+            if (textWidth > 0f)
+            {
+                rectTrans2.sizeDelta = new Vector2(textWidth, rectTrans2.sizeDelta.y);
+            }
+            else
+            {
+                rectTrans2.sizeDelta = new Vector2(-textWidth, rectTrans2.sizeDelta.y);
+            }
+            rectTrans2.pivot = new Vector2(0f, 1f);
+            rectTrans2.localPosition = new Vector3(textWidth <= 0f ? width + 10f : width, rectTrans2.localPosition.y, rectTrans2.localPosition.z);
+        }
+        sl.labelFormat = "G";
+
+        // var bg = sl.slider.transform.Find("Background")?.GetComponent<Image>();
+        // if (bg != null)
+        // {
+        //     bg.color = new Color(0.5f, 0.5f, 0.5f, 0.5f);
+        // }
+        // var fill = sl.slider.fillRect.GetComponent<Image>();
+        // if (fill != null)
+        // {
+        //     fill.color = new Color(1f, 1f, 1f, 0.28f);
+        // }
+
+        sl.UpdateLabel();
+
+        return sl;
+    }
+
+    public void SetEnable(bool on)
+    {
+        lock (this)
+        {
+            if (slider) slider.interactable = on;
+        }
+    }
+
+    public float Value
+    {
+        get => slider.value;
+        set
+        {
+            var sliderVal = value;
+            if (sliderVal.Equals(slider.value)) return;
+            if (sliderVal > slider.maxValue)
+            {
+                sliderVal = slider.maxValue;
+            }
+            else if (sliderVal < slider.minValue)
+            {
+                sliderVal = slider.minValue;
+            }
+
+            slider.value = sliderVal;
+            UpdateLabel();
+        }
+    }
+
+    public MySideSlider WithValue(float value)
+    {
+        Value = value;
+        return this;
+    }
+
+    public MySideSlider WithMinMaxValue(float min, float max)
+    {
+        slider.minValue = min;
+        slider.maxValue = max;
+        return this;
+    }
+
+    public MySideSlider WithLabelFormat(string format)
+    {
+        if (format == labelFormat) return this;
+        labelFormat = format;
+        UpdateLabel();
+        return this;
+    }
+
+    public MySideSlider WithFontSize(int fontSize)
+    {
+        labelText.fontSize = fontSize;
+        return this;
+    }
+
+    public MySideSlider WithEnable(bool on)
+    {
+        SetEnable(on);
+        return this;
+    }
+
+    public void UpdateLabel()
+    {
+        if (labelText != null)
+        {
+            labelText.text = slider.value.ToString(labelFormat);
+        }
+    }
+
+    public void SetLabelText(string text)
+    {
+        if (labelText != null)
+        {
+            labelText.text = text;
+        }
+    }
+
+    public void SliderChanged(float val)
+    {
+        lock (this)
+        {
+            UpdateLabel();
+            OnValueChanged?.Invoke();
+        }
+    }
+}

UXAssist/UI/MySlider.cs

@@ -53,7 +53,7 @@ public class MySlider : MonoBehaviour
             }
         }
         sl.labelFormat = "G";
-        
+
         sl.handleSlideArea = sl.transform.Find("Handle Slide Area")?.GetComponent<RectTransform>();
 
         var bg = sl.slider.transform.Find("Background")?.GetComponent<Image>();
@@ -105,14 +105,14 @@ public class MySlider : MonoBehaviour
         Value = value;
         return this;
     }
-    
+
     public MySlider WithMinMaxValue(float min, float max)
     {
         slider.minValue = min;
         slider.maxValue = max;
         return this;
     }
-    
+
     public MySlider WithLabelFormat(string format)
     {
         if (format == labelFormat) return this;