using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Json;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using SCTCommon;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SCTBuildUpgrade.Scanner")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SCTBuildUpgrade.Scanner")]
[assembly: AssemblyTitle("SCTBuildUpgrade.Scanner")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace SCTCommon
{
internal static class Il2CppUtil
{
public static bool IsPlayer(Driller driller)
{
if (driller != null)
{
return (Object)(object)((Il2CppObjectBase)driller).TryCast<Player>() != (Object)null;
}
return false;
}
public static string Guid(BasePlugin plugin)
{
return MetadataHelper.GetMetadata((object)plugin).GUID;
}
public static IEnumerable<PluginInfo> Plugins()
{
if (IL2CPPChainloader.Instance == null)
{
yield break;
}
foreach (PluginInfo value in ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.Values)
{
yield return value;
}
}
}
internal static class Safe
{
private static readonly ManualLogSource Log = Logger.CreateLogSource("SCT Safe");
private static readonly HashSet<string> Reported = new HashSet<string>();
public static void Run(string where, Action action)
{
try
{
action();
}
catch (Exception e)
{
Report(where, e);
}
}
public static bool Prefix(string where, Func<bool> prefix)
{
try
{
return prefix();
}
catch (Exception e)
{
Report(where, e);
return true;
}
}
private static void Report(string where, Exception e)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
if (Reported.Add(where + e.GetType().Name + e.Message))
{
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(33, 4, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(where);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" : ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.GetType().Name);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" : ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.Message);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (ignoré, le jeu continue)\n");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.StackTrace);
}
Log.LogError(val);
}
}
}
internal static class Vanilla
{
private const string Key = "sct.vanilla";
public static bool Active
{
get
{
object data = AppDomain.CurrentDomain.GetData("sct.vanilla");
bool flag = default(bool);
int num;
if (data is bool)
{
flag = (bool)data;
num = 1;
}
else
{
num = 0;
}
return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
}
}
public static void Set(bool active)
{
AppDomain.CurrentDomain.SetData("sct.vanilla", active);
}
}
internal static class Lang
{
public static bool IsFrench
{
get
{
try
{
Locale selectedLocale = LocalizationSettings.SelectedLocale;
return ((selectedLocale != null) ? selectedLocale.Identifier.Code : null)?.StartsWith("fr", StringComparison.OrdinalIgnoreCase) ?? false;
}
catch (Exception)
{
return false;
}
}
}
public static string Pick(string fr, string en)
{
if (!IsFrench)
{
return en;
}
return fr;
}
}
internal static class SaveSlotApi
{
private const string VersionKey = "sct.saveslot.version";
public const string Prefix = "sct_";
public static string Directory => GameInstance.SaveDirectory;
public static int Version
{
get
{
object data = AppDomain.CurrentDomain.GetData("sct.saveslot.version");
if (data is int)
{
return (int)data;
}
return 0;
}
}
public static string PathOf(string name)
{
return Path.Combine(Directory, "sct_" + name);
}
public static void BumpVersion()
{
AppDomain.CurrentDomain.SetData("sct.saveslot.version", Version + 1);
}
public static void Migrate(string oldPath, string name)
{
try
{
string text = PathOf(name);
if (File.Exists(oldPath) && !File.Exists(text))
{
File.Move(oldPath, text);
}
}
catch (Exception)
{
}
}
}
internal static class GameInstance
{
private const string IndexKey = "sct.instance.index";
private const string MutexKey = "sct.instance.mutex";
private const string ErrorKey = "sct.instance.error";
private const string MutexName = "SCT_SpaceCatDigger_Instance_";
public const int Max = 4;
public static int Index
{
get
{
object data = AppDomain.CurrentDomain.GetData("sct.instance.index");
if (data is int)
{
return (int)data;
}
int i = 0;
Mutex data2 = null;
for (; i < 4; i++)
{
bool createdNew;
Mutex mutex = new Mutex(initiallyOwned: false, "SCT_SpaceCatDigger_Instance_" + i, out createdNew);
if (createdNew)
{
data2 = mutex;
break;
}
mutex.Dispose();
}
AppDomain.CurrentDomain.SetData("sct.instance.mutex", data2);
AppDomain.CurrentDomain.SetData("sct.instance.index", i);
if (i > 0)
{
PrepareTestSaves(i);
}
return i;
}
}
public static bool IsTest => Index > 0;
public static string Suffix
{
get
{
if (!IsTest)
{
return "";
}
return "_test" + (Index + 1);
}
}
public static string SaveDirectory => DirectoryOf(Index);
public static string Error => AppDomain.CurrentDomain.GetData("sct.instance.error") as string;
private static string DirectoryOf(int index)
{
if (index <= 0)
{
return Application.persistentDataPath;
}
return Path.Combine(Application.persistentDataPath, "coop_test_" + (index + 1));
}
public static int OthersRunning()
{
int index = Index;
int num = 0;
for (int i = 0; i < 4; i++)
{
if (i != index && Mutex.TryOpenExisting("SCT_SpaceCatDigger_Instance_" + i, out Mutex result))
{
result.Dispose();
num++;
}
}
return num;
}
private static void PrepareTestSaves(int index)
{
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Expected O, but got Unknown
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Expected O, but got Unknown
ManualLogSource val = Logger.CreateLogSource("SCT Instance");
bool flag = default(bool);
try
{
string persistentDataPath = Application.persistentDataPath;
string text = DirectoryOf(index);
Directory.CreateDirectory(text);
string[] files = Directory.GetFiles(text);
for (int i = 0; i < files.Length; i++)
{
File.Delete(files[i]);
}
files = Directory.GetFiles(persistentDataPath);
foreach (string text2 in files)
{
string fileName = Path.GetFileName(text2);
if (fileName == "persistent.save" || fileName.StartsWith("sct_", StringComparison.Ordinal))
{
File.Copy(text2, Path.Combine(text, fileName), overwrite: true);
}
}
string text3 = text + "/game.save";
string text4 = text + "/persistent.save";
SaveSystem.GameFileName = text3;
SaveSystem.PersistentFileName = text4;
if (SaveSystem.GameFileName != text3 || SaveSystem.PersistentFileName != text4)
{
throw new InvalidOperationException("chemins de sauvegarde du jeu non modifiables");
}
BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(58, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Exemplaire n° ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(index + 1);
((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" du jeu sur ce PC : sauvegarde de test dans ");
((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
}
val.LogInfo(val2);
}
catch (Exception ex)
{
AppDomain.CurrentDomain.SetData("sct.instance.error", ex.Message);
BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(97, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Exemplaire n° ");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(index + 1);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" : sauvegarde de test impossible (");
((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("). CET EXEMPLAIRE ÉCRIT DANS LA VRAIE SAUVEGARDE.");
}
val.LogError(val3);
}
}
}
internal enum ColorVision
{
Normal,
Protanopia,
Deuteranopia,
Tritanopia
}
internal static class Palette
{
public const string VisionKey = "sct.colorblind.vision";
public const string RedundantKey = "sct.colorblind.redundant";
private static readonly Color Black = C(0);
private static readonly Color Orange = C(15113984);
private static readonly Color SkyBlue = C(5682409);
private static readonly Color Green = C(40563);
private static readonly Color Yellow = C(15787074);
private static readonly Color Blue = C(29362);
private static readonly Color Vermillion = C(13983232);
private static readonly Color Purple = C(13400487);
private static readonly Color White = C(16777215);
private static readonly Color Grey = C(7237230);
public static ColorVision Vision
{
get
{
object data = AppDomain.CurrentDomain.GetData("sct.colorblind.vision");
if (data is int)
{
return (ColorVision)(int)data;
}
return ColorVision.Normal;
}
}
public static bool Adapted => Vision != ColorVision.Normal;
public static bool Redundant
{
get
{
if (Adapted)
{
object data = AppDomain.CurrentDomain.GetData("sct.colorblind.redundant");
bool flag = default(bool);
int num;
if (data is bool)
{
flag = (bool)data;
num = 1;
}
else
{
num = 0;
}
return num == 0 || flag;
}
return false;
}
}
private static bool RedGreen
{
get
{
if (Vision != ColorVision.Protanopia)
{
return Vision == ColorVision.Deuteranopia;
}
return true;
}
}
public static Color Good(Color usual)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (Adapted)
{
if (!RedGreen)
{
return Green;
}
return SkyBlue;
}
return usual;
}
public static Color Bad(Color usual)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
if (Adapted)
{
return Vermillion;
}
return usual;
}
public static Color Warning(Color usual)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (Adapted)
{
if (!RedGreen)
{
return Orange;
}
return Yellow;
}
return usual;
}
public static Color Danger(Color usual)
{
//IL_001f: 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)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
if (Adapted)
{
if (!RedGreen)
{
return C(16719904);
}
return Vermillion;
}
return usual;
}
public static Color Accent(Color usual)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (Adapted)
{
if (!RedGreen)
{
return Purple;
}
return SkyBlue;
}
return usual;
}
public static string GoodHex(string usual = "80ff80")
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (!Adapted)
{
return usual;
}
return Hex(Good(White));
}
public static string BadHex(string usual = "ff8080")
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (!Adapted)
{
return usual;
}
return Hex(Bad(White));
}
public static string WarningHex(string usual = "ffcc66")
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
if (!Adapted)
{
return usual;
}
return Hex(Warning(White));
}
public static Color Ore(ResourceType type, Color usual)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected I4, but got Unknown
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: 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_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: 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)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
if (!Adapted)
{
return usual;
}
bool flag = Vision == ColorVision.Tritanopia;
switch (type - 2)
{
case 9:
return Grey;
case 0:
if (!flag)
{
return Blue;
}
return Vermillion;
case 2:
return Orange;
case 4:
return White;
case 6:
if (!flag)
{
return Yellow;
}
return C(16756912);
case 8:
return SkyBlue;
case 10:
if (!flag)
{
return Purple;
}
return Blue;
case 11:
if (!flag)
{
return Green;
}
return C(8323072);
case 12:
if (!flag)
{
return Vermillion;
}
return Black;
default:
return usual;
}
}
public static Color Tier(int level, Color usual)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: 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_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: 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_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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_0091: Unknown result type (might be due to invalid IL or missing references)
if (!Adapted || level <= 0)
{
return usual;
}
Color[] array = (Color[])(object)((Vision != ColorVision.Tritanopia) ? new Color[4] { Blue, Orange, White, Yellow } : new Color[4] { SkyBlue, Vermillion, White, Purple });
return array[Mathf.Clamp(level, 1, array.Length) - 1];
}
public static Color Marker(int index, Color usual)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: 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_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: 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_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: 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)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: 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_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
if (!Adapted)
{
return usual;
}
Color[] array = (Color[])(object)((Vision != ColorVision.Tritanopia) ? new Color[5] { Yellow, SkyBlue, Orange, White, Purple } : new Color[5]
{
Vermillion,
White,
SkyBlue,
C(16756912),
Green
});
return array[Math.Abs(index) % array.Length];
}
public static float Blink(float speed = 3f)
{
if (!Redundant)
{
return 1f;
}
return 0.45f + 0.55f * Mathf.Abs(Mathf.Sin(Time.unscaledTime * speed));
}
public static string Hex(Color c)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
return $"{Mathf.RoundToInt(Mathf.Clamp01(c.r) * 255f):X2}{Mathf.RoundToInt(Mathf.Clamp01(c.g) * 255f):X2}{Mathf.RoundToInt(Mathf.Clamp01(c.b) * 255f):X2}";
}
private static Color C(int rgb)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
return new Color((float)((rgb >> 16) & 0xFF) / 255f, (float)((rgb >> 8) & 0xFF) / 255f, (float)(rgb & 0xFF) / 255f);
}
}
internal static class CraftCosts
{
private const string OwnerKey = "sct.craft.owner";
private const string ProvidersKey = "sct.craft.providers";
private const float MinFactor = 0.25f;
private const int MaxBuildId = 512;
private static readonly Dictionary<int, int[]> Originals = new Dictionary<int, int[]>();
private static float _appliedFactor = 1f;
private static bool _isOwner;
public static float Factor
{
get
{
float num = 1f;
if (AppDomain.CurrentDomain.GetData("sct.craft.providers") is Dictionary<string, Func<float>> dictionary)
{
foreach (Func<float> value in dictionary.Values)
{
try
{
num *= 1f - Mathf.Clamp(value(), 0f, 0.9f);
}
catch (Exception)
{
}
}
}
return Mathf.Max(0.25f, num);
}
}
public static void RegisterDiscount(string id, Func<float> discount)
{
lock (AppDomain.CurrentDomain)
{
Dictionary<string, Func<float>> dictionary = (AppDomain.CurrentDomain.GetData("sct.craft.providers") as Dictionary<string, Func<float>>) ?? new Dictionary<string, Func<float>>();
dictionary[id] = discount;
AppDomain.CurrentDomain.SetData("sct.craft.providers", dictionary);
}
}
public static void Install(Harmony harmony, string owner)
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
lock (AppDomain.CurrentDomain)
{
if (AppDomain.CurrentDomain.GetData("sct.craft.owner") != null)
{
return;
}
AppDomain.CurrentDomain.SetData("sct.craft.owner", owner);
_isOwner = true;
}
HarmonyMethod val = new HarmonyMethod(typeof(CraftCosts), "SyncPrefix", (Type[])null);
string[] array = new string[3] { "Open", "RefreshCostItems", "TryPurchase" };
foreach (string text in array)
{
MethodInfo methodInfo = AccessTools.Method(typeof(CraftMenu), text, (Type[])null, (Type[])null);
if (methodInfo != null)
{
harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
}
}
private static void SyncPrefix()
{
Safe.Run("Coûts de craft", Sync);
}
public static void Sync()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
if (!_isOwner)
{
return;
}
Dictionary<BuildType, List<ResourceTypeQuantity>> craftingCosts = CraftMenu._craftingCosts;
if (craftingCosts == null)
{
return;
}
float factor = Factor;
bool flag = !Mathf.Approximately(factor, _appliedFactor);
for (int i = 0; i < 512; i++)
{
BuildType val = (BuildType)i;
if (!craftingCosts.ContainsKey(val))
{
continue;
}
List<ResourceTypeQuantity> val2 = craftingCosts[val];
if (!Originals.TryGetValue(i, out var value) || value.Length != val2.Count)
{
value = new int[val2.Count];
for (int j = 0; j < val2.Count; j++)
{
value[j] = val2[j].quantity;
}
Originals[i] = value;
flag = true;
}
if (flag)
{
for (int k = 0; k < val2.Count; k++)
{
ResourceTypeQuantity val3 = val2[k];
val3.quantity = ((factor >= 1f) ? value[k] : Mathf.Max(1, Mathf.CeilToInt((float)value[k] * factor)));
val2[k] = val3;
}
}
}
_appliedFactor = factor;
}
public static void AddRecipe(BuildType type, params (ResourceType Resource, int Quantity)[] ingredients)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: 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_0055: Unknown result type (might be due to invalid IL or missing references)
Dictionary<BuildType, List<ResourceTypeQuantity>> craftingCosts = CraftMenu._craftingCosts;
List<ResourceTypeQuantity> val = new List<ResourceTypeQuantity>();
for (int i = 0; i < ingredients.Length; i++)
{
var (resourceType, quantity) = ingredients[i];
val.Add(new ResourceTypeQuantity
{
resourceType = resourceType,
quantity = quantity
});
}
craftingCosts[type] = val;
}
}
internal static class RefundBonus
{
private const string ProvidersKey = "sct.refund.providers";
private const string ActiveKey = "sct.refund.active";
public static bool SalvageActive
{
get
{
if (!(AppDomain.CurrentDomain.GetData("sct.refund.active") is Dictionary<string, Func<bool>> dictionary))
{
return false;
}
foreach (Func<bool> value in dictionary.Values)
{
try
{
if (value())
{
return true;
}
}
catch (Exception)
{
}
}
return false;
}
}
public static float Total
{
get
{
float num = 0f;
if (AppDomain.CurrentDomain.GetData("sct.refund.providers") is Dictionary<string, Func<float>> dictionary)
{
foreach (Func<float> value in dictionary.Values)
{
try
{
num += Mathf.Max(0f, value());
}
catch (Exception)
{
}
}
}
return num;
}
}
public static void Register(string id, Func<float> bonus, Func<bool> active)
{
lock (AppDomain.CurrentDomain)
{
Dictionary<string, Func<float>> dictionary = (AppDomain.CurrentDomain.GetData("sct.refund.providers") as Dictionary<string, Func<float>>) ?? new Dictionary<string, Func<float>>();
dictionary[id] = bonus;
AppDomain.CurrentDomain.SetData("sct.refund.providers", dictionary);
Dictionary<string, Func<bool>> dictionary2 = (AppDomain.CurrentDomain.GetData("sct.refund.active") as Dictionary<string, Func<bool>>) ?? new Dictionary<string, Func<bool>>();
dictionary2[id] = active;
AppDomain.CurrentDomain.SetData("sct.refund.active", dictionary2);
}
}
}
internal static class SctGui
{
public const float LineHeight = 22f;
public const float Gap = 4f;
private static readonly ManualLogSource Log = Logger.CreateLogSource("SctGui");
private static readonly HashSet<string> Reported = new HashSet<string>();
private static bool _useBroken;
private static readonly HashSet<int> ClickLogged = new HashSet<int>();
private static GUIStyle _button;
private static GUIStyle _buttonHover;
private static GUIStyle _buttonOn;
private static GUIStyle _check;
private static GUIStyle _label;
private static GUIStyle _richBox;
private static GUIStyle _buttonToggle;
public static GUIStyle Label
{
get
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: 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_0049: Expected O, but got Unknown
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
if (_label == null)
{
GUIStyle label = GUI.skin.label;
_label = new GUIStyle
{
richText = true,
wordWrap = false,
alignment = (TextAnchor)3,
fontSize = label.fontSize,
padding = label.padding
};
_label.normal.textColor = label.normal.textColor;
}
return _label;
}
}
public static GUIStyle ButtonToggle => _buttonToggle ?? (_buttonToggle = GUI.skin.button);
public static GUIStyle RichBox => _richBox ?? (_richBox = BoxStyle(13, (TextAnchor)0));
public static bool Contains(Rect r, Vector2 p)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
if (p.x >= ((Rect)(ref r)).x && p.x < ((Rect)(ref r)).x + ((Rect)(ref r)).width && p.y >= ((Rect)(ref r)).y)
{
return p.y < ((Rect)(ref r)).y + ((Rect)(ref r)).height;
}
return false;
}
public static void Use(Event e)
{
if (_useBroken)
{
return;
}
try
{
e.Use();
}
catch (Exception e2)
{
_useBroken = true;
Report("Event.Use", e2);
}
}
public static void NoteClick(int owner, Vector2 position)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
if (ClickLogged.Add(owner))
{
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(36, 3, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Fenêtre ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(owner);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" : premier clic reçu en (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(position.x, "0");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(position.y, "0");
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
}
Log.LogInfo(val);
}
}
private static GUIStyle CopyState(GUIStyle source, GUIStyleState state, TextAnchor alignment)
{
//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_0006: 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_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Expected O, but got Unknown
GUIStyle val = new GUIStyle
{
alignment = alignment,
richText = true,
fontSize = source.fontSize,
border = source.border,
padding = source.padding,
wordWrap = false
};
val.normal.background = state.background;
val.normal.textColor = state.textColor;
return val;
}
public static void DrawButton(Rect rect, string text, bool on)
{
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
if (_button == null)
{
GUIStyle button = GUI.skin.button;
_button = CopyState(button, button.normal, (TextAnchor)4);
_buttonHover = CopyState(button, ((Object)(object)button.hover.background != (Object)null) ? button.hover : button.normal, (TextAnchor)4);
_buttonOn = CopyState(button, ((Object)(object)button.onNormal.background != (Object)null) ? button.onNormal : button.active, (TextAnchor)4);
}
bool flag = GUI.enabled && Event.current != null && Contains(rect, Event.current.mousePosition);
Color color = GUI.color;
if (on)
{
GUI.color = color * new Color(0.65f, 0.9f, 1f, 1f);
}
else if (!GUI.enabled)
{
GUI.color = color * new Color(1f, 1f, 1f, 0.5f);
}
GUI.Box(rect, text, on ? _buttonOn : (flag ? _buttonHover : _button));
GUI.color = color;
}
public static void DrawCheck(Rect rect, string text, bool on)
{
//IL_0057: 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)
if (_check == null)
{
_check = CopyState(GUI.skin.button, GUI.skin.button.normal, (TextAnchor)4);
}
GUI.Box(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y + (((Rect)(ref rect)).height - 16f) / 2f, 16f, 16f), on ? "x" : "", _check);
GUI.Label(new Rect(((Rect)(ref rect)).x + 20f, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width - 20f, ((Rect)(ref rect)).height), text, Label);
}
public static void Report(string where, Exception e)
{
string text = where + ": " + e.GetType().Name + ": " + e.Message;
if (Reported.Add(text))
{
Log.LogWarning((object)(text + "\n" + e.StackTrace));
}
}
public static GUIStyle BoxStyle(int fontSize, TextAnchor alignment)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
GUIStyle box = GUI.skin.box;
GUIStyle val = new GUIStyle
{
alignment = alignment,
richText = true,
fontSize = fontSize,
border = box.border,
padding = box.padding,
margin = box.margin,
wordWrap = box.wordWrap
};
val.normal.background = box.normal.background;
val.normal.textColor = box.normal.textColor;
return val;
}
public static GUIStyle TextureStyle(Texture2D texture)
{
//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_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
GUIStyle val = new GUIStyle
{
border = new RectOffset(),
padding = new RectOffset(),
margin = new RectOffset()
};
val.normal.background = texture;
return val;
}
public static void DrawTexture(Rect rect, GUIStyle textureStyle)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
GUI.Box(rect, "", textureStyle);
}
public static float TextHeight(string text)
{
return (float)Math.Max(1, text.Split('\n').Length) * 18f + 4f;
}
}
internal class SctWindow
{
private readonly int _id;
private readonly Func<string> _title;
private readonly Action<SctLayout> _content;
private readonly WindowFunction _function;
private readonly SctLayout _layout = new SctLayout();
private readonly bool _modal;
public Rect Rect;
public SctWindow(int id, Rect rect, Func<string> title, Action<SctLayout> content, bool modal = false)
{
//IL_0019: 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)
_id = id;
Rect = rect;
_title = title;
_content = content;
_modal = modal;
_function = WindowFunction.op_Implicit((Action<int>)Draw);
}
public void OnGUI()
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
Rect = (_modal ? GUI.ModalWindow(_id, Rect, _function, _title()) : GUI.Window(_id, Rect, _function, _title()));
}
private void Draw(int id)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
try
{
_layout.Begin(new Rect(8f, 22f, ((Rect)(ref Rect)).width - 16f, ((Rect)(ref Rect)).height - 28f), _id);
_content(_layout);
_layout.End();
}
catch (Exception ex)
{
SctGui.Report("Fenêtre " + _id, ex);
GUI.Label(new Rect(8f, 22f, ((Rect)(ref Rect)).width - 16f, 60f), "Erreur : " + ex.Message, SctGui.Label);
}
if (!_modal)
{
GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref Rect)).width, 20f));
}
}
}
internal class SctLayout
{
private struct Frame
{
public float X;
public float Y;
public float Width;
public bool Horizontal;
public float RowX;
public float RowHeight;
}
private readonly Stack<Frame> _frames = new Stack<Frame>();
private Frame _f;
private int _owner;
private int _counter;
private static string _activeSlider;
private static string _focusedField;
private static readonly Dictionary<string, float> ScrollOffsets = new Dictionary<string, float>();
private static readonly Dictionary<string, float> ContentHeights = new Dictionary<string, float>();
private static readonly Dictionary<string, float> BoxHeights = new Dictionary<string, float>();
private readonly Stack<float> _columnTops = new Stack<float>();
private readonly Stack<(string Key, float Top)> _boxKeys = new Stack<(string, float)>();
private readonly Stack<(string Key, float Height)> _scrollKeys = new Stack<(string, float)>();
public float Width
{
get
{
if (!_f.Horizontal)
{
return _f.Width;
}
return _f.Width - (_f.RowX - _f.X);
}
}
public static bool IsTyping => _focusedField != null;
public void Begin(Rect area, int owner = 0)
{
_frames.Clear();
_owner = owner;
_counter = 0;
_f = new Frame
{
X = ((Rect)(ref area)).x,
Y = ((Rect)(ref area)).y,
Width = ((Rect)(ref area)).width
};
}
public void End()
{
if (_f.Horizontal)
{
EndHorizontal();
}
}
private string NextKey()
{
return _owner + ":" + _counter++;
}
private Rect Next(float width, float height)
{
//IL_00b9: 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)
if (_f.Horizontal)
{
float num = ((width < 0f) ? (_f.Width - (_f.RowX - _f.X)) : width);
Rect result = new Rect(_f.RowX, _f.Y, num, height);
_f.RowX += num + 4f;
_f.RowHeight = Math.Max(_f.RowHeight, height);
return result;
}
Rect result2 = new Rect(_f.X, _f.Y, (width < 0f) ? _f.Width : width, height);
_f.Y += height + 4f;
return result2;
}
public void Space(float height = 8f)
{
if (_f.Horizontal)
{
_f.RowX += height;
}
else
{
_f.Y += height;
}
}
public void BeginHorizontal()
{
_frames.Push(_f);
_f.Horizontal = true;
_f.RowX = _f.X;
_f.RowHeight = 0f;
}
public void EndHorizontal()
{
float rowHeight = _f.RowHeight;
_f = _frames.Pop();
_f.Y += rowHeight + 4f;
}
public void BeginColumn(float width = -1f)
{
float width2 = ((width < 0f) ? (_f.Width - (_f.RowX - _f.X)) : width);
_frames.Push(_f);
_columnTops.Push(_f.Y);
_f = new Frame
{
X = _f.RowX,
Y = _f.Y,
Width = width2
};
}
public void EndColumn()
{
float val = _f.Y - _columnTops.Pop();
float width = _f.Width;
_f = _frames.Pop();
_f.RowX += width + 4f;
_f.RowHeight = Math.Max(_f.RowHeight, val);
}
public void BeginBox()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
string text = NextKey();
BoxHeights.TryGetValue(text, out var value);
if (value > 0f)
{
GUI.Box(new Rect(_f.X, _f.Y, _f.Width, value), "");
}
_frames.Push(_f);
_f.X += 6f;
_f.Width -= 12f;
_f.Y += 4f;
_boxKeys.Push((text, _f.Y - 4f));
}
public void EndBox()
{
(string Key, float Top) tuple = _boxKeys.Pop();
string item = tuple.Key;
float item2 = tuple.Top;
float y = _f.Y;
_f = _frames.Pop();
BoxHeights[item] = y - item2 + 2f;
_f.Y = y + 2f + 4f;
}
public void Label(string text, float width = -1f)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
GUI.Label(Next(width, text.Contains("\n") ? SctGui.TextHeight(text) : 22f), text, SctGui.Label);
}
private bool Clicked(Rect rect)
{
//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_001c: 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)
if (!GUI.enabled)
{
return false;
}
Event current = Event.current;
if (current == null || (int)current.type != 0 || !SctGui.Contains(rect, current.mousePosition))
{
return false;
}
SctGui.NoteClick(_owner, current.mousePosition);
SctGui.Use(current);
return true;
}
public Rect Area(float width, float height)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
return Next(width, height);
}
public bool AreaClick(Rect rect, out Vector2 local, out int button)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
local = Vector2.zero;
button = -1;
Event current = Event.current;
if (!GUI.enabled || current == null || (int)current.type != 0 || !SctGui.Contains(rect, current.mousePosition))
{
return false;
}
local = new Vector2(current.mousePosition.x - ((Rect)(ref rect)).x, current.mousePosition.y - ((Rect)(ref rect)).y);
try
{
button = current.button;
}
catch (Exception)
{
button = 0;
}
SctGui.NoteClick(_owner, current.mousePosition);
SctGui.Use(current);
return true;
}
public bool Button(string text, float width = -1f, float height = 22f)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
Rect rect = Next(width, height);
bool result = Clicked(rect);
SctGui.DrawButton(rect, text, on: false);
return result;
}
public bool Toggle(bool value, string text, float width = -1f)
{
//IL_0007: 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_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
Rect rect = Next(width, 22f);
if (Clicked(rect))
{
value = !value;
}
SctGui.DrawCheck(rect, text, value);
return value;
}
public bool ToggleButton(bool value, string text, float width = -1f, float height = 22f)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: 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)
Rect rect = Next(width, height);
if (Clicked(rect))
{
value = !value;
}
SctGui.DrawButton(rect, text, value);
return value;
}
public int Toolbar(int selected, string[] labels, float width = -1f)
{
//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_004e: 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)
float width2 = (((width < 0f) ? Width : width) - 4f * (float)(labels.Length - 1)) / (float)labels.Length;
bool horizontal = _f.Horizontal;
if (!horizontal)
{
BeginHorizontal();
}
int num = selected;
for (int i = 0; i < labels.Length; i++)
{
Rect rect = Next(width2, 22f);
if (Clicked(rect))
{
num = i;
}
SctGui.DrawButton(rect, labels[i], i == num);
}
if (!horizontal)
{
EndHorizontal();
}
return num;
}
public float Slider(float value, float min, float max, float width = -1f)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Invalid comparison between Unknown and I4
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_0113: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Invalid comparison between Unknown and I4
//IL_0131: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012d: Invalid comparison between Unknown and I4
string text = NextKey();
Rect r = Next(width, 22f);
Rect val = default(Rect);
((Rect)(ref val))..ctor(((Rect)(ref r)).x, ((Rect)(ref r)).y + ((Rect)(ref r)).height / 2f - 3f, ((Rect)(ref r)).width, 6f);
float num = ((max > min) ? Mathf.Clamp01((value - min) / (max - min)) : 0f);
GUI.Box(val, "");
GUI.Box(new Rect(((Rect)(ref val)).x + num * (((Rect)(ref val)).width - 12f), ((Rect)(ref r)).y + 2f, 12f, ((Rect)(ref r)).height - 4f), "");
Event current = Event.current;
if ((int)current.type == 0 && SctGui.Contains(r, current.mousePosition))
{
_activeSlider = text;
SctGui.Use(current);
}
else if ((int)current.type == 1 && _activeSlider == text)
{
_activeSlider = null;
SctGui.Use(current);
}
if (_activeSlider == text && ((int)current.type == 3 || (int)current.type == 0 || (int)current.type == 12))
{
float num2 = Mathf.Clamp01((current.mousePosition.x - ((Rect)(ref val)).x) / Math.Max(1f, ((Rect)(ref val)).width));
value = min + num2 * (max - min);
}
return value;
}
public string TextField(string value, int maxLength, float width = -1f)
{
//IL_000e: 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_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: 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_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Invalid comparison between Unknown and I4
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Invalid comparison between Unknown and I4
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Invalid comparison between Unknown and I4
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Invalid comparison between Unknown and I4
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Invalid comparison between Unknown and I4
string text = NextKey();
Rect val = Next(width, 22f);
bool flag = _focusedField == text;
Event current = Event.current;
if ((int)current.type == 0)
{
if (SctGui.Contains(val, current.mousePosition))
{
_focusedField = text;
flag = true;
SctGui.Use(current);
}
else if (flag)
{
_focusedField = null;
flag = false;
}
}
value = value ?? "";
if (flag && (int)current.type == 4)
{
if ((int)current.keyCode == 8)
{
if (value.Length > 0)
{
value = value.Substring(0, value.Length - 1);
}
SctGui.Use(current);
}
else if ((int)current.keyCode == 13 || (int)current.keyCode == 271 || (int)current.keyCode == 27)
{
_focusedField = null;
SctGui.Use(current);
}
else if (current.character != 0 && !char.IsControl(current.character))
{
if (value.Length < maxLength)
{
value += current.character;
}
SctGui.Use(current);
}
}
bool flag2 = flag && Time.realtimeSinceStartup % 1f < 0.5f;
GUI.Box(val, "");
GUI.Label(new Rect(((Rect)(ref val)).x + 4f, ((Rect)(ref val)).y, ((Rect)(ref val)).width - 8f, ((Rect)(ref val)).height), value + (flag2 ? "|" : ""), SctGui.Label);
return value;
}
public void BeginScroll(float height, string id = null)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Invalid comparison between Unknown and I4
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
string text = id ?? NextKey();
Rect r = Next(-1f, height);
ScrollOffsets.TryGetValue(text, out var value);
ContentHeights.TryGetValue(text, out var value2);
Event current = Event.current;
if ((int)current.type == 6 && SctGui.Contains(r, current.mousePosition))
{
value += current.delta.y * 20f;
SctGui.Use(current);
}
value = Mathf.Clamp(value, 0f, Math.Max(0f, value2 - height));
ScrollOffsets[text] = value;
if (value2 > height)
{
float num = Math.Max(20f, height * height / value2);
float num2 = ((Rect)(ref r)).y + (height - num) * (value / (value2 - height));
GUI.Box(new Rect(((Rect)(ref r)).x + ((Rect)(ref r)).width - 6f, num2, 6f, num), "");
}
GUI.BeginGroup(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width - 8f, height));
_frames.Push(_f);
_scrollKeys.Push((text, height));
_f = new Frame
{
X = 0f,
Y = 0f - value,
Width = ((Rect)(ref r)).width - 8f
};
}
public void EndScroll()
{
string item = _scrollKeys.Pop().Key;
ScrollOffsets.TryGetValue(item, out var value);
ContentHeights[item] = _f.Y + value;
GUI.EndGroup();
_f = _frames.Pop();
}
}
}
namespace SCTBuildUpgrades
{
internal class UpgradeTier
{
public string NameFr;
public string NameEn;
public (ResourceType Resource, int Quantity)[] Costs;
public Color Tint;
public Color Glow;
public string Name => Lang.Pick(NameFr, NameEn);
}
internal class BuildUpgradeDefinition
{
public BuildType Target;
public string TargetFr;
public string TargetEn;
public UpgradeTier[] Tiers;
public float[] Speed = new float[5] { 1f, 1.15f, 1.3f, 1.5f, 1.75f };
public float[] Consumption = new float[5] { 1f, 0.9f, 0.8f, 0.7f, 0.6f };
public float[] EnergyReserve = new float[5] { 1f, 1.5f, 2f, 3f, 4f };
public float[] Storage = new float[5] { 1f, 1.5f, 2f, 3f, 4f };
public int[] InputSlot;
public float[] OutputRate = new float[5] { 1f, 1f, 1.25f, 1.5f, 1.5f };
public string TargetName => Lang.Pick(TargetFr, TargetEn);
public static T At<T>(T[] values, int level)
{
return values[Math.Max(0, Math.Min(level, values.Length - 1))];
}
}
public abstract class BuildUpgradePlugin : BasePlugin
{
internal static BuildUpgradeDefinition Definition;
internal static ConfigEntry<bool> Enabled;
internal static ConfigEntry<Key> HoldKey;
internal static ConfigEntry<float> HoldSeconds;
internal static ConfigEntry<bool> GlowEnabled;
internal static ConfigEntry<int> RefundPercent;
internal static ConfigEntry<string> LightFactors;
internal static ManualLogSource Logger;
private static BuildUpgradePlugin _instance;
internal static bool Active
{
get
{
if (Enabled.Value)
{
return !Vanilla.Active;
}
return false;
}
}
internal abstract BuildUpgradeDefinition CreateDefinition();
protected abstract void AddHost();
internal virtual void ApplyEffects(Build build, int level)
{
}
protected virtual void BindConfig()
{
}
public override void Load()
{
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Expected O, but got Unknown
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Expected O, but got Unknown
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0189: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
//IL_01e2: Expected O, but got Unknown
_instance = this;
Logger = ((BasePlugin)this).Log;
Definition = CreateDefinition();
Enabled = ((BasePlugin)this).Config.Bind<bool>("Amelioration", "Enabled", true, "Permet d'améliorer les " + Definition.TargetFr.ToLowerInvariant() + "s.");
HoldKey = ((BasePlugin)this).Config.Bind<Key>("Amelioration", "Key", (Key)35, "Touche à maintenir devant le bâtiment pour l'améliorer.");
HoldSeconds = ((BasePlugin)this).Config.Bind<float>("Amelioration", "HoldSeconds", 0.6f, new ConfigDescription("Durée de maintien (secondes).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 3f), Array.Empty<object>()));
GlowEnabled = ((BasePlugin)this).Config.Bind<bool>("Amelioration", "Glow", true, "Lueur pulsée de la couleur du palier (bleu, cuivre, blanc, or).");
LightFactors = ((BasePlugin)this).Config.Bind<string>("Amelioration", "LightFactors", "1.5, 2.25, 3, 4, 5", "Rayon de lumière par palier (Fer, Cuivre, Quartz, Or, puis paliers suivants), séparés par des virgules. Bâtiment non amélioré : lumière d'origine. Valeur 1 = lumière d'origine pour ce palier.");
RefundPercent = ((BasePlugin)this).Config.Bind<int>("Amelioration", "RefundPercentWithSalvage", 50, new ConfigDescription("Part des lingots rendue au ramassage d'un bâtiment amélioré, UNIQUEMENT si le mod de perk Récupération est installé et activé (chaque perk prise la remonte jusqu'à 100 %). Sans ce mod, tout est rendu.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
BindConfig();
UpgradeStore.Name = $"buildupgrade_{Definition.Target}.json";
UpgradeStore.OldPath = Path.Combine(Paths.BepInExRootPath, "SCTBuildUpgrades", $"{Definition.Target}.json");
new Harmony(Il2CppUtil.Guid((BasePlugin)(object)this)).PatchAll(((object)this).GetType().Assembly);
AddHost();
ManualLogSource log = ((BasePlugin)this).Log;
bool flag = default(bool);
BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(37, 2, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Améliorations de ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Definition.TargetFr);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" chargées (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(Definition.Tiers.Length);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" paliers)");
}
log.LogInfo(val);
}
internal static bool IsTarget(Build build)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)build != (Object)null)
{
return build.BuildType == Definition.Target;
}
return false;
}
internal static void Apply(Build build)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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_002b: Unknown result type (might be due to invalid IL or missing references)
int num = (Active ? UpgradeStore.LevelAt(build.Position) : 0);
SpriteRenderer component = ((Component)build).GetComponent<SpriteRenderer>();
if ((Object)(object)component != (Object)null)
{
component.color = ((num > 0) ? Palette.Tier(num, Definition.Tiers[num - 1].Tint) : Color.white);
UpgradeGlow.Apply(component, num);
}
BuildStats.Apply(build, num);
_instance.ApplyEffects(build, num);
}
internal static int LevelOf(Build build)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (!Active || !((Object)(object)build != (Object)null) || !IsTarget(build))
{
return 0;
}
return UpgradeStore.LevelAt(build.Position);
}
}
internal static class BuildStats
{
private static readonly Dictionary<IntPtr, (float Consumption, float Reserve, int Capacity)> Base = new Dictionary<IntPtr, (float, float, int)>();
public static void Apply(Build build, int level)
{
if (!Base.TryGetValue(((Il2CppObjectBase)build).Pointer, out (float, float, int) value))
{
value = (build.energyConsumption, build.maxEnergy, build.maxCapacity);
Base[((Il2CppObjectBase)build).Pointer] = value;
}
BuildUpgradeDefinition definition = BuildUpgradePlugin.Definition;
build.energyConsumption = value.Item1 * BuildUpgradeDefinition.At(definition.Consumption, level);
build.maxEnergy = value.Item2 * BuildUpgradeDefinition.At(definition.EnergyReserve, level);
build.maxCapacity = Mathf.RoundToInt((float)value.Item3 * BuildUpgradeDefinition.At(definition.Storage, level));
}
}
[HarmonyPatch(typeof(Build), "GetTaskTime")]
internal static class UpgradeSpeedPatch
{
private static void Postfix(Build __instance, ref float __result)
{
int num = BuildUpgradePlugin.LevelOf(__instance);
if (__result > 0f && num > 0)
{
__result /= BuildUpgradeDefinition.At(BuildUpgradePlugin.Definition.Speed, num);
}
}
}
[HarmonyPatch(typeof(Build), "GetMaxInputSlotCapacity")]
internal static class UpgradeInputSlotPatch
{
private static void Postfix(Build __instance, ref int __result)
{
int[] inputSlot = BuildUpgradePlugin.Definition.InputSlot;
int num = BuildUpgradePlugin.LevelOf(__instance);
if (inputSlot != null && num > 0)
{
__result = Math.Max(__result, BuildUpgradeDefinition.At(inputSlot, num));
}
}
}
[HarmonyPatch(typeof(Build), "get_TransportOutputInterval")]
internal static class UpgradeOutputPatch
{
private static void Postfix(Build __instance, ref float __result)
{
int num = BuildUpgradePlugin.LevelOf(__instance);
if (num > 0)
{
__result /= BuildUpgradeDefinition.At(BuildUpgradePlugin.Definition.OutputRate, num);
}
}
}
internal static class UpgradeGlow
{
private const string ColorProperty = "_SineGlowColor";
private static Material[] _materials;
private static Material _source;
private static ColorVision _vision;
private static bool _failed;
private static Material For(int level)
{
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Expected O, but got Unknown
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
VisualManager instance = VisualManager.Instance;
if (_failed || level <= 0 || (Object)(object)instance == (Object)null || (Object)(object)instance.discoveryMaterial == (Object)null)
{
return null;
}
if ((Object)(object)_source == (Object)null || ((Il2CppObjectBase)_source).Pointer != ((Il2CppObjectBase)instance.discoveryMaterial).Pointer || _materials == null || _vision != Palette.Vision)
{
try
{
_source = instance.discoveryMaterial;
_vision = Palette.Vision;
Color val = (_source.HasProperty("_SineGlowColor") ? _source.GetColor("_SineGlowColor") : Color.white);
float num = Mathf.Max(val.r, Mathf.Max(new float[3] { val.g, val.b, 1f }));
UpgradeTier[] tiers = BuildUpgradePlugin.Definition.Tiers;
_materials = (Material[])(object)new Material[tiers.Length];
for (int i = 0; i < tiers.Length; i++)
{
Material val2 = Object.Instantiate<Material>(_source);
((Object)val2).hideFlags = (HideFlags)61;
Color val3 = Palette.Tier(i + 1, tiers[i].Glow) * num;
val3.a = val.a;
val2.SetColor("_SineGlowColor", val3);
_materials[i] = val2;
}
}
catch (Exception ex)
{
_failed = true;
ManualLogSource logger = BuildUpgradePlugin.Logger;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val4 = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("Lueur des paliers indisponible : ");
((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(ex.Message);
}
logger.LogWarning(val4);
return null;
}
}
return _materials[Mathf.Clamp(level, 1, _materials.Length) - 1];
}
public static bool IsOurs(Material material)
{
if ((Object)(object)material == (Object)null || _materials == null)
{
return false;
}
Material[] materials = _materials;
foreach (Material val in materials)
{
if ((Object)(object)val != (Object)null && ((Il2CppObjectBase)val).Pointer == ((Il2CppObjectBase)material).Pointer)
{
return true;
}
}
return false;
}
public static void Apply(SpriteRenderer renderer, int level)
{
VisualManager instance = VisualManager.Instance;
Material val = (BuildUpgradePlugin.GlowEnabled.Value ? For(level) : null);
if ((Object)(object)val != (Object)null)
{
((Renderer)renderer).sharedMaterial = val;
}
else if (IsOurs(((Renderer)renderer).sharedMaterial) && (Object)(object)instance != (Object)null && (Object)(object)instance.defaultMaterial != (Object)null)
{
((Renderer)renderer).sharedMaterial = instance.defaultMaterial;
}
}
public static void Maintain()
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
VisualManager instance = VisualManager.Instance;
BuildManager instance2 = BuildManager.Instance;
if (_failed || (Object)(object)instance == (Object)null || (Object)(object)instance2 == (Object)null || !BuildUpgradePlugin.GlowEnabled.Value || !BuildUpgradePlugin.Active)
{
return;
}
List<Build> builds = instance2.builds;
for (int i = 0; i < builds.Count; i++)
{
Build val = builds[i];
if (!BuildUpgradePlugin.IsTarget(val))
{
continue;
}
int num = UpgradeStore.LevelAt(val.Position);
if (num <= 0)
{
continue;
}
SpriteRenderer component = ((Component)val).GetComponent<SpriteRenderer>();
if (!((Object)(object)component == (Object)null))
{
Color val2 = Palette.Tier(num, BuildUpgradePlugin.Definition.Tiers[num - 1].Tint);
if (component.color != val2)
{
component.color = val2;
}
Material sharedMaterial = ((Renderer)component).sharedMaterial;
bool num2 = (Object)(object)sharedMaterial != (Object)null && (Object)(object)instance.interactableMaterial != (Object)null && ((Il2CppObjectBase)sharedMaterial).Pointer == ((Il2CppObjectBase)instance.interactableMaterial).Pointer;
Material val3 = For(num);
if (!num2 && (Object)(object)val3 != (Object)null && ((Object)(object)sharedMaterial == (Object)null || ((Il2CppObjectBase)sharedMaterial).Pointer != ((Il2CppObjectBase)val3).Pointer))
{
((Renderer)component).sharedMaterial = val3;
}
}
}
}
}
[Serializable]
public class UpgradeEntry
{
public int x;
public int y;
public int level;
public List<int> paid = new List<int>();
}
[Serializable]
public class UpgradeSave
{
public List<UpgradeEntry> entries = new List<UpgradeEntry>();
}
internal static class UpgradeStore
{
public static string Name;
public static string OldPath;
private static bool _migrated;
private static int _slotVersion;
private static UpgradeSave _state;
private static readonly JsonSerializerOptions Options = new JsonSerializerOptions
{
IncludeFields = true,
WriteIndented = true
};
public static string FilePath
{
get
{
if (!_migrated)
{
_migrated = true;
SaveSlotApi.Migrate(OldPath, Name);
}
return SaveSlotApi.PathOf(Name);
}
}
private static UpgradeSave State
{
get
{
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Expected O, but got Unknown
if (_slotVersion != SaveSlotApi.Version)
{
_slotVersion = SaveSlotApi.Version;
_state = null;
}
if (_state != null)
{
return _state;
}
try
{
if (File.Exists(FilePath))
{
_state = JsonSerializer.Deserialize<UpgradeSave>(File.ReadAllText(FilePath), Options);
}
}
catch (Exception ex)
{
ManualLogSource logger = BuildUpgradePlugin.Logger;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(21, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Paliers illisibles : ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
logger.LogWarning(val);
}
return _state ?? (_state = new UpgradeSave());
}
}
public static UpgradeEntry At(Vector3Int p)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
return State.entries.Find((UpgradeEntry e) => e.x == ((Vector3Int)(ref p)).x && e.y == ((Vector3Int)(ref p)).y);
}
public static int LevelAt(Vector3Int p)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return At(p)?.level ?? 0;
}
public static UpgradeEntry GetOrAdd(Vector3Int p)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
UpgradeEntry upgradeEntry = At(p);
if (upgradeEntry == null)
{
upgradeEntry = new UpgradeEntry
{
x = ((Vector3Int)(ref p)).x,
y = ((Vector3Int)(ref p)).y
};
State.entries.Add(upgradeEntry);
}
return upgradeEntry;
}
public static void Remove(UpgradeEntry entry)
{
State.entries.Remove(entry);
Write();
}
public static void Write()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Expected O, but got Unknown
try
{
Directory.CreateDirectory(Path.GetDirectoryName(FilePath));
File.WriteAllText(FilePath, JsonSerializer.Serialize(State, Options));
}
catch (Exception ex)
{
ManualLogSource logger = BuildUpgradePlugin.Logger;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(36, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Sauvegarde des paliers impossible : ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
}
logger.LogWarning(val);
}
}
public static void Reload()
{
_state = null;
}
public static void Delete()
{
_state = new UpgradeSave();
try
{
if (File.Exists(FilePath))
{
File.Delete(FilePath);
}
}
catch (Exception)
{
}
}
}
internal static class UpgradeShop
{
public static float RefundRate
{
get
{
if (!RefundBonus.SalvageActive)
{
return 1f;
}
return Mathf.Clamp01((float)BuildUpgradePlugin.RefundPercent.Value / 100f + RefundBonus.Total);
}
}
public static Build Target()
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: 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_0058: 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_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Invalid comparison between Unknown and I4
Game instance = Game.Instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance.player == (Object)null || (Object)(object)BlockManager.Instance == (Object)null || (Object)(object)BuildManager.Instance == (Object)null)
{
return null;
}
Vector3Int val = BlockManager.Instance.PositionToCell(Vector2.op_Implicit(((Component)instance.player).transform.position));
TileData tile = BlockManager.Instance.GetTile(val);
if (tile == null || (int)tile.tileType != 4 || (Object)(object)tile.build == (Object)null)
{
return null;
}
if (!BuildUpgradePlugin.IsTarget(tile.build))
{
return null;
}
return tile.build;
}
public static int Cost(int quantity)
{
return Mathf.Max(1, Mathf.CeilToInt((float)quantity * CraftCosts.Factor));
}
public static UpgradeTier Next(Build build)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
int num = UpgradeStore.LevelAt(build.Position);
UpgradeTier[] tiers = BuildUpgradePlugin.Definition.Tiers;
if (num >= tiers.Length)
{
return null;
}
return tiers[num];
}
public static List<(ResourceType Resource, int Missing)> Missing(UpgradeTier tier)
{
//IL_0024: 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_0036: 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)
Player player = Game.Instance.player;
List<(ResourceType, int)> list = new List<(ResourceType, int)>();
(ResourceType, int)[] costs = tier.Costs;
for (int i = 0; i < costs.Length; i++)
{
(ResourceType, int) tuple = costs[i];
ResourceType item = tuple.Item1;
int num = Cost(tuple.Item2) - player.GetResourceQuantity(item);
if (num > 0)
{
list.Add((item, num));
}
}
return list;
}
public static bool TryUpgrade(Build build)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Expected I4, but got Unknown
UpgradeTier upgradeTier = Next(build);
if (upgradeTier == null || Missing(upgradeTier).Count > 0)
{
return false;
}
UpgradeEntry orAdd = UpgradeStore.GetOrAdd(build.Position);
(ResourceType, int)[] costs = upgradeTier.Costs;
for (int i = 0; i < costs.Length; i++)
{
(ResourceType, int) tuple = costs[i];
ResourceType item = tuple.Item1;
int num = Cost(tuple.Item2);
Game.Instance.player.RemoveResource(item, num);
orAdd.paid.Add((int)item);
orAdd.paid.Add(num);
}
orAdd.level++;
UpgradeStore.Write();
BuildUpgradePlugin.Apply(build);
AudioManager.Play("PLACE", (MixerTarget)3, 0.5f, 1.3f);
return true;
}
public static string Describe(Build build, out bool canUpgrade)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
BuildUpgradeDefinition definition = BuildUpgradePlugin.Definition;
int num = UpgradeStore.LevelAt(build.Position);
string text = ((num == 0) ? Lang.Pick("base", "basic") : definition.Tiers[num - 1].Name);
UpgradeTier upgradeTier = Next(build);
if (upgradeTier == null)
{
canUpgrade = false;
return Lang.Pick(definition.TargetName + " " + text + " (niveau max)", definition.TargetName + " " + text + " (max level)") + RefundNote(num);
}
List<(ResourceType, int)> list = Missing(upgradeTier);
canUpgrade = list.Count == 0;
string value = string.Join(" + ", Array.ConvertAll(upgradeTier.Costs, ((ResourceType Resource, int Quantity) c) => $"{Cost(c.Quantity)} {ResourceNames.Of(c.Resource)}"));
string text2 = Lang.Pick($"Améliorer ({text} → {upgradeTier.Name}) : {value}", $"Upgrade ({text} → {upgradeTier.Name}): {value}");
if (!canUpgrade)
{
string value2 = string.Join(", ", list.ConvertAll(((ResourceType Resource, int Missing) m) => $"{m.Missing} {ResourceNames.Short(m.Resource)}"));
text2 += Lang.Pick($" <color=#{Palette.BadHex()}>(manque {value2})</color>", $" <color=#{Palette.BadHex()}>({value2} missing)</color>");
}
return text2 + RefundNote(num);
}
private static string RefundNote(int level)
{
if (level <= 0 || !RefundBonus.SalvageActive)
{
return "";
}
int num = Mathf.RoundToInt(RefundRate * 100f);
string value = ((num >= 100) ? ("#" + Palette.GoodHex()) : ("#" + Palette.WarningHex()));
return Lang.Pick($" <color={value}>· retrait : {num} % rendu</color>", $" <color={value}>· pickup: {num}% refunded</color>");
}
}
internal static class ResourceNames
{
public unsafe static string Of(ResourceType type)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected I4, but got Unknown
return (type - 1) switch
{
2 => Lang.Pick("lingots de fer", "iron ingots"),
4 => Lang.Pick("lingots de cuivre", "copper ingots"),
6 => Lang.Pick("quartz raffinés", "refined quartz"),
8 => Lang.Pick("lingots d'or", "gold ingots"),
0 => Lang.Pick("pierres", "stone"),
10 => Lang.Pick("charbon", "coal"),
_ => ((object)(*(ResourceType*)(&type))/*cast due to .constrained prefix*/).ToString(),
};
}
public static string Short(ResourceType type)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected I4, but got Unknown
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
return (type - 3) switch
{
0 => Lang.Pick("fer", "iron"),
2 => Lang.Pick("cuivre", "copper"),
4 => Lang.Pick("quartz", "quartz"),
6 => Lang.Pick("or", "gold"),
_ => Of(type),
};
}
}
internal static class UpgradeHold
{
internal static float Progress;
private static bool _waitRelease;
private static GUIStyle _style;
internal static bool CanInteract()
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Invalid comparison between Unknown and I4
Game instance = Game.Instance;
if (BuildUpgradePlugin.Active && (Object)(object)instance != (Object)null && !instance.paused && !instance._runEnded && !instance.IsUIOpen() && !instance.HideGameplayUI && (Object)(object)BuildManager.Instance != (Object)null)
{
return (int)BuildManager.Instance.currentBuildPrefab == 0;
}
return false;
}
public static void Update()
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
Keyboard current = Keyboard.current;
Build build = (CanInteract() ? UpgradeShop.Target() : null);
bool flag = current != null && ((ButtonControl)current[BuildUpgradePlugin.HoldKey.Value]).isPressed;
if ((Object)(object)build == (Object)null || !flag)
{
Progress = 0f;
_waitRelease = false;
}
else
{
if (_waitRelease)
{
return;
}
UpgradeTier upgradeTier = UpgradeShop.Next(build);
if (upgradeTier == null || UpgradeShop.Missing(upgradeTier).Count > 0)
{
Progress = 0f;
return;
}
Progress += Time.deltaTime / Mathf.Max(0.1f, BuildUpgradePlugin.HoldSeconds.Value);
if (!(Progress < 1f))
{
Progress = 0f;
_waitRelease = true;
Safe.Run("Amélioration du bâtiment", delegate
{
UpgradeShop.TryUpgrade(build);
});
}
}
}
public static void LateUpdate()
{
Safe.Run("Lueur des paliers", UpgradeGlow.Maintain);
}
public static void OnGUI()
{
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
if (UpgradePrompt.Ready || !CanInteract())
{
return;
}
Build val = UpgradeShop.Target();
if (!((Object)(object)val == (Object)null))
{
if (_style == null)
{
_style = SctGui.BoxStyle(14, (TextAnchor)4);
}
bool canUpgrade;
string text = "[" + UpgradePrompt.KeyName + "] " + UpgradeShop.Describe(val, out canUpgrade) + ((Progress > 0f) ? $" {Mathf.RoundToInt(Progress * 100f)} %" : "");
GUI.Box(new Rect((float)(Screen.width - 460) / 2f, (float)(Screen.height - 120), 460f, 30f), text, _style);
}
}
}
internal static class UpgradePrompt
{
private static GameObject _row;
private static TMP_Text _label;
private static TMP_Text _key;
private static Image _fill;
private static Image _gamepad;
private static bool _failed;
public static bool Ready => (Object)(object)_row != (Object)null;
public static string KeyName
{
get
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
try
{
return ((InputControl)Keyboard.current[BuildUpgradePlugin.HoldKey.Value]).displayName;
}
catch (Exception)
{
return ((object)BuildUpgradePlugin.HoldKey.Value/*cast due to .constrained prefix*/).ToString();
}
}
}
private static void Create(BuildInteractionPrompt prompt)
{
ActionPromptRow deleteRow = prompt.deleteRow;
if ((Object)(object)deleteRow == (Object)null)
{
_failed = true;
return;
}
GameObject val = Object.Instantiate<GameObject>(((Component)deleteRow).gameObject, ((Component)deleteRow).transform.parent);
((Object)val).name = "SCT Upgrade Row";
val.transform.SetSiblingIndex(((Component)deleteRow).transform.GetSiblingIndex() + 1);
ActionPromptRow component = val.GetComponent<ActionPromptRow>();
_key = component.keyboardText;
_fill = component.holdFill;
_gamepad = component.gamepadImage;
_label = (((Object)(object)component.label != (Object)null) ? ((Component)component.label).GetComponent<TMP_Text>() : null);
if ((Object)(object)component.label != (Object)null)
{
Object.Destroy((Object)(object)component.label);
}
Object.Destroy((Object)(object)component);
if ((Object)(object)_label == (Object)null || (Object)(object)_key == (Object)null)
{
Object.Destroy((Object)(object)val);
_failed = true;
}
else
{
_row = val;
}
}
public static void Refresh(BuildInteractionPrompt prompt)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
if ((Object)(object)_row == (Object)null && !_failed)
{
try
{
Create(prompt);
}
catch (Exception ex)
{
_failed = true;
ManualLogSource logger = BuildUpgradePlugin.Logger;
bool flag = default(bool);
BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(80, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Ligne d'amélioration non ajoutée à l'indication du jeu (");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") : affichage de secours");
}
logger.LogWarning(val);
}
}
if ((Object)(object)_row == (Object)null)
{
return;
}
Build val2 = ((UpgradeHold.CanInteract() && (Object)(object)prompt.panel != (Object)null && prompt.panel.activeSelf) ? UpgradeShop.Target() : null);
_row.SetActive((Object)(object)val2 != (Object)null);
if (!((Object)(object)val2 == (Object)null))
{
_label.text = UpgradeShop.Describe(val2, out var canUpgrade);
bool flag2 = UpgradeShop.Next(val2) == null;
_key.text = (flag2 ? "—" : KeyName);
if ((Object)(object)_gamepad != (Object)null)
{
((Component)_gamepad).gameObject.SetActive(false);
}
if ((Object)(object)_fill != (Object)null)
{
_fill.fillAmount = (canUpgrade ? UpgradeHold.Progress : 0f);
}
}
}
}
[HarmonyPatch(typeof(BuildInteractionPrompt), "LateUpdate")]
internal static class UpgradePromptPatch
{
private static void Postfix(BuildInteractionPrompt __instance)
{
Safe.Run("Indication d'amélioration", delegate
{
UpgradePrompt.Refresh(__instance);
});
}
}
[HarmonyPatch(typeof(LightEmitter), "FlickerLights")]
internal static class UpgradeLightPatch
{
private static readonly Dictionary<IntPtr, Build> Owners = new Dictionary<IntPtr, Build>();
private static string _parsedFrom;
private static float[] _factors = Array.Empty<float>();
private static readonly List<IntPtr> Scaled = new List<IntPtr>(8);
private static void Postfix(LightEmitter __instance)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
if (!BuildUpgradePlugin.Active)
{
return;
}
if (!Owners.TryGetValue(((Il2CppObjectBase)__instance).Pointer, out var value) || (Object)(object)value == (Object)null)
{
value = ((Component)__instance).GetComponentInParent<Build>();
Owners[((Il2CppObjectBase)__instance).Pointer] = value;
}
if ((Object)(object)value == (Object)null || !BuildUpgradePlugin.IsTarget(value))
{
return;
}
int num = UpgradeStore.LevelAt(value.Position);
if (num > 0)
{
float num2 = LightFactor(num);
if (!(num2 <= 0f) && !Mathf.Approximately(num2, 1f))
{
Scaled.Clear();
Scale((Component)(object)__instance.lightRenderer, num2);
Scale((Component)(object)__instance.smallLightRenderer, num2);
Scale((Component)(object)__instance.smallMask, num2);
Scale((Component)(object)__instance.bigMask, num2);
Scale((Component)(object)__instance.shadowMask, num2);
Scale((Component)(object)__instance.backgroundMask, num2);
}
}
}
private static float LightFactor(int level)
{
string text = BuildUpgradePlugin.LightFactors.Value ?? "";
if (text != _parsedFrom)
{
_parsedFrom = text;
List<float> list = new List<float>();
string[] array = text.Split(',');
for (int i = 0; i < array.Length; i++)
{
if (float.TryParse(array[i].Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
list.Add(result);
}
}
_factors = list.ToArray();
}
if (_factors.Length != 0)
{
return _factors[Mathf.Clamp(level, 1, _factors.Length) - 1];
}
return 1f;
}
private static void Scale(Component component, float factor)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)component == (Object)null))
{
Transform transform = component.transform;
if (!Scaled.Contains(((Il2CppObjectBase)transform).Pointer))
{
Scaled.Add(((Il2CppObjectBase)transform).Pointer);
transform.localScale *= factor;
}
}
}
}
[HarmonyPatch(typeof(BuildManager), "SpawnBuild")]
internal static class UpgradeSpawnPatch
{
private static void Postfix(Build __result)
{
if (!BuildUpgradePlugin.IsTarget(__result))
{
return;
}
Safe.Run("Amélioration (pose)", delegate
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
UpgradeEntry upgradeEntry = UpgradeStore.At(__result.Position);
if (upgradeEntry != null)
{
UpgradeStore.Remove(upgradeEntry);
}
BuildUpgradePlugin.Apply(__result);
});
}
}
[HarmonyPatch(typeof(SaveSystem), "LoadGame")]
internal static class UpgradeLoadPatch
{
private static void Postfix()
{
Safe.Run("Amélioration (chargement)", delegate
{
UpgradeStore.Reload();
if (!((Object)(object)BuildManager.Instance == (Object)null))
{
List<Build> builds = BuildManager.Instance.builds;
for (int i = 0; i < builds.Count; i++)
{
if (BuildUpgradePlugin.IsTarget(builds[i]))
{
BuildUpgradePlugin.Apply(builds[i]);
}
}
}
});
}
}
[HarmonyPatch(typeof(BuildManager), "RemoveBuild")]
internal static class UpgradeRemovePatch
{
private static void Prefix(Build build)
{
if (!BuildUpgradePlugin.IsTarget(build) || build.unique)
{
return;
}
Safe.Run("Amélioration (ramassage)", delegate
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
UpgradeEntry upgradeEntry = UpgradeStore.At(build.Position);
if (upgradeEntry != null)
{
Player player = Game.Instance.player;
float refundRate = UpgradeShop.RefundRate;
Dictionary<ResourceType, int> dictionary = new Dictionary<ResourceType, int>();
for (int i = 0; i + 1 < upgradeEntry.paid.Count; i += 2)
{
ResourceType key = (ResourceType)upgradeEntry.paid[i];
dictionary[key] = (dictionary.TryGetValue(key, out var value) ? value : 0) + upgradeEntry.paid[i + 1];
}
foreach (KeyValuePair<ResourceType, int> item in dictionary)
{
int num = Mathf.FloorToInt((float)item.Value * refundRate);
if (num > 0)
{
player.GiveResource(item.Key, num);
}
}
UpgradeStore.Remove(upgradeEntry);
}
});
}
}
[HarmonyPatch(typeof(SaveSystem), "DeleteGameFile")]
internal static class UpgradeDeleteRunPatch
{
private static void Postfix()
{
UpgradeStore.Delete();
}
}
[HarmonyPatch(typeof(SaveSystem), "DeleteSavedProgress")]
internal static class UpgradeDeleteProgressPatch
{
private static void Postfix()
{
UpgradeStore.Delete();
}
}
}
namespace SCTBuildUpgrades.Scanner
{
[BepInPlugin("sct.buildupgrade.scanner", "SCT Amélioration - Scanners", "1.1.1")]
public class ScannerUpgrade : BuildUpgradePlugin
{
private static readonly int[] Range = new int[5] { 10, 12, 14, 18, 24 };
internal const int DoubleRingLevel = 4;
protected override void AddHost()
{
((BasePlugin)this).AddComponent<ScannerUpgradeHost>();
}
internal override BuildUpgradeDefinition CreateDefinition()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: 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_011b: 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_0193: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
//IL_0217: Unknown result type (might be due to invalid IL or missing references)
BuildUpgradeDefinition buildUpgradeDefinition = new BuildUpgradeDefinition();
buildUpgradeDefinition.Target = (BuildType)4;
buildUpgradeDefinition.TargetFr = "Scanner";
buildUpgradeDefinition.TargetEn = "Scanner";
buildUpgradeDefinition.Tiers = new UpgradeTier[4]
{
new UpgradeTier
{
NameFr = "Fer",
NameEn = "Iron",
Costs = new(ResourceType, int)[2]
{
((ResourceType)3, 3),
((ResourceType)7, 2)
},
Tint = new Color(0.6f, 0.75f, 1f),
Glow = new Color(0.25f, 0.5f, 1f)
},
new UpgradeTier
{
NameFr = "Cuivre",
NameEn = "Copper",
Costs = new(ResourceType, int)[2]
{
((ResourceType)5, 4),
((ResourceType)7, 4)
},
Tint = new Color(1f, 0.62f, 0.35f),
Glow = new Color(1f, 0.45f, 0.15f)
},
new UpgradeTier
{
NameFr = "Quartz",
NameEn = "Quartz",
Costs = new(ResourceType, int)[2]
{
((ResourceType)7, 6),
((ResourceType)9, 4)
},
Tint = new Color(0.8f, 0.92f, 1f),
Glow = new Color(1f, 1f, 1f)
},
new UpgradeTier
{
NameFr = "Or",
NameEn = "Gold",
Costs = new(ResourceType, int)[2]
{
((ResourceType)9, 10),
((ResourceType)3, 10)
},
Tint = new Color(1f, 0.85f, 0.3f),
Glow = new Color(1f, 0.75f, 0.1f)
}
};
return buildUpgradeDefinition;
}
internal static int RangeOf(Build build)
{
return BuildUpgradeDefinition.At(Range, BuildUpgradePlugin.LevelOf(build));
}
}
[HarmonyPatch(typeof(Scanner), "CanPerformTask")]
internal static class ScannerRangePatch
{
private static void Postfix(Scanner __instance, ref bool __result)
{
if (BuildUpgradePlugin.Active)
{
__result = __instance.currentRange < ScannerUpgrade.RangeOf((Build)(object)__instance);
}
}
}
[HarmonyPatch(typeof(Scanner), "ProcessTask")]
internal static class ScannerDoubleRingPatch
{
private static void Postfix(Scanner __instance)
{
if (BuildUpgradePlugin.LevelOf((Build)(object)__instance) >= 4 && __instance.currentRange < ScannerUpgrade.RangeOf((Build)(object)__instance))
{
Safe.Run("Scanner doré", delegate
{
Scanner obj = __instance;
int currentRange = obj.currentRange;
obj.currentRange = currentRange + 1;
__instance.ShowScanEffect();
__instance.RevealOres();
});
}
}
}
internal class ScannerUpgradeHost : MonoBehaviour
{
public ScannerUpgradeHost(IntPtr ptr)
: base(ptr)
{
}
private void Update()
{
UpgradeHold.Update();
}
private void LateUpdate()
{
UpgradeHold.LateUpdate();
}
private void OnGUI()
{
UpgradeHold.OnGUI();
}
}
}
