using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using GSSerializer;
using GSSerializer.Internal;
using GSSerializer.Internal.DirectConverters;
using HarmonyLib;
using PCGSharp;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("GetFogged")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Make the fog harder.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+9f69af4d8a0be60322ee9e755828d94cab37f75f")]
[assembly: AssemblyProduct("GetFogged")]
[assembly: AssemblyTitle("GetFogged")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace GetFogged
{
public static class GF
{
private class exceptionOutput
{
public string exception;
public string version;
public exceptionOutput(string e)
{
version = Version;
exception = e;
}
}
private class ErrorObject
{
public readonly List<string> stack = new List<string>();
public string message;
public string version = Version;
}
public enum Alignment
{
Left,
Right,
Center
}
public class Random : Pcg
{
private int count;
private int seed = 1;
public int Seed
{
get
{
return seed;
}
set
{
seed = value;
reseed(value);
}
}
public string Id => $"[{seed}=>{count}]";
public Random(int seed)
: base(seed)
{
Seed = seed;
}
public bool NextPick(double chance)
{
return NextDouble() < chance;
}
public override uint NextUInt()
{
count++;
return base.NextUInt();
}
public float Normal(float averageValue, float standardDeviation)
{
return averageValue + standardDeviation * (float)(Math.Sqrt(-2.0 * Math.Log(1.0 - NextDouble())) * Math.Sin(Math.PI * 2.0 * NextDouble()));
}
public new float NextFloat(float min, float max)
{
if (Math.Abs(min - max) < float.MinValue)
{
return min;
}
if (min > max)
{
Warn($"{GetCaller()}-NextFloat: Min > Max. {min} {max}", 59);
return max;
}
return base.NextFloat(min, max);
}
public new int Next(int minInclusive, int maxExclusive)
{
if (minInclusive == maxExclusive)
{
return minInclusive;
}
if (minInclusive > maxExclusive)
{
Error($"Next: Min > Max. {minInclusive} {maxExclusive}", 74);
return maxExclusive - 1;
}
if (maxExclusive <= 0)
{
Error($"Max {maxExclusive} <= 0 {GetCaller()}", 80);
return maxExclusive;
}
return base.Next(minInclusive, maxExclusive);
}
public int NextInclusive(int minInclusive, int maxInclusive)
{
if (minInclusive == maxInclusive)
{
return minInclusive;
}
if (minInclusive > maxInclusive)
{
Error($"Next: Min > Max. {minInclusive} {maxInclusive}", 93);
return maxInclusive;
}
return base.Next(minInclusive, maxInclusive + 1);
}
public float ClampedNormal(float min, float max, int bias)
{
float num = max - min;
float num2 = (float)bias / 100f * num + min;
float val = (max - num2) / 3f;
float val2 = (num2 - min) / 3f;
float standardDeviation = Math.Max(val2, val);
float num3 = Normal(num2, standardDeviation);
return Mathf.Clamp(num3, min, max);
}
public VectorLF3 PointOnSphere(double radius)
{
//IL_008c: 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_0095: Unknown result type (might be due to invalid IL or missing references)
double num = NextDouble() * 2.0 * radius - radius;
double num2 = NextDouble() * Math.PI * 2.0;
double num3 = Math.Sqrt(Math.Pow(radius, 2.0) - Math.Pow(num, 2.0)) * Math.Cos(num2);
double num4 = Math.Sqrt(Math.Pow(radius, 2.0) - Math.Pow(num, 2.0)) * Math.Sin(num2);
return new VectorLF3(num3, num4, num);
}
public T Item<T>(List<T> items)
{
if (items.Count == 0)
{
Error("Item Length 0 " + GetCaller(), 124);
}
return items[Next(items.Count)];
}
public (int, T) ItemWithIndex<T>(List<T> items)
{
if (items.Count == 0)
{
Error("Item Length 0 " + GetCaller(), 133);
}
int num = Next(items.Count);
return (num, items[num]);
}
public T ItemAndRemove<T>(List<T> items)
{
if (items.Count == 0)
{
Error("Item Length 0 " + GetCaller(), 143);
}
int index = Next(items.Count);
T result = items[index];
items.RemoveAt(index);
return result;
}
public T Item<T>(T[] items)
{
if (items.Length == 0)
{
Error("Item Length 0 " + GetCaller(), 154);
}
return items[Next(items.Length)];
}
public (int, T) ItemWithIndex<T>(T[] items)
{
if (items.Length == 0)
{
Error("Item Length 0 " + GetCaller(), 163);
}
int num = Next(items.Length);
return (num, items[num]);
}
public KeyValuePair<W, X> Item<W, X>(Dictionary<W, X> items)
{
if (items.Count == 0)
{
Error("Item Length 0 " + GetCaller(), 173);
}
W[] array = new W[0];
items.Keys.CopyTo(array, 0);
W key = array[Next(array.Length)];
return new KeyValuePair<W, X>(key, items[key]);
}
}
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static Response <>9__31_0;
internal void <AbortGameStart>b__31_0()
{
UIRoot.instance.OpenMainMenuUI();
UIRoot.ClearFatalError();
}
}
public static int PreferencesVersion = 2104;
public static string Version;
public static string AssemblyPath;
public static bool DebugOn = true;
public static void DumpObjectToJson(string path, object obj)
{
fsSerializer fsSerializer = new fsSerializer();
fsSerializer.TrySerialize(obj, out var data).AssertSuccessWithoutWarnings();
string contents = fsJsonPrinter.PrettyJson(data);
File.WriteAllText(path, contents);
}
public static void DumpException(Exception e)
{
Error(e.Message + " " + GetCaller(1) + " " + GetCaller(2) + " " + GetCaller(3) + " " + GetCaller(4) + " " + GetCaller(5), 23);
string text = Path.Combine(AssemblyPath, "ErrorLog");
if (!Directory.Exists(text))
{
Directory.CreateDirectory(text);
}
text = Path.Combine(text, DateTime.Now.ToString("yyMMddHHmmss"));
text += ".exceptionlog.json";
if (!File.Exists(text))
{
Log(text, 31);
Log("Logging Error to " + text, 32);
exceptionOutput instance = new exceptionOutput(e.ToString());
fsSerializer fsSerializer = new fsSerializer();
fsSerializer.TrySerialize(instance, out var data).AssertSuccessWithoutWarnings();
string contents = fsJsonPrinter.PrettyJson(data);
File.WriteAllText(text, contents);
Log("End", 38);
}
}
public static void DumpError(string message)
{
string text = Path.Combine(AssemblyPath, "ErrorLog");
if (!Directory.Exists(text))
{
Directory.CreateDirectory(text);
}
text = Path.Combine(text, DateTime.Now.ToString("yyMMddHHmmss"));
text += ".errorlog.json";
Log(text, 47);
Log("Logging Error to " + text, 48);
ErrorObject errorObject = new ErrorObject();
errorObject.message = message;
for (int i = 0; i < 100; i++)
{
string caller = GetCaller(i);
if (caller != "")
{
errorObject.stack.Add(caller);
}
}
fsSerializer fsSerializer = new fsSerializer();
fsSerializer.TrySerialize(errorObject, out var data).AssertSuccessWithoutWarnings();
string contents = fsJsonPrinter.PrettyJson(data);
File.AppendAllText(text, contents);
Log("End", 61);
}
private static void CleanErrorLogs()
{
string path = Path.Combine(AssemblyPath, "ErrorLog");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string[] files = Directory.GetFiles(path, "*.json");
string[] array = files;
foreach (string fileName in array)
{
FileInfo fileInfo = new FileInfo(fileName);
if (fileInfo.LastAccessTime < DateTime.Now.AddDays(-7.0))
{
fileInfo.Delete();
}
}
}
private static bool CheckJsonFileExists(string path)
{
if (File.Exists(path))
{
return true;
}
Log("Json file does not exist at " + path, 83);
return false;
}
public static void ConsoleSplash()
{
//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)
GlobalObject.LoadVersions();
Version gameVersion = GameConfig.gameVersion;
string text = ((object)(Version)(ref gameVersion)).ToString();
Debug.Log((object)"GetFogged.");
}
public static void Log(string s, [CallerLineNumber] int lineNumber = 0)
{
if (DebugOn)
{
Bootstrap.Debug(lineNumber.ToString().PadLeft(4) + ":" + GetCaller() + s);
}
}
public static void LogTop(int width = 80)
{
if (BCE.disabled)
{
Log("-----", 25);
return;
}
int num = width - 21;
int num2 = Mathf.FloorToInt((float)(num / 2)) - 2;
int spaces = num - num2 - 4;
BCE.Console.Write("\r\n╔═", ConsoleColor.White);
BCE.Console.Write("═", ConsoleColor.Gray);
BCE.Console.Write("═", ConsoleColor.DarkGray);
BCE.Console.Write(SpaceString(num2), ConsoleColor.Green);
BCE.Console.Write("*", ConsoleColor.Yellow);
BCE.Console.Write(".·", ConsoleColor.Gray);
BCE.Console.Write(":", ConsoleColor.DarkGray);
BCE.Console.Write("·.", ConsoleColor.Gray);
BCE.Console.Write("✧", ConsoleColor.DarkCyan);
BCE.Console.Write(" ✦ ", ConsoleColor.Cyan);
BCE.Console.Write("✧", ConsoleColor.DarkCyan);
BCE.Console.Write(".·", ConsoleColor.Gray);
BCE.Console.Write(":", ConsoleColor.DarkGray);
BCE.Console.Write("·.", ConsoleColor.Gray);
BCE.Console.Write("*", ConsoleColor.Yellow);
BCE.Console.Write(SpaceString(spaces), ConsoleColor.Green);
BCE.Console.Write("═", ConsoleColor.DarkGray);
BCE.Console.Write("═", ConsoleColor.Gray);
BCE.Console.Write("═╗\r\n", ConsoleColor.White);
}
public static void LogBot(int width = 80)
{
if (BCE.disabled)
{
Log("-----", 57);
return;
}
int num = width - 21;
int num2 = Mathf.FloorToInt((float)(num / 2)) - 2;
int spaces = num - num2 - 4;
BCE.Console.Write("╚═", ConsoleColor.White);
BCE.Console.Write("═", ConsoleColor.Gray);
BCE.Console.Write("═", ConsoleColor.DarkGray);
BCE.Console.Write(SpaceString(num2), ConsoleColor.Green);
BCE.Console.Write("*", ConsoleColor.Yellow);
BCE.Console.Write(".·", ConsoleColor.Gray);
BCE.Console.Write(":", ConsoleColor.DarkGray);
BCE.Console.Write("·.", ConsoleColor.Gray);
BCE.Console.Write("✧", ConsoleColor.DarkCyan);
BCE.Console.Write(" ✦ ", ConsoleColor.Cyan);
BCE.Console.Write("✧", ConsoleColor.DarkCyan);
BCE.Console.Write(".·", ConsoleColor.Gray);
BCE.Console.Write(":", ConsoleColor.DarkGray);
BCE.Console.Write("·.", ConsoleColor.Gray);
BCE.Console.Write("*", ConsoleColor.Yellow);
BCE.Console.Write(SpaceString(spaces), ConsoleColor.Green);
BCE.Console.Write("═", ConsoleColor.DarkGray);
BCE.Console.Write("═", ConsoleColor.Gray);
BCE.Console.WriteLine("═╝", ConsoleColor.White);
}
public static string SpaceString(int spaces)
{
return new string(' ', spaces);
}
public static void LogMid(string text, int width = 80)
{
string[] array = text.Split(new char[1] { '\n' });
if (array.Length > 1)
{
string[] array2 = array;
foreach (string text2 in array2)
{
LogMid(text2, width);
}
}
if (BCE.disabled)
{
Log(text, 106);
return;
}
if (text.Length < width - 4)
{
LogMidLine(text, width);
return;
}
List<string> list = new List<string>();
int startIndex = 0;
while (text.Length > width - 4)
{
LogMidLine(text.Substring(startIndex, width - 4), width);
text = text.Remove(startIndex, width - 4);
}
}
public static void LogMidLine(string text, int width = 80)
{
BCE.Console.Write("║ ", ConsoleColor.White);
BCE.Console.Write(string.Format("{0," + (width - 4) + "}", text), ConsoleColor.Green);
BCE.Console.Write(" ║\r\n", ConsoleColor.White);
}
public static void LogSpace(int lineCount = 1)
{
if (DebugOn)
{
for (int i = 0; i < lineCount; i++)
{
Bootstrap.Debug(" ", (LogLevel)8, isActive: true);
}
}
}
public static void Error(string message, [CallerLineNumber] int lineNumber = 0)
{
Bootstrap.Debug($"{lineNumber,4}:{GetCaller()}{message}", (LogLevel)2, isActive: true);
DumpError(lineNumber + "|" + message);
}
public static void Warn(string message, [CallerLineNumber] int lineNumber = 0)
{
Bootstrap.Debug(lineNumber.ToString().PadLeft(4) + ":" + GetCaller() + message, (LogLevel)4, isActive: true);
}
public static void LogJson(object o, bool force = false)
{
if (DebugOn || force)
{
fsSerializer fsSerializer = new fsSerializer();
fsSerializer.TrySerialize(o, out var data).AssertSuccessWithoutWarnings();
string text = fsJsonPrinter.PrettyJson(data);
Bootstrap.Debug(GetCaller() + text);
}
}
public static void WarnJson(object o)
{
fsSerializer fsSerializer = new fsSerializer();
fsSerializer.TrySerialize(o, out var data).AssertSuccessWithoutWarnings();
string text = fsJsonPrinter.PrettyJson(data);
Bootstrap.Debug(GetCaller() + text, (LogLevel)4, isActive: true);
}
public static string GetCaller(int depth = 0)
{
depth += 2;
StackTrace stackTrace = new StackTrace();
if (stackTrace.FrameCount <= depth)
{
return "";
}
string text = stackTrace.GetFrame(depth).GetMethod().Name;
Type reflectedType = stackTrace.GetFrame(depth).GetMethod().ReflectedType;
if (reflectedType != null)
{
string text2 = reflectedType.ToString().Split(new char[1] { '.' })[^1];
if (text == ".ctor")
{
text = "<Constructor>";
}
return text2 + "|" + text + "|";
}
return "ERROR GETTING CALLER";
}
public static void LogError(object sender, UnhandledExceptionEventArgs e, [CallerLineNumber] int lineNumber = 0)
{
Error($"{lineNumber} {GetCaller()}", 187);
LogException(e.ExceptionObject as Exception);
}
private static void LogException(Exception ex)
{
Error(ex.StackTrace, 193);
}
public static string FormatTableHeader(string[] headers, int[] columnWidths, params Alignment[] alignments)
{
if (headers.Length != columnWidths.Length || headers.Length != alignments.Length)
{
throw new ArgumentException("Input arrays must have the same length.");
}
string format = GenerateFormatString(columnWidths, alignments);
string text = string.Format(format, headers);
return text ?? "";
}
public static string FormatTable(string[] values, int[] columnWidths, params Alignment[] alignments)
{
if (values.Length != columnWidths.Length || values.Length != alignments.Length)
{
throw new ArgumentException("Input arrays must have the same length.");
}
string format = GenerateFormatString(columnWidths, alignments);
string text = string.Format(format, values);
return text ?? "";
}
private static string GenerateFormatString(int[] columnWidths, Alignment[] alignments)
{
if (columnWidths.Length != alignments.Length)
{
throw new ArgumentException("Column widths and alignments must have the same length.");
}
string text = "";
for (int i = 0; i < columnWidths.Length; i++)
{
text += $"{{{i},-{columnWidths[i]}}}";
if (i < columnWidths.Length - 1)
{
text += " ";
}
}
return text;
}
public static IEnumerable<CodeInstruction> LogTranspilerError(IEnumerable<CodeInstruction> instructions, string text)
{
Error(text, 253);
Log(GetCaller(), 254);
LogTop();
foreach (CodeInstruction instruction in instructions)
{
LogMid(((object)instruction).ToString());
}
LogBot();
return instructions;
}
public static bool AbortGameStart(string message)
{
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Expected O, but got Unknown
Error("Aborting Game Start|" + message, 7);
UIRoot.instance.CloseLoadingUI();
UIRoot.instance.CloseGameUI();
UIRoot.instance.launchSplash.Restart();
DSPGame.StartDemoGame(0);
string text = "Cannot Start Game. Possibly reason: " + message;
object obj = <>c.<>9__31_0;
if (obj == null)
{
Response val = delegate
{
UIRoot.instance.OpenMainMenuUI();
UIRoot.ClearFatalError();
};
<>c.<>9__31_0 = val;
obj = (object)val;
}
UIMessageBox.Show("Somewhat Fatal Error", text, "Rats!", 3, (Response)obj);
UIRoot.ClearFatalError();
return false;
}
public static void EndGame()
{
GameMain.End();
}
}
[BepInPlugin("dsp.getfogged", "Get Fogged Plug-In", "1.0.0")]
public class Bootstrap : BaseUnityPlugin
{
public static Bootstrap instance;
public static ManualLogSource Logger;
public static Queue buffer = new Queue();
internal void Awake()
{
instance = this;
InitializeLogger();
ApplyHarmonyPatches();
}
private void InitializeLogger()
{
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Expected O, but got Unknown
AppDomain.CurrentDomain.UnhandledException += delegate(object o, UnhandledExceptionEventArgs e)
{
GF.LogError(o, e, 34);
};
Version version = Assembly.GetExecutingAssembly().GetName().Version;
Assembly assembly = Assembly.GetAssembly(typeof(Patches));
GF.Version = $"{version.Major}.{version.Minor}.{version.Build}";
BCE.Console.Init();
Logger = new ManualLogSource("GF");
Logger.Sources.Add((ILogSource)(object)Logger);
GF.ConsoleSplash();
}
private void ApplyHarmonyPatches()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
try
{
Harmony val = new Harmony("dsp.getfogged");
val.PatchAll(typeof(Patches));
}
catch (Exception ex)
{
GF.Error(ex.ToString(), 56);
}
}
public static void Debug(object data, LogLevel logLevel, bool isActive)
{
//IL_008b: 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_0039: Unknown result type (might be due to invalid IL or missing references)
if (isActive && Logger != null)
{
while (buffer.Count > 0)
{
object obj = buffer.Dequeue();
(object, LogLevel, bool) tuple = ((object, LogLevel, bool))obj;
if (tuple.Item3)
{
Logger.Log(tuple.Item2, (object)("Q:" + tuple.Item1));
}
}
Logger.Log(logLevel, data);
}
else
{
buffer.Enqueue((data, logLevel, true));
}
}
public static void Debug(object data)
{
Debug(data, (LogLevel)8, isActive: true);
}
}
public static class Patches
{
[HarmonyPrefix]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public static bool get_difficulty(ref CombatSettings __instance, ref float __result)
{
float num = ((__instance.aggressiveness < -0.1f) ? (-0.2f) : ((__instance.aggressiveness < 0.25f) ? 0f : ((__instance.aggressiveness < 0.75f) ? 0.5f : ((__instance.aggressiveness < 1.5f) ? 0.75f : ((!(__instance.aggressiveness < 2.5f)) ? 1.125f : 0.875f)))));
float num2 = __instance.initialLevel * 0.8f;
float num3 = ((__instance.initialGrowth < 0.15f) ? 0f : ((__instance.initialGrowth < 0.3f) ? 0.25f : ((__instance.initialGrowth < 0.65f) ? 0.5f : ((__instance.initialGrowth < 0.8f) ? 0.75f : ((__instance.initialGrowth < 1.15f) ? 1f : ((!(__instance.initialGrowth < 1.65f)) ? __instance.initialGrowth : 1.25f))))));
float num4 = ((__instance.initialColonize < 0.15f) ? 0f : ((__instance.initialColonize < 0.3f) ? 0.25f : ((__instance.initialColonize < 0.65f) ? 0.5f : ((__instance.initialColonize < 0.8f) ? 0.75f : ((__instance.initialColonize < 1.15f) ? 1f : ((!(__instance.initialColonize < 1.65f)) ? __instance.initialColonize : 1.25f))))));
float num5 = __instance.maxDensity - 1f;
float num6 = ((__instance.growthSpeedFactor < 0.35f) ? 0.3f : ((__instance.growthSpeedFactor < 0.75f) ? 0.7f : ((__instance.growthSpeedFactor < 1.5f) ? 1f : ((!(__instance.growthSpeedFactor < 2.5f)) ? (__instance.growthSpeedFactor / 2f) : 1.2f))));
float num7 = ((__instance.powerThreatFactor < 0.05f) ? 0.125f : ((__instance.powerThreatFactor < 0.15f) ? 0.3f : ((__instance.powerThreatFactor < 0.25f) ? 0.6f : ((__instance.powerThreatFactor < 0.55f) ? 0.8f : ((__instance.powerThreatFactor < 1.15f) ? 1f : ((__instance.powerThreatFactor < 2.15f) ? 1.2f : ((__instance.powerThreatFactor < 5.15f) ? 1.5f : ((!(__instance.powerThreatFactor < 8.15f)) ? (__instance.powerThreatFactor / 4f) : 1.8f))))))));
float num8 = ((__instance.battleThreatFactor < 0.05f) ? 0.125f : ((__instance.battleThreatFactor < 0.15f) ? 0.3f : ((__instance.battleThreatFactor < 0.25f) ? 0.6f : ((__instance.battleThreatFactor < 0.55f) ? 0.8f : ((__instance.battleThreatFactor < 1.15f) ? 1f : ((__instance.battleThreatFactor < 2.15f) ? 1.2f : ((__instance.battleThreatFactor < 5.15f) ? 1.5f : ((!(__instance.battleThreatFactor < 8.15f)) ? (__instance.battleExpFactor / 4f) : 1.8f))))))));
float num9 = ((__instance.battleExpFactor < 0.05f) ? 0f : ((__instance.battleExpFactor < 0.15f) ? 1f : ((__instance.battleExpFactor < 0.25f) ? 3f : ((__instance.battleExpFactor < 0.55f) ? 6f : ((__instance.battleExpFactor < 1.15f) ? 10f : ((__instance.battleExpFactor < 2.15f) ? 12f : ((__instance.battleExpFactor < 5.15f) ? 14f : ((!(__instance.battleExpFactor < 8.15f)) ? (__instance.battleExpFactor * 2f) : 16f))))))));
float num10 = ((num < 0f) ? 0f : (0.25f + num * (num7 * 0.5f + num8 * 0.5f)));
float num11 = 0.375f + 0.625f * ((num2 + num9) / 10f);
float num12 = 0.375f + 0.625f * ((num4 * 0.6f + num3 * 0.4f * (num4 * 0.75f + 0.25f)) * 0.6f + num6 * 0.4f * (num4 * 0.8f + 0.2f) + num5 * 0.29f * (num4 * 0.5f + 0.5f));
__result = (float)(int)(num10 * num11 * num12 * 10000f + 0.5f) / 10000f;
if (__result < 0f || __result > 9001f)
{
__result = 9001f;
}
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnCombatThreatSliderChanged")]
private static bool OnCombatThreatSliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.combatThreatSlider.value;
if (value < 0.5f)
{
__instance.combatSettings.battleThreatFactor = 0.01f;
}
else if (value < 1.5f)
{
__instance.combatSettings.battleThreatFactor = 0.1f;
}
else if (value < 2.5f)
{
__instance.combatSettings.battleThreatFactor = 0.2f;
}
else if (value < 3.5f)
{
__instance.combatSettings.battleThreatFactor = 0.5f;
}
else if (value < 4.5f)
{
__instance.combatSettings.battleThreatFactor = 1f;
}
else if (value < 5.5f)
{
__instance.combatSettings.battleThreatFactor = 2f;
}
else if (value < 6.5f)
{
__instance.combatSettings.battleThreatFactor = 5f;
}
else if (value < 7.5f)
{
__instance.combatSettings.battleThreatFactor = 8f;
}
else
{
__instance.combatSettings.battleThreatFactor = Mathf.FloorToInt(value);
}
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnEXPSliderChanged")]
private static bool OnEXPSliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.DFExpSlider.value;
if (value < 0.5f)
{
__instance.combatSettings.battleExpFactor = 0.01f;
}
else if (value < 1.5f)
{
__instance.combatSettings.battleExpFactor = 0.1f;
}
else if (value < 2.5f)
{
__instance.combatSettings.battleExpFactor = 0.2f;
}
else if (value < 3.5f)
{
__instance.combatSettings.battleExpFactor = 0.5f;
}
else if (value < 4.5f)
{
__instance.combatSettings.battleExpFactor = 1f;
}
else if (value < 5.5f)
{
__instance.combatSettings.battleExpFactor = 2f;
}
else if (value < 6.5f)
{
__instance.combatSettings.battleExpFactor = 5f;
}
else if (value < 7.5f)
{
__instance.combatSettings.battleExpFactor = 8f;
}
else
{
__instance.combatSettings.battleExpFactor = Mathf.FloorToInt(value + 1f);
}
__instance.UpdateUIParametersDisplay();
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnGrowthSpeedSliderChanged")]
private static bool OnGrowthSpeedSliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.growthSpeedSlider.value;
if (value < 0.5f)
{
__instance.combatSettings.growthSpeedFactor = 0.25f;
}
else if (value < 1.5f)
{
__instance.combatSettings.growthSpeedFactor = 0.5f;
}
else if (value < 2.5f)
{
__instance.combatSettings.growthSpeedFactor = 1f;
}
else if (value < 3.5f)
{
__instance.combatSettings.growthSpeedFactor = 2f;
}
else
{
__instance.combatSettings.growthSpeedFactor = Mathf.RoundToInt(value - 1.5f);
}
__instance.UpdateUIParametersDisplay();
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnInitGrowthSliderChanged")]
private static bool OnInitGrowthSliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.initGrowthSlider.value;
if (value < 0.5f)
{
__instance.combatSettings.initialGrowth = 0f;
}
else if (value < 1.5f)
{
__instance.combatSettings.initialGrowth = 0.25f;
}
else if (value < 2.5f)
{
__instance.combatSettings.initialGrowth = 0.5f;
}
else if (value < 3.5f)
{
__instance.combatSettings.initialGrowth = 0.75f;
}
else if (value < 4.5f)
{
__instance.combatSettings.initialGrowth = 1f;
}
else if (value < 5.5f)
{
__instance.combatSettings.initialGrowth = 1.5f;
}
else
{
__instance.combatSettings.initialGrowth = Mathf.FloorToInt(value / 3f);
}
__instance.UpdateUIParametersDisplay();
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnInitOccupiedSliderChanged")]
private static bool OnInitOccupiedSliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.initOccupiedSlider.value;
if (value < 0.5f)
{
__instance.combatSettings.initialColonize = 0.01f;
}
else if (value < 1.5f)
{
__instance.combatSettings.initialColonize = 0.25f;
}
else if (value < 2.5f)
{
__instance.combatSettings.initialColonize = 0.5f;
}
else if (value < 3.5f)
{
__instance.combatSettings.initialColonize = 0.75f;
}
else if (value < 4.5f)
{
__instance.combatSettings.initialColonize = 1f;
}
else if (value < 5.5f)
{
__instance.combatSettings.initialColonize = 1.5f;
}
else
{
__instance.combatSettings.initialColonize = Mathf.FloorToInt(value / 3f);
}
__instance.UpdateUIParametersDisplay();
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnMaxDensitySliderChanged")]
private static bool OnMaxDensitySliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.maxDensitySlider.value;
if (value < 0.5f)
{
__instance.combatSettings.maxDensity = 1f;
}
else if (value < 1.5f)
{
__instance.combatSettings.maxDensity = 1.5f;
}
else if (value < 2.5f)
{
__instance.combatSettings.maxDensity = 2f;
}
else if (value < 3.5f)
{
__instance.combatSettings.maxDensity = 2.5f;
}
else
{
__instance.combatSettings.maxDensity = Mathf.FloorToInt(value);
}
__instance.UpdateUIParametersDisplay();
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnPowerThreatSliderChanged")]
private static bool OnPowerThreatSliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.powerThreatSlider.value;
if (value < 0.5f)
{
__instance.combatSettings.powerThreatFactor = 0.01f;
}
else if (value < 1.5f)
{
__instance.combatSettings.powerThreatFactor = 0.1f;
}
else if (value < 2.5f)
{
__instance.combatSettings.powerThreatFactor = 0.2f;
}
else if (value < 3.5f)
{
__instance.combatSettings.powerThreatFactor = 0.5f;
}
else if (value < 4.5f)
{
__instance.combatSettings.powerThreatFactor = 1f;
}
else if (value < 5.5f)
{
__instance.combatSettings.powerThreatFactor = 2f;
}
else if (value < 6.5f)
{
__instance.combatSettings.powerThreatFactor = 5f;
}
else if (value < 7.5f)
{
__instance.combatSettings.powerThreatFactor = 8f;
}
else
{
__instance.combatSettings.powerThreatFactor = Mathf.FloorToInt(value);
}
__instance.UpdateUIParametersDisplay();
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "OnInitLevelSliderChanged")]
private static bool OnInitLevelSliderChanged(ref UICombatSettingsDF __instance, float arg0)
{
float value = __instance.initLevelSlider.value;
if (value < 0.5f)
{
__instance.combatSettings.initialLevel = 0f;
}
else if (value < 1.5f)
{
__instance.combatSettings.initialLevel = 1f;
}
else if (value < 2.5f)
{
__instance.combatSettings.initialLevel = 2f;
}
else if (value < 3.5f)
{
__instance.combatSettings.initialLevel = 3f;
}
else if (value < 4.5f)
{
__instance.combatSettings.initialLevel = 4f;
}
else if (value < 5.5f)
{
__instance.combatSettings.initialLevel = 5f;
}
else if (value < 6.5f)
{
__instance.combatSettings.initialLevel = 6f;
}
else if (value < 7.5f)
{
__instance.combatSettings.initialLevel = 7f;
}
else if (value < 8.5f)
{
__instance.combatSettings.initialLevel = 8f;
}
else if (value < 9.5f)
{
__instance.combatSettings.initialLevel = 9f;
}
else
{
__instance.combatSettings.initialLevel = Mathf.FloorToInt(value);
}
__instance.UpdateUIParametersDisplay();
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(UICombatSettingsDF), "UpdateUIParametersDisplay")]
public static bool UpdateUIParametersDisplay(ref UICombatSettingsDF __instance)
{
//IL_0bd1: Unknown result type (might be due to invalid IL or missing references)
//IL_0bd7: Expected O, but got Unknown
//IL_0c34: Unknown result type (might be due to invalid IL or missing references)
//IL_0c3b: Invalid comparison between Unknown and I4
//IL_0c67: Unknown result type (might be due to invalid IL or missing references)
//IL_0c6c: Unknown result type (might be due to invalid IL or missing references)
float aggressiveness = __instance.combatSettings.aggressiveness;
string text = "";
if (aggressiveness < -0.99f)
{
__instance.aggresiveSlider.value = 0f;
}
else if (aggressiveness < 0.01f)
{
__instance.aggresiveSlider.value = 1f;
}
else if (aggressiveness < 0.51f)
{
__instance.aggresiveSlider.value = 2f;
}
else if (aggressiveness < 1.01f)
{
__instance.aggresiveSlider.value = 3f;
}
else if (aggressiveness < 2.01f)
{
__instance.aggresiveSlider.value = 4f;
}
else
{
__instance.aggresiveSlider.value = 5f;
}
switch ((int)(__instance.aggresiveSlider.value + 0.5f))
{
case 0:
text = Localization.Translate("活靶子");
break;
case 1:
text = Localization.Translate("被动");
break;
case 2:
text = Localization.Translate("消极");
break;
case 3:
text = Localization.Translate("正常");
break;
case 4:
text = Localization.Translate("积极");
break;
case 5:
text = Localization.Translate("狂暴");
break;
}
__instance.aggresiveText.text = text;
aggressiveness = __instance.combatSettings.initialLevel;
if (aggressiveness < 0.01f)
{
__instance.initLevelSlider.value = 0f;
}
else if (aggressiveness < 1.01f)
{
__instance.initLevelSlider.value = 1f;
}
else if (aggressiveness < 2.01f)
{
__instance.initLevelSlider.value = 2f;
}
else if (aggressiveness < 3.01f)
{
__instance.initLevelSlider.value = 3f;
}
else if (aggressiveness < 4.01f)
{
__instance.initLevelSlider.value = 4f;
}
else if (aggressiveness < 5.01f)
{
__instance.initLevelSlider.value = 5f;
}
else if (aggressiveness < 6.01f)
{
__instance.initLevelSlider.value = 6f;
}
else if (aggressiveness < 7.01f)
{
__instance.initLevelSlider.value = 7f;
}
else if (aggressiveness < 8.01f)
{
__instance.initLevelSlider.value = 8f;
}
else if (aggressiveness < 9.01f)
{
__instance.initLevelSlider.value = 9f;
}
else
{
__instance.initLevelSlider.value = Mathf.CeilToInt(__instance.initLevelSlider.value);
}
text = aggressiveness.ToString();
__instance.initLevelText.text = text;
aggressiveness = __instance.combatSettings.initialGrowth;
if (aggressiveness < 0.01f)
{
__instance.initGrowthSlider.value = 0f;
}
else if (aggressiveness < 0.26f)
{
__instance.initGrowthSlider.value = 1f;
}
else if (aggressiveness < 0.51f)
{
__instance.initGrowthSlider.value = 2f;
}
else if (aggressiveness < 0.76f)
{
__instance.initGrowthSlider.value = 3f;
}
else if (aggressiveness < 1.01f)
{
__instance.initGrowthSlider.value = 4f;
}
else if (aggressiveness < 1.51f)
{
__instance.initGrowthSlider.value = 5f;
}
else
{
__instance.initGrowthSlider.value = Mathf.CeilToInt(aggressiveness * 3.33f);
}
text = aggressiveness * 100f + "%";
__instance.initGrowthText.text = text;
aggressiveness = __instance.combatSettings.initialColonize;
if (aggressiveness < 0.02f)
{
__instance.initOccupiedSlider.value = 0f;
}
else if (aggressiveness < 0.26f)
{
__instance.initOccupiedSlider.value = 1f;
}
else if (aggressiveness < 0.51f)
{
__instance.initOccupiedSlider.value = 2f;
}
else if (aggressiveness < 0.76f)
{
__instance.initOccupiedSlider.value = 3f;
}
else if (aggressiveness < 1.01f)
{
__instance.initOccupiedSlider.value = 4f;
}
else if (aggressiveness < 1.51f)
{
__instance.initOccupiedSlider.value = 5f;
}
else
{
__instance.initOccupiedSlider.value = Mathf.CeilToInt(aggressiveness * 3.33f);
}
text = aggressiveness * 100f + "%";
__instance.initOccupiedText.text = text;
aggressiveness = __instance.combatSettings.maxDensity;
if (aggressiveness < 1.01f)
{
__instance.maxDensitySlider.value = 0f;
}
else if (aggressiveness < 1.51f)
{
__instance.maxDensitySlider.value = 1f;
}
else if (aggressiveness < 2.01f)
{
__instance.maxDensitySlider.value = 2f;
}
else if (aggressiveness < 2.51f)
{
__instance.maxDensitySlider.value = 3f;
}
else
{
__instance.maxDensitySlider.value = Mathf.FloorToInt(aggressiveness);
}
text = aggressiveness + "x";
__instance.maxDensityText.text = text;
aggressiveness = __instance.combatSettings.growthSpeedFactor;
if (aggressiveness < 0.26f)
{
__instance.growthSpeedSlider.value = 0f;
}
else if (aggressiveness < 0.51f)
{
__instance.growthSpeedSlider.value = 1f;
}
else if (aggressiveness < 1.01f)
{
__instance.growthSpeedSlider.value = 2f;
}
else if (aggressiveness < 2.01f)
{
__instance.growthSpeedSlider.value = 3f;
}
else
{
__instance.growthSpeedSlider.value = (float)Mathf.CeilToInt(aggressiveness) + 1f;
}
text = aggressiveness * 100f + "%";
__instance.growthSpeedText.text = text;
aggressiveness = __instance.combatSettings.powerThreatFactor;
if (aggressiveness < 0.02f)
{
__instance.powerThreatSlider.value = 0f;
}
else if (aggressiveness < 0.11f)
{
__instance.powerThreatSlider.value = 1f;
}
else if (aggressiveness < 0.21000001f)
{
__instance.powerThreatSlider.value = 2f;
}
else if (aggressiveness < 0.51f)
{
__instance.powerThreatSlider.value = 3f;
}
else if (aggressiveness < 1.01f)
{
__instance.powerThreatSlider.value = 4f;
}
else if (aggressiveness < 2.01f)
{
__instance.powerThreatSlider.value = 5f;
}
else if (aggressiveness < 5.01f)
{
__instance.powerThreatSlider.value = 6f;
}
else if (aggressiveness < 8.01f)
{
__instance.powerThreatSlider.value = 7f;
}
else
{
__instance.powerThreatSlider.value = Mathf.FloorToInt(aggressiveness);
}
text = aggressiveness * 100f + "%";
__instance.powerThreatText.text = text;
aggressiveness = __instance.combatSettings.battleThreatFactor;
if (aggressiveness < 0.02f)
{
__instance.combatThreatSlider.value = 0f;
}
else if (aggressiveness < 0.11f)
{
__instance.combatThreatSlider.value = 1f;
}
else if (aggressiveness < 0.21000001f)
{
__instance.combatThreatSlider.value = 2f;
}
else if (aggressiveness < 0.51f)
{
__instance.combatThreatSlider.value = 3f;
}
else if (aggressiveness < 1.01f)
{
__instance.combatThreatSlider.value = 4f;
}
else if (aggressiveness < 2.01f)
{
__instance.combatThreatSlider.value = 5f;
}
else if (aggressiveness < 5.01f)
{
__instance.combatThreatSlider.value = 6f;
}
else if (aggressiveness < 8.01f)
{
__instance.combatThreatSlider.value = 7f;
}
else
{
__instance.combatThreatSlider.value = Mathf.FloorToInt(aggressiveness);
}
text = aggressiveness * 100f + "%";
__instance.combatThreatText.text = text;
aggressiveness = __instance.combatSettings.battleExpFactor;
if (aggressiveness < 0.02f)
{
__instance.DFExpSlider.value = 0f;
}
else if (aggressiveness < 0.11f)
{
__instance.DFExpSlider.value = 1f;
}
else if (aggressiveness < 0.21000001f)
{
__instance.DFExpSlider.value = 2f;
}
else if (aggressiveness < 0.51f)
{
__instance.DFExpSlider.value = 3f;
}
else if (aggressiveness < 1.01f)
{
__instance.DFExpSlider.value = 4f;
}
else if (aggressiveness < 2.01f)
{
__instance.DFExpSlider.value = 5f;
}
else if (aggressiveness < 5.01f)
{
__instance.DFExpSlider.value = 6f;
}
else if (aggressiveness < 8.01f)
{
__instance.DFExpSlider.value = 7f;
}
else
{
__instance.DFExpSlider.value = Mathf.FloorToInt(aggressiveness + 1f);
}
text = aggressiveness * 100f + "%";
__instance.DFExpText.text = text;
GameDesc val = new GameDesc();
float difficulty = ((CombatSettings)(ref __instance.combatSettings)).difficulty;
string arg = ((difficulty >= 9.9999f) ? difficulty.ToString("0.00") : difficulty.ToString("0.000"));
__instance.difficultyText.text = string.Format(Localization.Translate("难度系数值"), arg);
__instance.difficultTipGroupDF.SetActive(((int)((CombatSettings)(ref __instance.combatSettings)).aggressiveLevel == 40 && difficulty > 4.5f) || difficulty > 6f);
__instance.gameDesc.CopyTo(val);
val.combatSettings = __instance.combatSettings;
__instance.propertyMultiplierText.text = Localization.Translate("元数据生成倍率") + " " + val.propertyMultiplier.ToString("0%");
return false;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(UICombatSettingsDF), "_OnOpen")]
public static void _OnOpen(ref UICombatSettingsDF __instance)
{
__instance.initLevelSlider.maxValue = 100f;
__instance.initLevelSlider.m_MaxValue = 100f;
__instance.growthSpeedSlider.maxValue = 300f;
__instance.growthSpeedSlider.m_MaxValue = 300f;
__instance.initGrowthSlider.maxValue = 300f;
__instance.initGrowthSlider.m_MaxValue = 300f;
__instance.initOccupiedSlider.maxValue = 300f;
__instance.initOccupiedSlider.m_MaxValue = 300f;
__instance.maxDensitySlider.maxValue = 30f;
__instance.maxDensitySlider.m_MaxValue = 30f;
__instance.powerThreatSlider.maxValue = 1000f;
__instance.powerThreatSlider.m_MaxValue = 1000f;
__instance.DFExpSlider.maxValue = 1000f;
__instance.DFExpSlider.m_MaxValue = 1000f;
__instance.combatThreatSlider.maxValue = 1000f;
__instance.combatThreatSlider.m_MaxValue = 1000f;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(EvolveData), "AddExpPoint")]
public static bool AddExpPoint(ref EvolveData __instance, int _addexpp)
{
if (__instance.level >= 100)
{
if (__instance.expf != 0 || __instance.expp != 0 || __instance.level != 100)
{
__instance.level = 100;
__instance.expf = 0;
__instance.expp = 0;
__instance.expl = EvolveData.LevelCummulativeExp(100);
}
return false;
}
if (_addexpp > 0)
{
__instance.expp += _addexpp;
if (__instance.expp >= 10000)
{
__instance.expf += __instance.expp / 10000;
__instance.expp %= 10000;
while (__instance.expf >= EvolveData.levelExps[__instance.level])
{
int num = EvolveData.levelExps.Length - 1;
__instance.expf -= EvolveData.levelExps[__instance.level];
__instance.expl += EvolveData.levelExps[__instance.level];
__instance.level++;
if (__instance.level >= num)
{
__instance.level = num;
__instance.expf = 0;
__instance.expp = 0;
return false;
}
}
}
}
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(EvolveData), "AddExp")]
public static bool AddExp(ref EvolveData __instance, int _addexp)
{
if (__instance.level >= 100)
{
if (__instance.expf != 0 || __instance.expp != 0 || __instance.level != 100)
{
__instance.level = 100;
__instance.expf = 0;
__instance.expp = 0;
__instance.expl = EvolveData.LevelCummulativeExp(100);
}
return false;
}
__instance.expf += _addexp;
while (__instance.expf >= EvolveData.levelExps[__instance.level])
{
int num = EvolveData.levelExps.Length - 1;
__instance.expf -= EvolveData.levelExps[__instance.level];
__instance.expl += EvolveData.levelExps[__instance.level];
__instance.level++;
if (__instance.level >= num)
{
__instance.level = num;
__instance.expf = 0;
return false;
}
}
return false;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StarGen), "CreateStar")]
[HarmonyPatch(typeof(StarGen), "CreateBirthStar")]
public static void ClampHiveCount(ref StarData __result)
{
__result.maxHiveCount = Mathf.Clamp(__result.maxHiveCount, 0, 8);
__result.initialHiveCount = Mathf.Clamp(__result.initialHiveCount, 0, 8);
}
}
public static class BCE
{
public static class Console
{
public static void Init()
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
Assembly[] array = assemblies;
foreach (Assembly assembly in array)
{
if (!(assembly.GetName().Name != "BCE"))
{
t = assembly.GetType("BCE.console");
disabled = false;
}
}
initialized = true;
}
public static void Write(string s, ConsoleColor c)
{
if (!initialized)
{
Init();
}
if (!disabled)
{
t.GetMethod("Write", BindingFlags.Static | BindingFlags.Public)?.Invoke(null, new object[2] { s, c });
}
else
{
GF.Log(s, 35);
}
}
public static void WriteLine(string s, ConsoleColor c)
{
if (!initialized)
{
Init();
}
if (!disabled)
{
t.GetMethod("WriteLine", BindingFlags.Static | BindingFlags.Public)?.Invoke(null, new object[2] { s, c });
}
}
}
public static bool disabled = true;
private static bool initialized;
private static Type t;
}
public static class Utils
{
public static class AddressHelper
{
[StructLayout(LayoutKind.Explicit)]
private struct ObjectReinterpreter
{
[FieldOffset(0)]
public ObjectWrapper AsObject;
[FieldOffset(0)]
public readonly IntPtrWrapper AsIntPtr;
}
private class ObjectWrapper
{
public object Object;
}
private class IntPtrWrapper
{
public IntPtr Value;
}
private static readonly object mutualObject;
private static readonly ObjectReinterpreter reinterpreter;
static AddressHelper()
{
mutualObject = new object();
reinterpreter = default(ObjectReinterpreter);
reinterpreter.AsObject = new ObjectWrapper();
}
public static IntPtr GetAddress(object obj)
{
lock (mutualObject)
{
reinterpreter.AsObject.Object = obj;
IntPtr value = reinterpreter.AsIntPtr.Value;
reinterpreter.AsObject.Object = null;
return value;
}
}
public static T GetInstance<T>(IntPtr address)
{
lock (mutualObject)
{
reinterpreter.AsIntPtr.Value = address;
return (T)reinterpreter.AsObject.Object;
}
}
}
public static Dictionary<PlanetData, PlanetFactory> PlanetFactories = new Dictionary<PlanetData, PlanetFactory>();
public static CodeInstruction Call(Type type, string name, Type[] parameters = null, Type[] generics = null)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.Method(type, name, parameters, generics);
if ((object)methodInfo == null)
{
throw new ArgumentException($"No method found for type={type}, name={name}, parameters={GeneralExtensions.Description(parameters)}, generics={GeneralExtensions.Description(generics)}");
}
return new CodeInstruction(OpCodes.Call, (object)methodInfo);
}
public static CodeInstruction Call(string typeColonMethodname, Type[] parameters = null, Type[] generics = null)
{
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.Method(typeColonMethodname, parameters, generics);
if ((object)methodInfo == null)
{
throw new ArgumentException("No method found for " + typeColonMethodname + ", parameters=" + GeneralExtensions.Description(parameters) + ", generics=" + GeneralExtensions.Description(generics));
}
return new CodeInstruction(OpCodes.Call, (object)methodInfo);
}
public static CodeInstruction Call(Expression<Action> expression)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo(expression));
}
public static CodeInstruction Call<T>(Expression<Action<T>> expression)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo<T>(expression));
}
public static CodeInstruction Call<T, TResult>(Expression<Func<T, TResult>> expression)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo<T, TResult>(expression));
}
public static CodeInstruction Call(LambdaExpression expression)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo(expression));
}
public static CodeInstruction LoadField(Type type, string name, bool useAddress = false)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
FieldInfo fieldInfo = AccessTools.Field(type, name);
if ((object)fieldInfo == null)
{
throw new ArgumentException($"No field found for {type} and {name}");
}
return new CodeInstruction((!useAddress) ? (fieldInfo.IsStatic ? OpCodes.Ldsfld : OpCodes.Ldfld) : (fieldInfo.IsStatic ? OpCodes.Ldsflda : OpCodes.Ldflda), (object)fieldInfo);
}
public static CodeInstruction StoreField(Type type, string name)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
FieldInfo fieldInfo = AccessTools.Field(type, name);
if ((object)fieldInfo == null)
{
throw new ArgumentException($"No field found for {type} and {name}");
}
return new CodeInstruction(fieldInfo.IsStatic ? OpCodes.Stsfld : OpCodes.Stfld, (object)fieldInfo);
}
public static CodeInstruction LoadLocal(int index, bool useAddress = false)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Expected O, but got Unknown
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Expected O, but got Unknown
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Expected O, but got Unknown
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Expected O, but got Unknown
if (useAddress)
{
if (index < 256)
{
return new CodeInstruction(OpCodes.Ldloca_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Ldloca, (object)index);
}
if (index == 0)
{
return new CodeInstruction(OpCodes.Ldloc_0, (object)null);
}
if (index == 1)
{
return new CodeInstruction(OpCodes.Ldloc_1, (object)null);
}
if (index == 2)
{
return new CodeInstruction(OpCodes.Ldloc_2, (object)null);
}
if (index == 3)
{
return new CodeInstruction(OpCodes.Ldloc_3, (object)null);
}
if (index < 256)
{
return new CodeInstruction(OpCodes.Ldloc_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Ldloc, (object)index);
}
public static CodeInstruction StoreLocal(int index)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Expected O, but got Unknown
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Expected O, but got Unknown
if (index == 0)
{
return new CodeInstruction(OpCodes.Stloc_0, (object)null);
}
if (index == 1)
{
return new CodeInstruction(OpCodes.Stloc_1, (object)null);
}
if (index == 2)
{
return new CodeInstruction(OpCodes.Stloc_2, (object)null);
}
if (index == 3)
{
return new CodeInstruction(OpCodes.Stloc_3, (object)null);
}
if (index < 256)
{
return new CodeInstruction(OpCodes.Stloc_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Stloc, (object)index);
}
public static CodeInstruction LoadArgument(int index, bool useAddress = false)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Expected O, but got Unknown
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Expected O, but got Unknown
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Expected O, but got Unknown
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Expected O, but got Unknown
if (useAddress)
{
if (index < 256)
{
return new CodeInstruction(OpCodes.Ldarga_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Ldarga, (object)index);
}
if (index == 0)
{
return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
}
if (index == 1)
{
return new CodeInstruction(OpCodes.Ldarg_1, (object)null);
}
if (index == 2)
{
return new CodeInstruction(OpCodes.Ldarg_2, (object)null);
}
if (index == 3)
{
return new CodeInstruction(OpCodes.Ldarg_3, (object)null);
}
if (index < 256)
{
return new CodeInstruction(OpCodes.Ldarg_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Ldarg, (object)index);
}
public static CodeInstruction StoreArgument(int index)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
if (index < 256)
{
return new CodeInstruction(OpCodes.Starg_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Starg, (object)index);
}
public static double ModifyRadius(double vanilla, double realRadius)
{
bool flag = false;
if (realRadius < 0.0)
{
flag = true;
realRadius *= -1.0;
}
double num = vanilla - 200.0;
realRadius += num;
if (flag)
{
realRadius *= -1.0;
}
return realRadius;
}
public static T GetRadiusFromMecha<T>(T t, Mecha mecha)
{
double vanilla = Convert.ToDouble(t);
float? obj;
if (mecha == null)
{
obj = null;
}
else
{
Player player = mecha.player;
if (player == null)
{
obj = null;
}
else
{
PlanetData planetData = player.planetData;
obj = ((planetData != null) ? new float?(planetData.realRadius) : null);
}
}
double num = ModifyRadius(vanilla, ((double?)obj) ?? 200.0);
return (T)Convert.ChangeType(num, typeof(T));
}
public static T GetRadiusFromFactory<T>(T t, PlanetFactory factory)
{
double vanilla = Convert.ToDouble(t);
float? obj;
if (factory == null)
{
obj = null;
}
else
{
PlanetData planet = factory.planet;
obj = ((planet != null) ? new float?(planet.realRadius) : null);
}
double num = ModifyRadius(vanilla, ((double?)obj) ?? 200.0);
return (T)Convert.ChangeType(num, typeof(T));
}
public static float GetSquareRadiusFromAstroFactoryId(int id)
{
PlanetFactory val = GameMain.data.spaceSector.skillSystem.astroFactories[id];
float num = val.planet.realRadius * val.planet.realRadius;
if (VFInput.alt)
{
GF.Log($"GetRadiusSquareFromFactory Called By {GF.GetCaller()} {GF.GetCaller(1)} {GF.GetCaller(2)} returning {num}", 48);
}
return num;
}
public static T GetRadiusFromAstroId<T>(T t, int id)
{
double vanilla = Convert.ToDouble(t);
GalaxyData galaxy = GameMain.data.galaxy;
float? obj;
if (galaxy == null)
{
obj = null;
}
else
{
PlanetFactory obj2 = galaxy.astrosFactory[id];
if (obj2 == null)
{
obj = null;
}
else
{
PlanetData planet = obj2.planet;
obj = ((planet != null) ? new float?(planet.realRadius) : null);
}
}
double num = ModifyRadius(vanilla, ((double?)obj) ?? 200.0);
return (T)Convert.ChangeType(num, typeof(T));
}
public static T GetRadiusFromLocalPlanet<T>(T t)
{
double vanilla = Convert.ToDouble(t);
PlanetData localPlanet = GameMain.localPlanet;
double num = ModifyRadius(vanilla, ((double?)((localPlanet != null) ? new float?(localPlanet.realRadius) : null)) ?? 200.0);
return (T)Convert.ChangeType(num, typeof(T));
}
public static T GetRadiusFromEnemyData<T>(T t, ref EnemyData enemyData)
{
double vanilla = Convert.ToDouble(t);
PlanetData obj = GameMain.galaxy.PlanetById(enemyData.astroId);
double num = ModifyRadius(vanilla, ((double?)((obj != null) ? new float?(obj.realRadius) : null)) ?? 200.0);
return (T)Convert.ChangeType(num, typeof(T));
}
public static T GetRadiusFromAltitude<T>(T t, float alt)
{
double num = ModifyRadius(Convert.ToDouble(t), Convert.ToDouble(alt));
return (T)Convert.ChangeType(num, typeof(T));
}
public static PlanetFactory GetPlanetFactoryFromPlanetData(PlanetData planet)
{
if (planet == null)
{
return null;
}
if (PlanetFactories.ContainsKey(planet))
{
return PlanetFactories[planet];
}
PlanetFactory[] astrosFactory = GameMain.spaceSector.galaxy.astrosFactory;
foreach (PlanetFactory val in astrosFactory)
{
if (((val != null) ? val.planet : null) != null && !PlanetFactories.ContainsKey(val.planet))
{
PlanetFactories.Add(val.planet, val);
}
}
return PlanetFactories.ContainsKey(planet) ? PlanetFactories[planet] : null;
}
public static float getPlanetSize(float mod = 0f)
{
PlanetData localPlanet = GameMain.localPlanet;
return (localPlanet != null) ? (localPlanet.realRadius + mod) : (200f + mod);
}
public static string Serialize(object value, bool pretty = true)
{
fsSerializer fsSerializer = new fsSerializer();
fsSerializer.TrySerialize(value, out var data);
if (!pretty)
{
return fsJsonPrinter.CompressedJson(data);
}
return fsJsonPrinter.PrettyJson(data);
}
public static T DeSerialize<T>(string json)
{
fsSerializer fsSerializer = new fsSerializer();
fsData data;
fsResult fsResult = fsJsonParser.Parse(json, out data);
if (fsResult.Failed)
{
GF.Error("Deserialization of Json " + json + " failed. " + fsResult.FormattedMessages, 59);
return default(T);
}
T instance = default(T);
fsResult fsResult2 = fsSerializer.TryDeserialize(data, ref instance);
if (fsResult2.Failed)
{
GF.Error("Failed to deserialize " + json + ": " + fsResult2.FormattedMessages, 67);
return default(T);
}
return instance;
}
public static T[] ResourcesLoadArray<T>(string path, string format, bool emptyNull) where T : Object
{
List<T> list = new List<T>();
T val = Resources.Load<T>(path);
if ((Object)(object)val == (Object)null)
{
return null;
}
int num = 0;
if ((Object)(object)val != (Object)null)
{
list.Add(val);
num = 1;
}
do
{
val = Resources.Load<T>(string.Format(format, path, num));
if ((Object)(object)val == (Object)null || ((num == 1 || num == 2) && list.Contains(val)))
{
break;
}
list.Add(val);
num++;
}
while (num < 1024);
if (emptyNull && list.Count == 0)
{
return null;
}
return list.ToArray();
}
public static VectorLF3 PolarToCartesian(double p, double theta, double phi)
{
//IL_002d: 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_0035: Unknown result type (might be due to invalid IL or missing references)
double num = p * Math.Sin(phi) * Math.Cos(theta);
double num2 = p * Math.Sin(phi) * Math.Sin(theta);
double num3 = p * Math.Cos(phi);
return new VectorLF3(num3, num2, num3);
}
public static Vector3 RandomDirection(GF.Random random)
{
//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_0055: 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_0059: Unknown result type (might be due to invalid IL or missing references)
Vector3 zero = Vector3.zero;
zero.x = (float)random.NextDouble() * 2f - 1f;
zero.y = (float)random.NextDouble() * 2f - 1f;
zero.z = (float)random.NextDouble() * 2f - 1f;
return zero;
}
public static Type GetCallingType()
{
return new StackTrace().GetFrame(2).GetMethod().ReflectedType;
}
public static double DistanceVLF3(VectorLF3 a, VectorLF3 b)
{
//IL_0001: 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)
//IL_000e: 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_001b: 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_0028: 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)
VectorLF3 val = new VectorLF3(a.x - b.x, a.y - b.y, a.z - b.z);
return ((VectorLF3)(ref val)).magnitude;
}
public static bool ArrayCompare<T>(T[] a1, T[] a2)
{
return a1.SequenceEqual(a2);
}
public static T ReverseLookup<T, W>(Dictionary<T, W> dict, W val)
{
foreach (KeyValuePair<T, W> item in dict)
{
if (item.Value.ToString() == val.ToString())
{
return item.Key;
}
}
return default(T);
}
public static float diff(float a, float b)
{
return (!(a > b)) ? (b - a) : (a - b);
}
public static List<VectorLF3> RegularPointsOnSphere(float radius, int count)
{
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
List<VectorLF3> list = new List<VectorLF3>();
if (count == 0)
{
return list;
}
double num = Math.PI * 4.0 * (Math.Pow(radius, 2.0) / (double)count);
double num2 = Math.Sqrt(num);
int num3 = (int)Math.Round(Math.PI / num2);
double num4 = Math.PI / (double)num3;
double num5 = num / num4;
for (int i = 0; i < num3; i++)
{
double num6 = Math.PI * ((double)i + 0.5) / (double)num3;
int num7 = (int)Math.Round(Math.PI * 2.0 * Math.Sin(num6) / num5);
for (int j = 0; j < num7; j++)
{
double num8 = Math.PI * 2.0 * (double)j / (double)num7;
double num9 = (double)radius * Math.Sin(num6) * Math.Cos(num8);
double num10 = (double)radius * Math.Sin(num6) * Math.Sin(num8);
double num11 = (double)radius * Math.Cos(num6);
list.Add(new VectorLF3(num9, num10, num11));
}
}
return list;
}
public static float Round2DP(float num)
{
return Mathf.Round(num * 100f) / 100f;
}
}
public static class Methods
{
public static MethodInfo GetRadiusFromAstroId(this CodeMatcher matcher)
{
return AccessTools.Method(typeof(Utils), "GetRadiusFromAstroId", (Type[])null, (Type[])null).MakeGenericMethod(matcher.Operand?.GetType() ?? typeof(float));
}
public static MethodInfo GetRadiusFromLocalPlanet(this CodeMatcher matcher)
{
return AccessTools.Method(typeof(Utils), "GetRadiusFromLocalPlanet", (Type[])null, (Type[])null).MakeGenericMethod(matcher.Operand?.GetType() ?? typeof(float));
}
public static MethodInfo GetRadiusFromEnemyData(this CodeMatcher matcher)
{
return AccessTools.Method(typeof(Utils), "GetRadiusFromEnemyData", (Type[])null, (Type[])null).MakeGenericMethod(matcher.Operand?.GetType() ?? typeof(float));
}
public static MethodInfo GetRadiusFromMecha(this CodeMatcher matcher)
{
return AccessTools.Method(typeof(Utils), "GetRadiusFromMecha", (Type[])null, (Type[])null).MakeGenericMethod(matcher.Operand?.GetType() ?? typeof(float));
}
public static MethodInfo GetRadiusFromFactory(this CodeMatcher matcher)
{
return AccessTools.Method(typeof(Utils), "GetRadiusFromFactory", (Type[])null, (Type[])null).MakeGenericMethod(matcher.Operand?.GetType() ?? typeof(float));
}
public static MethodInfo GetRadiusFromAltitude(this CodeMatcher matcher)
{
return AccessTools.Method(typeof(Utils), "GetRadiusFromAltitude", (Type[])null, (Type[])null).MakeGenericMethod(matcher.Operand?.GetType() ?? typeof(float));
}
public static MethodInfo GetSquareRadiusFromAstroFactoryId(this CodeMatcher matcher)
{
return AccessTools.Method(typeof(Utils), "GetSquareRadiusFromAstroFactoryId", (Type[])null, (Type[])null);
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "GetFogged";
public const string PLUGIN_NAME = "GetFogged";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace PCGSharp
{
public class Pcg
{
private const ulong ShiftedIncrement = 721347520444481703uL;
private const ulong Multiplier = 6364136223846793005uL;
private const double ToDouble01 = 2.3283064365386963E-10;
private ulong _increment = 1442695040888963407uL;
private ulong _state;
public Pcg(int seed)
: this((ulong)seed)
{
}
public Pcg(ulong seed, ulong sequence = 721347520444481703uL)
{
Initialize(seed, sequence);
}
public int Next()
{
uint num = NextUInt();
return (int)(num >> 1);
}
public int Next(int maxExclusive)
{
if (maxExclusive <= 0)
{
throw new ArgumentException("Max Exclusive must be positive");
}
uint num = (uint)(0L - (long)(uint)maxExclusive) % (uint)maxExclusive;
uint num2;
do
{
num2 = NextUInt();
}
while (num2 < num);
return (int)(num2 % (uint)maxExclusive);
}
public int Next(int minInclusive, int maxExclusive)
{
if (maxExclusive <= minInclusive)
{
throw new ArgumentException("MaxExclusive must be larger than MinInclusive");
}
uint num = (uint)(maxExclusive - minInclusive);
uint num2 = (uint)(0L - (long)num) % num;
uint num3;
do
{
num3 = NextUInt();
}
while (num3 < num2);
return (int)(num3 % num + minInclusive);
}
public virtual uint NextUInt()
{
ulong state = _state;
_state = state * 6364136223846793005L + _increment;
uint num = (uint)(((state >> 18) ^ state) >> 27);
int num2 = (int)(state >> 59);
return (num >> num2) | (num << (-num2 & 0x1F));
}
public uint NextUInt(uint maxExclusive)
{
uint num = (uint)(0L - (long)maxExclusive) % maxExclusive;
uint num2;
do
{
num2 = NextUInt();
}
while (num2 < num);
return num2 % maxExclusive;
}
public uint NextUInt(uint minInclusive, uint maxExclusive)
{
if (maxExclusive <= minInclusive)
{
throw new ArgumentException();
}
uint num = maxExclusive - minInclusive;
uint num2 = (uint)(0L - (long)num) % num;
uint num3;
do
{
num3 = NextUInt();
}
while (num3 < num2);
return num3 % num + minInclusive;
}
public float NextFloat()
{
return (float)((double)NextUInt() * 2.3283064365386963E-10);
}
public float NextFloat(float maxInclusive)
{
if (maxInclusive <= 0f)
{
throw new ArgumentException("MaxInclusive must be larger than 0");
}
return (float)((double)NextUInt() * 2.3283064365386963E-10) * maxInclusive;
}
public float NextFloat(float minInclusive, float maxInclusive)
{
if (maxInclusive < minInclusive)
{
throw new ArgumentException("Max must be larger than min");
}
return (float)((double)NextUInt() * 2.3283064365386963E-10) * (maxInclusive - minInclusive) + minInclusive;
}
public double NextDouble()
{
return (double)NextUInt() * 2.3283064365386963E-10;
}
public double NextDouble(double maxInclusive)
{
if (maxInclusive <= 0.0)
{
throw new ArgumentException("Max must be larger than 0");
}
return (double)NextUInt() * 2.3283064365386963E-10 * maxInclusive;
}
public double NextDouble(double minInclusive, double maxInclusive)
{
if (maxInclusive < minInclusive)
{
throw new ArgumentException("Max must be larger than min");
}
return (double)NextUInt() * 2.3283064365386963E-10 * (maxInclusive - minInclusive) + minInclusive;
}
public bool NextBool()
{
uint num = NextUInt();
return num % 2 == 1;
}
public void SetStream(ulong sequence)
{
_increment = (sequence << 1) | 1;
}
protected void reseed(int seed)
{
Initialize((ulong)seed, 721347520444481703uL);
}
protected void Initialize(ulong seed, ulong initseq)
{
_state = 0uL;
SetStream(initseq);
NextUInt();
_state += seed;
NextUInt();
}
}
}
namespace GSSerializer
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
public sealed class fsForwardAttribute : Attribute
{
public string MemberName;
public fsForwardAttribute(string memberName)
{
MemberName = memberName;
}
}
public class fsConverterRegistrar
{
public static AnimationCurve_DirectConverter Register_AnimationCurve_DirectConverter;
public static Bounds_DirectConverter Register_Bounds_DirectConverter;
public static Gradient_DirectConverter Register_Gradient_DirectConverter;
public static GUIStyleState_DirectConverter Register_GUIStyleState_DirectConverter;
public static GUIStyle_DirectConverter Register_GUIStyle_DirectConverter;
public static Keyframe_DirectConverter Register_Keyframe_DirectConverter;
public static LayerMask_DirectConverter Register_LayerMask_DirectConverter;
public static RectOffset_DirectConverter Register_RectOffset_DirectConverter;
public static Rect_DirectConverter Register_Rect_DirectConverter;
public static List<Type> Converters;
static fsConverterRegistrar()
{
Converters = new List<Type>();
FieldInfo[] declaredFields = typeof(fsConverterRegistrar).GetDeclaredFields();
foreach (FieldInfo fieldInfo in declaredFields)
{
if (fieldInfo.Name.StartsWith("Register_"))
{
Converters.Add(fieldInfo.FieldType);
}
}
MethodInfo[] declaredMethods = typeof(fsConverterRegistrar).GetDeclaredMethods();
foreach (MethodInfo methodInfo in declaredMethods)
{
if (methodInfo.Name.StartsWith("Register_"))
{
methodInfo.Invoke(null, null);
}
}
List<Type> list = new List<Type>(Converters);
foreach (Type converter in Converters)
{
object obj = null;
try
{
obj = Activator.CreateInstance(converter);
}
catch (Exception)
{
}
if (obj is fsIAotConverter fsIAotConverter2)
{
fsMetaType currentModel = fsMetaType.Get(new fsConfig(), fsIAotConverter2.ModelType);
if (!fsAotCompilationManager.IsAotModelUpToDate(currentModel, fsIAotConverter2))
{
list.Remove(converter);
}
}
}
Converters = list;
}
}
public class fsAotCompilationManager
{
public static HashSet<Type> AotCandidateTypes = new HashSet<Type>();
private static bool HasMember(fsAotVersionInfo versionInfo, fsAotVersionInfo.Member member)
{
fsAotVersionInfo.Member[] members = versionInfo.Members;
foreach (fsAotVersionInfo.Member member2 in members)
{
if (member2 == member)
{
return true;
}
}
return false;
}
public static bool IsAotModelUpToDate(fsMetaType currentModel, fsIAotConverter aotModel)
{
if (currentModel.IsDefaultConstructorPublic != aotModel.VersionInfo.IsConstructorPublic)
{
return false;
}
if (currentModel.Properties.Length != aotModel.VersionInfo.Members.Length)
{
return false;
}
fsMetaProperty[] properties = currentModel.Properties;
foreach (fsMetaProperty property in properties)
{
if (!HasMember(aotModel.VersionInfo, new fsAotVersionInfo.Member(property)))
{
return false;
}
}
return true;
}
public static string RunAotCompilationForType(fsConfig config, Type type)
{
fsMetaType fsMetaType2 = fsMetaType.Get(config, type);
fsMetaType2.EmitAotData(throwException: true);
return GenerateDirectConverterForTypeInCSharp(type, fsMetaType2.Properties, fsMetaType2.IsDefaultConstructorPublic);
}
private static string EmitVersionInfo(string prefix, Type type, fsMetaProperty[] members, bool isConstructorPublic)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine("new fsAotVersionInfo {");
stringBuilder.AppendLine(prefix + " IsConstructorPublic = " + (isConstructorPublic ? "true" : "false") + ",");
stringBuilder.AppendLine(prefix + " Members = new fsAotVersionInfo.Member[] {");
foreach (fsMetaProperty fsMetaProperty in members)
{
stringBuilder.AppendLine(prefix + " new fsAotVersionInfo.Member {");
stringBuilder.AppendLine(prefix + " MemberName = \"" + fsMetaProperty.MemberName + "\",");
stringBuilder.AppendLine(prefix + " JsonName = \"" + fsMetaProperty.JsonName + "\",");
stringBuilder.AppendLine(prefix + " StorageType = \"" + fsMetaProperty.StorageType.CSharpName(includeNamespace: true) + "\",");
if (fsMetaProperty.OverrideConverterType != null)
{
stringBuilder.AppendLine(prefix + " OverrideConverterType = \"" + fsMetaProperty.OverrideConverterType.CSharpName(includeNamespace: true) + "\",");
}
stringBuilder.AppendLine(prefix + " },");
}
stringBuilder.AppendLine(prefix + " }");
stringBuilder.Append(prefix + "}");
return stringBuilder.ToString();
}
private static string GetConverterString(fsMetaProperty member)
{
if (member.OverrideConverterType == null)
{
return "null";
}
return $"typeof({member.OverrideConverterType.CSharpName(includeNamespace: true)})";
}
public static string GetQualifiedConverterNameForType(Type type)
{
return "FullSerializer.Speedup." + type.CSharpName(includeNamespace: true, ensureSafeDeclarationName: true) + "_DirectConverter";
}
private static string GenerateDirectConverterForTypeInCSharp(Type type, fsMetaProperty[] members, bool isConstructorPublic)
{
StringBuilder stringBuilder = new StringBuilder();
string text = type.CSharpName(includeNamespace: true);
string text2 = type.CSharpName(includeNamespace: true, ensureSafeDeclarationName: true);
stringBuilder.AppendLine("using System;");
stringBuilder.AppendLine("using System.Collections.Generic;");
stringBuilder.AppendLine();
stringBuilder.AppendLine("namespace FullSerializer {");
stringBuilder.AppendLine(" partial class fsConverterRegistrar {");
stringBuilder.AppendLine(" public static Speedup." + text2 + "_DirectConverter Register_" + text2 + ";");
stringBuilder.AppendLine(" }");
stringBuilder.AppendLine("}");
stringBuilder.AppendLine();
stringBuilder.AppendLine("namespace FullSerializer.Speedup {");
stringBuilder.AppendLine(" public class " + text2 + "_DirectConverter : fsDirectConverter<" + text + ">, fsIAotConverter {");
stringBuilder.AppendLine(" private fsAotVersionInfo _versionInfo = " + EmitVersionInfo(" ", type, members, isConstructorPublic) + ";");
stringBuilder.AppendLine(" fsAotVersionInfo fsIAotConverter.VersionInfo { get { return _versionInfo; } }");
stringBuilder.AppendLine();
stringBuilder.AppendLine(" protected override fsResult DoSerialize(" + text + " model, Dictionary<string, fsData> serialized) {");
stringBuilder.AppendLine(" var result = fsResult.Success;");
stringBuilder.AppendLine();
foreach (fsMetaProperty fsMetaProperty in members)
{
stringBuilder.AppendLine(" result += SerializeMember(serialized, " + GetConverterString(fsMetaProperty) + ", \"" + fsMetaProperty.JsonName + "\", model." + fsMetaProperty.MemberName + ");");
}
stringBuilder.AppendLine();
stringBuilder.AppendLine(" return result;");
stringBuilder.AppendLine(" }");
stringBuilder.AppendLine();
stringBuilder.AppendLine(" protected override fsResult DoDeserialize(Dictionary<string, fsData> data, ref " + text + " model) {");
stringBuilder.AppendLine(" var result = fsResult.Success;");
stringBuilder.AppendLine();
for (int j = 0; j < members.Length; j++)
{
fsMetaProperty fsMetaProperty2 = members[j];
stringBuilder.AppendLine(" var t" + j + " = model." + fsMetaProperty2.MemberName + ";");
stringBuilder.AppendLine(" result += DeserializeMember(data, " + GetConverterString(fsMetaProperty2) + ", \"" + fsMetaProperty2.JsonName + "\", out t" + j + ");");
stringBuilder.AppendLine(" model." + fsMetaProperty2.MemberName + " = t" + j + ";");
stringBuilder.AppendLine();
}
stringBuilder.AppendLine(" return result;");
stringBuilder.AppendLine(" }");
stringBuilder.AppendLine();
stringBuilder.AppendLine(" public override object CreateInstance(fsData data, Type storageType) {");
if (isConstructorPublic)
{
stringBuilder.AppendLine(" return new " + text + "();");
}
else
{
stringBuilder.AppendLine(" return Activator.CreateInstance(typeof(" + text + "), /*nonPublic:*/true);");
}
stringBuilder.AppendLine(" }");
stringBuilder.AppendLine(" }");
stringBuilder.AppendLine("}");
return stringBuilder.ToString();
}
}
[CreateAssetMenu(menuName = "Full Serializer AOT Configuration")]
public class fsAotConfiguration : ScriptableObject
{
public enum AotState
{
Default,
Enabled,
Disabled
}
[Serializable]
public struct Entry
{
public AotState State;
public string FullTypeName;
public Entry(Type type)
{
FullTypeName = type.FullName;
State = AotState.Default;
}
public Entry(Type type, AotState state)
{
FullTypeName = type.FullName;
State = state;
}
}
public List<Entry> aotTypes = new List<Entry>();
public string outputDirectory = "Assets/AotModels";
public bool TryFindEntry(Type type, out Entry result)
{
string fullName = type.FullName;
foreach (Entry aotType in aotTypes)
{
if (aotType.FullTypeName == fullName)
{
result = aotType;
return true;
}
}
result = default(Entry);
return false;
}
public void UpdateOrAddEntry(Entry entry)
{
for (int i = 0; i < aotTypes.Count; i++)
{
if (aotTypes[i].FullTypeName == entry.FullTypeName)
{
aotTypes[i] = entry;
return;
}
}
aotTypes.Add(entry);
}
}
public struct fsAotVersionInfo
{
public struct Member
{
public string MemberName;
public string JsonName;
public string StorageType;
public string OverrideConverterType;
public Member(fsMetaProperty property)
{
MemberName = property.MemberName;
JsonName = property.JsonName;
StorageType = property.StorageType.CSharpName(includeNamespace: true);
OverrideConverterType = null;
if (property.OverrideConverterType != null)
{
OverrideConverterType = property.OverrideConverterType.CSharpName();
}
}
public override bool Equals(object obj)
{
if (!(obj is Member))
{
return false;
}
return this == (Member)obj;
}
public override int GetHashCode()
{
return MemberName.GetHashCode() + 17 * JsonName.GetHashCode() + 17 * StorageType.GetHashCode() + ((!string.IsNullOrEmpty(OverrideConverterType)) ? (17 * OverrideConverterType.GetHashCode()) : 0);
}
public static bool operator ==(Member a, Member b)
{
return a.MemberName == b.MemberName && a.JsonName == b.JsonName && a.StorageType == b.StorageType && a.OverrideConverterType == b.OverrideConverterType;
}
public static bool operator !=(Member a, Member b)
{
return !(a == b);
}
}
public bool IsConstructorPublic;
public Member[] Members;
}
public abstract class fsBaseConverter
{
public fsSerializer Serializer;
public virtual object CreateInstance(fsData data, Type storageType)
{
if (RequestCycleSupport(storageType))
{
throw new InvalidOperationException("Please override CreateInstance for " + GetType().FullName + "; the object graph for " + storageType?.ToString() + " can contain potentially contain cycles, so separated instance creation is needed");
}
return storageType;
}
public virtual bool RequestCycleSupport(Type storageType)
{
if (storageType == typeof(string))
{
return false;
}
return storageType.Resolve().IsClass || storageType.Resolve().IsInterface;
}
public virtual bool RequestInheritanceSupport(Type storageType)
{
return !storageType.Resolve().IsSealed;
}
public abstract fsResult TrySerialize(object instance, out fsData serialized, Type storageType);
public abstract fsResult TryDeserialize(fsData data, ref object instance, Type storageType);
protected fsResult FailExpectedType(fsData data, params fsDataType[] types)
{
return fsResult.Fail(GetType().Name + " expected one of " + string.Join(", ", types.Select((fsDataType t) => t.ToString()).ToArray()) + " but got " + data.Type.ToString() + " in " + data);
}
protected fsResult CheckType(fsData data, fsDataType type)
{
if (data.Type != type)
{
return fsResult.Fail(GetType().Name + " expected " + type.ToString() + " but got " + data.Type.ToString() + " in " + data);
}
return fsResult.Success;
}
protected fsResult CheckKey(fsData data, string key, out fsData subitem)
{
return CheckKey(data.AsDictionary, key, out subitem);
}
protected fsResult CheckKey(Dictionary<string, fsData> data, string key, out fsData subitem)
{
if (!data.TryGetValue(key, out subitem))
{
return fsResult.Fail(GetType().Name + " requires a <" + key + "> key in the data " + data);
}
return fsResult.Success;
}
protected fsResult SerializeMember<T>(Dictionary<string, fsData> data, Type overrideConverterType, string name, T value)
{
fsData data2;
fsResult result = Serializer.TrySerialize(typeof(T), overrideConverterType, value, out data2);
if (result.Succeeded)
{
data[name] = data2;
}
return result;
}
protected fsResult DeserializeMember<T>(Dictionary<string, fsData> data, Type overrideConverterType, string name, out T value)
{
if (!data.TryGetValue(name, out var value2))
{
value = default(T);
return fsResult.Fail("Unable to find member \"" + name + "\"");
}
object result = null;
fsResult result2 = Serializer.TryDeserialize(value2, typeof(T), overrideConverterType, ref result);
value = (T)result;
return result2;
}
}
public static class fsGlobalConfig
{
public static bool IsCaseSensitive = true;
public static bool AllowInternalExceptions = true;
public static string InternalFieldPrefix = "$";
}
public class fsConfig
{
public bool CoerceStringsToNumbers = false;
public string CustomDateTimeFormatString = null;
public fsMemberSerialization DefaultMemberSerialization = fsMemberSerialization.Default;
public bool EnablePropertySerialization = true;
public Func<string, MemberInfo, string> GetJsonNameFromMemberName = (string name, MemberInfo info) => name;
public Type[] IgnoreSerializeAttributes = new Type[2]
{
typeof(NonSerializedAttribute),
typeof(fsIgnoreAttribute)
};
public Type[] IgnoreSerializeTypeAttributes = new Type[1] { typeof(fsIgnoreAttribute) };
public bool Serialize64BitIntegerAsString = false;
public Type[] SerializeAttributes = new Type[2]
{
typeof(SerializeField),
typeof(fsPropertyAttribute)
};
public bool SerializeEnumsAsInteger = false;
public bool SerializeNonAutoProperties = false;
public bool SerializeNonPublicSetProperties = true;
}
public sealed class fsContext
{
private readonly Dictionary<Type, object> _contextObjects = new Dictionary<Type, object>();
public void Reset()
{
_contextObjects.Clear();
}
public void Set<T>(T obj)
{
_contextObjects[typeof(T)] = obj;
}
public bool Has<T>()
{
return _contextObjects.ContainsKey(typeof(T));
}
public T Get<T>()
{
if (_contextObjects.TryGetValue(typeof(T), out var value))
{
return (T)value;
}
throw new InvalidOperationException("There is no context object of type " + typeof(T));
}
}
public abstract class fsConverter : fsBaseConverter
{
public abstract bool CanProcess(Type type);
}
public enum fsDataType
{
Array,
Object,
Double,
Int64,
Boolean,
String,
Null
}
public sealed class fsData
{
private object _value;
public static readonly fsData True = new fsData(boolean: true);
public static readonly fsData False = new fsData(boolean: false);
public static readonly fsData Null = new fsData();
public fsDataType Type
{
get
{
if (_value == null)
{
return fsDataType.Null;
}
if (_value is double)
{
return fsDataType.Double;
}
if (_value is long)
{
return fsDataType.Int64;
}
if (_value is bool)
{
return fsDataType.Boolean;
}
if (_value is string)
{
return fsDataType.String;
}
if (_value is Dictionary<string, fsData>)
{
return fsDataType.Object;
}
if (_value is List<fsData>)
{
return fsDataType.Array;
}
throw new InvalidOperationException("unknown JSON data type");
}
}
public bool IsNull => _value == null;
public bool IsDouble => _value is double;
public bool IsInt64 => _value is long;
public bool IsBool => _value is bool;
public bool IsString => _value is string;
public bool IsDictionary => _value is Dictionary<string, fsData>;
public bool IsList => _value is List<fsData>;
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public double AsDouble => Cast<double>();
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public long AsInt64 => Cast<long>();
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public bool AsBool => Cast<bool>();
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public string AsString => Cast<string>();
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public Dictionary<string, fsData> AsDictionary => Cast<Dictionary<string, fsData>>();
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
public List<fsData> AsList => Cast<List<fsData>>();
public override string ToString()
{
return fsJsonPrinter.CompressedJson(this);
}
public fsData()
{
_value = null;
}
public fsData(bool boolean)
{
_value = boolean;
}
public fsData(double f)
{
_value = f;
}
public fsData(long i)
{
_value = i;
}
public fsData(string str)
{
_value = str;
}
public fsData(Dictionary<string, fsData> dict)
{
_value = dict;
}
public fsData(List<fsData> list)
{
_value = list;
}
public static fsData CreateDictionary()
{
return new fsData(new Dictionary<string, fsData>(fsGlobalConfig.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase));
}
public static fsData CreateList()
{
return new fsData(new List<fsData>());
}
public static fsData CreateList(int capacity)
{
return new fsData(new List<fsData>(capacity));
}
internal void BecomeDictionary()
{
_value = new Dictionary<string, fsData>();
}
internal fsData Clone()
{
fsData fsData2 = new fsData();
fsData2._value = _value;
return fsData2;
}
private T Cast<T>()
{
if (_value is T)
{
return (T)_value;
}
throw new InvalidCastException("Unable to cast <" + this?.ToString() + "> (with type = " + _value.GetType()?.ToString() + ") to type " + typeof(T));
}
public override bool Equals(object obj)
{
return Equals(obj as fsData);
}
public bool Equals(fsData other)
{
if (other == null || Type != other.Type)
{
return false;
}
switch (Type)
{
case fsDataType.Null:
return true;
case fsDataType.Double:
return AsDouble == other.AsDouble || Math.Abs(AsDouble - other.AsDouble) < double.Epsilon;
case fsDataType.Int64:
return AsInt64 == other.AsInt64;
case fsDataType.Boolean:
return AsBool == other.AsBool;
case fsDataType.String:
return AsString == other.AsString;
case fsDataType.Array:
{
List<fsData> asList = AsList;
List<fsData> asList2 = other.AsList;
if (asList.Count != asList2.Count)
{
return false;
}
for (int i = 0; i < asList.Count; i++)
{
if (!asList[i].Equals(asList2[i]))
{
return false;
}
}
return true;
}
case fsDataType.Object:
{
Dictionary<string, fsData> asDictionary = AsDictionary;
Dictionary<string, fsData> asDictionary2 = other.AsDictionary;
if (asDictionary.Count != asDictionary2.Count)
{
return false;
}
foreach (string key in asDictionary.Keys)
{
if (!asDictionary2.ContainsKey(key))
{
return false;
}
if (!asDictionary[key].Equals(asDictionary2[key]))
{
return false;
}
}
return true;
}
default:
throw new Exception("Unknown data type");
}
}
public static bool operator ==(fsData a, fsData b)
{
if ((object)a == b)
{
return true;
}
if ((object)a == null || (object)b == null)
{
return false;
}
if (a.IsDouble && b.IsDouble)
{
return Math.Abs(a.AsDouble - b.AsDouble) < double.Epsilon;
}
return a.Equals(b);
}
public static bool operator !=(fsData a, fsData b)
{
return !(a == b);
}
public override int GetHashCode()
{
return _value.GetHashCode();
}
}
public abstract class fsDirectConverter : fsBaseConverter
{
public abstract Type ModelType { get; }
}
public abstract class fsDirectConverter<TModel> : fsDirectConverter
{
public override Type ModelType => typeof(TModel);
public sealed override fsResult TrySerialize(object instance, out fsData serialized, Type storageType)
{
Dictionary<string, fsData> dictionary = new Dictionary<string, fsData>();
fsResult result = DoSerialize((TModel)instance, dictionary);
serialized = new fsData(dictionary);
return result;
}
public sealed override fsResult TryDeserialize(fsData data, ref object instance, Type storageType)
{
fsResult success = fsResult.Success;
fsResult fsResult2 = (success += CheckType(data, fsDataType.Object));
if (fsResult2.Failed)
{
return success;
}
TModel model = (TModel)instance;
success += DoDeserialize(data.AsDictionary, ref model);
instance = model;
return success;
}
protected abstract fsResult DoSerialize(TModel model, Dictionary<string, fsData> serialized);
protected abstract fsResult DoDeserialize(Dictionary<string, fsData> data, ref TModel model);
}
public sealed class fsMissingVersionConstructorException : Exception
{
public fsMissingVersionConstructorException(Type versionedType, Type constructorType)
: base(versionedType?.ToString() + " is missing a constructor for previous model type " + constructorType)
{
}
}
public sealed class fsDuplicateVersionNameException : Exception
{
public fsDuplicateVersionNameException(Type typeA, Type typeB, string version)
: base(typeA?.ToString() + " and " + typeB?.ToString() + " have the same version string (" + version + "); please change one of them.")
{
}
}
public interface fsIAotConverter
{
Type ModelType { get; }
fsAotVersionInfo VersionInfo { get; }
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field)]
public sealed class fsIgnoreAttribute : Attribute
{
}
public interface fsISerializationCallbacks
{
void OnBeforeSerialize(Type storageType);
void OnAfterSerialize(Type storageType, ref fsData data);
void OnBeforeDeserialize(Type storageType, ref fsData data);
void OnAfterDeserialize(Type storageType);
}
public class fsJsonParser
{
private readonly StringBuilder _cachedStringBuilder = new StringBuilder(256);
private readonly string _input;
private int _start;
private fsJsonParser(string input)
{
_input = input;
_start = 0;
}
private fsResult MakeFailure(string message)
{
int num = Math.Max(0, _start - 20);
int length = Math.Min(50, _input.Length - num);
string warning = "Error while parsing: " + message + "; context = <" + _input.Substring(num, length) + ">";
return fsResult.Fail(warning);
}
private bool TryMoveNext()
{
if (_start < _input.Length)
{
_start++;
return true;
}
return false;
}
private bool HasValue()
{
return HasValue(0);
}
private bool HasValue(int offset)
{
return _start + offset >= 0 && _start + offset < _input.Length;
}
private char Character()
{
return Character(0);
}
private char Character(int offset)
{
return _input[_start + offset];
}
private void SkipSpace()
{
while (HasValue())
{
char c = Character();
if (char.IsWhiteSpace(c))
{
TryMoveNext();
continue;
}
if (!HasValue(1) || Character(0) != '/')
{
break;
}
if (Character(1) == '/')
{
while (HasValue() && !Environment.NewLine.Contains(Character().ToString() ?? ""))
{
TryMoveNext();
}
}
else
{
if (Character(1) != '*')
{
continue;
}
TryMoveNext();
TryMoveNext();
while (HasValue(1))
{
if (Character(0) == '*' && Character(1) == '/')
{
TryMoveNext();
TryMoveNext();
TryMoveNext();
break;
}
TryMoveNext();
}
}
}
}
private fsResult TryParseExact(string content)
{
for (int i = 0; i < content.Length; i++)
{
if (Character() != content[i])
{
return MakeFailure("Expected " + content[i]);
}
if (!TryMoveNext())
{
return MakeFailure("Unexpected end of content when parsing " + content);
}
}
return fsResult.Success;
}
private fsResult TryParseTrue(out fsData data)
{
fsResult result = TryParseExact("true");
if (result.Succeeded)
{
data = new fsData(boolean: true);
return fsResult.Success;
}
data = null;
return result;
}
private fsResult TryParseFalse(out fsData data)
{
fsResult result = TryParseExact("false");
if (result.Succeeded)
{
data = new fsData(boolean: false);
return fsResult.Success;
}
data = null;
return result;
}
private fsResult TryParseNull(out fsData data)
{
fsResult result = TryParseExact("null");
if (result.Succeeded)
{
data = new fsData();
return fsResult.Success;
}
data = null;
return result;
}
private bool IsSeparator(char c)
{
return char.IsWhiteSpace(c) || c == ',' || c == '}' || c == ']';
}
private fsResult TryParseNumber(out fsData data)
{
int start = _start;
while (TryMoveNext() && HasValue() && !IsSeparator(Character()))
{
}
string text = _input.Substring(start, _start - start);
if (text.Contains(".") || text.Contains("e") || text.Contains("E") || text == "Infinity" || text == "-Infinity" || text == "NaN")
{
if (!double.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
{
data = null;
return MakeFailure("Bad double format with " + text);
}
data = new fsData(result);
return fsResult.Success;
}
if (!long.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out var result2))
{
data = null;
return MakeFailure("Bad Int64 format with " + text);
}
data = new fsData(result2);
return fsResult.Success;
}
private fsResult TryParseString(out string str)
{
_cachedStringBuilder.Length = 0;
if (Character() != '"' || !TryMoveNext())
{
str = string.Empty;
return MakeFailure("Expected initial \" when parsing a string");
}
while (HasValue() && Character() != '"')
{
char c = Character();
if (c == '\\')
{
char escaped;
fsResult result = TryUnescapeChar(out escaped);
if (result.Failed)
{
str = string.Empty;
return result;
}
_cachedStringBuilder.Append(escaped);
}
else
{
_cachedStringBuilder.Append(c);
if (!TryMoveNext())
{
str = string.Empty;
return MakeFailure("Unexpected end of input when reading a string");
}
}
}
if (!HasValue() || Character() != '"' || !TryMoveNext())
{
str = string.Empty;
return MakeFailure("No closing \" when parsing a string");
}
str = _cachedStringBuilder.ToString();
return fsResult.Success;
}
private fsResult TryParseArray(out fsData arr)
{
if (Character() != '[')
{
arr = null;
return MakeFailure("Expected initial [ when parsing an array");
}
if (!TryMoveNext())
{
arr = null;
return MakeFailure("Unexpected end of input when parsing an array");
}
SkipSpace();
List<fsData> list = new List<fsData>();
while (HasValue() && Character() != ']')
{
fsData data;
fsResult result = RunParse(out data);
if (result.Failed)
{
arr = null;
return result;
}
list.Add(data);
SkipSpace();
if (HasValue() && Character() == ',')
{
if (!TryMoveNext())
{
break;
}
SkipSpace();
}
}
if (!HasValue() || Character() != ']' || !TryMoveNext())
{
arr = null;
return MakeFailure("No closing ] for array");
}
arr = new fsData(list);
return fsResult.Success;
}
private fsResult TryParseObject(out fsData obj)
{
if (Character() != '{')
{
obj = null;
return MakeFailure("Expected initial { when parsing an object");
}
if (!TryMoveNext())
{
obj = null;
return MakeFailure("Unexpected end of input when parsing an object");
}
SkipSpace();
Dictionary<string, fsData> dictionary = new Dictionary<string, fsData>(fsGlobalConfig.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);
while (HasValue() && Character() != '}')
{
SkipSpace();
fsResult result = TryParseString(out var str);
if (result.Failed)
{
obj = null;
return result;
}
SkipSpace();
if (!HasValue() || Character() != ':' || !TryMoveNext())
{
obj = null;
return MakeFailure("Expected : after key \"" + str + "\"");
}
SkipSpace();
result = RunParse(out var data);
if (result.Failed)
{
obj = null;
return result;
}
dictionary.Add(str, data);
SkipSpace();
if (HasValue() && Character() == ',')
{
if (!TryMoveNext())
{
break;
}
SkipSpace();
}
}
if (!HasValue() || Character() != '}' || !TryMoveNext())
{
obj = null;
return MakeFailure("No closing } for object");
}
obj = new fsData(dictionary);
return fsResult.Success;
}
private fsResult RunParse(out fsData data)
{
SkipSpace();
if (!HasValue())
{
data = null;
return MakeFailure("Unexpected end of input");
}
switch (Character())
{
case '+':
case '-':
case '.':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 'I':
case 'N':
return TryParseNumber(out data);
case '"':
{
string str;
fsResult result = TryParseString(out str);
if (result.Failed)
{
data = null;
return result;
}
data = new fsData(str);
return fsResult.Success;
}
case '[':
return TryParseArray(out data);
case '{':
return TryParseObject(out data);
case 't':
return TryParseTrue(out data);
case 'f':
return TryParseFalse(out data);
case 'n':
return TryParseNull(out data);
default:
data = null;
return MakeFailure("unable to parse; invalid token \"" + Character() + "\"");
}
}
public static fsResult Parse(string input, out fsData data)
{
if (string.IsNullOrEmpty(input))
{
data = null;
return fsResult.Fail("No input");
}
fsJsonParser fsJsonParser2 = new fsJsonParser(input);
return fsJsonParser2.RunParse(out data);
}
public static fsData Parse(string input)
{
Parse(input, out var data).AssertSuccess();
return data;
}
private bool IsHex(char c)
{
return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
}
private uint ParseSingleChar(char c1, uint multipliyer)
{
uint result = 0u;
if (c1 >= '0' && c1 <= '9')
{
result = (uint)(c1 - 48) * multipliyer;
}
else if (c1 >= 'A' && c1 <= 'F')
{
result = (uint)(c1 - 65 + 10) * multipliyer;
}
else if (c1 >= 'a' && c1 <= 'f')
{
result = (uint)(c1 - 97 + 10) * multipliyer;
}
return result;
}
private uint ParseUnicode(char c1, char c2, char c3, char c4)
{
uint num = ParseSingleChar(c1, 4096u);
uint num2 = ParseSingleChar(c2, 256u);
uint num3 = ParseSingleChar(c3, 16u);
uint num4 = ParseSingleChar(c4, 1u);
return num + num2 + num3 + num
