using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CommonAPI;
using CommonAPI.Systems.ModLocalization;
using HarmonyLib;
using UnityEngine;
using UnityEngine.UI;
using xiaoye97;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
namespace StackingEnhancement;
[BepInPlugin("com.komonad.dsp.stackingenhancement", "堆叠增强", "0.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[CommonAPISubmoduleDependency(new string[] { "LocalizationModule", "ProtoRegistry" })]
public class Plugin : BaseUnityPlugin
{
private static class StationWindowFields
{
public static readonly FieldInfo EventLock = AccessTools.Field(typeof(UIStationWindow), "event_lock");
public static readonly FieldInfo Transport = AccessTools.Field(typeof(UIStationWindow), "transport");
public static readonly FieldInfo StationId = AccessTools.Field(typeof(UIStationWindow), "_stationId");
public static readonly FieldInfo MinPilerSlider = AccessTools.Field(typeof(UIStationWindow), "minPilerSlider");
public static readonly FieldInfo MinPilerSliderFillImage = AccessTools.Field(typeof(UIStationWindow), "minPilerSliderFillImage");
public static readonly FieldInfo MinPilerValue = AccessTools.Field(typeof(UIStationWindow), "minPilerValue");
public static readonly FieldInfo TechPilerCheck = AccessTools.Field(typeof(UIStationWindow), "techPilerCheck");
}
private static class StationInspectorFields
{
public static readonly FieldInfo EventLock = AccessTools.Field(typeof(UIControlPanelStationInspector), "event_lock");
public static readonly FieldInfo Transport = AccessTools.Field(typeof(UIControlPanelStationInspector), "transport");
public static readonly FieldInfo StationId = AccessTools.Field(typeof(UIControlPanelStationInspector), "_stationId");
public static readonly FieldInfo MinPilerSlider = AccessTools.Field(typeof(UIControlPanelStationInspector), "minPilerSlider");
public static readonly FieldInfo MinPilerSliderFillImage = AccessTools.Field(typeof(UIControlPanelStationInspector), "minPilerSliderFillImage");
public static readonly FieldInfo MinPilerValue = AccessTools.Field(typeof(UIControlPanelStationInspector), "minPilerValue");
public static readonly FieldInfo TechPilerCheck = AccessTools.Field(typeof(UIControlPanelStationInspector), "techPilerCheck");
}
private static class CargoContainerFields
{
public static readonly FieldInfo CargoPool = AccessTools.Field(typeof(CargoContainer), "cargoPool");
public static readonly FieldInfo Cursor = AccessTools.Field(typeof(CargoContainer), "cursor");
public static readonly FieldInfo PoolCapacity = AccessTools.Field(typeof(CargoContainer), "poolCapacity");
public static readonly FieldInfo CargoMatInst = AccessTools.Field(typeof(CargoContainer), "cargoMatInst");
}
private static class CargoContainerMethods
{
public static readonly MethodInfo Expand2x = AccessTools.Method(typeof(CargoContainer), "Expand2x", (Type[])null, (Type[])null);
}
[HarmonyPatch]
private static class GameDataPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(GameData), "SetForNewGame")]
private static void SetForNewGamePostfix(GameData __instance)
{
EnsureTechStates(__instance?.history);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(GameData), "Import")]
private static void ImportPostfix(GameData __instance)
{
EnsureTechStates(__instance?.history);
}
}
[HarmonyPatch(typeof(UIStationWindow))]
private static class UIStationWindowPatch
{
[HarmonyPostfix]
[HarmonyPatch("OnStationIdChange")]
private static void OnStationIdChangePostfix(UIStationWindow __instance)
{
RefreshPilerUi(__instance);
}
[HarmonyPrefix]
[HarmonyPatch("OnMinPilerValueChange")]
private static bool OnMinPilerValueChangePrefix(UIStationWindow __instance, float value)
{
ApplyFixedPilerCount(__instance, value);
return false;
}
[HarmonyPrefix]
[HarmonyPatch("OnTechPilerClick")]
private static bool OnTechPilerClickPrefix(UIStationWindow __instance)
{
ApplyTechPilerToggle(__instance);
return false;
}
}
[HarmonyPatch(typeof(UIControlPanelStationInspector))]
private static class UIControlPanelStationInspectorPatch
{
[HarmonyPostfix]
[HarmonyPatch("OnStationIdChange")]
private static void OnStationIdChangePostfix(UIControlPanelStationInspector __instance)
{
RefreshPilerUi(__instance);
}
[HarmonyPrefix]
[HarmonyPatch("OnMinPilerValueChange")]
private static bool OnMinPilerValueChangePrefix(UIControlPanelStationInspector __instance, float value)
{
ApplyFixedPilerCount(__instance, value);
return false;
}
[HarmonyPrefix]
[HarmonyPatch("OnTechPilerClick")]
private static bool OnTechPilerClickPrefix(UIControlPanelStationInspector __instance)
{
ApplyTechPilerToggle(__instance);
return false;
}
}
[HarmonyPatch(typeof(CargoContainer), "Draw")]
private static class CargoContainerPatch
{
[HarmonyPrefix]
private static void DrawPrefix(CargoContainer __instance)
{
_cargoRenderDrawCount = 0;
if (!_cargoStackRenderPatchDisabled)
{
try
{
EnsureCargoRenderCapacity(__instance);
}
catch (Exception arg)
{
_cargoStackRenderPatchDisabled = true;
ManualLogSource logger = _logger;
if (logger != null)
{
logger.LogWarning((object)$"Cargo stack render patch disabled: {arg}");
}
}
}
if (_cargoShaderDrawPatchDisabled)
{
return;
}
try
{
ApplyCargoShader(GetFieldValue<Material>(CargoContainerFields.CargoMatInst, __instance));
}
catch (Exception arg2)
{
_cargoShaderDrawPatchDisabled = true;
ManualLogSource logger2 = _logger;
if (logger2 != null)
{
logger2.LogWarning((object)$"Cargo shader draw patch disabled: {arg2}");
}
}
}
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> DrawTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Expected O, but got Unknown
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_0189: Expected O, but got Unknown
MethodInfo objB = AccessTools.Method(typeof(ComputeBuffer), "SetData", new Type[4]
{
typeof(Array),
typeof(int),
typeof(int),
typeof(int)
}, (Type[])null);
MethodInfo methodInfo = AccessTools.Method(typeof(Plugin), "UploadCargoRenderData", (Type[])null, (Type[])null);
MethodInfo methodInfo2 = AccessTools.Method(typeof(Plugin), "GetCargoRenderDrawCount", (Type[])null, (Type[])null);
FieldInfo cursor = CargoContainerFields.Cursor;
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
int num = 0;
int num2 = 0;
for (int i = 0; i < list.Count; i++)
{
CodeInstruction val = list[i];
if ((val.opcode == OpCodes.Call || val.opcode == OpCodes.Callvirt) && object.Equals(val.operand, objB))
{
list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo)
{
labels = val.labels,
blocks = val.blocks
};
num++;
}
else if (val.opcode == OpCodes.Ldfld && object.Equals(val.operand, cursor) && i + 1 < list.Count && list[i + 1].opcode == OpCodes.Stelem_I4)
{
list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2)
{
labels = val.labels,
blocks = val.blocks
};
num2++;
}
}
if (num != 1 || num2 != 1)
{
Debug.LogWarning((object)string.Format("[{0}] Unexpected CargoContainer.Draw patch shape. Replaced uploads={1}, drawCounts={2}.", "堆叠增强", num, num2));
}
return list;
}
}
[HarmonyPatch(typeof(PilerComponent), "InternalUpdate")]
private static class PilerComponentPatch
{
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> InternalUpdateTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Expected O, but got Unknown
int num = 0;
int num2 = 0;
List<CodeInstruction> list = new List<CodeInstruction>();
foreach (CodeInstruction instruction in instructions)
{
if (instruction.opcode == OpCodes.Ldc_I4_4)
{
num++;
list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "GetMaxPilerStack", (Type[])null, (Type[])null)));
}
else if (instruction.opcode == OpCodes.Ldc_R4 && instruction.operand is float num3 && Math.Abs(num3 - 4f) < 0.001f)
{
num2++;
list.Add(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Plugin), "GetMaxPilerStackFloat", (Type[])null, (Type[])null)));
}
else
{
list.Add(instruction);
}
}
if (num != 3 || num2 != 1)
{
Debug.LogWarning((object)string.Format("[{0}] Unexpected PilerComponent.InternalUpdate patch shape. Replaced int4={1}, float4={2}.", "堆叠增强", num, num2));
}
return list;
}
}
[HarmonyPatch(typeof(InserterComponent), "InternalUpdate_Bidirectional")]
private static class InserterBidirectionalPatch
{
private static byte _savedStackOutput;
[HarmonyPrepare]
private static bool Prepare()
{
return _enhancePileSorter?.Value ?? false;
}
[HarmonyPrefix]
private static void Prefix(ref InserterComponent __instance)
{
_savedStackOutput = __instance.stackOutput;
int maxPilerStack = GetMaxPilerStack();
if (maxPilerStack > __instance.stackOutput)
{
__instance.stackOutput = (byte)maxPilerStack;
}
}
[HarmonyFinalizer]
private static void Finalizer(ref InserterComponent __instance)
{
__instance.stackOutput = _savedStackOutput;
}
}
public const string ModGuid = "com.komonad.dsp.stackingenhancement";
public const string ModName = "堆叠增强";
public const string Version = "0.1.0";
private const int DefaultPilerStack = 4;
private const int MaxPilerStack = 8;
private const float TallCargoUpperBlockOffset = 0.4f;
private const string ShaderBundleFileName = "stacking-enhancement-shaders";
private const string CargoShaderAssetPath = "Assets/CargoInstancing8.shader";
private const string CargoShaderName = "VF Shaders/Batching/Cargo Instancing 8";
private const int FunctionStationPilerLevel = 29;
private const int ItemUniverseMatrix = 6006;
private const int FallbackPreTechLogisticsPiler = 1607;
private const string FallbackTechIconPath = "Icons/Tech/1607";
private static readonly int[] DefaultTechIds = new int[4] { 9442, 9443, 9444, 9445 };
private static readonly int[] LegacyStationStackTechIds = new int[4] { 9446, 9447, 9448, 9449 };
private static readonly long[] EnhancementHashNeededByLevel = new long[4] { 115200000L, 144000000L, 172800000L, 201600000L };
private static int[] _techIds = (int[])DefaultTechIds.Clone();
private static int _stationAnchorTechId = 1607;
private static ManualLogSource _logger;
private static AssetBundle _shaderBundle;
private static Shader _cargoShader;
private static Shader _originalCargoShader;
private static bool _cargoShaderLoadAttempted;
private static bool _cargoShaderAppliedLogged;
private static bool _cargoShaderDrawPatchDisabled;
private static bool _cargoStackRenderPatchDisabled;
private static Cargo[] _cargoRenderBuffer = (Cargo[])(object)new Cargo[128];
private static int _cargoRenderDrawCount;
private static ConfigEntry<bool> _enableCargoStackShader;
private static ConfigEntry<bool> _enhancePileSorter;
private static readonly Color SliderAutoNormalColor = new Color(1f, 1f, 1f, 0.1f);
private static readonly Color SliderAutoHighlightColor = new Color(1f, 1f, 1f, 0.2f);
private static readonly Color SliderFixedNormalColor = new Color(1f, 1f, 1f, 0.5f);
private static readonly Color SliderFixedHighlightColor = new Color(1f, 1f, 1f, 1f);
private void Awake()
{
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
_logger = ((BaseUnityPlugin)this).Logger;
_enableCargoStackShader = ((BaseUnityPlugin)this).Config.Bind<bool>("Rendering", "EnableCargoStackShader", true, "Enables cargo rendering with native stack height and side layer support up to 8 layers.");
_enhancePileSorter = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "EnhancePileSorter", false, "When enabled, pile sorters output stacks matching the Stacking Enhancement tech level instead of the default 4-layer cap.");
((BaseUnityPlugin)this).Logger.LogInfo((object)"堆叠增强 loaded.");
RegisterLocalizations();
LDBTool.PreAddDataAction = (Action)Delegate.Combine(LDBTool.PreAddDataAction, new Action(RegisterProtos));
LDBTool.PostAddDataAction = (Action)Delegate.Combine(LDBTool.PostAddDataAction, new Action(PostAddData));
new Harmony("com.komonad.dsp.stackingenhancement").PatchAll();
LogPatchStatus();
}
private void OnDestroy()
{
LDBTool.PreAddDataAction = (Action)Delegate.Remove(LDBTool.PreAddDataAction, new Action(RegisterProtos));
LDBTool.PostAddDataAction = (Action)Delegate.Remove(LDBTool.PostAddDataAction, new Action(PostAddData));
if ((Object)(object)_shaderBundle != (Object)null)
{
_shaderBundle.Unload(false);
_shaderBundle = null;
_cargoShader = null;
_cargoShaderLoadAttempted = false;
_cargoShaderAppliedLogged = false;
_cargoShaderDrawPatchDisabled = false;
_cargoStackRenderPatchDisabled = false;
}
}
private void RegisterProtos()
{
List<TechProto> list = ResolveStationPilerTechs();
_techIds = ResolveFreeTechIds(DefaultTechIds);
_stationAnchorTechId = ((list.Count > 0) ? ((Proto)list[list.Count - 1]).ID : 1607);
int preTechId = _stationAnchorTechId;
for (int i = 0; i < _techIds.Length; i++)
{
int stackLevel = 4 + i + 1;
TechProto obj = CreateStackingTech(_techIds[i], stackLevel, preTechId, i);
LDBTool.PreAddProto((Proto)(object)obj);
preTechId = ((Proto)obj).ID;
}
((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("Registered stacking enhancement techs: ids={0}, anchor={1}", string.Join(",", _techIds), _stationAnchorTechId));
}
private static void RegisterLocalizations()
{
for (int i = 5; i <= 8; i++)
{
LocalizationModule.RegisterTranslation(TechNameKey(i), $"Stacking Enhancement {i}", $"堆叠增强 {i} 层", "");
LocalizationModule.RegisterTranslation(TechDescriptionKey(i), $"Improves logistics station cargo output stacking to {i} layers. Automatic pilers can also combine cargo up to {i} layers, while pile sorters keep their normal stacking limits.", $"将物流运输站输出货物堆叠上限提升至 {i} 层，并允许自动集装机生成最高 {i} 层货物。", "");
LocalizationModule.RegisterTranslation(TechConclusionKey(i), $"Logistics station cargo output stacking has been improved to {i} layers. Automatic pilers can now output cargo stacks up to {i} layers.", $"物流运输站输出货物堆叠已提升至 {i} 层。自动集装机现在可以输出最高 {i} 层货物。", "");
}
}
private void PostAddData()
{
RefreshTechProtoLinks();
EnsureTechStates(GameMain.history);
ApplyCargoShader(null);
}
private static TechProto CreateStackingTech(int techId, int stackLevel, int preTechId, int index)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
TechProto anchorTech = ((ProtoSet<TechProto>)(object)LDB.techs).Select(_stationAnchorTechId);
return CreateBaseTech(techId, TechNameKey(stackLevel), TechDescriptionKey(stackLevel), TechConclusionKey(stackLevel), GetTechPosition(anchorTech, index), GetIconPath(anchorTech), GetIconTag(anchorTech), (preTechId <= 0) ? Array.Empty<int>() : new int[1] { preTechId }, new int[1] { 6006 }, new int[1] { 1 }, EnhancementHashNeededByLevel[Math.Min(index, EnhancementHashNeededByLevel.Length - 1)], new int[1] { 29 }, new double[1] { 1.0 });
}
private static TechProto CreateBaseTech(int techId, string name, string description, string conclusion, Vector2 position, string iconPath, string iconTag, int[] preTechs, int[] items, int[] itemPoints, long hashNeeded, int[] unlockFunctions, double[] unlockValues)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Expected O, but got Unknown
return new TechProto
{
ID = techId,
Name = name,
Desc = description,
Conclusion = conclusion,
IconPath = iconPath,
IconTag = iconTag,
IsHiddenTech = false,
PreItem = Array.Empty<int>(),
Position = position,
PreTechs = preTechs,
PreTechsImplicit = Array.Empty<int>(),
Items = items,
ItemPoints = itemPoints,
HashNeeded = hashNeeded,
UnlockRecipes = Array.Empty<int>(),
UnlockFunctions = unlockFunctions,
UnlockValues = unlockValues,
Published = true,
Level = 0,
MaxLevel = 0,
LevelCoef1 = 0,
LevelCoef2 = 0,
IsLabTech = true,
PreTechsMax = false,
AddItems = Array.Empty<int>(),
AddItemCounts = Array.Empty<int>(),
PropertyOverrideItems = Array.Empty<int>(),
PropertyItemCounts = Array.Empty<int>()
};
}
private static Vector2 GetTechPosition(TechProto anchorTech, int index)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
Vector2 val = (Vector2)(((??)anchorTech?.Position) ?? new Vector2(41f, 33f));
return new Vector2(val.x + 4f + (float)index * 4f, val.y);
}
private static string GetIconPath(TechProto anchorTech)
{
if (!string.IsNullOrEmpty(anchorTech?.IconPath))
{
return anchorTech.IconPath;
}
return "Icons/Tech/1607";
}
private static string GetIconTag(TechProto anchorTech)
{
if (!string.IsNullOrEmpty(anchorTech?.IconTag))
{
return anchorTech.IconTag;
}
return "ddzq";
}
private static List<TechProto> ResolveStationPilerTechs()
{
return (from tech in ((ProtoSet<TechProto>)(object)LDB.techs)?.dataArray ?? Array.Empty<TechProto>()
where tech != null && tech.Published && tech.UnlockFunctions != null && tech.UnlockFunctions.Contains(29)
orderby ((Proto)tech).ID
select tech).ToList();
}
private static int[] ResolveFreeTechIds(IEnumerable<int> defaultIds)
{
HashSet<int> hashSet = new HashSet<int>(from tech in ((ProtoSet<TechProto>)(object)LDB.techs)?.dataArray ?? Array.Empty<TechProto>()
where tech != null
select ((Proto)tech).ID);
List<int> list = new List<int>();
foreach (int defaultId in defaultIds)
{
int i;
for (i = defaultId; hashSet.Contains(i); i++)
{
}
hashSet.Add(i);
list.Add(i);
}
return list.ToArray();
}
private static void RefreshTechProtoLinks()
{
((ProtoSet<TechProto>)(object)LDB.techs).OnAfterDeserialize();
TechProto[] dataArray = ((ProtoSet<TechProto>)(object)LDB.techs).dataArray;
foreach (TechProto obj in dataArray)
{
if (obj != null)
{
obj.Preload();
}
}
dataArray = ((ProtoSet<TechProto>)(object)LDB.techs).dataArray;
foreach (TechProto val in dataArray)
{
if (val != null)
{
val.PreTechsImplicit = (val.PreTechsImplicit ?? Array.Empty<int>()).Except(val.PreTechs ?? Array.Empty<int>()).ToArray();
val.UnlockRecipes = (val.UnlockRecipes ?? Array.Empty<int>()).Distinct().ToArray();
val.Preload2();
}
}
}
private static void EnsureTechStates(GameHistoryData history)
{
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
if (history?.techStates == null)
{
return;
}
int[] techIds = _techIds;
foreach (int num in techIds)
{
if (history.techStates.ContainsKey(num))
{
continue;
}
TechProto val = ((ProtoSet<TechProto>)(object)LDB.techs).Select(num);
if (val != null)
{
int num2 = 0;
int num3 = Array.IndexOf(val.Items ?? Array.Empty<int>(), 6006);
if (num3 >= 0 && val.ItemPoints != null && num3 < val.ItemPoints.Length)
{
num2 = val.ItemPoints[num3];
}
history.techStates.Add(num, new TechState(false, val.Level, val.MaxLevel, 0L, val.GetHashNeeded(val.Level), num2));
}
}
SyncStationPilerLevelFromUnlockedTechs(history);
}
public static int GetMaxPilerStack()
{
int val = GameMain.history?.stationPilerLevel ?? 4;
return Math.Min(8, Math.Max(4, val));
}
public static float GetMaxPilerStackFloat()
{
return GetMaxPilerStack();
}
private static int GetStationOutputStackLevel(GameHistoryData history)
{
int val = history?.stationPilerLevel ?? 1;
return Math.Min(8, Math.Max(1, val));
}
private static void SyncStationPilerLevelFromUnlockedTechs(GameHistoryData history)
{
if (history?.techStates != null)
{
int stationPilerLevel = history.stationPilerLevel;
stationPilerLevel = Math.Max(stationPilerLevel, GetHighestUnlockedStackLevel(history, _techIds));
stationPilerLevel = Math.Max(stationPilerLevel, GetHighestUnlockedStackLevel(history, LegacyStationStackTechIds));
stationPilerLevel = Math.Min(8, stationPilerLevel);
if (stationPilerLevel > history.stationPilerLevel)
{
history.stationPilerLevel = stationPilerLevel;
}
}
}
private static int GetHighestUnlockedStackLevel(GameHistoryData history, int[] techIds)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
int num = 0;
for (int i = 0; i < techIds.Length; i++)
{
if (history.techStates.TryGetValue(techIds[i], out var value) && value.unlocked)
{
num = Math.Max(num, 4 + i + 1);
}
}
return num;
}
private static string TechNameKey(int stackLevel)
{
return $"StackingEnhancement.Tech.{stackLevel}.Name";
}
private static string TechDescriptionKey(int stackLevel)
{
return $"StackingEnhancement.Tech.{stackLevel}.Description";
}
private static string TechConclusionKey(int stackLevel)
{
return $"StackingEnhancement.Tech.{stackLevel}.Conclusion";
}
private static T GetFieldValue<T>(FieldInfo field, object instance) where T : class
{
return field?.GetValue(instance) as T;
}
private static bool GetBoolFieldValue(FieldInfo field, object instance)
{
object obj = field?.GetValue(instance);
bool flag = default(bool);
int num;
if (obj is bool)
{
flag = (bool)obj;
num = 1;
}
else
{
num = 0;
}
return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
}
private static int GetIntFieldValue(FieldInfo field, object instance)
{
object obj = field?.GetValue(instance);
if (obj is int)
{
return (int)obj;
}
return 0;
}
private static void SetBoolFieldValue(FieldInfo field, object instance, bool value)
{
field?.SetValue(instance, value);
}
private static void LogPatchStatus()
{
Patches patchInfo = Harmony.GetPatchInfo((MethodBase)AccessTools.Method(typeof(CargoContainer), "Draw", (Type[])null, (Type[])null));
int valueOrDefault = (patchInfo?.Prefixes?.Count((Patch patch) => patch.owner == "com.komonad.dsp.stackingenhancement")).GetValueOrDefault();
int valueOrDefault2 = (patchInfo?.Postfixes?.Count((Patch patch) => patch.owner == "com.komonad.dsp.stackingenhancement")).GetValueOrDefault();
int valueOrDefault3 = (patchInfo?.Finalizers?.Count((Patch patch) => patch.owner == "com.komonad.dsp.stackingenhancement")).GetValueOrDefault();
int valueOrDefault4 = (patchInfo?.Transpilers?.Count((Patch patch) => patch.owner == "com.komonad.dsp.stackingenhancement")).GetValueOrDefault();
ManualLogSource logger = _logger;
if (logger != null)
{
logger.LogInfo((object)$"CargoContainer.Draw patches: prefix={valueOrDefault}, postfix={valueOrDefault2}, finalizer={valueOrDefault3}, transpiler={valueOrDefault4}");
}
}
private static Shader LoadCargoShader()
{
if ((Object)(object)_cargoShader != (Object)null)
{
return _cargoShader;
}
if (_cargoShaderLoadAttempted)
{
return null;
}
_cargoShaderLoadAttempted = true;
string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty, "stacking-enhancement-shaders");
if (!File.Exists(text))
{
ManualLogSource logger = _logger;
if (logger != null)
{
logger.LogWarning((object)("Cargo shader bundle missing: " + text));
}
return null;
}
_shaderBundle = AssetBundle.LoadFromFile(text);
if ((Object)(object)_shaderBundle == (Object)null)
{
ManualLogSource logger2 = _logger;
if (logger2 != null)
{
logger2.LogWarning((object)("Failed to load cargo shader bundle: " + text));
}
return null;
}
_cargoShader = _shaderBundle.LoadAsset<Shader>("Assets/CargoInstancing8.shader");
if ((Object)(object)_cargoShader == (Object)null)
{
_cargoShader = ((IEnumerable<Shader>)_shaderBundle.LoadAllAssets<Shader>()).FirstOrDefault((Func<Shader, bool>)((Shader shader) => (Object)(object)shader != (Object)null && ((Object)shader).name == "VF Shaders/Batching/Cargo Instancing 8"));
}
if ((Object)(object)_cargoShader == (Object)null)
{
ManualLogSource logger3 = _logger;
if (logger3 != null)
{
logger3.LogWarning((object)("Cargo shader asset missing in bundle: " + text));
}
}
else
{
ManualLogSource logger4 = _logger;
if (logger4 != null)
{
logger4.LogInfo((object)("Loaded cargo shader: " + ((Object)_cargoShader).name));
}
}
return _cargoShader;
}
private static void ApplyCargoShader(Material material)
{
Shader val = LoadCargoShader();
Material val2 = Configs.builtin?.cargoMat;
ConfigEntry<bool> enableCargoStackShader = _enableCargoStackShader;
if (enableCargoStackShader == null || !enableCargoStackShader.Value)
{
if ((Object)(object)_originalCargoShader != (Object)null)
{
if ((Object)(object)val2 != (Object)null && (Object)(object)val2.shader != (Object)(object)_originalCargoShader)
{
val2.shader = _originalCargoShader;
}
if ((Object)(object)material != (Object)null && (Object)(object)material.shader != (Object)(object)_originalCargoShader)
{
material.shader = _originalCargoShader;
}
}
}
else
{
if ((Object)(object)val == (Object)null)
{
return;
}
if ((Object)(object)val2 != (Object)null && (Object)(object)val2.shader != (Object)(object)val)
{
if ((Object)(object)_originalCargoShader == (Object)null)
{
_originalCargoShader = val2.shader;
}
val2.shader = val;
}
if ((Object)(object)material != (Object)null && (Object)(object)material.shader != (Object)(object)val)
{
material.shader = val;
}
if (!_cargoShaderAppliedLogged && (Object)(object)val2 != (Object)null)
{
_cargoShaderAppliedLogged = true;
ManualLogSource logger = _logger;
if (logger != null)
{
logger.LogInfo((object)("Applied cargo shader: " + ((Object)val).name));
}
}
}
}
private static void EnsureCargoRenderCapacity(CargoContainer container)
{
ConfigEntry<bool> enableCargoStackShader = _enableCargoStackShader;
if ((enableCargoStackShader != null && enableCargoStackShader.Value) || _cargoStackRenderPatchDisabled)
{
return;
}
Cargo[] fieldValue = GetFieldValue<Cargo[]>(CargoContainerFields.CargoPool, container);
int intFieldValue = GetIntFieldValue(CargoContainerFields.Cursor, container);
if (fieldValue == null || intFieldValue <= 0)
{
return;
}
int cargoCount = Math.Min(intFieldValue, fieldValue.Length);
int num = CalculateCargoRenderCount(fieldValue, cargoCount);
while (GetIntFieldValue(CargoContainerFields.PoolCapacity, container) < num)
{
if (CargoContainerMethods.Expand2x == null)
{
throw new MissingMethodException("CargoContainer", "Expand2x");
}
CargoContainerMethods.Expand2x.Invoke(container, null);
}
}
private static void UploadCargoRenderData(ComputeBuffer buffer, Array source, int managedBufferStartIndex, int computeBufferStartIndex, int count)
{
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
//IL_0159: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_0179: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Unknown result type (might be due to invalid IL or missing references)
ConfigEntry<bool> enableCargoStackShader = _enableCargoStackShader;
if ((enableCargoStackShader != null && enableCargoStackShader.Value) || _cargoStackRenderPatchDisabled || !(source is Cargo[] array))
{
_cargoRenderDrawCount = count;
buffer.SetData(source, managedBufferStartIndex, computeBufferStartIndex, count);
return;
}
int num = Math.Min(count, array.Length - managedBufferStartIndex);
if (num <= 0)
{
_cargoRenderDrawCount = 0;
buffer.SetData(source, managedBufferStartIndex, computeBufferStartIndex, count);
return;
}
int num2 = CalculateCargoRenderCount(array, num, managedBufferStartIndex);
if (num2 <= count)
{
_cargoRenderDrawCount = count;
buffer.SetData(source, managedBufferStartIndex, computeBufferStartIndex, count);
return;
}
if (num2 > buffer.count - computeBufferStartIndex)
{
_cargoStackRenderPatchDisabled = true;
_cargoRenderDrawCount = count;
ManualLogSource logger = _logger;
if (logger != null)
{
logger.LogWarning((object)$"Cargo stack render patch disabled: renderCount={num2}, bufferCount={buffer.count}, uploadOffset={computeBufferStartIndex}");
}
buffer.SetData(source, managedBufferStartIndex, computeBufferStartIndex, count);
return;
}
EnsureCargoRenderBufferCapacity(num2);
int num3 = 0;
int num4 = managedBufferStartIndex + num;
for (int i = managedBufferStartIndex; i < num4; i++)
{
Cargo val = array[i];
int stack = val.stack;
if (val.item <= 0 || stack <= 4 || stack > 8)
{
_cargoRenderBuffer[num3++] = val;
continue;
}
Cargo val2 = val;
val2.stack = 4;
_cargoRenderBuffer[num3++] = val2;
Cargo val3 = val;
val3.stack = (byte)(stack - 4);
ref Vector3 position = ref val3.position;
position += val3.rotation * new Vector3(0f, 0.4f, 0f);
_cargoRenderBuffer[num3++] = val3;
}
_cargoRenderDrawCount = num3;
buffer.SetData((Array)_cargoRenderBuffer, 0, computeBufferStartIndex, num3);
}
private static int GetCargoRenderDrawCount(CargoContainer container)
{
if (_cargoRenderDrawCount <= 0)
{
return GetIntFieldValue(CargoContainerFields.Cursor, container);
}
return _cargoRenderDrawCount;
}
private static int CalculateCargoRenderCount(Cargo[] cargos, int cargoCount, int startIndex = 0)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
int num = cargoCount;
int num2 = Math.Min(cargos.Length, startIndex + cargoCount);
for (int i = startIndex; i < num2; i++)
{
Cargo val = cargos[i];
int stack = val.stack;
if (val.item > 0 && stack > 4 && stack <= 8)
{
num++;
}
}
return num;
}
private static void EnsureCargoRenderBufferCapacity(int capacity)
{
if (_cargoRenderBuffer.Length < capacity)
{
int newSize = Math.Max(capacity, _cargoRenderBuffer.Length * 2);
Array.Resize(ref _cargoRenderBuffer, newSize);
}
}
private static void ApplyFixedPilerCount(UIStationWindow window, float value)
{
StationComponent stationComponent = GetStationComponent(window);
Image fieldValue = GetFieldValue<Image>(StationWindowFields.TechPilerCheck, window);
if (stationComponent != null && !GetBoolFieldValue(StationWindowFields.EventLock, window) && (fieldValue == null || !((Behaviour)fieldValue).enabled))
{
stationComponent.pilerCount = ClampStationPilerCount(Mathf.RoundToInt(value), GameMain.history);
RefreshPilerUi(window);
}
}
private static void ApplyFixedPilerCount(UIControlPanelStationInspector inspector, float value)
{
StationComponent stationComponent = GetStationComponent(inspector);
Image fieldValue = GetFieldValue<Image>(StationInspectorFields.TechPilerCheck, inspector);
if (stationComponent != null && !GetBoolFieldValue(StationInspectorFields.EventLock, inspector) && (fieldValue == null || !((Behaviour)fieldValue).enabled))
{
stationComponent.pilerCount = ClampStationPilerCount(Mathf.RoundToInt(value), GameMain.history);
RefreshPilerUi(inspector);
}
}
private static void ApplyTechPilerToggle(UIStationWindow window)
{
StationComponent stationComponent = GetStationComponent(window);
if (stationComponent != null && !GetBoolFieldValue(StationWindowFields.EventLock, window))
{
Image fieldValue = GetFieldValue<Image>(StationWindowFields.TechPilerCheck, window);
bool flag = fieldValue == null || !((Behaviour)fieldValue).enabled;
stationComponent.pilerCount = ((!flag) ? GetStationOutputStackLevel(GameMain.history) : 0);
RefreshPilerUi(window);
}
}
private static void ApplyTechPilerToggle(UIControlPanelStationInspector inspector)
{
StationComponent stationComponent = GetStationComponent(inspector);
if (stationComponent != null && !GetBoolFieldValue(StationInspectorFields.EventLock, inspector))
{
Image fieldValue = GetFieldValue<Image>(StationInspectorFields.TechPilerCheck, inspector);
bool flag = fieldValue == null || !((Behaviour)fieldValue).enabled;
stationComponent.pilerCount = ((!flag) ? GetStationOutputStackLevel(GameMain.history) : 0);
RefreshPilerUi(inspector);
}
}
private static void RefreshPilerUi(UIStationWindow window)
{
StationComponent stationComponent = GetStationComponent(window);
if (stationComponent != null)
{
bool boolFieldValue = GetBoolFieldValue(StationWindowFields.EventLock, window);
SetBoolFieldValue(StationWindowFields.EventLock, window, value: true);
RefreshPilerUi(stationComponent, GetFieldValue<Slider>(StationWindowFields.MinPilerSlider, window), GetFieldValue<Image>(StationWindowFields.MinPilerSliderFillImage, window), GetFieldValue<Text>(StationWindowFields.MinPilerValue, window), GetFieldValue<Image>(StationWindowFields.TechPilerCheck, window));
SetBoolFieldValue(StationWindowFields.EventLock, window, boolFieldValue);
}
}
private static void RefreshPilerUi(UIControlPanelStationInspector inspector)
{
StationComponent stationComponent = GetStationComponent(inspector);
if (stationComponent != null)
{
bool boolFieldValue = GetBoolFieldValue(StationInspectorFields.EventLock, inspector);
SetBoolFieldValue(StationInspectorFields.EventLock, inspector, value: true);
RefreshPilerUi(stationComponent, GetFieldValue<Slider>(StationInspectorFields.MinPilerSlider, inspector), GetFieldValue<Image>(StationInspectorFields.MinPilerSliderFillImage, inspector), GetFieldValue<Text>(StationInspectorFields.MinPilerValue, inspector), GetFieldValue<Image>(StationInspectorFields.TechPilerCheck, inspector));
SetBoolFieldValue(StationInspectorFields.EventLock, inspector, boolFieldValue);
}
}
private static void RefreshPilerUi(StationComponent station, Slider slider, Image sliderFillImage, Text valueText, Image techPilerCheck)
{
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
int stationOutputStackLevel = GetStationOutputStackLevel(GameMain.history);
if (station.pilerCount > stationOutputStackLevel)
{
station.pilerCount = stationOutputStackLevel;
}
bool flag = station.pilerCount == 0;
if ((Object)(object)slider != (Object)null)
{
slider.maxValue = stationOutputStackLevel;
slider.value = (flag ? stationOutputStackLevel : station.pilerCount);
((Selectable)slider).interactable = !flag;
ColorBlock colors = ((Selectable)slider).colors;
((ColorBlock)(ref colors)).normalColor = (flag ? SliderAutoNormalColor : SliderFixedNormalColor);
((ColorBlock)(ref colors)).highlightedColor = (flag ? SliderAutoHighlightColor : SliderFixedHighlightColor);
((ColorBlock)(ref colors)).pressedColor = (flag ? SliderAutoHighlightColor : SliderFixedHighlightColor);
((Selectable)slider).colors = colors;
}
if ((Object)(object)sliderFillImage != (Object)null)
{
((Graphic)sliderFillImage).color = (flag ? SliderAutoNormalColor : SliderFixedNormalColor);
}
if ((Object)(object)techPilerCheck != (Object)null)
{
((Behaviour)techPilerCheck).enabled = flag;
}
if ((Object)(object)valueText != (Object)null)
{
valueText.text = (flag ? stationOutputStackLevel : station.pilerCount).ToString();
}
}
private static int ClampStationPilerCount(int value, GameHistoryData history)
{
return Math.Min(GetStationOutputStackLevel(history), Math.Max(1, value));
}
private static StationComponent GetStationComponent(UIStationWindow window)
{
PlanetTransport fieldValue = GetFieldValue<PlanetTransport>(StationWindowFields.Transport, window);
int intFieldValue = GetIntFieldValue(StationWindowFields.StationId, window);
if ((Object)(object)window == (Object)null || fieldValue == null || fieldValue.stationPool == null || intFieldValue <= 0 || intFieldValue >= fieldValue.stationPool.Length)
{
return null;
}
StationComponent val = fieldValue.stationPool[intFieldValue];
if (val == null || val.id != intFieldValue)
{
return null;
}
return val;
}
private static StationComponent GetStationComponent(UIControlPanelStationInspector inspector)
{
PlanetTransport fieldValue = GetFieldValue<PlanetTransport>(StationInspectorFields.Transport, inspector);
int intFieldValue = GetIntFieldValue(StationInspectorFields.StationId, inspector);
if ((Object)(object)inspector == (Object)null || fieldValue == null || fieldValue.stationPool == null || intFieldValue <= 0 || intFieldValue >= fieldValue.stationPool.Length)
{
return null;
}
StationComponent val = fieldValue.stationPool[intFieldValue];
if (val == null || val.id != intFieldValue)
{
return null;
}
return val;
}
}
