using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("1.11.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace CodyGunCards.Presentation
{
	public static class Visuals
	{
		private struct Pt
		{
			public float x;

			public float y;

			public Pt(float a, float b)
			{
				x = a;
				y = b;
			}

			public static Pt operator +(Pt a, Pt b)
			{
				return new Pt(a.x + b.x, a.y + b.y);
			}

			public static Pt operator -(Pt a, Pt b)
			{
				return new Pt(a.x - b.x, a.y - b.y);
			}

			public static Pt operator *(Pt a, float s)
			{
				return new Pt(a.x * s, a.y * s);
			}
		}

		private class Part
		{
			public object sr;

			public object tr;

			public int frame;
		}

		private class Hit
		{
			public float until;

			public int streak;

			public int dir;
		}

		private class ObjFx
		{
			public int pid;

			public int id;

			public float until;
		}

		private class Flash
		{
			public Pt at;

			public float start;

			public int color;

			public bool portal;
		}

		private class Bolt
		{
			public object go;

			public float until;

			public bool pie;

			public Pt last;
		}

		private const BindingFlags BF = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private static Dictionary<string, Type> types = new Dictionary<string, Type>();

		private static Dictionary<string, MemberInfo> members = new Dictionary<string, MemberInfo>();

		private static Dictionary<string, MethodInfo> methods = new Dictionary<string, MethodInfo>();

		private static object White = null;

		private static Dictionary<string, Part> parts = new Dictionary<string, Part>();

		private static int frame;

		private static float nextTick;

		private static HashSet<string> warned = new HashSet<string>();

		private static float epoch;

		private static bool battling;

		private static float musicScan;

		private static object music;

		private static object clip;

		private static Dictionary<object, bool> muted = new Dictionary<object, bool>();

		private static bool doorWindow;

		private static bool doorBattleSeen;

		private static Dictionary<int, Hit> hits = new Dictionary<int, Hit>();

		private static Dictionary<long, ObjFx> objects = new Dictionary<long, ObjFx>();

		private static List<Flash> flashes = new List<Flash>();

		private static List<Bolt> bolts = new List<Bolt>();

		private static object ottoClip;

		private static object ottoSource;

		private static bool ottoLoaded;

		private static readonly Dictionary<object, float> reloads = new Dictionary<object, float>();

		private static readonly Dictionary<object, bool> reloadKeys = new Dictionary<object, bool>();

		private static object reloadPermit;

		private static bool ammoInstalled;

		private static bool rideWasPlaying;

		private static float Time => F(G(T("UnityEngine.Time"), "time"));

		private static Type T(string n)
		{
			if (types.TryGetValue(n, out var value))
			{
				return value;
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				if ((value = assemblies[i].GetType(n)) != null)
				{
					return types[n] = value;
				}
			}
			throw new TypeLoadException(n);
		}

		private static Type X(string n)
		{
			return T("CodyGunCards.Extras." + n);
		}

		private static Type R(string n)
		{
			return T("CodyGunCards.Runtime." + n);
		}

		private static MemberInfo Member(object o, string n)
		{
			Type type = (o as Type) ?? o.GetType();
			string text = type.FullName + "/" + n;
			if (members.TryGetValue(text, out var value))
			{
				return value;
			}
			while (type != null)
			{
				value = (MemberInfo)(((object)type.GetField(n, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)) ?? ((object)type.GetProperty(n, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)));
				if (value != null)
				{
					return members[text] = value;
				}
				type = type.BaseType;
			}
			throw new MissingMemberException(text);
		}

		private static object G(object o, string n)
		{
			if (o == null)
			{
				return null;
			}
			MemberInfo memberInfo = Member(o, n);
			if (!(memberInfo is FieldInfo))
			{
				return ((PropertyInfo)memberInfo).GetValue((o is Type) ? null : o, null);
			}
			return ((FieldInfo)memberInfo).GetValue((o is Type) ? null : o);
		}

		private static void S(object o, string n, object v)
		{
			MemberInfo memberInfo = Member(o, n);
			if (memberInfo is FieldInfo)
			{
				((FieldInfo)memberInfo).SetValue((o is Type) ? null : o, v);
			}
			else
			{
				((PropertyInfo)memberInfo).SetValue((o is Type) ? null : o, v, null);
			}
		}

		private static object C(object o, string n, params object[] a)
		{
			Type type = (o as Type) ?? o.GetType();
			string text = type.FullName + "/" + n + "/" + string.Join(",", a.Select((object x) => (x != null) ? x.GetType().FullName : "null").ToArray());
			if (!methods.TryGetValue(text, out var value))
			{
				Type type2 = type;
				while (type2 != null && value == null)
				{
					MethodInfo[] array = type2.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (MethodInfo methodInfo in array)
					{
						if (!(methodInfo.Name != n) && !methodInfo.ContainsGenericParameters)
						{
							ParameterInfo[] parameters = methodInfo.GetParameters();
							if (parameters.Length == a.Length && !parameters.Where((ParameterInfo v, int i) => a[i] != null && !v.ParameterType.IsInstanceOfType(a[i])).Any())
							{
								value = methodInfo;
								break;
							}
						}
					}
					type2 = type2.BaseType;
				}
				if (value == null)
				{
					throw new MissingMethodException(text);
				}
				methods[text] = value;
			}
			return value.Invoke((o is Type) ? null : o, a);
		}

		private static float F(object v)
		{
			if (v != null)
			{
				return Convert.ToSingle(v);
			}
			return 0f;
		}

		private static int I(object v)
		{
			if (v != null)
			{
				return Convert.ToInt32(v);
			}
			return 0;
		}

		private static bool B(object v)
		{
			if (v is bool)
			{
				return (bool)v;
			}
			return false;
		}

		private static IEnumerable<object> Each(object o)
		{
			if (o != null)
			{
				return ((IEnumerable)o).Cast<object>();
			}
			return Enumerable.Empty<object>();
		}

		private static bool Live(object o)
		{
			if (o != null)
			{
				return B(C(T("UnityEngine.Object"), "op_Implicit", o));
			}
			return false;
		}

		private static object V2(float x, float y)
		{
			return Activator.CreateInstance(T("UnityEngine.Vector2"), x, y);
		}

		private static object V3(float x, float y, float z = 0f)
		{
			return Activator.CreateInstance(T("UnityEngine.Vector3"), x, y, z);
		}

		private static object Col(float r, float g, float b, float a = 1f)
		{
			return Activator.CreateInstance(T("UnityEngine.Color"), r, g, b, a);
		}

		private static float Sin(float x)
		{
			return (float)Math.Sin(x);
		}

		private static float Cos(float x)
		{
			return (float)Math.Cos(x);
		}

		private static float Clamp(float x, float a = 0f, float b = 1f)
		{
			return Math.Max(a, Math.Min(b, x));
		}

		private static object Color(int i, float a = 1f)
		{
			return (i % 4) switch
			{
				0 => Col(1f, 0.27f, 0.66f, a), 
				1 => Col(0.24f, 0.93f, 1f, a), 
				2 => Col(1f, 0.81f, 0.24f, a), 
				_ => Col(0.62f, 0.38f, 1f, a), 
			};
		}

		private static Pt Pos(object o)
		{
			object o2 = G(G(o, "transform"), "position");
			return new Pt(F(G(o2, "x")), F(G(o2, "y")));
		}

		private static Pt P(object v)
		{
			return new Pt(F(G(v, "x")), F(G(v, "y")));
		}

		private static void Safe(string n, Action f)
		{
			try
			{
				f();
			}
			catch (Exception ex)
			{
				if (warned.Add(n))
				{
					C(T("CodyGunCards.Plugin"), "Warn", "Presentation " + n + ": " + (ex.InnerException ?? ex).Message);
				}
			}
		}

		private static object Shape(string key, string shape, Pt at, float w, float h, object color, int z = 15, float angle = 0f)
		{
			if (!parts.TryGetValue(key, out var value) || !Live(value.sr))
			{
				value = new Part();
				value.sr = C(R("Fx"), "MakeSprite", "CGC_VFX_" + key, G(R("Fx"), shape), color, z);
				value.tr = G(value.sr, "transform");
				parts[key] = value;
			}
			value.frame = frame;
			S(value.sr, "enabled", true);
			S(value.sr, "color", color);
			S(value.tr, "position", V3(at.x, at.y));
			S(value.tr, "localScale", V3(w, h, 1f));
			S(value.tr, "rotation", C(T("UnityEngine.Quaternion"), "Euler", 0f, 0f, angle));
			return value.sr;
		}

		private static void Dot(string k, Pt p, float s, object c, int z = 15)
		{
			Shape(k, "Disc", p, s, s, c, z);
		}

		private static void Line(string k, Pt a, Pt b, float w, object c, int z = 15)
		{
			Pt pt = b - a;
			Shape(k, "Pixel", (a + b) * 0.5f, (float)Math.Sqrt(pt.x * pt.x + pt.y * pt.y), w, c, z, (float)(Math.Atan2(pt.y, pt.x) * 180.0 / Math.PI));
		}

		private static void Ring(string k, Pt p, float s, object c, int z = 14)
		{
			Shape(k, "Ring", p, s, s, c, z);
		}

		private static void Star(string k, Pt p, float s, object c, int z = 18)
		{
			Line(k + "x", p + new Pt(0f - s, 0f), p + new Pt(s, 0f), s * 0.24f, c, z);
			Line(k + "y", p + new Pt(0f, 0f - s), p + new Pt(0f, s), s * 0.24f, c, z);
		}

		private static void Arc(string k, Pt p, float r, float from, float length, object c, float width = 0.045f, int count = 12)
		{
			for (int i = 0; i < count; i++)
			{
				float x = from + length * (float)i / (float)count;
				float x2 = from + length * (float)(i + 1) / (float)count;
				Line(k + i, p + new Pt(Cos(x), Sin(x)) * r, p + new Pt(Cos(x2), Sin(x2)) * r, width, c);
			}
		}

		private static void Eyes(string k, Pt p, float s, float face = 1f)
		{
			for (int i = 0; i < 2; i++)
			{
				Pt pt = p + new Pt(((i == 0) ? (-0.16f) : 0.16f) * s, 0.08f * s);
				Dot(k + "w" + i, pt, 0.23f * s, Col(1f, 1f, 0.96f), 24);
				Dot(k + "p" + i, pt + new Pt(0.04f * face * s, 0f), 0.1f * s, Col(0.07f, 0.055f, 0.1f), 25);
			}
		}

		private static void HideOld(string p)
		{
			C(X("Pen"), "Off", p);
		}

		private static object State(string type, string field, int id)
		{
			if (!(G(X(type), field) is IDictionary dictionary) || !dictionary.Contains(id))
			{
				return null;
			}
			return dictionary[id];
		}

		private static bool Has(object p, long flag)
		{
			return B(C(R("Loadout"), "Has", p, Enum.ToObject(T("CodyGunCards.Core.Weapon"), flag)));
		}

		public static void Prepare()
		{
			Safe("audio preload", delegate
			{
				if (clip != null)
				{
					return;
				}
				using Stream stream = typeof(Visuals).Assembly.GetManifestResourceStream("CodyGunCards.Presentation.NeonSteps.pcm");
				if (stream == null)
				{
					throw new FileNotFoundException("NeonSteps.pcm");
				}
				BinaryReader binaryReader = new BinaryReader(stream);
				float[] array = new float[stream.Length / 2];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = (float)binaryReader.ReadInt16() / 32768f;
				}
				clip = C(T("UnityEngine.AudioClip"), "Create", "Neon Steps - 133.333 BPM", array.Length / 2, 2, 22050, false);
				C(clip, "SetData", array, 0);
			});
		}

		public static float NextSpawn(float now)
		{
			return epoch + (float)(Math.Floor((double)(now - epoch) / 0.9) + 1.0) * 0.9f;
		}

		public static float Arrival(float now)
		{
			return epoch + (float)Math.Round((double)(now - epoch) / 0.9) * 0.9f + 1.8f;
		}

		public static void Reset()
		{
			EndDoors();
			Safe("reload reset", ClearReloads);
			ResetRide();
			foreach (Part value in parts.Values)
			{
				if (Live(value.sr))
				{
					C(T("UnityEngine.Object"), "Destroy", G(value.sr, "gameObject"));
				}
			}
			parts.Clear();
			hits.Clear();
			objects.Clear();
			flashes.Clear();
			bolts.Clear();
			StopMusic();
			OttoAudio(active: false);
			battling = false;
			nextTick = 0f;
		}

		private static void StopMusic()
		{
			if (Live(music))
			{
				C(music, "Stop");
			}
			foreach (KeyValuePair<object, bool> item in muted)
			{
				if (Live(item.Key))
				{
					S(item.Key, "mute", item.Value);
				}
			}
			muted.Clear();
		}

		private static bool MusicSource(object s)
		{
			if (s == music || s == ottoSource)
			{
				return false;
			}
			string text = "";
			object o = G(s, "transform");
			int num = 0;
			while (num < 7 && Live(o))
			{
				text = text + " " + G(o, "name");
				num++;
				o = G(o, "parent");
			}
			object o2 = G(s, "outputAudioMixerGroup");
			if (Live(o2))
			{
				text = text + " " + G(o2, "name");
			}
			object o3 = G(s, "clip");
			if (Live(o3))
			{
				text = text + " " + G(o3, "name");
			}
			text = text.ToLowerInvariant();
			if (!text.Contains("music") && !text.Contains("soundtrack"))
			{
				return text.Contains("bgm");
			}
			return true;
		}

		private static void Music(bool active, float now)
		{
			if (!active)
			{
				if (muted.Count > 0 || (Live(music) && B(G(music, "isPlaying"))))
				{
					StopMusic();
				}
				return;
			}
			if (!Live(clip))
			{
				Prepare();
			}
			if (!Live(clip))
			{
				return;
			}
			if (!Live(music))
			{
				object obj = Activator.CreateInstance(T("UnityEngine.GameObject"), "CGC_NeonSteps");
				music = C(obj, "AddComponent", T("UnityEngine.AudioSource"));
				C(T("UnityEngine.Object"), "DontDestroyOnLoad", obj);
				S(music, "clip", clip);
				S(music, "loop", true);
				S(music, "playOnAwake", false);
				S(music, "spatialBlend", 0f);
				S(music, "volume", 0.65f);
			}
			if (now >= musicScan)
			{
				musicScan = now + 0.5f;
				foreach (object item in Each(C(T("UnityEngine.Object"), "FindObjectsOfType", T("UnityEngine.AudioSource"))))
				{
					if (Live(item) && MusicSource(item))
					{
						if (!muted.ContainsKey(item))
						{
							muted[item] = B(G(item, "mute"));
						}
						S(item, "mute", true);
						object obj2 = G(item, "outputAudioMixerGroup");
						if (Live(obj2))
						{
							S(music, "outputAudioMixerGroup", obj2);
						}
					}
				}
			}
			float num = F(G(T("UnityEngine.Time"), "timeScale"));
			S(music, "pitch", num);
			float num2 = (now - epoch) % 28.8f;
			if (num2 < 0f)
			{
				num2 += 28.8f;
			}
			if (!B(G(music, "isPlaying")))
			{
				S(music, "time", num2);
				C(music, "Play");
			}
			else if (Math.Abs(F(G(music, "time")) - num2) > 0.06f)
			{
				S(music, "time", num2);
			}
		}

		public static bool CanUseDoors()
		{
			object obj = G(T("GameManager"), "instance");
			if (doorWindow && obj != null && B(G(obj, "isPlaying")))
			{
				return B(G(obj, "battleOngoing"));
			}
			return false;
		}

		public static void EndDoors()
		{
			doorWindow = false;
			doorBattleSeen = false;
			Safe("portal data cleanup", delegate
			{
				string[] array = new string[3] { "Doors", "Travelled", "Stepped" };
				foreach (string n in array)
				{
					if (G(X("Spells"), n) is IDictionary dictionary)
					{
						dictionary.Clear();
					}
				}
			});
			Safe("portal sprite cleanup", delegate
			{
				string[] array = parts.Keys.Where((string k) => k.StartsWith("portal", StringComparison.Ordinal)).ToArray();
				foreach (string key in array)
				{
					Part part = parts[key];
					if (Live(part.sr))
					{
						S(part.sr, "enabled", false);
						C(T("UnityEngine.Object"), "Destroy", G(part.sr, "gameObject"));
					}
					parts.Remove(key);
				}
				flashes.RemoveAll((Flash f) => f.portal);
				if (G(X("Pen"), "Sprites") is IDictionary dictionary)
				{
					array = (from string k in dictionary.Keys
						where k.StartsWith("door", StringComparison.Ordinal)
						select k).ToArray();
					foreach (string key2 in array)
					{
						object o = dictionary[key2];
						if (Live(o))
						{
							S(o, "enabled", false);
							C(T("UnityEngine.Object"), "Destroy", G(o, "gameObject"));
						}
						dictionary.Remove(key2);
					}
				}
			});
		}

		public static IEnumerator EndDoorsHook(object ignored)
		{
			EndDoors();
			ResetRide();
			return new object[0].GetEnumerator();
		}

		public static IEnumerator BeginDoorsHook(object ignored)
		{
			EndDoors();
			doorWindow = true;
			return new object[0].GetEnumerator();
		}

		public static void DoorLifecycleTick()
		{
			Safe("portal lifecycle", delegate
			{
				if (CanUseDoors())
				{
					doorBattleSeen = true;
				}
				else if (!doorWindow || doorBattleSeen)
				{
					IDictionary dictionary = G(X("Spells"), "Doors") as IDictionary;
					if (doorWindow || (dictionary != null && dictionary.Count > 0) || parts.Keys.Any((string k) => k.StartsWith("portal", StringComparison.Ordinal)))
					{
						EndDoors();
					}
				}
			});
		}

		public static bool InBattle()
		{
			object obj = G(T("GameManager"), "instance");
			if (obj != null && B(G(obj, "isPlaying")))
			{
				return B(G(obj, "battleOngoing"));
			}
			return false;
		}

		public static void BeginFrame()
		{
			DoorLifecycleTick();
			GameplayTick();
			Safe("battle clock", delegate
			{
				if (Live(music))
				{
					S(music, "pitch", F(G(T("UnityEngine.Time"), "timeScale")));
				}
				if (InBattle() && !battling)
				{
					battling = true;
					epoch = Time;
					musicScan = 0f;
				}
			});
		}

		public static void Tick()
		{
			Safe("frame", delegate
			{
				float now = Time;
				if (!InBattle())
				{
					if (battling)
					{
						Reset();
					}
				}
				else
				{
					if (!battling)
					{
						battling = true;
						epoch = now;
						musicScan = 0f;
					}
					if (!(now < nextTick))
					{
						nextTick = now + 1f / 30f;
						frame++;
						White = Col(1f, 1f, 1f);
						bool dance = false;
						foreach (object p in Each(G(G(T("PlayerManager"), "instance"), "players")))
						{
							if (Live(p))
							{
								bool num = B(C(R("Util"), "Alive", p));
								if (Has(p, 268435456L))
								{
									dance = true;
								}
								if (num)
								{
									Safe("player", delegate
									{
										Player(p, now);
									});
								}
							}
						}
						Safe("doors", delegate
						{
							IDictionary dictionary = (IDictionary)G(X("Spells"), "Doors");
							if (CanUseDoors())
							{
								foreach (DictionaryEntry item in dictionary)
								{
									Door("portal" + item.Key?.ToString() + "a/", G(item.Value, "A"), Color(3), now);
									Door("portal" + item.Key?.ToString() + "b/", G(item.Value, "B"), Color(1), now);
								}
							}
						});
						Safe("disco", delegate
						{
							Discos(now);
						});
						Safe("slot machine", delegate
						{
							Slots(now);
						});
						Safe("objects", delegate
						{
							Objects(now);
						});
						Safe("projectile effects", delegate
						{
							Projectiles(now);
						});
						Safe("music", delegate
						{
							Music(dance, now);
						});
						foreach (Part value in parts.Values)
						{
							if (value.frame != frame && Live(value.sr))
							{
								S(value.sr, "enabled", false);
							}
						}
						if (frame % 60 == 0)
						{
							string[] array = parts.Keys.ToArray();
							foreach (string key in array)
							{
								Part part = parts[key];
								if (frame - part.frame > 120)
								{
									if (Live(part.sr))
									{
										C(T("UnityEngine.Object"), "Destroy", G(part.sr, "gameObject"));
									}
									parts.Remove(key);
								}
							}
						}
					}
				}
			});
		}

		public static void Door(string key, object at, object color, float time)
		{
			Safe("portal", delegate
			{
				Pt pt = P(at);
				object c = Col(F(G(color, "r")), F(G(color, "g")), F(G(color, "b")), 0.8f);
				Shape(key + "glow", "Glow", pt, 2.1f, 3.2f, Col(0.45f, 0.2f, 1f, 0.22f), 4);
				Dot(key + "arch", pt + new Pt(0f, 0.48f), 1.35f, Col(0.005f, 0.004f, 0.013f), 6);
				Shape(key + "body", "Pixel", pt + new Pt(0f, -0.4f), 1.35f, 1.78f, Col(0.005f, 0.004f, 0.013f), 6);
				Arc(key + "rim", pt + new Pt(0f, 0.48f), 0.69f, 0f, (float)Math.PI, c, 0.035f, 16);
				Line(key + "left", pt + new Pt(-0.69f, 0.48f), pt + new Pt(-0.69f, -1.29f), 0.035f, c, 7);
				Line(key + "right", pt + new Pt(0.69f, 0.48f), pt + new Pt(0.69f, -1.29f), 0.035f, c, 7);
				for (int i = 0; i < 10; i++)
				{
					float num = (time * 0.75f + (float)i * 0.137f) % 1f;
					float num2 = Sin((float)i * 73f) * 0.55f;
					Pt p = pt + new Pt(num2 * (1f - num), -1.02f + num * 2.05f);
					Star(key + "spark" + i, p, 0.02f + 0.05f * Sin(num * (float)Math.PI), Col(0.65f + 0.35f * num, 0.5f + 0.5f * num, 1f, Sin(num * (float)Math.PI)), 8);
				}
			});
		}

		private static void Sheep(object p, Pt at, float s, float t, string k)
		{
			HideOld("sheep" + I(G(p, "playerID")) + "_");
			Pt pt = P(C(R("Motion"), "Velocity", p));
			float num = ((!(pt.x < -0.1f)) ? 1 : (-1));
			float num2 = Sin(t * (6f + Math.Min(18f, Math.Abs(pt.x) * 2f)));
			Shape(k + "shadow", "Glow", at + new Pt(0f, -0.56f * s), 1.6f * s, 0.38f * s, Col(0.08f, 0.06f, 0.12f, 0.4f), 10);
			for (int i = 0; i < 4; i++)
			{
				float num3 = ((float)i * 0.27f - 0.43f) * s;
				float num4 = ((i % 2 == 0) ? num2 : (0f - num2)) * 0.07f * s;
				Line(k + "leg" + i, at + new Pt(num3, -0.2f * s), at + new Pt(num3 + num4, -0.63f * s), 0.15f * s, Col(0.19f, 0.17f, 0.23f), 17);
				Dot(k + "hoof" + i, at + new Pt(num3 + num4, -0.63f * s), 0.2f * s, Col(0.07f, 0.06f, 0.1f), 18);
			}
			for (int j = 0; j < 9; j++)
			{
				float x = (float)j * 6.283185f / 9f;
				Pt pt2 = at + new Pt(Cos(x) * 0.44f * s, Sin(x) * 0.31f * s);
				Dot(k + "woolshadow" + j, pt2, 0.54f * s, Col(0.69f, 0.7f, 0.77f), 19);
				Dot(k + "wool" + j, pt2 + new Pt(-0.025f, 0.045f) * s, 0.47f * s, Col(0.98f, 0.97f, 0.9f), 20);
			}
			Shape(k + "body", "Disc", at, 1.08f * s, 0.84f * s, Col(0.98f, 0.97f, 0.9f), 20);
			Pt pt3 = at + new Pt(0.56f * num, 0.12f) * s;
			Shape(k + "head", "Disc", pt3, 0.48f * s, 0.63f * s, Col(0.19f, 0.17f, 0.23f), 21, (0f - num) * 12f);
			Shape(k + "ear", "Disc", pt3 + new Pt(-0.19f * num, 0.21f) * s, 0.42f * s, 0.15f * s, Col(0.19f, 0.17f, 0.23f), 22, num * 25f);
			Eyes(k, pt3, 0.75f * s, num);
			Line(k + "brow", pt3 + new Pt(-0.21f, 0.23f) * s, pt3 + new Pt(0.14f, 0.16f) * s, 0.06f * s, Col(0.08f, 0.06f, 0.12f), 26);
			for (int l = 0; l < 3; l++)
			{
				Dot(k + "tuft" + l, pt3 + new Pt((float)(l - 1) * 0.15f, 0.31f) * s, 0.23f * s, Col(1f, 0.99f, 0.94f), 23);
			}
		}

		private static void Player(object p, float t)
		{
			ReloadIndicator(p, t);
			int id = I(G(p, "playerID"));
			string text = "p" + id + "/";
			Pt pt = Pos(p);
			float num = Clamp(F(C(X("Wild"), "SizeOf", p)), 0.5f, 3f);
			object obj = State("Spells", "Minds", id);
			if (obj != null && F(G(obj, "SheepUntil")) > t)
			{
				Sheep(p, pt, num, t, text + "sheep/");
			}
			if (obj != null && F(G(obj, "DanceUntil")) > t)
			{
				HideOld("note" + id + "_");
				for (int i = 0; i < 3; i++)
				{
					float x = t * 2f + (float)i * 2.1f;
					Pt p2 = pt + new Pt(Cos(x) * num, (1.2f + 0.15f * Sin(t * 8f + (float)i)) * num);
					Note(text + "note" + i, p2, 0.23f, Color(i));
				}
			}
			if (B(C(X("Images"), "IsImage", p)))
			{
				Mirror(text, pt, num, t, id);
			}
			object obj2 = State("Wild", "States", id);
			if (obj2 != null)
			{
				Wild(p, obj2, text + "wild/", pt, num, t);
			}
			object obj3 = State("Boosts", "States", id);
			if (obj3 != null)
			{
				Boost(p, obj3, text, pt, num, t);
			}
			object obj4 = State("Dance", "States", id);
			if (obj4 != null && Has(p, 268435456L) && B(C(R("Util"), "IsMine", p)))
			{
				Dance(p, obj4, text + "dance/", pt, num, t);
			}
			object obj5 = Each(G(X("Slip"), "Live")).FirstOrDefault((object d) => G(d, "P") == p);
			if (obj5 != null && F(G(obj5, "Until")) > t)
			{
				Wind(text + "slip/", pt, P(G(obj5, "Dir")), num, t);
			}
		}

		private static void Note(string k, Pt p, float s, object c)
		{
			Shape(k + "dot", "Disc", p, s * 1.1f, s * 0.75f, c, 22, -20f);
			Line(k + "stem", p + new Pt(s * 0.4f, 0f), p + new Pt(s * 0.4f, s * 1.8f), s * 0.18f, c, 22);
			Line(k + "flag", p + new Pt(s * 0.4f, s * 1.8f), p + new Pt(s * 1.1f, s * 1.35f), s * 0.25f, c, 22);
		}

		private static void Mirror(string k, Pt p, float s, float t, int id)
		{
			for (int i = 0; i < 4; i++)
			{
				float x = t * 0.9f + (float)i * 1.5708f + (float)id;
				Pt p2 = p + new Pt(Cos(x), Sin(x)) * s * 0.85f;
				Star(k + "shard" + i, p2, 0.1f * s, Col(0.6f, 0.8f, 1f, 0.35f + 0.25f * Sin(t * 5f + (float)i)));
			}
			Shape(k + "scan", "Pixel", p + new Pt(0f, Sin(t * 2.8f) * s * 0.55f), 1.05f * s, 0.035f, Col(0.6f, 1f, 1f, 0.55f), 20);
		}

		private static void Wind(string k, Pt p, Pt dir, float s, float t)
		{
			float num = (float)Math.Sqrt(dir.x * dir.x + dir.y * dir.y);
			if (num < 0.01f)
			{
				dir = new Pt(1f, 0f);
			}
			else
			{
				dir *= 1f / num;
			}
			Pt pt = new Pt(0f - dir.y, dir.x);
			for (int i = 0; i < 3; i++)
			{
				float num2 = (float)(i - 1) * 0.42f * s;
				for (int j = 0; j < 5; j++)
				{
					float num3 = (float)j * 0.46f;
					Pt a = p - dir * (num3 + 0.2f) + pt * (num2 + Sin(t * 15f + (float)j * 0.7f + (float)i) * 0.065f);
					Pt b = p - dir * (num3 + 0.64f) + pt * (num2 + Sin(t * 15f + (float)(j + 1) * 0.7f + (float)i) * 0.065f);
					Line(k + i + "/" + j, a, b, (0.065f - 0.008f * (float)j) * s, Col(0.42f, 0.9f, 1f, 0.65f - (float)j * 0.1f), 12);
				}
			}
		}

		private static void Boost(object p, object b, string k, Pt at, float s, float t)
		{
			int num = I(G(b, "Level"));
			float num2 = F(G(b, "Charge"));
			if (num > 0 || num2 > 0f)
			{
				float num3 = Clamp(((float)num + num2) / 5f);
				for (int i = 0; i < 10; i++)
				{
					float x = 2.7f - (float)i * 0.24f;
					Pt pt = new Pt(Cos(x), Sin(x));
					Line(k + "rpm" + i, at + pt * 1f * s, at + pt * 1.12f * s, 0.07f * s, ((float)i < num3 * 10f) ? Col(1f, 0.6f * (1f - num3), 0.16f, 0.9f) : Col(0.25f, 0.18f, 0.2f, 0.35f), 14);
				}
				Pt pt2 = P(C(R("Motion"), "Velocity", p));
				float num4 = (float)Math.Sqrt(pt2.x * pt2.x + pt2.y * pt2.y);
				if (num4 > 2f)
				{
					Pt pt3 = pt2 * (1f / num4);
					Pt pt4 = new Pt(0f - pt3.y, pt3.x);
					for (int j = 0; j < 3; j++)
					{
						Line(k + "redtrail" + j, at - pt3 * 0.6f + pt4 * ((float)(j - 1) * 0.2f), at - pt3 * (1f + num3 * 2f) + pt4 * ((float)(j - 1) * 0.25f), 0.06f, Col(1f, 0.3f + 0.35f * (1f - num3), 0.12f, num3 * 0.6f), 10);
					}
				}
			}
			float num5 = t - F(G(b, "BouncedAt"));
			if (num5 >= 0f && num5 < 0.5f)
			{
				Ring(k + "bounce", at, (1f + num5 * 4f) * s, Col(0.45f, 1f, 0.5f, (1f - num5 * 2f) * 0.6f));
				for (int l = 0; l < 4; l++)
				{
					float x2 = (float)l * 1.5708f + 0.5f;
					Star(k + "spring" + l, at + new Pt(Cos(x2), Sin(x2)) * (0.7f + num5 * 3f) * s, 0.12f * (1f - num5 * 2f), Col(0.65f, 1f, 0.6f));
				}
			}
			if (F(G(b, "RubberUntil")) > t)
			{
				Arc(k + "elastic", at, 1f * s, t * 4f, 2.5f, Col(0.5f, 1f, 0.65f, 0.5f));
			}
		}

		public static void Feedback(int pid, int streak, float heal, int dir)
		{
			hits[pid] = new Hit
			{
				until = Time + 0.6f,
				streak = streak,
				dir = dir
			};
		}

		private static void Arrow(string k, Pt p, int d, float s, object c, bool target)
		{
			Pt pt = d switch
			{
				1 => new Pt(0f, 1f), 
				0 => new Pt(-1f, 0f), 
				_ => new Pt(1f, 0f), 
			};
			Pt pt2 = new Pt(0f - pt.y, pt.x);
			Pt pt3 = p + pt * (0.26f * s);
			Line(k + "stem", p - pt * (0.28f * s), pt3, (target ? 0.055f : 0.12f) * s, c, 22);
			Line(k + "a", pt3, pt3 - pt * (0.26f * s) + pt2 * (0.25f * s), (target ? 0.055f : 0.12f) * s, c, 22);
			Line(k + "b", pt3, pt3 - pt * (0.26f * s) - pt2 * (0.25f * s), (target ? 0.055f : 0.12f) * s, c, 22);
		}

		private static void Dance(object p, object st, string k, Pt at, float s, float t)
		{
			s = Clamp(s, 0.65f, 1.6f);
			Pt pt = at + new Pt(0f, 1.65f * s);
			float num = (B(C(R("Controls"), "CrouchHeld", p)) ? 1f : 0.48f);
			float num2 = (t - epoch) / 0.45f;
			float num3 = (float)Math.Pow(1f - (num2 - (float)Math.Floor(num2)), 4.0);
			Shape(k + "panel", "Pixel", pt + new Pt(0f, 0.88f * s), 2.65f * s, 2.48f * s, Col(0.025f, 0.035f, 0.09f, 0.58f * num), 11);
			for (int i = 0; i < 3; i++)
			{
				Pt pt2 = pt + new Pt((float)(i - 1) * 0.85f * s, 0f);
				Line(k + "lane" + i, pt2 + new Pt(-0.37f * s, -0.24f * s), pt2 + new Pt(-0.37f * s, 2.02f * s), 0.018f, Color(i, 0.3f * num), 12);
				Shape(k + "targetglow" + i, "Glow", pt2, 0.8f * s, 0.8f * s, Color(i, (0.18f + 0.18f * num3) * num), 13);
				Arrow(k + "target" + i, pt2, i, s, Color(i, 0.75f * num), target: true);
			}
			Line(k + "judge", pt + new Pt(-1.25f * s, 0f), pt + new Pt(1.25f * s, 0f), 0.023f, Col(1f, 1f, 1f, 0.24f * num), 14);
			int num4 = 0;
			foreach (object item in Each(G(st, "Arrows")))
			{
				foreach (object item2 in Each(G(item, "Parts")))
				{
					if (Live(item2))
					{
						S(item2, "enabled", false);
					}
				}
				int num5 = I(G(item, "Dir"));
				float num6 = (F(G(item, "Arrives")) - t) / 1.8f;
				Pt pt3 = pt + new Pt((float)(num5 - 1) * 0.85f * s, 1.92f * s * num6);
				float num7 = Clamp(1.15f - num6) * num;
				Shape(k + "noteGlow" + num4, "Glow", pt3, 0.67f * s, 0.67f * s, Color(num5, num7 * 0.3f), 18);
				Arrow(k + "note" + num4, pt3, num5, s, Color(num5, num7), target: false);
				num4++;
			}
			int num8 = I(G(st, "Streak"));
			for (int j = 0; j < 5; j++)
			{
				Dot(k + "combo" + j, pt + new Pt((float)(j - 2) * 0.23f * s, -0.34f * s), 0.09f * s, (j < num8) ? Color(j % 3, num) : Col(0.4f, 0.45f, 0.6f, 0.24f * num), 22);
			}
			if (!hits.TryGetValue(I(G(p, "playerID")), out var value) || !(t < value.until))
			{
				return;
			}
			float num9 = (value.until - t) / 0.6f;
			Pt pt4 = pt + new Pt((float)(value.dir - 1) * 0.85f * s, 0f);
			Ring(k + "hit", pt4, (0.7f + (1f - num9) * 0.8f) * s, (value.streak > 0) ? Col(1f, 1f, 1f, num9 * 0.8f) : Col(1f, 0.2f, 0.25f, num9));
			if (value.streak > 0)
			{
				for (int l = 0; l < 4; l++)
				{
					float x = (float)l * 1.5708f + 0.7f;
					Star(k + "hitstar" + l, pt4 + new Pt(Cos(x), Sin(x)) * (1f - num9) * s, 0.085f * num9, Color(value.dir, num9));
				}
			}
		}

		private static void Discos(float t)
		{
			int num = 0;
			bool active = false;
			foreach (object item in Each(G(X("Spells"), "Discos")))
			{
				if (!(F(G(item, "Until")) <= t))
				{
					active = true;
					HideOld("disco");
					DiscoSphere("discoV" + num++ + "/", P(G(item, "At")), t, F(G(item, "Radius")));
				}
			}
			Safe("Otto audio", delegate
			{
				OttoAudio(active);
			});
		}

		public static void Enchant(int pid, int id)
		{
			long key = ((long)pid << 32) | (uint)id;
			objects[key] = new ObjFx
			{
				pid = pid,
				id = id,
				until = Time + 13f
			};
		}

		public static void EndEnchant(int pid, int id)
		{
			objects.Remove(((long)pid << 32) | (uint)id);
		}

		private static void ObjectFace(string k, object obj, float t)
		{
			if (Live(obj))
			{
				Pt pt = Pos(obj);
				Eyes(k, pt, 0.9f);
				Line(k + "browL", pt + new Pt(-0.32f, 0.26f), pt + new Pt(-0.08f, 0.19f), 0.055f, Col(0.11f, 0.08f, 0.18f), 26);
				Line(k + "browR", pt + new Pt(0.32f, 0.26f), pt + new Pt(0.08f, 0.19f), 0.055f, Col(0.11f, 0.08f, 0.18f), 26);
				Arc(k + "spell", pt, 0.67f, t * 2f, 3.5f, Col(0.65f, 0.4f, 1f, 0.6f), 0.035f, 8);
				for (int i = 0; i < 2; i++)
				{
					float x = t * 2f + (float)i * 3.14159f;
					Star(k + "star" + i, pt + new Pt(Cos(x), Sin(x)) * 0.8f, 0.075f, Col(0.82f, 0.64f, 1f, 0.8f));
				}
			}
		}

		private static void Objects(float t)
		{
			KeyValuePair<long, ObjFx>[] array = objects.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<long, ObjFx> keyValuePair = array[i];
				ObjFx value = keyValuePair.Value;
				object obj = C(R("LaunchedBox"), "Find", value.pid, value.id);
				if (t > value.until || !Live(obj))
				{
					objects.Remove(keyValuePair.Key);
				}
				else
				{
					ObjectFace("object" + keyValuePair.Key + "/", obj, t);
				}
			}
			int num = 0;
			foreach (object item in Each(G(X("Spells"), "Things")))
			{
				if (I(G(item, "Id")) < 0)
				{
					ObjectFace("loose" + num++ + "/", G(item, "Loose"), t);
				}
			}
		}

		public static void SpellProjectile(object go)
		{
			Track(go, pie: false);
		}

		public static void PieProjectile(object go)
		{
			Track(go, pie: true);
		}

		private static void Track(object go, bool pie)
		{
			Safe("projectile", delegate
			{
				if (Live(go))
				{
					if (bolts.Count >= 64)
					{
						bolts.RemoveAt(0);
					}
					bolts.Add(new Bolt
					{
						go = go,
						until = Time + 8f,
						pie = pie,
						last = Pos(go)
					});
				}
			});
		}

		public static void SheepBurst(int pid, float duration)
		{
			Safe("transformation", delegate
			{
				object o = C(R("Util"), "PlayerById", pid);
				if (Live(o))
				{
					AddFlash(Pos(o), 3);
				}
			});
		}

		private static void AddFlash(Pt at, int c, bool portal = false)
		{
			if (flashes.Count >= 24)
			{
				flashes.RemoveAt(0);
			}
			flashes.Add(new Flash
			{
				at = at,
				start = Time,
				color = c,
				portal = portal
			});
		}

		public static void PortalBurst(float ax, float ay, float bx, float by)
		{
			if (CanUseDoors())
			{
				AddFlash(new Pt(ax, ay), 3, portal: true);
				AddFlash(new Pt(bx, by), 1, portal: true);
			}
		}

		private static void Projectiles(float t)
		{
			for (int num = bolts.Count - 1; num >= 0; num--)
			{
				Bolt bolt = bolts[num];
				if (!Live(bolt.go) || t > bolt.until)
				{
					bolts.RemoveAt(num);
				}
				else
				{
					Pt pt = Pos(bolt.go);
					string text = "bolt" + num + "/";
					if (bolt.pie)
					{
						Shape(text + "crust", "Disc", pt, 0.66f, 0.36f, Col(0.88f, 0.64f, 0.32f), 20);
						Shape(text + "cream", "Disc", pt + new Pt(0f, 0.05f), 0.58f, 0.25f, Col(1f, 0.97f, 0.86f), 21);
						Dot(text + "cherry", pt + new Pt(0f, 0.16f), 0.12f, Col(1f, 0.18f, 0.27f), 22);
					}
					else
					{
						Shape(text + "glow", "Glow", pt, 0.9f, 0.9f, Col(0.75f, 0.35f, 1f, 0.3f), 13);
						for (int i = 0; i < 3; i++)
						{
							float x = t * 9f + (float)i * 2.0944f;
							Star(text + "star" + i, pt + new Pt(Cos(x), Sin(x)) * 0.25f, 0.055f, Color(i, 0.8f));
						}
						Line(text + "trail", bolt.last, pt, 0.035f, Col(0.8f, 0.5f, 1f, 0.5f), 12);
					}
					bolt.last = pt;
				}
			}
			for (int num2 = flashes.Count - 1; num2 >= 0; num2--)
			{
				Flash flash = flashes[num2];
				float num3 = (t - flash.start) / 0.55f;
				if (num3 >= 1f)
				{
					flashes.RemoveAt(num2);
				}
				else
				{
					string text2 = (flash.portal ? "portalFlash" : "flash") + num2 + "/";
					Ring(text2 + "ring", flash.at, 0.4f + num3 * 2.3f, Color(flash.color, (1f - num3) * 0.7f));
					for (int j = 0; j < 8; j++)
					{
						float x2 = (float)j * 0.7854f;
						Star(text2 + j, flash.at + new Pt(Cos(x2), Sin(x2)) * (0.25f + num3 * 1.6f), 0.1f * (1f - num3), Color((j + flash.color) % 4, 1f - num3));
					}
				}
			}
			int num4 = 0;
			foreach (object item in Each(G(X("WildBlobs"), "Live")))
			{
				if (!B(G(item, "Bounce")))
				{
					continue;
				}
				Pt pt2 = P(G(item, "Pos"));
				float num5 = F(G(item, "Radius"));
				string text3 = "grocery" + num4 + "/";
				if (num4 % 3 == 0)
				{
					Dot(text3 + "apple", pt2, num5 * 2f, Col(0.9f, 0.2f, 0.15f), 18);
					Line(text3 + "stem", pt2 + new Pt(0f, num5 * 0.5f), pt2 + new Pt(0.05f, num5 * 1.3f), 0.04f, Col(0.4f, 0.25f, 0.12f), 19);
					Shape(text3 + "leaf", "Disc", pt2 + new Pt(num5 * 0.6f, num5), num5, num5 * 0.4f, Col(0.4f, 0.85f, 0.3f), 20, 25f);
				}
				else if (num4 % 3 == 1)
				{
					Shape(text3 + "milk", "Pixel", pt2, num5 * 1.6f, num5 * 2.3f, Col(0.92f, 0.98f, 1f), 18, Sin(t * 4f + (float)num4) * 12f);
					Shape(text3 + "label", "Pixel", pt2, num5 * 1.25f, num5 * 0.75f, Col(0.25f, 0.65f, 1f), 19);
				}
				else
				{
					Shape(text3 + "bread", "Disc", pt2, num5 * 2.4f, num5 * 1.5f, Col(0.9f, 0.66f, 0.32f), 18, 30f);
					for (int k = 0; k < 2; k++)
					{
						Line(text3 + "score" + k, pt2 + new Pt(((float)k - 0.5f) * num5, (0f - num5) * 0.3f), pt2 + new Pt(((float)k - 0.8f) * num5, num5 * 0.3f), 0.045f, Col(1f, 0.89f, 0.6f), 19);
					}
				}
				num4++;
			}
		}

		private static void Wild(object player, object st, string k, Pt p, float s, float t)
		{
			IDictionary dictionary = G(st, "Sprites") as IDictionary;
			float num = F(G(st, "Face"));
			if (num == 0f)
			{
				num = 1f;
			}
			Func<int, bool> func = (int i) => B(C(X("Wild"), "Has", st, i));
			if (func(2))
			{
				string[] array = new string[3] { "2_crownL", "2_crownM", "2_crownR" };
				foreach (string key in array)
				{
					if (dictionary != null && dictionary.Contains(key) && Live(dictionary[key]))
					{
						S(dictionary[key], "enabled", false);
					}
				}
				Pt pt = p + new Pt(0f, 1.02f * s);
				Line(k + "crownbase", pt + new Pt(-0.4f * s, 0f), pt + new Pt(0.4f * s, 0f), 0.17f * s, Col(1f, 0.73f, 0.12f), 20);
				for (int num3 = 0; num3 < 3; num3++)
				{
					Pt pt2 = pt + new Pt((float)(num3 - 1) * 0.28f * s, 0.24f * s);
					Line(k + "prong" + num3, pt2 - new Pt(0f, 0.24f * s), pt2, 0.14f * s, Col(1f, 0.84f, 0.25f), 20);
					Dot(k + "gem" + num3, pt2, 0.1f * s, Color(num3), 21);
				}
				Arc(k + "bossAura", p, s * 1.13f, t * 0.8f, 2f, Col(1f, 0.72f, 0.15f, 0.24f));
			}
			if (func(3) && t < F(G(st, "StretchUntil")))
			{
				Pt p2 = P(G(st, "StretchTo"));
				Eyes(k + "accordion", p2, 0.7f * s, num);
				for (int num4 = 0; num4 < 3; num4++)
				{
					Note(k + "accnote" + num4, p + new Pt((float)(num4 - 1) * s, (1.3f + 0.1f * Sin(t * 8f + (float)num4)) * s), 0.14f, Color(num4));
				}
			}
			if (func(4))
			{
				for (int num5 = 0; num5 < 3; num5++)
				{
					string key2 = "4_rock" + num5;
					if (dictionary != null && dictionary.Contains(key2) && Live(dictionary[key2]) && B(G(dictionary[key2], "enabled")))
					{
						Pt pt3 = Pos(dictionary[key2]);
						Dot(k + "crater" + num5, pt3 + new Pt(0.07f, 0.04f) * s, 0.13f * s, Col(0.32f, 0.36f, 0.48f), 20);
						Dot(k + "craterB" + num5, pt3 + new Pt(-0.1f, -0.075f) * s, 0.065f * s, Col(0.4f, 0.43f, 0.53f), 20);
						Star(k + "moonstar" + num5, pt3 + new Pt(-0.24f, 0.2f) * s, 0.045f, Col(0.8f, 0.9f, 1f, 0.7f));
					}
				}
				Arc(k + "orbit", p, 1.8f * s, t * 0.4f, 1.4f, Col(0.65f, 0.8f, 1f, 0.16f), 0.025f);
			}
			if (func(5))
			{
				Pt pt4 = p + new Pt(0f, -0.55f * s);
				Line(k + "basketbase", pt4 + new Pt(-0.7f, -0.25f) * s, pt4 + new Pt(0.65f, -0.25f) * s, 0.06f * s, Col(0.7f, 0.82f, 0.9f), 18);
				for (int num6 = 0; num6 < 5; num6++)
				{
					Line(k + "basketbar" + num6, pt4 + new Pt((float)(num6 - 2) * 0.27f, -0.25f) * s, pt4 + new Pt((float)(num6 - 2) * 0.32f, 0.35f) * s, 0.035f * s, Col(0.7f, 0.82f, 0.9f), 18);
				}
				Line(k + "basketrim", pt4 + new Pt(-0.72f, 0.35f) * s, pt4 + new Pt(0.72f, 0.35f) * s, 0.07f * s, Col(0.8f, 0.9f, 1f), 18);
			}
			if (func(6))
			{
				for (int num7 = 0; num7 < 4; num7++)
				{
					string key3 = "6_duck" + num7;
					if (dictionary != null && dictionary.Contains(key3) && Live(dictionary[key3]) && B(G(dictionary[key3], "enabled")))
					{
						Pt pt5 = Pos(dictionary[key3]);
						Dot(k + "duckhead" + num7, pt5 + new Pt(0.12f * num, 0.18f), 0.28f, Col(1f, 0.87f, 0.27f), 19);
						Dot(k + "duckeye" + num7, pt5 + new Pt(0.17f * num, 0.23f), 0.058f, Col(0.06f, 0.07f, 0.1f), 21);
						Shape(k + "duckwing" + num7, "Disc", pt5 + new Pt(-0.04f * num, -0.01f), 0.27f, 0.14f, Col(1f, 0.67f, 0.12f), 20, Sin(t * 12f + (float)num7) * 15f);
						Line(k + "duckbeak" + num7, pt5 + new Pt(0.22f * num, 0.16f), pt5 + new Pt(0.38f * num, 0.16f), 0.1f, Col(1f, 0.42f, 0.08f), 20);
					}
				}
			}
			if (func(7))
			{
				for (int num8 = 0; num8 < 5; num8++)
				{
					Dot(k + "clownhair" + num8, p + new Pt((float)(num8 - 2) * 0.21f, 0.74f + Sin(num8) * 0.08f) * s, 0.3f * s, Color(num8), 19);
				}
				Shape(k + "shoeL", "Disc", p + new Pt(-0.4f, -0.8f) * s, 0.65f * s, 0.24f * s, Col(1f, 0.2f, 0.22f), 18, -8f);
				Shape(k + "shoeR", "Disc", p + new Pt(0.4f, -0.8f) * s, 0.65f * s, 0.24f * s, Col(0.3f, 0.6f, 1f), 18, 8f);
			}
			if (func(8))
			{
				Shape(k + "balloonshine", "Disc", p + new Pt(-0.3f, 0.32f) * s, 0.14f * s, 0.38f * s, Col(1f, 1f, 1f, 0.5f), 22, -30f);
				for (int num9 = 0; num9 < 5; num9++)
				{
					float num10 = (float)num9 * 0.22f;
					Line(k + "balloonstring" + num9, p + new Pt(Sin(t * 2f + (float)num9 * 0.6f) * 0.1f, -0.8f - num10) * s, p + new Pt(Sin(t * 2f + (float)(num9 + 1) * 0.6f) * 0.1f, -1.02f - num10) * s, 0.027f, Col(1f, 1f, 1f, 0.65f), 13);
				}
			}
			if (func(9))
			{
				Shape(k + "fridge", "Pixel", p, 1.35f * s, 1.82f * s, Col(0.78f, 0.86f, 0.88f), 17);
				Shape(k + "fridgefront", "Pixel", p + new Pt(-0.06f, 0.02f) * s, 1.14f * s, 1.66f * s, Col(0.93f, 0.98f, 0.94f), 18);
				Line(k + "seam", p + new Pt(-0.55f, 0.32f) * s, p + new Pt(0.52f, 0.32f) * s, 0.045f * s, Col(0.38f, 0.5f, 0.58f), 19);
				Line(k + "handle", p + new Pt(0.4f, -0.18f) * s, p + new Pt(0.4f, 0.18f) * s, 0.065f * s, Col(0.3f, 0.42f, 0.48f), 20);
				Eyes(k + "fridge", p + new Pt(-0.1f, 0.57f) * s, 0.55f * s);
			}
			if (func(10))
			{
				for (int num11 = 0; num11 < 8; num11++)
				{
					float num12 = (t * 0.8f + (float)num11 * 0.131f) % 1f;
					Pt at = p + new Pt(Sin((float)num11 * 31f) * 2f * s, (2.4f - num12 * 3f) * s);
					Shape(k + "confetti" + num11, "Pixel", at, 0.07f, 0.13f, Color(num11, (1f - num12) * 0.65f), 16, t * 120f + (float)(num11 * 35));
				}
				Star(k + "spotlight", p + new Pt(2.5f, 5f), 0.2f, Col(1f, 0.93f, 0.6f, 0.6f));
			}
			if (func(11))
			{
				Shape(k + "forkbody", "Pixel", p + new Pt(-0.27f * num, -0.45f) * s, 1.14f * s, 0.5f * s, Col(1f, 0.68f, 0.07f), 17);
				for (int num13 = 0; num13 < 2; num13++)
				{
					Pt p3 = p + new Pt(((num13 == 0) ? (-0.65f) : 0.25f) * s, -0.78f * s);
					Dot(k + "tire" + num13, p3, 0.38f * s, Col(0.11f, 0.12f, 0.15f), 18);
					Dot(k + "hub" + num13, p3, 0.18f * s, Col(0.65f, 0.7f, 0.72f), 19);
				}
				float num14 = 0.4f + 0.6f * Math.Max(0f, Sin(t * 8f));
				Shape(k + "beaconGlow", "Glow", p + new Pt(-0.25f * num, 1f) * s, 0.55f, 0.5f, Col(1f, 0.6f, 0.05f, num14 * 0.3f), 19);
				Dot(k + "beacon", p + new Pt(-0.25f * num, 1f) * s, 0.16f * s, Col(1f, 0.65f, 0.1f, num14), 20);
			}
			if (func(12))
			{
				Shape(k + "printerbody", "Pixel", p, 1.35f * s, 0.88f * s, Col(0.82f, 0.85f, 0.85f), 18);
				Shape(k + "printertop", "Pixel", p + new Pt(0f, 0.38f) * s, 1.15f * s, 0.23f * s, Col(0.2f, 0.23f, 0.28f), 19);
				Shape(k + "paper", "Pixel", p + new Pt(0f, 0.69f) * s, 0.68f * s, 0.4f * s, Col(0.97f, 0.97f, 0.9f), 18);
				for (int num15 = 0; num15 < 3; num15++)
				{
					Line(k + "printline" + num15, p + new Pt(-0.23f, 0.61f + (float)num15 * 0.075f) * s, p + new Pt(0.18f, 0.61f + (float)num15 * 0.075f) * s, 0.025f * s, Col(0.35f, 0.4f, 0.45f), 19);
				}
				Eyes(k + "printer", p, 0.65f * s);
				bool flag = t < F(G(st, "JamUntil"));
				Dot(k + "printerled", p + new Pt(0.48f, -0.25f) * s, 0.1f * s, flag ? Col(1f, 0.15f, 0.1f) : Col(0.35f, 1f, 0.55f), 22);
			}
		}

		public static Random NewRandom()
		{
			return new SecureRandom();
		}

		private static void ReloadIndicator(object player, float t)
		{
			object obj = AmmoFor(C(R("Util"), "GunOf", player));
			if (obj != null && reloads.TryGetValue(obj, out var value))
			{
				float num = Math.Max(0.05f, F(C(obj, "ReloadTime")));
				float num2 = Clamp(1f - (value - t) / num);
				Pt pt = Pos(player) + new Pt(0f, -1.1f);
				string text = "reload" + I(G(player, "playerID")) + "/";
				Shape(text + "track", "Pixel", pt, 1.2f, 0.09f, Col(0.08f, 0.11f, 0.19f, 0.85f), 18);
				Shape(text + "fill", "Pixel", pt + new Pt((num2 - 1f) * 0.6f, 0f), 1.2f * num2, 0.06f, Col(0.5f, 0.92f, 1f), 19);
			}
		}

		private static void DiscoSphere(string k, Pt p, float t, float radius)
		{
			float num = (float)Math.Pow(1f - ((t - epoch) / 0.45f % 1f + 1f) % 1f, 4.0);
			Line(k + "wire", p, p + new Pt(0f, 3f), 0.025f, Col(0.65f, 0.72f, 0.88f, 0.55f), 5);
			Shape(k + "halo", "Glow", p, 1.65f, 1.65f, Col(0.4f, 0.7f, 1f, 0.14f + 0.07f * num), 14);
			Dot(k + "rim", p, 1.04f, Col(0.035f, 0.06f, 0.12f), 16);
			Dot(k + "ball", p, 0.98f, Col(0.19f, 0.25f, 0.34f), 17);
			for (int i = -4; i <= 4; i++)
			{
				float x = (float)i * 0.29f;
				float b = Sin(x) * 0.46f;
				float num2 = Cos(x) * 0.46f;
				for (int j = 0; j < 20; j++)
				{
					float x2 = (float)j * 0.314159f + t * 0.9f;
					float num3 = Cos(x2);
					if (!(num3 <= 0.03f))
					{
						float a = Sin(x2) * num2;
						float w = Math.Max(0.014f, num2 * 0.27f * num3);
						float h = 0.105f * Cos(x);
						float num4 = (float)Math.Pow(Math.Max(0f, num3 * 0.74f - Sin(x2) * 0.45f + Sin(x) * 0.32f), 7.0);
						Shape(k + "facet" + i + "/" + j, "Pixel", p + new Pt(a, b), w, h, Col(0.28f + 0.7f * num4 + 0.12f * num3, 0.4f + 0.57f * num4 + 0.1f * num3, 0.55f + 0.43f * num4), 18);
					}
				}
			}
			Star(k + "glintA", p + new Pt(-0.19f, 0.25f), 0.11f + 0.04f * num, Col(1f, 1f, 1f, 0.95f), 20);
			Star(k + "glintB", p + new Pt(0.3f, -0.15f), 0.065f, Col(0.7f, 0.9f, 1f, 0.8f), 20);
			for (int l = 0; l < 8; l++)
			{
				float x3 = t * 0.34f + (float)l * 0.785398f;
				Pt pt = new Pt(Cos(x3), Sin(x3) * 0.72f);
				Pt pt2 = p + pt * radius;
				for (int m = 1; m <= 5; m++)
				{
					float num5 = (float)m / 5f;
					Pt at = p + pt * (radius * num5 * 0.85f);
					Shape(k + "wash" + l + "/" + m, "Glow", at, 0.12f + num5 * 0.65f, 0.12f + num5 * 0.65f, Color(l, (0.02f + 0.016f * num) * (1f - num5 * 0.5f)), 3);
				}
				Shape(k + "softBeam" + l, "SoftLine", (p + pt2) * 0.5f, (float)Math.Sqrt((pt2 - p).x * (pt2 - p).x + (pt2 - p).y * (pt2 - p).y), 0.3f + 0.18f * num, Color(l, 0.1f + 0.05f * num), 3, (float)(Math.Atan2(pt.y, pt.x) * 180.0 / Math.PI));
				Line(k + "beam" + l, p + pt * 0.5f, pt2, 0.018f, Color(l, 0.18f + 0.12f * num), 4);
				Shape(k + "spot" + l, "Glow", pt2, 0.55f, 0.23f, Color(l, 0.23f + 0.22f * num), 5);
				Star(k + "spark" + l, pt2, 0.055f + 0.055f * num, Color(l, 0.65f), 6);
			}
		}

		private static void SlotSymbol(string k, Pt p, int symbol, float s)
		{
			object c = Col(1f, 0.77f, 0.12f);
			symbol = (symbol % 5 + 5) % 5;
			switch (symbol)
			{
			case 0:
			{
				for (int m = 0; m < 5; m++)
				{
					float x = 1.5708f + (float)m * 1.25664f;
					Line(k + m, p, p + new Pt(Cos(x), Sin(x)) * 0.24f * s, 0.12f * s, c, 24);
				}
				Dot(k + "core", p, 0.23f * s, c, 24);
				Star(k + "shine", p + new Pt(-0.06f, 0.07f) * s, 0.045f * s, White, 25);
				break;
			}
			case 1:
			{
				Dot(k + "skull", p + new Pt(0f, 0.04f) * s, 0.36f * s, Col(1f, 0.18f, 0.25f), 24);
				Shape(k + "jaw", "Pixel", p + new Pt(0f, -0.13f) * s, 0.22f * s, 0.13f * s, Col(1f, 0.18f, 0.25f), 24);
				for (int j = 0; j < 2; j++)
				{
					Dot(k + "eye" + j, p + new Pt((j == 0) ? (-0.075f) : 0.075f, 0.05f) * s, 0.08f * s, Col(0.13f, 0.035f, 0.1f), 25);
				}
				break;
			}
			case 2:
				Shape(k + "diamond", "Pixel", p, 0.3f * s, 0.3f * s, Col(0.16f, 0.79f, 1f), 24, 45f);
				Line(k + "cut", p + new Pt(-0.17f, 0.03f) * s, p + new Pt(0.17f, 0.03f) * s, 0.025f * s, Col(0.7f, 1f, 1f), 25);
				Line(k + "facet", p + new Pt(0f, 0.19f) * s, p + new Pt(0f, -0.19f) * s, 0.02f * s, Col(0.7f, 1f, 1f), 25);
				break;
			case 3:
			{
				for (int l = 0; l < 2; l++)
				{
					Pt pt = p + new Pt((l == 0) ? (-0.1f) : 0.1f, -0.06f) * s;
					Dot(k + "cherry" + l, pt, 0.23f * s, Col(1f, 0.15f, 0.37f), 24);
					Line(k + "stem" + l, pt + new Pt(0f, 0.1f) * s, p + new Pt(0f, 0.24f) * s, 0.035f * s, Col(0.2f, 0.65f, 0.25f), 24);
					Dot(k + "shine" + l, pt + new Pt(-0.035f, 0.045f) * s, 0.055f * s, Col(1f, 0.85f, 0.8f), 25);
				}
				break;
			}
			default:
			{
				Line(k + "crown", p + new Pt(-0.19f, -0.1f) * s, p + new Pt(0.19f, -0.1f) * s, 0.12f * s, c, 24);
				for (int i = 0; i < 3; i++)
				{
					Line(k + "point" + i, p + new Pt((float)(i - 1) * 0.15f, -0.06f) * s, p + new Pt((float)(i - 1) * 0.18f, 0.15f) * s, 0.1f * s, c, 24);
				}
				Dot(k + "gem", p, 0.065f * s, Col(0.6f, 0.25f, 1f), 25);
				break;
			}
			}
		}

		private static void Slots(float t)
		{
			Type o;
			try
			{
				o = T("LetItRide.Machine");
			}
			catch (TypeLoadException)
			{
				return;
			}
			if (!(G(o, "States") is IDictionary dictionary))
			{
				return;
			}
			foreach (DictionaryEntry item in dictionary)
			{
				object value = item.Value;
				float num = t - F(G(value, "SpinFrom"));
				if (num < 0f || num > 3f)
				{
					continue;
				}
				object obj = C(R("Util"), "PlayerById", (int)item.Key);
				if (!Live(obj) || !B(C(R("Util"), "Alive", obj)))
				{
					continue;
				}
				float num2 = Clamp(Math.Abs(F(G(G(G(obj, "transform"), "localScale"), "x"))), 0.7f, 1.5f);
				Pt pt = Pos(obj) + new Pt(0f, 2.3f * num2);
				string text = "slotV" + item.Key?.ToString() + "/";
				Shape(text + "shadow", "Glow", pt, 3.4f * num2, 2f * num2, Col(0.03f, 0.025f, 0.09f, 0.35f), 10);
				Shape(text + "rim", "Pixel", pt, 2.54f * num2, 1.35f * num2, Col(1f, 0.67f, 0.12f), 19);
				Shape(text + "body", "Pixel", pt + new Pt(0f, 0.015f) * num2, 2.4f * num2, 1.2f * num2, Col(0.6f, 0.04f, 0.13f), 20);
				Shape(text + "recess", "Pixel", pt, 2.13f * num2, 0.87f * num2, Col(0.13f, 0.035f, 0.065f), 21);
				for (int i = 0; i < 12; i++)
				{
					float a = ((float)i - 5.5f) * 0.19f * num2;
					bool flag = (i + (int)(t * 10f)) % 3 == 0;
					Dot(text + "bulb" + i, pt + new Pt(a, 0.57f * num2), 0.067f * num2, flag ? Col(1f, 1f, 0.7f) : Col(0.88f, 0.39f, 0.08f), 22);
					if (flag)
					{
						Shape(text + "bulbGlow" + i, "Glow", pt + new Pt(a, 0.57f * num2), 0.18f * num2, 0.18f * num2, Col(1f, 0.7f, 0.1f, 0.35f), 21);
					}
				}
				for (int j = 0; j < 3; j++)
				{
					Pt pt2 = pt + new Pt((float)(j - 1) * 0.7f * num2, 0f);
					Shape(text + "window" + j, "Pixel", pt2, 0.62f * num2, 0.73f * num2, Col(1f, 0.96f, 0.79f), 22);
					float num3 = 1.8f * (0.55f + 0.2f * (float)j);
					bool flag2 = num < num3;
					int symbol = (flag2 ? ((int)(num * 14f + (float)(j * 2))) : I(C(o, "Stopped", I(G(value, "Outcome")), j)));
					float b = (flag2 ? ((0.5f - num * 14f % 1f) * 0.35f * num2) : 0f);
					SlotSymbol(text + "symbol" + j + "/", pt2 + new Pt(0f, b), symbol, num2);
					Line(text + "windowTop" + j, pt2 + new Pt(-0.29f, 0.34f) * num2, pt2 + new Pt(0.29f, 0.34f) * num2, 0.05f * num2, Col(0.8f, 0.58f, 0.23f, 0.65f), 26);
				}
				float num4 = Clamp(num / 0.25f) * (1f - Clamp((num - 0.25f) / 0.3f));
				Pt pt3 = pt + new Pt(1.48f, 0.56f - 0.8f * num4) * num2;
				Line(text + "lever", pt + new Pt(1.19f, -0.22f) * num2, pt3, 0.075f * num2, Col(0.65f, 0.73f, 0.82f), 21);
				Dot(text + "knob", pt3, 0.27f * num2, Col(1f, 0.15f, 0.25f), 22);
				Dot(text + "knobShine", pt3 + new Pt(-0.045f, 0.055f) * num2, 0.07f * num2, Col(1f, 0.8f, 0.75f), 23);
				if (!(num >= 1.8f))
				{
					continue;
				}
				int num5 = I(G(value, "Outcome"));
				object c = ((num5 == 1) ? Col(1f, 0.84f, 0.23f) : ((num5 < 0) ? Col(1f, 0.18f, 0.3f) : Col(0.3f, 0.85f, 1f)));
				Line(text + "result", pt + new Pt(-1.12f, -0.56f) * num2, pt + new Pt(1.12f, -0.56f) * num2, 0.06f * num2, c, 25);
				if (num5 == 1)
				{
					for (int k = 0; k < 8; k++)
					{
						float x = (float)k * 0.7854f + t;
						Star(text + "win" + k, pt + new Pt(Cos(x) * 1.55f, Sin(x) * 0.9f) * num2, 0.065f * num2, c, 26);
					}
				}
			}
		}

		private static void OttoAudio(bool active)
		{
			if (!active)
			{
				if (Live(ottoSource))
				{
					C(ottoSource, "Stop");
				}
				return;
			}
			if (!ottoLoaded)
			{
				ottoLoaded = true;
				string path = Path.Combine(Path.GetDirectoryName(typeof(Visuals).Assembly.Location), "OttoDisco.wav");
				if (File.Exists(path))
				{
					using BinaryReader binaryReader = new BinaryReader(File.OpenRead(path));
					if (new string(binaryReader.ReadChars(4)) != "RIFF")
					{
						throw new InvalidDataException("OttoDisco.wav must be PCM16 WAV");
					}
					binaryReader.ReadInt32();
					if (new string(binaryReader.ReadChars(4)) != "WAVE")
					{
						throw new InvalidDataException("Invalid WAV");
					}
					int num = 0;
					int num2 = 0;
					byte[] array = null;
					while (binaryReader.BaseStream.Position + 8 <= binaryReader.BaseStream.Length)
					{
						string text = new string(binaryReader.ReadChars(4));
						int num3 = binaryReader.ReadInt32();
						if (num3 < 0 || num3 > binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)
						{
							throw new InvalidDataException("WAV chunk");
						}
						long num4 = binaryReader.BaseStream.Position + num3;
						if (text == "fmt ")
						{
							if (num3 < 16 || binaryReader.ReadInt16() != 1)
							{
								throw new InvalidDataException("Use PCM16 WAV");
							}
							num = binaryReader.ReadInt16();
							num2 = binaryReader.ReadInt32();
							binaryReader.ReadInt32();
							binaryReader.ReadInt16();
							if (binaryReader.ReadInt16() != 16)
							{
								throw new InvalidDataException("Use 16-bit WAV");
							}
						}
						else if (text == "data")
						{
							array = binaryReader.ReadBytes(num3);
						}
						binaryReader.BaseStream.Position = num4 + num3 % 2;
					}
					if (array == null || num < 1 || num > 2 || num2 < 8000 || num2 > 96000 || array.Length % (num * 2) != 0)
					{
						throw new InvalidDataException("Unsupported WAV");
					}
					float[] array2 = new float[array.Length / 2];
					for (int i = 0; i < array2.Length; i++)
					{
						array2[i] = (float)BitConverter.ToInt16(array, i * 2) / 32768f;
					}
					ottoClip = C(T("UnityEngine.AudioClip"), "Create", "Otto Disco", array2.Length / num, num, num2, false);
					C(ottoClip, "SetData", array2, 0);
				}
			}
			if (Live(ottoClip))
			{
				if (!Live(ottoSource))
				{
					object obj = Activator.CreateInstance(T("UnityEngine.GameObject"), "CGC_OttoDisco");
					ottoSource = C(obj, "AddComponent", T("UnityEngine.AudioSource"));
					C(T("UnityEngine.Object"), "DontDestroyOnLoad", obj);
					S(ottoSource, "clip", ottoClip);
					S(ottoSource, "loop", true);
					S(ottoSource, "playOnAwake", false);
					S(ottoSource, "volume", 0.6f);
					S(ottoSource, "spatialBlend", 0f);
				}
				S(ottoSource, "pitch", F(G(T("UnityEngine.Time"), "timeScale")));
				if (!B(G(ottoSource, "isPlaying")))
				{
					C(ottoSource, "Play");
				}
			}
		}

		private static object AmmoFor(object gun)
		{
			if (!Live(gun))
			{
				return null;
			}
			return C(gun, "GetComponentInChildren", T("GunAmmo"), true);
		}

		private static object GunFor(object ammo)
		{
			foreach (object item in Each(G(G(T("PlayerManager"), "instance"), "players")))
			{
				if (Live(item))
				{
					object obj = C(R("Util"), "GunOf", item);
					if (AmmoFor(obj) == ammo)
					{
						return obj;
					}
				}
			}
			return null;
		}

		private static object OwnerFor(object ammo)
		{
			foreach (object item in Each(G(G(T("PlayerManager"), "instance"), "players")))
			{
				if (Live(item) && AmmoFor(C(R("Util"), "GunOf", item)) == ammo)
				{
					return item;
				}
			}
			return null;
		}

		private static void HarmonyPatch(object harmony, MethodInfo target, string prefix, string postfix = null)
		{
			if (target == null)
			{
				throw new MissingMethodException("GunAmmo patch target");
			}
			Type type = T("HarmonyLib.HarmonyMethod");
			object[] parameters = new object[5]
			{
				target,
				(prefix == null) ? null : Activator.CreateInstance(type, typeof(Visuals).GetMethod(prefix)),
				(postfix == null) ? null : Activator.CreateInstance(type, typeof(Visuals).GetMethod(postfix)),
				null,
				null
			};
			harmony.GetType().GetMethods().Single((MethodInfo m) => m.Name == "Patch" && m.GetParameters().Length == 5)
				.Invoke(harmony, parameters);
		}

		public static void InstallGameplay()
		{
		}

		private static bool WeaponCooldown(object ammo)
		{
			object obj = OwnerFor(ammo);
			if (!Live(obj))
			{
				return false;
			}
			return (Convert.ToInt64(C(R("Loadout"), "Of", obj)) & 0x501) != 0;
		}

		public static bool AmmoUpdatePrefix(object __instance)
		{
			return true;
		}

		public static bool AmmoReloadPrefix(object __instance)
		{
			return true;
		}

		public static void AmmoShootPostfix(object __instance)
		{
		}

		public static void CompleteCardReload(object gun)
		{
			Safe("card reload", delegate
			{
				object obj = AmmoFor(gun);
				if (Live(obj))
				{
					FinishAmmo(obj, gun);
				}
			});
		}

		private static void FinishAmmo(object ammo, object gun)
		{
			object obj = reloadPermit;
			try
			{
				reloadPermit = ammo;
				C(ammo, "ReloadAmmo", true);
			}
			finally
			{
				reloadPermit = obj;
				reloads.Remove(ammo);
				if (Live(gun))
				{
					S(gun, "isReloading", false);
				}
			}
		}

		public static bool CanFire(object gun)
		{
			return true;
		}

		public static bool RequestReload(object player)
		{
			return false;
		}

		public static void BeginManualReload(int pid)
		{
		}

		private static bool ReloadHeld(object player)
		{
			bool flag = B(C(R("Controls"), "Action", player, "Reload"));
			if (B(C(R("Controls"), "IsKeyboardPlayer", player)))
			{
				if (!flag)
				{
					return B(C(T("UnityEngine.Input"), "GetKey", Enum.ToObject(T("UnityEngine.KeyCode"), 114)));
				}
				return true;
			}
			object obj = G(G(G(player, "data"), "playerActions"), "Device");
			if (!flag)
			{
				if (obj != null)
				{
					return B(G(G(obj, "RightStickButton"), "IsPressed"));
				}
				return false;
			}
			return true;
		}

		public static void GameplayTick()
		{
			Safe("slot lifecycle", delegate
			{
				bool num = CanUseDoors();
				if (!num && rideWasPlaying)
				{
					ResetRide();
				}
				rideWasPlaying = num;
			});
		}

		private static void ClearReloads()
		{
			object[] array = reloads.Keys.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				object o = GunFor(array[i]);
				if (Live(o))
				{
					S(o, "isReloading", false);
				}
			}
			reloads.Clear();
			reloadKeys.Clear();
		}

		public static bool CanPull(int pid)
		{
			if (!CanUseDoors() || !B(C(T("LetItRide.Machine"), "IsHost")))
			{
				return false;
			}
			Type o = T("LetItRide.Machine");
			C(o, "Resolve");
			if (G(o, "_remove") == null)
			{
				return false;
			}
			object o2 = C(o, "Of", pid);
			if (Time < F(G(o2, "NextPull")) || Time - F(G(o2, "SpinFrom")) < 3f)
			{
				return false;
			}
			S(o2, "NextPull", Time + 0.5f);
			return true;
		}

		public static bool CanReceiveSpin()
		{
			return CanUseDoors();
		}

		public static void StartReturnedCoroutine(object result)
		{
			if (result is IEnumerator enumerator)
			{
				object o = G(T("LetItRide.Plugin"), "Instance");
				if (Live(o))
				{
					C(o, "StartCoroutine", enumerator);
				}
			}
		}

		public static void ResetRide()
		{
			Safe("slot reset", delegate
			{
				Type o;
				try
				{
					o = T("LetItRide.Machine");
				}
				catch (TypeLoadException)
				{
					return;
				}
				object o2 = G(T("LetItRide.Plugin"), "Instance");
				if (Live(o2))
				{
					C(o2, "StopAllCoroutines");
				}
				if (G(o, "States") is IDictionary dictionary)
				{
					dictionary.Clear();
				}
				Type o3 = T("LetItRide.Draw");
				if (G(o3, "Named") is IDictionary dictionary2)
				{
					foreach (object value in dictionary2.Values)
					{
						if (Live(value))
						{
							C(T("UnityEngine.Object"), "Destroy", G(value, "gameObject"));
						}
					}
					dictionary2.Clear();
				}
				if (G(o3, "Pieces") is IList list)
				{
					foreach (object item in list)
					{
						object o4 = G(item, "Sprite");
						if (Live(o4))
						{
							C(T("UnityEngine.Object"), "Destroy", G(o4, "gameObject"));
						}
					}
					list.Clear();
				}
				object o5 = G(o3, "_source");
				if (Live(o5))
				{
					C(o5, "Stop");
				}
				foreach (object item2 in Each(C(T("UnityEngine.Object"), "FindObjectsOfType", T("LetItRide.FloatingLabel"))))
				{
					if (Live(item2))
					{
						C(T("UnityEngine.Object"), "Destroy", G(item2, "gameObject"));
					}
				}
			});
		}
	}
	public sealed class SecureRandom : Random
	{
		private readonly RandomNumberGenerator generator = RandomNumberGenerator.Create();

		private readonly byte[] bytes = new byte[4];

		private readonly object gate = new object();

		private uint Draw()
		{
			generator.GetBytes(bytes);
			return BitConverter.ToUInt32(bytes, 0);
		}

		private uint Below(uint bound)
		{
			if (bound == 0)
			{
				return 0u;
			}
			uint num = (0 - bound) % bound;
			lock (gate)
			{
				uint num2;
				do
				{
					num2 = Draw();
				}
				while (num2 < num);
				return num2 % bound;
			}
		}

		public override int Next()
		{
			return (int)Below(2147483647u);
		}

		public override int Next(int maxValue)
		{
			if (maxValue < 0)
			{
				throw new ArgumentOutOfRangeException("maxValue");
			}
			return (int)Below((uint)maxValue);
		}

		public override int Next(int minValue, int maxValue)
		{
			if (minValue > maxValue)
			{
				throw new ArgumentOutOfRangeException("minValue");
			}
			return (int)(minValue + Below((uint)((ulong)maxValue - (ulong)minValue)));
		}

		protected override double Sample()
		{
			lock (gate)
			{
				return (double)Draw() / 4294967296.0;
			}
		}

		public override double NextDouble()
		{
			return Sample();
		}

		public override void NextBytes(byte[] buffer)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			lock (gate)
			{
				generator.GetBytes(buffer);
			}
		}
	}
}