Please disclose if any significant portion of your mod was created using AI tools by adding the 'AI Generated' category. Failing to do so may result in the mod being removed from Thunderstore.
Decompiled source of NeedStamina v1.0.1
plugins/NeedStaminaCruiser.dll
Decompiled 2 hours ago
The result has been truncated due to the large size, download it to view full contents!
using System; using System.Collections; using System.Collections.Concurrent; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.IO; using System.IO.Compression; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using System.Text.RegularExpressions; using System.Threading; using BepInEx; using BepInEx.Configuration; using BepInEx.Logging; using Microsoft.CodeAnalysis; using Unity.Collections; using Unity.Netcode; using UnityEngine; using UnityEngine.Events; using UnityEngine.InputSystem; using UnityEngine.InputSystem.Controls; using UnityEngine.InputSystem.Utilities; using UnityEngine.Rendering; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("NeedStaminaCruiser")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyInformationalVersion("1.0.0")] [assembly: AssemblyProduct("NeedStaminaCruiser")] [assembly: AssemblyTitle("NeedStaminaCruiser")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.0.0")] [module: UnverifiableCode] [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 NeedStaminaCruiser { internal static class Cruiser { private const BindingFlags Inst = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; private const BindingFlags Stat = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; private static readonly Dictionary<string, Type> typeCache = new Dictionary<string, Type>(); private static Component vehicle; private static bool dumped; private static Component sorCache; private static string magnetSource; private static readonly string[] MagnetBoolNames = new string[3] { "magnetOn", "isMagnetOn", "magnetEnabled" }; private static Component magnetLever; private static bool listedCandidates; private static float nextLeverSearch; public static Type FindType(string name) { if (typeCache.TryGetValue(name, out var value) && value != null) { return value; } Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); foreach (Assembly assembly in assemblies) { try { value = assembly.GetType(name, throwOnError: false); } catch { value = null; } if (value != null) { typeCache[name] = value; return value; } } return null; } private static FieldInfo GetField(Type type, string name) { Type type2 = type; while (type2 != null) { FieldInfo field = type2.GetField(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if (field != null) { return field; } type2 = type2.BaseType; } return null; } public static object GetValue(object obj, string name) { if (obj == null) { return null; } FieldInfo field = GetField(obj.GetType(), name); if (!(field != null)) { return null; } return field.GetValue(obj); } public static bool GetBool(object obj, string name) { object value = GetValue(obj, name); if (value is bool) { return (bool)value; } return false; } public static bool SetValue(object obj, string name, object value) { if (obj == null || value == null) { return false; } FieldInfo field = GetField(obj.GetType(), name); if (field == null || !field.FieldType.IsInstanceOfType(value)) { return false; } field.SetValue(obj, value); return true; } public static Component FindFirst(string typeName) { Type type = FindType(typeName); if (type == null) { return null; } Object obj = Object.FindObjectOfType(type); return (Component)(object)((obj is Component) ? obj : null); } public static Component LocalPlayer() { Type type = FindType("GameNetworkManager"); if (type == null) { return null; } object obj = null; FieldInfo field = type.GetField("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (field != null) { obj = field.GetValue(null); } if (obj == null) { PropertyInfo property = type.GetProperty("Instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (property != null) { obj = property.GetValue(null, null); } } object value = GetValue(obj, "localPlayerController"); return (Component)((value is Component) ? value : null); } public static Component Find() { if ((Object)(object)vehicle != (Object)null) { return vehicle; } vehicle = FindFirst("VehicleController"); if ((Object)(object)vehicle != (Object)null && !dumped) { dumped = true; if (Plugin.Verbose.Value) { Dump(vehicle); } } return vehicle; } private static Rigidbody GetRigidbody(Component v) { object value = GetValue(v, "mainRigidbody"); Rigidbody val = (Rigidbody)((value is Rigidbody) ? value : null); if ((Object)(object)val == (Object)null) { val = v.GetComponent<Rigidbody>(); } if ((Object)(object)val == (Object)null) { val = v.GetComponentInChildren<Rigidbody>(); } return val; } private static Bounds CarBounds(Component v) { //IL_0008: Unknown result type (might be due to invalid IL or missing references) //IL_000d: 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_003a: Unknown result type (might be due to invalid IL or missing references) Bounds result = default(Bounds); ((Bounds)(ref result))..ctor(v.transform.position, Vector3.zero); Collider[] componentsInChildren = v.GetComponentsInChildren<Collider>(); foreach (Collider val in componentsInChildren) { if ((Object)(object)val != (Object)null && !val.isTrigger) { ((Bounds)(ref result)).Encapsulate(val.bounds); } } ((Bounds)(ref result)).Expand(1f); return result; } public static void Teleport(Component v, Vector3 pos, Quaternion rot, bool zeroVelocity, bool carryPassengers) { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0015: 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_00a4: 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_00c7: 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) //IL_009c: 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_003f: 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_00e7: Unknown result type (might be due to invalid IL or missing references) //IL_00e8: Unknown result type (might be due to invalid IL or missing references) //IL_00ed: Unknown result type (might be due to invalid IL or missing references) //IL_007f: Unknown result type (might be due to invalid IL or missing references) //IL_008a: Unknown result type (might be due to invalid IL or missing references) //IL_005c: 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_0125: Unknown result type (might be due to invalid IL or missing references) //IL_0145: Unknown result type (might be due to invalid IL or missing references) Transform transform = v.transform; Rigidbody rigidbody = GetRigidbody(v); Component val = null; Vector3 val2 = Vector3.zero; bool flag = false; if (carryPassengers) { val = LocalPlayer(); if ((Object)(object)val != (Object)null && !GetBool(val, "inVehicleAnimation")) { Bounds val3 = CarBounds(v); if (((Bounds)(ref val3)).Contains(val.transform.position)) { val2 = transform.InverseTransformPoint(val.transform.position); flag = true; } } } if ((Object)(object)rigidbody != (Object)null) { if (zeroVelocity && !rigidbody.isKinematic) { rigidbody.velocity = Vector3.zero; rigidbody.angularVelocity = Vector3.zero; } rigidbody.position = pos; rigidbody.rotation = rot; } transform.SetPositionAndRotation(pos, rot); Physics.SyncTransforms(); SetValue(v, "syncedPosition", pos); SetValue(v, "syncedRotation", rot); if (!flag || !((Object)(object)val != (Object)null)) { return; } try { Vector3 val4 = transform.TransformPoint(val2); CharacterController component = val.GetComponent<CharacterController>(); bool enabled = (Object)(object)component != (Object)null && ((Collider)component).enabled; if ((Object)(object)component != (Object)null) { ((Collider)component).enabled = false; } val.transform.position = val4; if ((Object)(object)component != (Object)null) { ((Collider)component).enabled = enabled; } SetValue(val, "serverPlayerPosition", val4); } catch (Exception ex) { Plugin.Log.LogWarning((object)("Не удалось перенести игрока вместе с машиной: " + ex.Message)); } } public static bool SetNumber(object obj, string name, double value) { if (obj == null) { return false; } FieldInfo field = GetField(obj.GetType(), name); if (field == null) { return false; } if (field.FieldType == typeof(int)) { field.SetValue(obj, (int)value); } else if (field.FieldType == typeof(float)) { field.SetValue(obj, (float)value); } else { if (!(field.FieldType == typeof(double))) { return false; } field.SetValue(obj, value); } return true; } public static bool SetFlag(Component target, string name, bool value) { return SetValue(target, name, value); } private static int Report(string source, bool on) { if (magnetSource != source) { magnetSource = source; if (Plugin.Verbose.Value) { Plugin.Log.LogInfo((object)("Magnet state source: " + source)); } } return on ? 1 : 0; } public static int MagnetState() { if ((Object)(object)sorCache == (Object)null) { sorCache = FindFirst("StartOfRound"); } if ((Object)(object)sorCache != (Object)null) { string[] magnetBoolNames = MagnetBoolNames; foreach (string text in magnetBoolNames) { object value = GetValue(sorCache, text); if (value is bool) { return Report("StartOfRound." + text, (bool)value); } } FieldInfo[] fields = ((object)sorCache).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (FieldInfo fieldInfo in fields) { if (fieldInfo.FieldType == typeof(bool) && fieldInfo.Name.ToLowerInvariant().Contains("magnet")) { return Report("StartOfRound." + fieldInfo.Name, (bool)fieldInfo.GetValue(sorCache)); } } } Component val = FindMagnetLever(null, force: false); if ((Object)(object)val != (Object)null) { object value2 = GetValue(val, "boolValue"); if (value2 is bool) { return Report("lever.boolValue", (bool)value2); } } return -1; } public static bool IsOwner(Component v) { NetworkBehaviour val = (NetworkBehaviour)(object)((v is NetworkBehaviour) ? v : null); if ((Object)(object)val != (Object)null) { return val.IsOwner; } return false; } public static void Pin(Component v, Vector3 pos, Quaternion rot) { //IL_0024: 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_0043: 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_0018: Unknown result type (might be due to invalid IL or missing references) Rigidbody rigidbody = GetRigidbody(v); if ((Object)(object)rigidbody != (Object)null) { rigidbody.position = pos; rigidbody.rotation = rot; } v.transform.SetPositionAndRotation(pos, rot); SetValue(v, "syncedPosition", pos); SetValue(v, "syncedRotation", rot); } public static string Describe(Component v) { //IL_00bb: Unknown result type (might be due to invalid IL or missing references) //IL_00c0: Unknown result type (might be due to invalid IL or missing references) NetworkBehaviour val = (NetworkBehaviour)(object)((v is NetworkBehaviour) ? v : null); Rigidbody rigidbody = GetRigidbody(v); return "owner=" + ((Object)(object)val != (Object)null && val.IsOwner) + " ownerId=" + (((Object)(object)val != (Object)null) ? val.OwnerClientId.ToString() : "?") + " kinematic=" + (((Object)(object)rigidbody != (Object)null) ? rigidbody.isKinematic.ToString() : "?") + " magnetedToShip=" + GetBool(v, "magnetedToShip") + " pos=" + ((object)v.transform.position/*cast due to .constrained prefix*/).ToString(); } private static string PathOf(Transform t) { StringBuilder stringBuilder = new StringBuilder(((Object)t).name); Transform parent = t.parent; while ((Object)(object)parent != (Object)null) { stringBuilder.Insert(0, ((Object)parent).name + "/"); parent = parent.parent; } return stringBuilder.ToString(); } private static Component FindMagnetLever(Component v, bool force) { if ((Object)(object)magnetLever != (Object)null) { return magnetLever; } if (!force && Time.unscaledTime < nextLeverSearch) { return null; } nextLeverSearch = Time.unscaledTime + 3f; Component val = FindFirst("StartOfRound"); if ((Object)(object)val != (Object)null) { object value = GetValue(val, "magnetLever"); magnetLever = (Component)((value is Component) ? value : null); if ((Object)(object)magnetLever == (Object)null) { FieldInfo[] fields = ((object)val).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (FieldInfo fieldInfo in fields) { if (fieldInfo.Name.ToLowerInvariant().Contains("magnet") && typeof(Component).IsAssignableFrom(fieldInfo.FieldType)) { object? value2 = fieldInfo.GetValue(val); Component val2 = (Component)((value2 is Component) ? value2 : null); if ((Object)(object)val2 != (Object)null) { magnetLever = val2; break; } } } } } if ((Object)(object)magnetLever == (Object)null && (Object)(object)v != (Object)null) { object value3 = GetValue(v, "magnetLever"); magnetLever = (Component)((value3 is Component) ? value3 : null); } if ((Object)(object)magnetLever == (Object)null) { string[] array = new string[2] { "AnimatedObjectTrigger", "InteractTrigger" }; for (int i = 0; i < array.Length; i++) { Type type = FindType(array[i]); if (type == null) { continue; } Object[] array2 = Object.FindObjectsOfType(type); foreach (Object obj in array2) { Component val3 = (Component)(object)((obj is Component) ? obj : null); if ((Object)(object)val3 != (Object)null && PathOf(val3.transform).ToLowerInvariant().Contains("magnet")) { magnetLever = val3; break; } } if ((Object)(object)magnetLever != (Object)null) { break; } } } if ((Object)(object)magnetLever != (Object)null) { Plugin.Log.LogInfo((object)("Magnet lever: " + ((object)magnetLever).GetType().Name + " at " + PathOf(magnetLever.transform))); } else if (!listedCandidates && Plugin.Verbose.Value) { listedCandidates = true; StringBuilder stringBuilder = new StringBuilder("Magnet lever NOT found. StartOfRound found: " + ((Object)(object)val != (Object)null) + ". Triggers in scene:\n"); Type type2 = FindType("AnimatedObjectTrigger"); if (type2 != null) { Object[] array2 = Object.FindObjectsOfType(type2); foreach (Object obj2 in array2) { Component val4 = (Component)(object)((obj2 is Component) ? obj2 : null); if ((Object)(object)val4 != (Object)null) { stringBuilder.AppendLine(" " + PathOf(val4.transform)); } } } Plugin.Log.LogWarning((object)stringBuilder.ToString()); } return magnetLever; } public static bool ToggleMagnet(Component v, out string result) { Component val = LocalPlayer(); if ((Object)(object)val == (Object)null) { result = "no local player"; return false; } Component val2 = FindMagnetLever(v, force: true); if ((Object)(object)val2 == (Object)null) { result = "magnet lever not found"; return false; } MethodInfo[] methods = ((object)val2).GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (MethodInfo methodInfo in methods) { if (!(methodInfo.Name != "TriggerAnimation")) { ParameterInfo[] parameters = methodInfo.GetParameters(); if (parameters.Length == 1 && parameters[0].ParameterType.IsInstanceOfType(val)) { methodInfo.Invoke(val2, new object[1] { val }); result = "magnet toggled"; return true; } } } Type type = FindType("InteractTrigger"); if (type != null) { Component val3 = val2.GetComponent(type); if ((Object)(object)val3 == (Object)null) { val3 = val2.GetComponentInParent(type); } if ((Object)(object)val3 == (Object)null) { val3 = val2.GetComponentInChildren(type); } object value = GetValue(val3, "onInteract"); if (value != null) { methods = value.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public); foreach (MethodInfo methodInfo2 in methods) { if (!(methodInfo2.Name != "Invoke")) { ParameterInfo[] parameters2 = methodInfo2.GetParameters(); if (parameters2.Length == 1 && parameters2[0].ParameterType.IsInstanceOfType(val)) { methodInfo2.Invoke(value, new object[1] { val }); result = "magnet toggled"; return true; } } } } } result = "magnet: no usable method"; return false; } private static void Dump(Component v) { try { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.AppendLine("VehicleController найден. Поля, важные для мода:"); Type type = ((object)v).GetType(); while (type != null && type != typeof(MonoBehaviour)) { FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (FieldInfo fieldInfo in fields) { string text = fieldInfo.Name.ToLowerInvariant(); if (text.Contains("magnet") || text.Contains("synced") || text.Contains("rigidbody") || text.Contains("driver")) { stringBuilder.AppendLine(" " + fieldInfo.FieldType.Name + " " + fieldInfo.Name); } } type = type.BaseType; } object value = GetValue(v, "magnetLever"); if (value != null) { stringBuilder.AppendLine("magnetLever: " + value.GetType().Name + ", методы:"); MethodInfo[] methods = value.GetType().GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (MethodInfo methodInfo in methods) { stringBuilder.AppendLine(" " + methodInfo.Name); } } else { stringBuilder.AppendLine("поле magnetLever НЕ найдено"); } if (GetValue(v, "mainRigidbody") == null) { stringBuilder.AppendLine("поле mainRigidbody не найдено, используется GetComponent<Rigidbody>()"); } Plugin.Log.LogInfo((object)stringBuilder.ToString()); } catch (Exception ex) { Plugin.Log.LogWarning((object)("Dump failed: " + ex.Message)); } } } internal sealed class GifWriter { public const int Tolerance = 6; private readonly Stream o; private readonly int W; private readonly int H; private readonly byte[] canvas; private readonly byte[] changed; private bool first = true; public long Bytes; private readonly int[] hCount = new int[32768]; private readonly int[] hR = new int[32768]; private readonly int[] hG = new int[32768]; private readonly int[] hB = new int[32768]; private readonly int[] lut = new int[32768]; private readonly int[] keys = new int[32768]; private readonly int[] order = new int[32768]; private readonly int[] tmpKey = new int[32768]; private readonly int[] boxLo = new int[256]; private readonly int[] boxHi = new int[256]; private readonly byte[] pal = new byte[768]; private readonly int[] hashKey = new int[5003]; private readonly int[] hashVal = new int[5003]; private const int HashSize = 5003; private const int ClearCode = 256; private const int EofCode = 257; private const int MaxMaxCode = 4096; private int nBits; private int maxCode; private int freeEnt; private bool clearFlag; private uint curAcc; private int curBits; private readonly byte[] blk = new byte[255]; private int blkLen; public GifWriter(Stream output, int width, int height) { o = output; W = width; H = height; canvas = new byte[W * H * 3]; changed = new byte[W * H]; byte[] obj = new byte[13] { 71, 73, 70, 56, 57, 97, 0, 0, 0, 0, 112, 0, 0 }; obj[6] = (byte)(W & 0xFF); obj[7] = (byte)(W >> 8); obj[8] = (byte)(H & 0xFF); obj[9] = (byte)(H >> 8); byte[] array = obj; Write(array, array.Length); byte[] array2 = new byte[19] { 33, 255, 11, 78, 69, 84, 83, 67, 65, 80, 69, 50, 46, 48, 3, 1, 0, 0, 0 }; Write(array2, array2.Length); } private void Write(byte[] b, int n) { o.Write(b, 0, n); Bytes += n; } private void WriteByte(int b) { o.WriteByte((byte)b); Bytes++; } public void AddFrame(byte[] rgb, int delayCs) { int num = W; int num2 = H; int num3 = -1; int num4 = -1; if (first) { for (int i = 0; i < changed.Length; i++) { changed[i] = 1; } num = 0; num2 = 0; num3 = W - 1; num4 = H - 1; } else { for (int j = 0; j < H; j++) { int num5 = j * W; for (int k = 0; k < W; k++) { int num6 = (num5 + k) * 3; int num7 = rgb[num6] - canvas[num6]; if (num7 < 0) { num7 = -num7; } int num8 = rgb[num6 + 1] - canvas[num6 + 1]; if (num8 < 0) { num8 = -num8; } int num9 = rgb[num6 + 2] - canvas[num6 + 2]; if (num9 < 0) { num9 = -num9; } if (num7 > 6 || num8 > 6 || num9 > 6) { changed[num5 + k] = 1; if (k < num) { num = k; } if (k > num3) { num3 = k; } if (j < num2) { num2 = j; } if (j > num4) { num4 = j; } } else { changed[num5 + k] = 0; } } } } if (num3 < 0) { WriteGce(delayCs, transparent: true); WriteImageHeader(0, 0, 1, 1); for (int l = 0; l < 768; l++) { pal[l] = 0; } Write(pal, 768); WriteLzw(new byte[1] { 255 }, 1); return; } Array.Clear(hCount, 0, hCount.Length); Array.Clear(hR, 0, hR.Length); Array.Clear(hG, 0, hG.Length); Array.Clear(hB, 0, hB.Length); int distinct = 0; for (int m = num2; m <= num4; m++) { int num10 = m * W; for (int n = num; n <= num3; n++) { if (changed[num10 + n] != 0) { int num11 = (num10 + n) * 3; int num12 = (rgb[num11] >> 3 << 10) | (rgb[num11 + 1] >> 3 << 5) | (rgb[num11 + 2] >> 3); if (hCount[num12] == 0) { keys[distinct++] = num12; } hCount[num12]++; hR[num12] += rgb[num11]; hG[num12] += rgb[num11 + 1]; hB[num12] += rgb[num11 + 2]; } } } int target = (first ? 256 : 255); int num13 = MedianCut(distinct, target); for (int num14 = 0; num14 < num13; num14++) { long num15 = 0L; long num16 = 0L; long num17 = 0L; long num18 = 0L; for (int num19 = boxLo[num14]; num19 < boxHi[num14]; num19++) { int num20 = keys[order[num19]]; num15 += hCount[num20]; num16 += hR[num20]; num17 += hG[num20]; num18 += hB[num20]; lut[num20] = num14; } if (num15 < 1) { num15 = 1L; } pal[num14 * 3] = (byte)(num16 / num15); pal[num14 * 3 + 1] = (byte)(num17 / num15); pal[num14 * 3 + 2] = (byte)(num18 / num15); } for (int num21 = num13; num21 < 256; num21++) { pal[num21 * 3] = 0; pal[num21 * 3 + 1] = 0; pal[num21 * 3 + 2] = 0; } int num22 = num3 - num + 1; int num23 = num4 - num2 + 1; byte[] array = new byte[num22 * num23]; for (int num24 = 0; num24 < num23; num24++) { int num25 = num2 + num24; for (int num26 = 0; num26 < num22; num26++) { int num27 = num + num26; if (changed[num25 * W + num27] == 0) { array[num24 * num22 + num26] = byte.MaxValue; continue; } int num28 = (num25 * W + num27) * 3; int num29 = (rgb[num28] >> 3 << 10) | (rgb[num28 + 1] >> 3 << 5) | (rgb[num28 + 2] >> 3); int num30 = lut[num29]; array[num24 * num22 + num26] = (byte)num30; canvas[num28] = pal[num30 * 3]; canvas[num28 + 1] = pal[num30 * 3 + 1]; canvas[num28 + 2] = pal[num30 * 3 + 2]; } } WriteGce(delayCs, !first); WriteImageHeader(num, num2, num22, num23); Write(pal, 768); WriteLzw(array, num22 * num23); first = false; } public void Finish() { WriteByte(59); o.Flush(); } private void WriteGce(int delayCs, bool transparent) { if (delayCs < 1) { delayCs = 1; } if (delayCs > 65535) { delayCs = 65535; } byte[] obj = new byte[8] { 33, 249, 4, 0, 0, 0, 0, 0 }; obj[3] = (byte)(4u | (transparent ? 1u : 0u)); obj[4] = (byte)(delayCs & 0xFF); obj[5] = (byte)(delayCs >> 8); obj[6] = (byte)(transparent ? 255u : 0u); byte[] array = obj; Write(array, array.Length); } private void WriteImageHeader(int x, int y, int w, int h) { byte[] array = new byte[10] { 44, (byte)(x & 0xFF), (byte)(x >> 8), (byte)(y & 0xFF), (byte)(y >> 8), (byte)(w & 0xFF), (byte)(w >> 8), (byte)(h & 0xFF), (byte)(h >> 8), 135 }; Write(array, array.Length); } private int MedianCut(int distinct, int target) { for (int i = 0; i < distinct; i++) { order[i] = i; } int j = 1; boxLo[0] = 0; boxHi[0] = distinct; for (; j < target; j++) { int num = -1; int num2 = 0; long num3 = -1L; for (int k = 0; k < j; k++) { if (boxHi[k] - boxLo[k] < 2) { continue; } int num4 = 31; int num5 = 31; int num6 = 31; int num7 = 0; int num8 = 0; int num9 = 0; long num10 = 0L; for (int l = boxLo[k]; l < boxHi[k]; l++) { int num11 = keys[order[l]]; int num12 = (num11 >> 10) & 0x1F; int num13 = (num11 >> 5) & 0x1F; int num14 = num11 & 0x1F; if (num12 < num4) { num4 = num12; } if (num12 > num7) { num7 = num12; } if (num13 < num5) { num5 = num13; } if (num13 > num8) { num8 = num13; } if (num14 < num6) { num6 = num14; } if (num14 > num9) { num9 = num14; } num10 += hCount[num11]; } int num15 = num7 - num4; int num16 = num8 - num5; int num17 = num9 - num6; int num18 = num15; int num19 = 0; if (num16 > num18) { num18 = num16; num19 = 1; } if (num17 > num18) { num18 = num17; num19 = 2; } if (num18 != 0) { long num20 = num10 * num18; if (num20 > num3) { num3 = num20; num = k; num2 = num19; } } } if (num < 0) { break; } int num21 = boxLo[num]; int num22 = boxHi[num]; int num23 = num2 switch { 1 => 5, 0 => 10, _ => 0, }; for (int m = num21; m < num22; m++) { tmpKey[m] = (keys[order[m]] >> num23) & 0x1F; } Array.Sort(tmpKey, order, num21, num22 - num21); long num24 = 0L; for (int n = num21; n < num22; n++) { num24 += hCount[keys[order[n]]]; } long num25 = 0L; int num26 = num21 + 1; for (int num27 = num21; num27 < num22; num27++) { num25 += hCount[keys[order[num27]]]; if (num25 * 2 >= num24) { num26 = num27 + 1; break; } } if (num26 <= num21) { num26 = num21 + 1; } if (num26 >= num22) { num26 = num22 - 1; } boxHi[num] = num26; boxLo[j] = num26; boxHi[j] = num22; } return j; } private void WriteLzw(byte[] pix, int n) { WriteByte(8); nBits = 9; maxCode = 511; freeEnt = 258; clearFlag = false; curAcc = 0u; curBits = 0; blkLen = 0; for (int i = 0; i < 5003; i++) { hashKey[i] = -1; } Emit(256); int num = pix[0]; for (int j = 1; j < n; j++) { int num2 = pix[j]; int num3 = (num << 8) | num2; int num4 = (int)((uint)(num3 * -1640531535) % 5003u); bool flag = false; while (hashKey[num4] != -1) { if (hashKey[num4] == num3) { flag = true; break; } num4++; if (num4 == 5003) { num4 = 0; } } if (flag) { num = hashVal[num4]; continue; } Emit(num); if (freeEnt < 4096) { hashKey[num4] = num3; hashVal[num4] = freeEnt++; } else { for (int k = 0; k < 5003; k++) { hashKey[k] = -1; } freeEnt = 258; clearFlag = true; Emit(256); } num = num2; } Emit(num); Emit(257); if (curBits > 0) { AddByte((byte)(curAcc & 0xFF)); } FlushBlock(); WriteByte(0); } private void Emit(int code) { curAcc |= (uint)(code << curBits); curBits += nBits; while (curBits >= 8) { AddByte((byte)(curAcc & 0xFF)); curAcc >>= 8; curBits -= 8; } if (freeEnt > maxCode || clearFlag) { if (clearFlag) { nBits = 9; maxCode = 511; clearFlag = false; } else { nBits++; maxCode = ((nBits == 12) ? 4096 : ((1 << nBits) - 1)); } } } private void AddByte(byte b) { blk[blkLen++] = b; if (blkLen == 255) { FlushBlock(); } } private void FlushBlock() { if (blkLen != 0) { WriteByte(blkLen); o.Write(blk, 0, blkLen); Bytes += blkLen; blkLen = 0; } } } internal static class GothicData { public const string Corner = "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"; public const string Star = "iVBORw0KGgoAAAANSUhEUgAAAQQAAABUCAYAAABk8UlJAAANq0lEQVR42u2deaxcVR3HP/Nm3ist3R9La60YCqUCUloW4bG0sYooIYoUMUYUENEEBKK4VAyLQpCAxiUBU1INrogGIUFFI5Yim22lRYIgqAjIY6kFWtrSt8yMf/y+h3u4zmtnXufOTLm/bzKZO3e2e8/5ne9vPecUqtUqDofDAdDlTeCQHBS9GRwlbwInA6BS49jhFoIjhwqhAiwEztaxKwm3EBw5VQbDwGHALcAk4L/AzXIfyt5EbiE48tPvVWARcLvIYBi4XucqLhtOCI78oCBCmAVMjc5N1bmqXjvyJhiedsw9KRwH/ATYDTgLWIYHF50QHLlENzAEnAEcJUII5xzuMjhyhioWQJwB7KVjtwycEBw5RhnoBfbUsZuMTgiOnCJYA/thAcUxeEDRCcGRe0yQ21B0C8EJwZFPhCzDeOCtWB3CW6L3HE4IjpwhBBXHYVWr05wQnBAc+bUQAGbLZQCY4s3ihODINyGMx2oPAN7uFoITgiPfhDA3OjclciUcTgiOHCJ2E+Y5ITghOPKJSspNKMtqcHfBCcGRY+wJvAQ8AhwKTBRZODE4IThyFD+oYunGA4H7gdv0eriDr7ngVowTgiMbhBLlicAr2GpJYGlIOmjQFbAaiWrqAVZD4TLcRPgSavm2EGbreRXwqN6b0EGEEJZyG8ZSo5MjIltHssxbmKXpwVAnhI4ecJ18fWA1CAVgM/CEzs0F7mozIXTp/8vYHItLsQxInBF5HtgILAHW7CTt7i5DjlCMCLaaet2phHCwnh8EXtR1T+2Aa6uIDM4EVgNbgY8AR+rRB5wH3APcCnxHro/P1HQLoWPIIF6leKK0V6drraBxh4DndK37RKTWDgVVBeYA3wCmA6cAd9f47PMii2XAVSKGDwHr23j9biE4XiODE4AbgAeAlcAdwDmR1uokzRVqEA7R9f0dWwthI7B3mwZUaJ9uLOMxDMwXGZRIgovx53uAfuA0WRHX4CtGOyF0ABlcKI32BHCByOFW4GTgRg2uTmzrXmBQxwPAw9gU6HYslBIWdn0PsAV4v/6/KHIokKREd9fzoEiiBHxCBDKTpMjK4YTQ0rYrAx8HPo0tUnopFpD7p/zad2JR+4v02WINQmn1nopxDcL+wENY2hFp2TeTpPlaifB/lwGXpwg3kMXHsGzIPbJqzozIol/30eey7YRAmwbVTA32Y+W7jpHJG8zZAvBZbFXjcfz/AqZl2rNDUtD+UzSQwj2t1HsTU2Z8q6yDeTr+NcnOUiGleBpwJfBFke/5ih+cqhhIAcs2HNHia3dCcLwW/OrD8uH90qoDkXAO63PPkhQAhYEY0mrnSrBb2Rddeuyn1/eTFPu8oOvaN7rGVsrhV4B/YWnQroi8uoEvAZ+UK7YO+C3wQSxD4nLshNB2CwFpo7UkqbI5wEk6Dqmzo2WKr4+IJDwvBE5soUYrRNo4uCoTRA4HYJF7gF2iz7TiuoLldCewPGrP8Nyra7qbpDqxC/iVXIjQngeL4MCzDKOCpx2bK9RzsSDi+7CUWB9wrbTbUDQIK8CuWIrv9BYJcHBzhnRdF+j8rrreLmxvBoDPA5uAe1PfzZoQvlsjplDAsh9VLA35GMlmMt267gHgTViw8d6ISBxOCC3zwYO5fX5k1v5cA+zbkaAvAX5EEoQsyZ04Qe+vJfut08KA7gV+AfyGJF9/LRagA9v09VzgKawA6HKsDmA9ramnKEaxldiK3QL8APim2i1kRsIOU71YMPdrwNP4VnTuMrTBGkDaaIK0U1WD/fsywY+SC/HDlJlejvzlS1rgLoQaiGkisBVYvj6k7vpFZt2RmT4DS6Ou0Hem0ZpailpB1pCduQLLIvwRq1KchQVzL8WyDt/D6kB896kdERbf27EmQdYjUGFw3wDsAbxX53ukuaqRFRaEOuTRb5XPvr/OVTPUvoGMbheBfVWD/y4R10wsiAcwVj75OrkVg8DFOj6+jZq3EFlm52DBxBmyHB4CbsIyE0Uay9o00t9OCNvpmCy0WKXNZFBp4D7DNfdKIP+DpcT6t/Gdo7H6hGeBz8lUz+K+Q/AwDJDDgXeLDALWA49jgdGZsgJWAfdhwblx0f1fJM3854jg2jG7MHZb4vJwRkkGlYzlut3y3/B9lUbZgM3UFIVIQ7ZLAwW//gIsMHgGSdpte425DviA/O2VwPXy0Z+OOmMy8BlgsQbXsuh/qzSvOCkIVSVlfi8GfollNA6Vxp8q8hqLlQrPFhGsFUncKYJYofs6WWQxmJKJrgwHU6XG/YU225h63Uh1YklWXLq/aSPJNVv+RzVea1kIxW34d+N0vGUUQlwY4aIH5YNPw+YB9IyiUSo72HDDWI57qc4tBT41it86ECuemYQtTRbwku7tMpLUXpaYiNUSHAEchgUGx6T67EFZKx+W9QAWTPwpsEjfi7EZm5/xe333Yd3Xzopa/V2vEtiepm9E9uqV/0avqd7x+jpLrxGXYREW6UWMekeTOmYylnveT0Gi1W0UjqBVe6Tpl6ixtmceh5r7jdI849XBgfU3YEU/47F8+u7R+zsaqAvfn4RNVjpSg3lC9JkwT2G5YgcPAS/LMugjKaLq0nWeiKX3FgDHYPUSB+jaA15VXz0ggniyyRp2k1yaWgN0tP8RAo6nYkHIdH+f3QbZy0r+RzVe04TQo+BYT0pYx0ibTIk03nkStHpNor30qKZ8pgXAQfrsi8CPqW9b8kJkjh/UQENtTf12UYOimjK7uySUjVobYWGPYFoP6j96InN+IsnmKFngWQUQl0v77KKYRcB0kcF8kUEp0ipF9cNJIo+AL2B1E6uwORqHyArJEutrnOtmx7JjVZFl3N/hvteoz2MSGlPH/wWZflKPeqyMYMa/KyX/N/L6peIKIu+/NnCP9YzX8NsrSCpUq6XU4Cqqo8emBm56sY+SPldugK1LNQId3ZFQleXXLmowOFRh+wuDhvsrKcBWTHVM+J1ijYYdaPBaSAlSOxYceR5bRXml+mmv1Pt7YBmOtCvXFfXDvilC2ChLZ43en4FNhBqb4X301jg31GCfjOQSx/0d2mBeDdn7B5bu3NYgD9/fexQk+baU/E8WMRRSLuDhDViM9YzXML4fiAmhE1yGQ/Rbk4CzooBbVhgfEV3Q6FfJbRiOGnAVtuDGBhpPC8YEtH8Noml2Pr9bAjNfAjanhqa9G6spWK3A4XTgDyKHSoqoz8CKrPqiOMT8GsTSL1dkJfAXabJmFjDV+p16BuhIfRLI/+sj9PfiGv39SsbymJX8N8VlgJEzD8OpIEUzqhxDUGUhFuVeqt/NMtMw0m8vlZAgAT9+Jw2aFWXaz5awHaOBvUvqc8tFDqdiayAE7XGnfmNBylQewgqAVmjwP4ZlUrbspEHFevs7y4KsENCO5b+7SYRa73gtjzaomFXaMavf3V4QLt3hZazEeK6COy/TnKq3VlWDBo1Zy926BpsdOF1m8aG6x59h5b73yyw9RURwLvAnac010pLHpuIQ8f110bp03Y4WcTXa31nfV0eNqywKk4qjvPgCrVkboLCNcwWx6gaSUt5Wo9wkgY9XG3qHAoFXRJ/ZjGUHjpR5ORu4Dqs1mIvNyQjXsUSWQ1yYVKU5FZbtmE/TSH+3guh2RP4rdcQ26r4HL11+4yNU8MWlyz2KKewjdyFkU3oUX9iq2EEoXT4KW9qsSHsWdHG0CM1m525pm+4Ovd9urHw4+GmFbZjerUYVy0xcR3NnQIYU6ulyAwpYgdR6LFjYRbLK0xgsKPk7kcElwEcVh8iiOnUyVuHZTq00Un8H+VhNEvXvJO0Zru8+bNetplyfz3Zsj4nY6vupYsusH6EYwYXY3IsqVlE5JAIIQvWM4gUL9J3nyHYClvd3h8Bdhhz1dST8fcCXsbUFvoVNXCpgWYmLsXTkJbRugRTHG9RlCD5rpw+MTkY5o8EXTMySBvqVIoQJJJWUL+qzV+sz6ancO4sM5smCaOqs01JGAu3oXOEOMYUgRI8Ct+g4LPg6QFK1mPWAGPZu6Rx4DCF/CPMp/qbBvoBkf4ipOteP76bsLoMjVxjSY0pk1c2TW/HMTmIuO9xCcDTBbQgLl67F5lqEqdK7Y9kH3wrNCcGRQ2LYJAuhgtUizMTmJwzgmQUnBEfu+v0+Dfq95T7MwIpcHE4IjhwiTCMeh00Lr2LzG1w2cgoPKubXXYBkua45JCsFveDN4xaCI58IaxlM1gMs0IjHD9xCcOQHYZLSI3qeGykHLyxzC8GRUwyJAHpJ1kZ8OEUaDrcQHDmIIYRahDXYBi2hQMldBScER46J4SVsluNuih9swXdPdpfBkdu+X0WSetyITzZyoXDkGlsiayHUIHjZshOCI4fuQrAQAglscEJwQnDkG69G5PDvFFk4nBAcOUFci/Cyjp/wZnFCcOQbgyKHQZKt6t1CcEJw5AyhFuEVbFu2EvCUE4ITgsOJYYBkU1MPKOYYXpjkCqGClStPxYuSXCC8CVwGsHTjVpcHhwtAvlGQNfAU8LiOi94sORYI37kp9+7CYcBt2AKri4Gb8U1d3UJw5K7fq9jGvLcDe+j19TpXcdlwQnDky1WoArNINmcp63gWI++M7XCXwfEGJ4XjgJuAScBZwDI80+CE4MglSth054XAbGBpdM7hhODIIeIAolsGTghOCA665EJ4ZsFNRofDrQKH4X/19sDRDTrNXwAAAABJRU5ErkJggg=="; public const string Blade = "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"; public const string Ink = "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