Decompiled source of Zips Void Cards v0.7.2

BepInEx/plugins/ZipsVoidCards/ZipsCards.dll

Decompiled 2 days ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Photon.Pun;
using UnboundLib.Cards;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("ZipsCards")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.7.2.0")]
[assembly: AssemblyInformationalVersion("0.7.2")]
[assembly: AssemblyProduct("ZipsCards")]
[assembly: AssemblyTitle("ZipsCards")]
[assembly: AssemblyVersion("0.7.2.0")]
namespace ZipsCards;

internal static class CardArtTemplates
{
	private static readonly Dictionary<CardArtScene, GameObject> Templates = new Dictionary<CardArtScene, GameObject>();

	internal static GameObject Get(CardArtScene scene)
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Expected O, but got Unknown
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
		if (Templates.TryGetValue(scene, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		value = new GameObject("Zip's Cards Art - " + scene, new Type[3]
		{
			typeof(RectTransform),
			typeof(RectMask2D),
			typeof(ArtFrameLayout)
		});
		value.transform.position = new Vector3(100000f, 100000f, 0f);
		((RectTransform)value.transform).sizeDelta = new Vector2(360f, 420f);
		GameObject val = new GameObject("Animated illustration", new Type[2]
		{
			typeof(RectTransform),
			typeof(WarpCardArt)
		});
		val.transform.SetParent(value.transform, false);
		val.GetComponent<WarpCardArt>().Scene = scene;
		Object.DontDestroyOnLoad((Object)(object)value);
		Templates[scene] = value;
		return value;
	}
}
public sealed class ArtFrameLayout : MonoBehaviour
{
	private void LateUpdate()
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: 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_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: 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)
		Transform transform = ((Component)this).transform;
		RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		Transform parent = ((Component)this).transform.parent;
		RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
		if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
		{
			return;
		}
		Rect rect = val2.rect;
		if (!(((Rect)(ref rect)).width <= 1f))
		{
			rect = val2.rect;
			if (!(((Rect)(ref rect)).height <= 1f))
			{
				val.anchorMin = Vector2.zero;
				val.anchorMax = Vector2.one;
				val.pivot = new Vector2(0.5f, 0.5f);
				val.offsetMin = Vector2.zero;
				val.offsetMax = Vector2.zero;
				((Transform)val).localScale = Vector3.one;
			}
		}
	}
}
public sealed class WeakenedVoidBullets : CustomCard
{
	protected override string GetTitle()
	{
		return "Weakened Void Bullets";
	}

	protected override string GetDescription()
	{
		return "Makes your bullets deal void damage, but over 2 seconds";
	}

	protected override Rarity GetRarity()
	{
		return (Rarity)1;
	}

	protected override CardThemeColorType GetTheme()
	{
		return (CardThemeColorType)4;
	}

	public override string GetModName()
	{
		return "Zip's Void Cards";
	}

	protected override GameObject GetCardArt()
	{
		return CardArtTemplates.Get(CardArtScene.WeakenedVoidBullets);
	}

	protected override CardInfoStat[] GetStats()
	{
		//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_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Expected O, but got Unknown
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Expected O, but got Unknown
		return (CardInfoStat[])(object)new CardInfoStat[4]
		{
			new CardInfoStat
			{
				positive = true,
				amount = "-30%",
				stat = "Target slowed"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "+50%",
				stat = "Damage"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "+0.5s",
				stat = "Reload time"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "+20%",
				stat = "Void damage taken"
			}
		};
	}

	public override void SetupCard(CardInfo info, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers stats, Block block)
	{
		gun.damage = 1.5f;
		gun.reloadTimeAdd = 0.5f;
	}

	public override void OnAddCard(Player player, Gun gun, GunAmmo ammo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers stats)
	{
		VoidWorldStatus.Get(data);
	}
}
public sealed class VoidMagnet : CustomCard
{
	protected override string GetTitle()
	{
		return "Void Magnet";
	}

	protected override string GetDescription()
	{
		return "Pull an enemy towards the void on hit. Doesn't get used if no void in sight";
	}

	protected override Rarity GetRarity()
	{
		return (Rarity)1;
	}

	protected override CardThemeColorType GetTheme()
	{
		return (CardThemeColorType)4;
	}

	public override string GetModName()
	{
		return "Zip's Void Cards";
	}

	protected override GameObject GetCardArt()
	{
		return CardArtTemplates.Get(CardArtScene.VoidMagnet);
	}

	protected override CardInfoStat[] GetStats()
	{
		//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_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		return (CardInfoStat[])(object)new CardInfoStat[2]
		{
			new CardInfoStat
			{
				positive = false,
				amount = "10s",
				stat = "Pull cooldown"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "-25%",
				stat = "Damage"
			}
		};
	}

	public override void SetupCard(CardInfo info, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers stats, Block block)
	{
		gun.damage = 0.75f;
		gun.knockback = 1.7777778f;
	}

	public override void OnAddCard(Player player, Gun gun, GunAmmo ammo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers stats)
	{
		VoidWorldStatus.Get(data);
	}
}
public sealed class VoidKing : CustomCard
{
	protected override string GetTitle()
	{
		return "Void King";
	}

	protected override string GetDescription()
	{
		return "True king of the void, hold s while falling to warp through the void, get block back from dashing. Also get 10% damage in your next bullet for every void touch.";
	}

	protected override Rarity GetRarity()
	{
		return (Rarity)2;
	}

	protected override CardThemeColorType GetTheme()
	{
		return (CardThemeColorType)4;
	}

	public override string GetModName()
	{
		return "Zip's Void Cards";
	}

	protected override GameObject GetCardArt()
	{
		return CardArtTemplates.Get(CardArtScene.VoidKing);
	}

	protected override CardInfoStat[] GetStats()
	{
		//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_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Expected O, but got Unknown
		return (CardInfoStat[])(object)new CardInfoStat[3]
		{
			new CardInfoStat
			{
				positive = true,
				amount = "No",
				stat = "void damage"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "+30%",
				stat = "Void block rebound"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "-20%",
				stat = "Health"
			}
		};
	}

	public override void SetupCard(CardInfo info, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers stats, Block block)
	{
		info.allowMultiple = false;
		stats.health = 0.8f;
	}

	public override void OnAddCard(Player player, Gun gun, GunAmmo ammo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers stats)
	{
		VoidWorldStatus.Get(data);
	}
}
[BepInPlugin("robin.zipscards", "Zip's Void Cards", "0.7.2")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInProcess("Rounds.exe")]
public sealed class Plugin : BaseUnityPlugin
{
	public const string Id = "robin.zipscards";

	public const string DisplayName = "Zip's Void Cards";

	public const string Version = "0.7.2";

	private void Awake()
	{
		Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "robin.zipscards");
	}

	private void Start()
	{
		CustomCard.BuildCard<DimensionalHorizontalWarping>();
		CustomCard.BuildCard<DimensionalVerticalWarping>();
		CustomCard.BuildCard<VoidResistance>();
		CustomCard.BuildCard<VoidJumper>();
		CustomCard.BuildCard<VoidDasher>();
		CustomCard.BuildCard<VoidLeaper>();
		CustomCard.BuildCard<VoidHunter>();
		CustomCard.BuildCard<WeakenedVoidBullets>();
		CustomCard.BuildCard<VoidMagnet>();
		CustomCard.BuildCard<VoidKing>();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Zip's Void Cards loaded: ten cards.");
	}
}
public abstract class DimensionalWarpingCard : CustomCard
{
	protected abstract bool Vertical { get; }

	protected override string GetTitle()
	{
		if (!Vertical)
		{
			return "Dimensional Horizontal Warping";
		}
		return "Dimensional Vertical Warping";
	}

	protected override string GetDescription()
	{
		if (!Vertical)
		{
			return "The horizon folds.";
		}
		return "As above. So below.";
	}

	protected override Rarity GetRarity()
	{
		if (Vertical)
		{
			return (Rarity)0;
		}
		return (Rarity)1;
	}

	protected override CardThemeColorType GetTheme()
	{
		return (CardThemeColorType)4;
	}

	public override string GetModName()
	{
		return "Zip's Void Cards";
	}

	protected override CardInfoStat[] GetStats()
	{
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Expected O, but got Unknown
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Expected O, but got Unknown
		//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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected O, but got Unknown
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Expected O, but got Unknown
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Expected O, but got Unknown
		if (!Vertical)
		{
			return (CardInfoStat[])(object)new CardInfoStat[2]
			{
				new CardInfoStat
				{
					positive = true,
					amount = "+1",
					stat = "Horizontal warp"
				},
				new CardInfoStat
				{
					positive = false,
					amount = "-10%",
					stat = "Damage"
				}
			};
		}
		return (CardInfoStat[])(object)new CardInfoStat[3]
		{
			new CardInfoStat
			{
				positive = true,
				amount = "+2",
				stat = "Vertical warps"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "-10%",
				stat = "Damage"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "-10%",
				stat = "Attack speed"
			}
		};
	}

	protected override GameObject GetCardArt()
	{
		return CardArtTemplates.Get(Vertical ? CardArtScene.Vertical : CardArtScene.Horizontal);
	}

	public override void SetupCard(CardInfo info, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers stats, Block block)
	{
		gun.damage = 0.9f;
		if (Vertical)
		{
			gun.attackSpeed = 1.1111112f;
		}
	}

	public override void OnAddCard(Player player, Gun gun, GunAmmo ammo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers stats)
	{
	}
}
public sealed class DimensionalHorizontalWarping : DimensionalWarpingCard
{
	protected override bool Vertical => false;
}
public sealed class DimensionalVerticalWarping : DimensionalWarpingCard
{
	protected override bool Vertical => true;
}
public sealed class VoidResistance : CustomCard
{
	protected override string GetTitle()
	{
		return "Void Resistance";
	}

	protected override string GetDescription()
	{
		return "The dark bites less deeply.";
	}

	protected override Rarity GetRarity()
	{
		return (Rarity)0;
	}

	protected override CardThemeColorType GetTheme()
	{
		return (CardThemeColorType)2;
	}

	public override string GetModName()
	{
		return "Zip's Void Cards";
	}

	protected override GameObject GetCardArt()
	{
		return CardArtTemplates.Get(CardArtScene.VoidResistance);
	}

	protected override CardInfoStat[] GetStats()
	{
		//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_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Expected O, but got Unknown
		return (CardInfoStat[])(object)new CardInfoStat[3]
		{
			new CardInfoStat
			{
				positive = true,
				amount = "-50%",
				stat = "Void damage taken"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "+5%",
				stat = "Movement speed"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "+0.25s",
				stat = "Block cooldown"
			}
		};
	}

	public override void SetupCard(CardInfo info, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers stats, Block block)
	{
		stats.movementSpeed = 1.05f;
		block.cdAdd = 0.25f;
	}

	public override void OnAddCard(Player player, Gun gun, GunAmmo ammo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers stats)
	{
	}
}
internal static class CardStacks
{
	internal static int Count<T>(Player player) where T : CustomCard
	{
		if (!((Object)(object)player != (Object)null) || !((Object)(object)player.data != (Object)null))
		{
			return 0;
		}
		return player.data.currentCards.Count((CardInfo c) => (Object)(object)c != (Object)null && (Object)(object)((Component)c).GetComponent<T>() != (Object)null);
	}
}
[HarmonyPatch]
internal static class TemporaryVoidStats
{
	private static IEnumerable<MethodBase> TargetMethods()
	{
		yield return AccessTools.Method(typeof(PlayerJump), "Update", (Type[])null, (Type[])null);
		yield return AccessTools.Method(typeof(PlayerJump), "Jump", (Type[])null, (Type[])null);
		yield return AccessTools.Method(typeof(PlayerMovement), "Move", (Type[])null, (Type[])null);
	}

	private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		FieldInfo jump = AccessTools.Field(typeof(CharacterStatModifiers), "jump");
		FieldInfo speed = AccessTools.Field(typeof(CharacterStatModifiers), "movementSpeed");
		foreach (CodeInstruction instruction in instructions)
		{
			if (instruction.opcode == OpCodes.Ldfld && (object.Equals(instruction.operand, jump) || object.Equals(instruction.operand, speed)))
			{
				bool flag = object.Equals(instruction.operand, jump);
				instruction.opcode = OpCodes.Call;
				instruction.operand = AccessTools.Method(typeof(TemporaryVoidStats), flag ? "JumpStrength" : "MovementSpeed", (Type[])null, (Type[])null);
			}
			yield return instruction;
		}
	}

	private static float JumpStrength(CharacterStatModifiers stats)
	{
		VoidAbilityController component = ((Component)stats).GetComponent<VoidAbilityController>();
		return stats.jump * (((Object)(object)component != (Object)null && component.State.JumpBoostRemaining > 0f) ? Mathf.Sqrt(1.2f) : 1f);
	}

	private static float MovementSpeed(CharacterStatModifiers stats)
	{
		VoidAbilityController component = ((Component)stats).GetComponent<VoidAbilityController>();
		return stats.movementSpeed * (((Object)(object)component != (Object)null && component.State.DashSpeedRemaining > 0f) ? 1.3f : 1f);
	}
}
public sealed class VoidJumper : CustomCard
{
	protected override string GetTitle()
	{
		return "Void Jumper";
	}

	protected override string GetDescription()
	{
		return "Use the void for vertical mobility with a safety net (5s cd)";
	}

	protected override Rarity GetRarity()
	{
		return (Rarity)0;
	}

	protected override CardThemeColorType GetTheme()
	{
		return (CardThemeColorType)1;
	}

	public override string GetModName()
	{
		return "Zip's Void Cards";
	}

	protected override GameObject GetCardArt()
	{
		return CardArtTemplates.Get(CardArtScene.VoidJumper);
	}

	protected override CardInfoStat[] GetStats()
	{
		//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_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Expected O, but got Unknown
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Expected O, but got Unknown
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Expected O, but got Unknown
		return (CardInfoStat[])(object)new CardInfoStat[5]
		{
			new CardInfoStat
			{
				positive = true,
				amount = "+1",
				stat = "Air jump until landing"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "+20%",
				stat = "Jump height for 3s"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "2x",
				stat = "Next bullet damage"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "+0.25s",
				stat = "Reload time"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "-10%",
				stat = "Health"
			}
		};
	}

	public override void SetupCard(CardInfo card, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers stats, Block block)
	{
		gun.reloadTimeAdd = 0.25f;
		stats.health = 0.9f;
	}

	public override void OnAddCard(Player player, Gun gun, GunAmmo ammo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers stats)
	{
		VoidAbilityController.Get(data);
	}
}
public sealed class VoidDasher : CustomCard
{
	protected override string GetTitle()
	{
		return "Void Dasher";
	}

	protected override string GetDescription()
	{
		return "allows you to void dash (7s cd)";
	}

	protected override Rarity GetRarity()
	{
		return (Rarity)1;
	}

	protected override CardThemeColorType GetTheme()
	{
		return (CardThemeColorType)2;
	}

	public override string GetModName()
	{
		return "Zip's Void Cards";
	}

	protected override GameObject GetCardArt()
	{
		return CardArtTemplates.Get(CardArtScene.VoidDasher);
	}

	protected override CardInfoStat[] GetStats()
	{
		//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_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Expected O, but got Unknown
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Expected O, but got Unknown
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Expected O, but got Unknown
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Expected O, but got Unknown
		return (CardInfoStat[])(object)new CardInfoStat[5]
		{
			new CardInfoStat
			{
				positive = true,
				amount = "+50%",
				stat = "Side rebound force"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "30%",
				stat = "speed boost (3s)"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "0.1s",
				stat = "block cd refresh"
			},
			new CardInfoStat
			{
				positive = true,
				amount = "+150%",
				stat = "Health for 2.5s"
			},
			new CardInfoStat
			{
				positive = false,
				amount = "+0.5s",
				stat = "Block cooldown"
			}
		};
	}

	public override void SetupCard(CardInfo card, Gun gun, ApplyCardStats cardStats, CharacterStatModifiers stats, Block block)
	{
		block.cdAdd = 0.5f;
	}

	public override void OnAddCard(Player player, Gun gun, GunAmmo ammo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers stats)
	{
		VoidAbilityController.Get(data);
	}
}
public sealed class VoidAbilityController : MonoBehaviour
{
	private const string JumpEvent = "ZipsCards_VoidJump";

	private const string DashEvent = "ZipsCards_VoidDash";

	internal readonly VoidAbilityState State = new VoidAbilityState();

	private CharacterData data;

	private ChildRPC rpc;

	private bool healthApplied;

	private bool dashImpulsePending;

	private static readonly FieldRef<PlayerVelocity, bool> IsSimulated = AccessTools.FieldRefAccess<PlayerVelocity, bool>("simulated");

	internal static VoidAbilityController Get(CharacterData character)
	{
		if ((Object)(object)character == (Object)null)
		{
			return null;
		}
		VoidAbilityController component = ((Component)character).GetComponent<VoidAbilityController>();
		if (!((Object)(object)component != (Object)null))
		{
			return ((Component)character).gameObject.AddComponent<VoidAbilityController>();
		}
		return component;
	}

	private void Awake()
	{
		data = ((Component)this).GetComponent<CharacterData>();
		rpc = ((Component)this).GetComponent<ChildRPC>();
		if (!((Object)(object)rpc == (Object)null))
		{
			rpc.childRPCsInt["ZipsCards_VoidJump"] = ReceiveJump;
			rpc.childRPCsInt["ZipsCards_VoidDash"] = ReceiveDash;
		}
	}

	private static float NetworkAge(int stamp)
	{
		if (!PhotonNetwork.OfflineMode)
		{
			return Mathf.Clamp((float)(PhotonNetwork.ServerTimestamp - stamp) / 1000f, 0f, 10f);
		}
		return 0f;
	}

	private void ReceiveJump(int stamp)
	{
		if (!((Object)(object)data == (Object)null) && !data.dead && CardStacks.Count<VoidJumper>(data.player) != 0)
		{
			State.TryActivateJump(NetworkAge(stamp), fromOwner: true);
		}
	}

	private void ReceiveDash(int stamp)
	{
		if (!((Object)(object)data == (Object)null) && !data.dead && CardStacks.Count<VoidDasher>(data.player) != 0)
		{
			State.TryActivateDash(NetworkAge(stamp), fromOwner: true);
			data.block.ResetCD(true);
			dashImpulsePending = (Object)(object)data.view != (Object)null && data.view.IsMine;
			UpdateTemporaryHealth();
		}
	}

	internal void SuccessfulVoidBlock(Vector2 inwardNormal)
	{
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)data == (Object)null || data.dead || (Object)(object)data.view == (Object)null || !data.view.IsMine)
		{
			return;
		}
		bool flag = Mathf.Abs(inwardNormal.y) >= Mathf.Abs(inwardNormal.x);
		string text = null;
		if (flag && CardStacks.Count<VoidJumper>(data.player) > 0 && State.JumpCooldown <= 0f)
		{
			text = "ZipsCards_VoidJump";
		}
		if (!flag && CardStacks.Count<VoidDasher>(data.player) > 0 && State.DashCooldown <= 0f)
		{
			text = "ZipsCards_VoidDash";
		}
		if (text != null)
		{
			int serverTimestamp = PhotonNetwork.ServerTimestamp;
			if ((Object)(object)rpc != (Object)null)
			{
				rpc.CallFunction(text, serverTimestamp);
			}
			else if (flag)
			{
				ReceiveJump(serverTimestamp);
			}
			else
			{
				ReceiveDash(serverTimestamp);
			}
		}
	}

	internal Vector2 EnhanceVoidRebound(Vector2 force)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		if (!dashImpulsePending || Mathf.Abs(force.x) <= Mathf.Abs(force.y))
		{
			return force;
		}
		dashImpulsePending = false;
		return force * 1.5f;
	}

	private void Update()
	{
		if ((Object)(object)data == (Object)null)
		{
			return;
		}
		if (data.dead)
		{
			Clear();
			return;
		}
		if (data.isPlaying && (Object)(object)data.playerVel != (Object)null && IsSimulated.Invoke(data.playerVel))
		{
			State.Tick(TimeHandler.deltaTime);
		}
		if (CardStacks.Count<VoidJumper>(data.player) == 0 && CardStacks.Count<VoidDasher>(data.player) == 0)
		{
			Clear();
		}
		else
		{
			UpdateTemporaryHealth();
		}
	}

	private void UpdateTemporaryHealth()
	{
		if (!((Object)(object)data == (Object)null) && healthApplied != State.DashHealthActive)
		{
			float num = (State.DashHealthActive ? 2.5f : 0.4f);
			CharacterData obj = data;
			obj.maxHealth *= num;
			CharacterData obj2 = data;
			obj2.health *= num;
			healthApplied = State.DashHealthActive;
		}
	}

	internal void Clear()
	{
		((MonoBehaviour)this).StopAllCoroutines();
		State.Reset();
		dashImpulsePending = false;
		UpdateTemporaryHealth();
	}

	private void OnDisable()
	{
		Clear();
	}
}
[HarmonyPatch(typeof(CharacterData), "Start")]
internal static class InitializeVoidAbilities
{
	private static void Postfix(CharacterData __instance)
	{
		VoidAbilityController.Get(__instance);
		VoidWorldStatus.Get(__instance);
	}
}
[HarmonyPatch(typeof(CharacterData), "TouchGround")]
internal static class ClearAirJumpOnGround
{
	private static void Postfix(CharacterData __instance)
	{
		VoidAbilityController component = ((Component)__instance).GetComponent<VoidAbilityController>();
		if ((Object)(object)component != (Object)null)
		{
			component.State.Land();
		}
	}
}
[HarmonyPatch(typeof(PlayerJump), "Jump")]
internal static class ExtraVoidJump
{
	private static void Prefix(PlayerJump __instance, bool forceJump, out CharacterData __state)
	{
		__state = null;
		if (forceJump)
		{
			return;
		}
		CharacterData component = ((Component)__instance).GetComponent<CharacterData>();
		if (!((Object)(object)component == (Object)null) && !component.dead && !component.isGrounded && !(component.sinceJump < 0.1f) && component.currentJumps <= 0 && !(component.sinceWallGrab <= 0.1f))
		{
			VoidAbilityController component2 = ((Component)component).GetComponent<VoidAbilityController>();
			if (!((Object)(object)component2 == (Object)null) && component2.State.ConsumeExtraJump())
			{
				component.currentJumps = 1;
				__state = component;
			}
		}
	}

	private static void Postfix(CharacterData __state)
	{
		if ((Object)(object)__state != (Object)null)
		{
			__state.currentJumps = 0;
		}
	}
}
[HarmonyPatch(typeof(Gun), "BulletInit")]
internal static class EmpowerNextVoidBullet
{
	private static void Postfix(GameObject bullet, bool useAmmo)
	{
		if ((Object)(object)bullet == (Object)null)
		{
			return;
		}
		ProjectileHit component = bullet.GetComponent<ProjectileHit>();
		ProjectileSetup.Attach(component);
		if (useAmmo && !((Object)(object)component == (Object)null) && !((Object)(object)component.ownPlayer == (Object)null))
		{
			VoidWorldStatus component2 = ((Component)component.ownPlayer).GetComponent<VoidWorldStatus>();
			if ((Object)(object)component2 != (Object)null && component2.IsKing)
			{
				component.damage *= component2.King.Consume();
			}
			VoidAbilityController component3 = ((Component)component.ownPlayer).GetComponent<VoidAbilityController>();
			if ((Object)(object)component3 != (Object)null && component3.State.ConsumeBullet())
			{
				component.damage *= 2f;
			}
		}
	}
}
[HarmonyPatch(typeof(HealthHandler), "Revive")]
internal static class ResetAbilitiesOnRevive
{
	private static void Prefix(HealthHandler __instance)
	{
		VoidAbilityController component = ((Component)__instance).GetComponent<VoidAbilityController>();
		if ((Object)(object)component != (Object)null)
		{
			component.Clear();
		}
		VoidWorldStatus component2 = ((Component)__instance).GetComponent<VoidWorldStatus>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.Clear();
		}
	}
}
[HarmonyPatch(typeof(CharacterStatModifiers), "ResetStats")]
internal static class ResetAbilitiesWithStats
{
	private static void Prefix(CharacterStatModifiers __instance)
	{
		VoidAbilityController component = ((Component)__instance).GetComponent<VoidAbilityController>();
		if ((Object)(object)component != (Object)null)
		{
			component.Clear();
		}
		VoidWorldStatus component2 = ((Component)__instance).GetComponent<VoidWorldStatus>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.Clear();
		}
	}
}
internal sealed class VoidAbilityState
{
	internal float JumpCooldown { get; private set; }

	internal float DashCooldown { get; private set; }

	internal float JumpBoostRemaining { get; private set; }

	internal float DashSpeedRemaining { get; private set; }

	internal float DashHealthRemaining { get; private set; }

	internal bool ExtraJumpReady { get; private set; }

	internal bool EmpoweredBulletReady { get; private set; }

	internal bool VoidImmune => JumpBoostRemaining > 0f;

	internal bool DashHealthActive => DashHealthRemaining > 0f;

	internal bool TryActivateJump(float age = 0f, bool fromOwner = false)
	{
		if (JumpCooldown > 0f && !fromOwner)
		{
			return false;
		}
		JumpCooldown = Math.Max(0f, 5f - age);
		JumpBoostRemaining = Math.Max(0f, 3f - age);
		ExtraJumpReady = true;
		EmpoweredBulletReady = true;
		return true;
	}

	internal bool TryActivateDash(float age = 0f, bool fromOwner = false)
	{
		if (DashCooldown > 0f && !fromOwner)
		{
			return false;
		}
		DashCooldown = Math.Max(0f, 7f - age);
		DashSpeedRemaining = Math.Max(0f, 3f - age);
		DashHealthRemaining = Math.Max(0f, 2.5f - age);
		return true;
	}

	internal void Tick(float dt)
	{
		dt = Math.Max(0f, dt);
		JumpCooldown = Math.Max(0f, JumpCooldown - dt);
		DashCooldown = Math.Max(0f, DashCooldown - dt);
		JumpBoostRemaining = Math.Max(0f, JumpBoostRemaining - dt);
		DashSpeedRemaining = Math.Max(0f, DashSpeedRemaining - dt);
		DashHealthRemaining = Math.Max(0f, DashHealthRemaining - dt);
	}

	internal bool ConsumeExtraJump()
	{
		bool extraJumpReady = ExtraJumpReady;
		ExtraJumpReady = false;
		return extraJumpReady;
	}

	internal bool ConsumeBullet()
	{
		bool empoweredBulletReady = EmpoweredBulletReady;
		EmpoweredBulletReady = false;
		return empoweredBulletReady;
	}

	internal void Land()
	{
		ExtraJumpReady = false;
	}

	internal void Reset()
	{
		float num = (DashHealthRemaining = 0f);
		float num3 = (DashSpeedRemaining = num);
		float num5 = (JumpBoostRemaining = num3);
		float jumpCooldown = (DashCooldown = num5);
		JumpCooldown = jumpCooldown;
		bool extraJumpReady = (EmpoweredBulletReady = false);
		ExtraJumpReady = extraJumpReady;
	}
}
public sealed class WarpCardArt : MaskableGraphic
{
	public CardArtScene Scene;

	public const float LoopSeconds = 9.6f;

	private float clock;

	private float sx;

	private float sy;

	private float aspect;

	private float stageX;

	private float stageY;

	private float stageAngle;

	private float stageZoom = 1f;

	private static readonly Color Ink = new Color(0.035f, 0.025f, 0.065f, 1f);

	private static readonly Color Purple = new Color(0.54f, 0.12f, 0.77f, 1f);

	private static readonly Color Lilac = new Color(0.79f, 0.47f, 0.94f, 1f);

	private static readonly Color Orange = new Color(0.94f, 0.3f, 0.045f, 1f);

	private static readonly Color Yellow = new Color(0.98f, 0.74f, 0.055f, 1f);

	private static readonly Color Blue = new Color(0.09f, 0.35f, 0.94f, 1f);

	private static readonly Color Paper = new Color(0.94f, 0.9f, 0.78f, 1f);

	private static readonly Color Mint = new Color(0.26f, 0.74f, 0.68f, 1f);

	public float Duration
	{
		get
		{
			if (Scene != CardArtScene.VoidKing && Scene != CardArtScene.VoidLeaper)
			{
				return 9.6f;
			}
			return 12f;
		}
	}

	private float Cycle => (float)Math.PI * 2f / Duration;

	private void DrawDirectedScene(VertexHelper m, float t)
	{
		switch (Scene)
		{
		case CardArtScene.Horizontal:
			FoldedHorizon(m, t);
			break;
		case CardArtScene.Vertical:
			VerticalMonument(m, t);
			break;
		case CardArtScene.VoidResistance:
			QuietStone(m, t);
			break;
		case CardArtScene.VoidJumper:
			SolarLeap(m, t);
			break;
		case CardArtScene.VoidDasher:
			BlueSlash(m, t);
			break;
		case CardArtScene.VoidLeaper:
			ImpossibleDoors(m, t);
			break;
		case CardArtScene.VoidHunter:
			BountyPortrait(m, t);
			break;
		case CardArtScene.WeakenedVoidBullets:
			FracturedRelic(m, t);
			break;
		case CardArtScene.VoidMagnet:
			BentField(m, t);
			break;
		case CardArtScene.VoidKing:
			Coronation(m, t);
			break;
		}
	}

	private void Base(VertexHelper m, Color c)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		Quad(m, 0f, 0f, 2.1f, 2.1f, c);
	}

	private void Rays(VertexHelper m, Vector2 p, float turn, Color a, Color b, int count)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: 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)
		for (int i = 0; i < count; i++)
		{
			float num = (float)i * (float)Math.PI * 2f / (float)count + turn;
			float num2 = (float)Math.PI / (float)count * 0.55f;
			Polygon(m, (Vector2[])(object)new Vector2[3]
			{
				p,
				Local(p, Mathf.Cos(num - num2) * 3f, Mathf.Sin(num - num2) * 3f),
				Local(p, Mathf.Cos(num + num2) * 3f, Mathf.Sin(num + num2) * 3f)
			}, (i % 2 == 0) ? a : b);
		}
	}

	private void Arch(VertexHelper m, float x, float y, float radius, float height, float width, Color c)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		Ring(m, x, y, radius, width, 0f, (float)Math.PI, c);
		Segment(m, x - radius * aspect, y, x - radius * aspect, y - height, width, c);
		Segment(m, x + radius * aspect, y, x + radius * aspect, y - height, width, c);
	}

	private void Star(VertexHelper m, Vector2 p, float size, float a, Color c)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 4; i++)
		{
			float num = a + (float)i * (float)Math.PI / 2f;
			Polygon(m, (Vector2[])(object)new Vector2[3]
			{
				p,
				Local(p, Mathf.Cos(num) * size, Mathf.Sin(num) * size),
				Local(p, Mathf.Cos(num + 0.3f) * size * 0.23f, Mathf.Sin(num + 0.3f) * size * 0.23f)
			}, c);
		}
	}

	private void FoldedHorizon(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01db: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_0222: Unknown result type (might be due to invalid IL or missing references)
		//IL_026f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0358: Unknown result type (might be due to invalid IL or missing references)
		//IL_036c: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.16f, 0.065f, 0.24f, 1f));
		float num = 0.16f * Mathf.Sin(t * Cycle);
		for (int i = -5; i < 6; i++)
		{
			float num2 = (float)i * 0.25f;
			for (int j = -5; j < 6; j++)
			{
				float num3 = (float)j * 0.25f + num + (float)(i % 2) * 0.11f;
				Polygon(m, (Vector2[])(object)new Vector2[4]
				{
					new Vector2(num3, num2),
					new Vector2(num3 + 0.2f, num2 + 0.14f),
					new Vector2(num3 + 0.25f, num2 + 0.1f),
					new Vector2(num3 + 0.055f, num2 - 0.04f)
				}, new Color(0.23f, 0.105f, 0.33f, 1f));
				Segment(m, num3, num2, num3 + 0.2f, num2 + 0.14f, 0.005f, new Color(0.32f, 0.15f, 0.44f, 1f));
			}
		}
		bool num4 = t >= Duration * 0.5f;
		float num5 = (num4 ? 1 : (-1));
		float num6 = (num4 ? (t - Duration * 0.5f) : t);
		Polygon(m, (Vector2[])(object)new Vector2[4]
		{
			new Vector2(num5 * 0.35f, -1f),
			new Vector2(num5 * 0.78f, 1f),
			new Vector2(num5 * 1.3f, 1f),
			new Vector2(num5 * 1.3f, -1f)
		}, Ink);
		Character(m, new Vector2(num5 * 0.62f, -0.56f), 0.57f, Purple, (num6 > 1.8f && num6 < 2.5f) ? FaceMood.Shocked : FaceMood.Curious, new Vector2(0f - num5, 0.12f), (num5 < 0f) ? 0.16f : 2.98f, 0f, 0f, num5 * 0.1f, t);
		float num7 = (0f - num5) * 0.61f;
		Segment(m, num7, -1f, num7, 1f, 0.012f, Lilac);
		for (int k = 0; k < 7; k++)
		{
			float num8 = -0.9f + (float)k * 0.3f;
			Segment(m, num7, num8, num7 + num5 * 0.18f, num8 + 0.04f * Mathf.Sin(t * Cycle + (float)k), 0.006f, Mint);
		}
		float num9 = Frac((num6 - 0.4f) / 3.3f);
		float num10 = Mathf.Lerp(num5 * 0.12f, (0f - num5) * 1.2f, num9);
		float num11 = 0.13f + 0.65f * num9 - 0.62f * num9 * num9;
		for (int num12 = 6; num12 >= 0; num12--)
		{
			Disc(m, num10 + num5 * (float)num12 * 0.034f, num11 - 0.005f * (float)num12, 0.027f - (float)num12 * 0.0025f, 0.027f - (float)num12 * 0.0025f, Alpha(Paper, 1f - (float)num12 * 0.13f));
		}
		float num13 = Mathf.Max(Bell(t, Duration * 0.5f, 0.2f), Mathf.Max(Bell(t, 0f, 0.18f), Bell(t, Duration, 0.18f)));
		if (num13 > 0f)
		{
			Quad(m, 0f, 0f, 2.05f * Ease(num13), 2.1f, Ink);
		}
	}

	private void VerticalMonument(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Unknown result type (might be due to invalid IL or missing references)
		//IL_022d: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0247: Unknown result type (might be due to invalid IL or missing references)
		//IL_024d: Unknown result type (might be due to invalid IL or missing references)
		//IL_026a: Unknown result type (might be due to invalid IL or missing references)
		//IL_02af: Unknown result type (might be due to invalid IL or missing references)
		//IL_0271: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_030f: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_042f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0473: Unknown result type (might be due to invalid IL or missing references)
		//IL_047a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0486: Unknown result type (might be due to invalid IL or missing references)
		//IL_0356: Unknown result type (might be due to invalid IL or missing references)
		//IL_035e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0363: Unknown result type (might be due to invalid IL or missing references)
		//IL_0367: Unknown result type (might be due to invalid IL or missing references)
		//IL_036e: Unknown result type (might be due to invalid IL or missing references)
		//IL_039e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0397: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.09f, 0.1f, 0.24f, 1f));
		float num = t * Cycle;
		float num2 = 0.22f * Mathf.Sin(num);
		for (int i = 0; i < 6; i++)
		{
			float radius = 0.22f + (float)i * 0.19f;
			Arch(m, -0.24f, 0.46f + num2 - (float)i * 0.1f, radius, 1.5f, 0.035f, (i % 2 == 0) ? new Color(0.24f, 0.19f, 0.4f, 1f) : new Color(0.16f, 0.17f, 0.32f, 1f));
		}
		for (int j = 0; j < 8; j++)
		{
			float num3 = -1.1f + (float)j * 0.3f + 0.12f * Mathf.Sin(num);
			Segment(m, -1f, num3, -0.59f, num3 + 0.1f, 0.032f, new Color(0.25f, 0.24f, 0.45f, 1f));
			Segment(m, 0.45f, num3 + 0.15f, 1f, num3 + 0.04f, 0.025f, new Color(0.14f, 0.21f, 0.36f, 1f));
		}
		Vector2 val = default(Vector2);
		((Vector2)(ref val))..ctor(-0.55f, -0.55f);
		float num4 = t - 0.75f;
		Vector2 val2 = Local(val, 0.49f * Mathf.Cos(1.35f), 0.49f * Mathf.Sin(1.35f));
		float num5 = (1.4f - Mathf.Sqrt(1.96f - 0.8f * (0.96f - val2.y))) / 0.4f;
		float num6 = (1.4f + Mathf.Sqrt(1.96f - 0.8f * (0.96f - val2.y))) / 0.4f;
		float num7 = (1.4f + Mathf.Sqrt(1.96f + 0.8f * (0.96f + val2.y))) / 0.4f;
		Vector2 val3 = VerticalShot(val2, Mathf.Max(0f, num4), num5, num6);
		Character(m, val, 0.2f, Purple, FaceMood.Curious, (Vector2)((num4 >= 0f && num4 <= num7) ? (val3 - val) : new Vector2(0f, 1f)), 1.35f, 0f, 0f, 0f, t);
		Segment(m, -0.87f, -0.96f, -0.22f, -0.96f, 0.018f, Lilac);
		for (int k = 0; k < 5; k++)
		{
			float num8 = -0.8f + (float)k * 0.35f;
			Segment(m, num8, 0.96f, num8 + 0.2f, 0.96f, 0.008f, Lilac);
			Segment(m, num8, -0.96f, num8 + 0.2f, -0.96f, 0.008f, Lilac);
		}
		if (num4 >= 0f && num4 <= num7)
		{
			for (int num9 = 7; num9 >= 0; num9--)
			{
				float num10 = num4 - (float)num9 * 0.026f;
				if (!(num10 < 0f))
				{
					Vector2 val4 = VerticalShot(val2, num10, num5, num6);
					Disc(m, val4.x, val4.y, 0.022f - (float)num9 * 0.0017f, 0.022f - (float)num9 * 0.0017f, Alpha((num9 == 0) ? Paper : Mint, 1f - (float)num9 * 0.1f));
				}
			}
		}
		float num11 = Bell(t, 0.75f, 0.12f);
		if (num11 > 0f)
		{
			Star(m, val2, 0.07f * num11, 0f, Paper);
		}
		float num12 = Mathf.Max(Bell(num4, num5, 0.18f), Bell(num4, num6, 0.18f));
		if (num12 > 0f)
		{
			Ring(m, val2.x + 0.055f * ((num4 < 3f) ? num5 : num6), 0.96f, 0.07f + (1f - num12) * 0.12f, 0.008f, 0f, (float)Math.PI * 2f, Alpha(Mint, num12));
			Ring(m, val2.x + 0.055f * ((num4 < 3f) ? num5 : num6), -0.96f, 0.07f + (1f - num12) * 0.12f, 0.008f, 0f, (float)Math.PI * 2f, Alpha(Mint, num12));
		}
	}

	private Vector2 VerticalShot(Vector2 origin, float u, float first, float second)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		float num = origin.y + 1.4f * u - 0.2f * u * u;
		if (u >= first && u < second)
		{
			num -= 1.92f;
		}
		return new Vector2(origin.x + 0.055f * u, num);
	}

	private void QuietStone(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0222: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_0241: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Unknown result type (might be due to invalid IL or missing references)
		//IL_0283: Unknown result type (might be due to invalid IL or missing references)
		//IL_02df: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.24f, 0.12f, 0.065f, 1f));
		for (int i = -4; i < 5; i++)
		{
			for (int j = -5; j < 6; j++)
			{
				float num = (float)j * 0.25f + (float)(i % 2) * 0.12f;
				float num2 = (float)i * 0.28f;
				Polygon(m, (Vector2[])(object)new Vector2[4]
				{
					new Vector2(num, num2 - 0.12f),
					new Vector2(num - 0.11f, num2 + 0.06f),
					new Vector2(num + 0.02f, num2 + 0.16f),
					new Vector2(num + 0.12f, num2)
				}, ((i + j) % 2 == 0) ? new Color(0.32f, 0.17f, 0.08f, 1f) : new Color(0.2f, 0.095f, 0.05f, 1f));
			}
		}
		Character(m, new Vector2(-0.55f, -0.49f + 0.018f * Mathf.Sin(t * Cycle)), 0.61f, Orange, FaceMood.Sleepy, new Vector2(1f, 0f), 0.5f, 0f, 0f, -0.08f, t);
		for (int k = 0; k < 8; k++)
		{
			float num3 = -1.2f + (float)k * 0.37f;
			float num4 = 0.36f + 0.12f * Mathf.Sin(t * Cycle + (float)k * 0.8f);
			Polygon(m, (Vector2[])(object)new Vector2[5]
			{
				new Vector2(num4, num3 - 0.1f),
				new Vector2(num4 - 0.2f, num3 + 0.07f),
				new Vector2(num4 + 0.04f, num3 + 0.22f),
				new Vector2(1.2f, num3 + 0.34f),
				new Vector2(1.2f, num3 - 0.16f)
			}, (Color)((k % 2 == 0) ? Ink : new Color(0.08f, 0.045f, 0.07f, 1f)));
			Segment(m, num4 - 0.19f, num3 + 0.07f, num4 + 0.03f, num3 + 0.22f, 0.007f, Alpha(Orange, 0.45f));
		}
		for (int l = 0; l < 5; l++)
		{
			float num5 = t * Cycle + (float)l * 1.26f;
			Diamond(m, 0.18f + 0.13f * Mathf.Cos(num5), 0.75f - (float)l * 0.35f, 0.025f, num5, Orange);
		}
	}

	private void SolarLeap(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0337: Unknown result type (might be due to invalid IL or missing references)
		//IL_034d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0368: Unknown result type (might be due to invalid IL or missing references)
		//IL_0200: Unknown result type (might be due to invalid IL or missing references)
		//IL_020a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0239: Unknown result type (might be due to invalid IL or missing references)
		//IL_0249: Unknown result type (might be due to invalid IL or missing references)
		//IL_027d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0287: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02de: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.29f, 0.2f, 0.035f, 1f));
		Rays(m, new Vector2(-0.3f, -0.48f), -0.14f + 0.06f * Mathf.Sin(t * Cycle), new Color(0.36f, 0.25f, 0.045f, 1f), new Color(0.31f, 0.22f, 0.035f, 1f), 16);
		for (int i = -4; i < 5; i++)
		{
			for (int j = -4; j < 5; j++)
			{
				float num = (float)j * 0.33f + (float)(i % 2) * 0.14f;
				float num2 = (float)i * 0.3f;
				Stroke(m, new Vector2(num - 0.035f, num2 - 0.03f), new Vector2(num + 0.035f, num2 + 0.06f), 0.023f, new Color(0.47f, 0.34f, 0.055f, 1f));
			}
		}
		float num3 = Frac(t / Duration);
		float num4 = Bell(num3, 0.44f, 0.25f);
		float num5 = Ease(Mathf.Clamp01((num3 - 0.12f) / 0.34f));
		Disc(m, 0.2f, 0.4f, 0.62f, 0.62f, new Color(0.67f, 0.43f, 0.045f, 1f));
		Ring(m, 0.2f, 0.4f, 0.71f, 0.014f, (0f - t) * Cycle, 5.183628f, Yellow);
		if (num3 < 0.62f)
		{
			float num6 = Mathf.Lerp(-0.73f, 0.38f, num5);
			float num7 = Mathf.Lerp(-0.59f, 0.14f, num5);
			for (int num8 = 3; num8 > 0; num8--)
			{
				Character(m, new Vector2(num7 - (float)num8 * 0.09f, num6 - (float)num8 * 0.18f), 0.19f, Alpha(Yellow, (0.08f + (float)num8 * 0.025f) * num5 * (1f - Ease((num3 - 0.48f) / 0.14f))), FaceMood.Focused, new Vector2(0f, 1f), 1.1f, 0f, 0f, -0.2f, t);
			}
			Character(m, new Vector2(num7, num6), 0.23f, Yellow, (num3 < 0.2f) ? FaceMood.Focused : FaceMood.Joy, new Vector2(0.2f, 1f), 1.2f, Mathf.Sin(t * Cycle * 12f), 0f, -0.17f * num5, t);
			Star(m, new Vector2(0.6f, 0.76f), 0.11f, t * Cycle, Paper);
		}
		else
		{
			float num9 = Ease((num3 - 0.62f) / 0.38f);
			Character(m, new Vector2(Mathf.Lerp(0.5f, -0.59f, num9), Mathf.Lerp(-0.56f, -0.73f, num9)), Mathf.Lerp(0.56f, 0.23f, num9), Yellow, (num3 > 0.9f) ? FaceMood.Focused : FaceMood.Joy, new Vector2(0.2f, 1f), Mathf.Lerp(0.8f, 1.2f, num9), 0f, 0f, -0.18f * (1f - num9), t);
		}
		if (num4 > 0.65f)
		{
			Star(m, new Vector2(-0.3f, 0.55f), 0.14f * (num4 - 0.65f) * 2.85f, 0f, Paper);
		}
	}

	private void BlueSlash(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0167: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: 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_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0262: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_027e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_0211: Unknown result type (might be due to invalid IL or missing references)
		//IL_021b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0225: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_033c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.025f, 0.07f, 0.23f, 1f));
		for (int i = -3; i < 5; i++)
		{
			for (int j = -3; j < 4; j++)
			{
				float x = (float)j * 0.38f + (float)(i % 2) * 0.19f;
				float y = (float)i * 0.41f;
				Disc(m, x, y, 0.17f, 0.27f, ((i + j) % 2 == 0) ? new Color(0.05f, 0.15f, 0.44f, 1f) : new Color(0.04f, 0.12f, 0.35f, 1f));
			}
		}
		for (int k = 0; k < 9; k++)
		{
			float num = Frac((float)k * 0.17f - t / Duration * 2f) * 3f - 1.5f;
			float num2 = -1.2f + (float)k * 0.27f;
			Polygon(m, (Vector2[])(object)new Vector2[4]
			{
				new Vector2(num - 0.8f, num2 - 0.12f),
				new Vector2(num + 0.65f, num2 + 0.28f),
				new Vector2(num + 0.75f, num2 + 0.34f),
				new Vector2(num - 0.7f, num2 - 0.03f)
			}, (k % 2 == 0) ? new Color(0.06f, 0.23f, 0.62f, 1f) : new Color(0.08f, 0.3f, 0.75f, 1f));
		}
		Segment(m, 0.96f, -1f, 0.96f, 1f, 0.014f, Mint);
		if (t >= 1.6f && t < 2.95f)
		{
			for (int num3 = 4; num3 > 0; num3--)
			{
				Character(m, DashPosition(Mathf.Max(1.6f, t - (float)num3 * 0.07f)), 0.26f, Alpha(Blue, 0.06f), FaceMood.Grit, new Vector2(-1f, 0f), 3.05f, 0f, 0f, -0.2f, t);
			}
		}
		Vector2 at = DashPosition(t);
		bool flag = t >= 1.6f && t < 3.5f;
		Character(m, at, 0.26f, Blue, (t < 3.5f) ? FaceMood.Grit : FaceMood.Joy, new Vector2((float)((!flag) ? 1 : (-1)), 0.05f), flag ? 3.05f : 0.12f, Mathf.Sin(t * Cycle * 12f) * 0.4f, Bell(t, 1.6f, 0.24f), flag ? (-0.22f) : 0.08f, t);
		float num4 = Bell(t, 1.6f, 0.35f);
		if (num4 > 0f)
		{
			Ring(m, 0.94f, -0.3f, 0.09f + (1f - num4) * 0.28f, 0.013f, -(float)Math.PI / 2f, (float)Math.PI, Alpha(Mint, num4));
		}
	}

	private Vector2 DashPosition(float t)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		if (t < 1.6f)
		{
			return new Vector2(Mathf.Lerp(-0.6f, 0.8f, Ease(t / 1.6f)), -0.3f);
		}
		if (t < 2.8f)
		{
			float num = (t - 1.6f) / 1.2f;
			float num2 = 1f - (1f - num) * (1f - num) * (1f - num);
			return new Vector2(Mathf.Lerp(0.8f, -0.72f, num2), -0.3f + 0.25f * Mathf.Sin(num * (float)Math.PI));
		}
		return new Vector2(Mathf.Lerp(-0.72f, -0.6f, Ease((t - 2.8f) / (Duration - 2.8f))), -0.3f);
	}

	private void ImpossibleDoors(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0237: Unknown result type (might be due to invalid IL or missing references)
		//IL_0257: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0348: Unknown result type (might be due to invalid IL or missing references)
		//IL_036d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03da: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.13f, 0.075f, 0.19f, 1f));
		float num = t * Cycle;
		for (int i = -3; i < 4; i++)
		{
			for (int j = -4; j < 5; j++)
			{
				float num2 = (float)j * 0.3f + 0.04f * Mathf.Sin(num);
				float num3 = (float)i * 0.34f + 0.025f * Mathf.Cos(num);
				Segment(m, num2 - 0.1f, num3 - 0.12f, num2 - 0.1f, num3 + 0.12f, 0.008f, new Color(0.27f, 0.17f, 0.34f, 1f));
				Segment(m, num2 - 0.1f, num3 + 0.12f, num2 + 0.11f, num3 + 0.12f, 0.008f, new Color(0.27f, 0.17f, 0.34f, 1f));
				Segment(m, num2 + 0.11f, num3 + 0.12f, num2 + 0.11f, num3 - 0.02f, 0.008f, new Color(0.27f, 0.17f, 0.34f, 1f));
			}
		}
		bool flag = t >= 6f;
		float num4 = (flag ? (t - 6f) : t);
		Arch(m, 0.55f, 0.33f, 0.27f, 0.95f, 0.09f, new Color(0.23f, 0.14f, 0.3f, 1f));
		Quad(m, 0.55f, -0.1f, 0.45f, 0.87f, Ink);
		Character(m, new Vector2(0.55f, -0.12f), 0.115f, Purple, FaceMood.Curious, new Vector2(-1f, 0f), 3f, Mathf.Sin(t * Cycle * 18f), 0f, (float)Math.PI, t);
		Arch(m, -0.18f, 0.2f, 0.58f, 1.2f, 0.12f, Lilac);
		Quad(m, -0.18f, -0.33f, 0.83f, 1.05f, Ink);
		float num5 = Ease(num4 / 4.5f);
		float num6 = (flag ? Mathf.Lerp(-0.5f, 0.1f, num5) : Mathf.Lerp(-0.08f, 0.52f, num5));
		Character(m, new Vector2(num6, -0.38f + 0.03f * Mathf.Sin(t * Cycle * 8f)), flag ? 0.33f : 0.21f, Purple, FaceMood.Curious, new Vector2((float)(flag ? 1 : (-1)), 0.1f), flag ? 0.1f : 3.1f, Mathf.Sin(t * Cycle * 18f), 0f, flag ? (-0.1f) : 0.08f, t);
		Quad(m, 0.9f, -0.15f, 0.32f, 2.3f, new Color(0.29f, 0.16f, 0.35f, 1f));
		Segment(m, 0.73f, -1f, 0.73f, 1f, 0.024f, Lilac);
		float num7 = Mathf.Max(Bell(t, 6f, 0.3f), Mathf.Max(Bell(t, 0f, 0.3f), Bell(t, 12f, 0.3f)));
		if (num7 > 0f)
		{
			Quad(m, -0.18f, 0f, 1.85f * Ease(num7), 2.1f, Ink);
		}
	}

	private void Reticle(VertexHelper m, Vector2 p, float r, float t, Color c)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		Ring(m, p.x, p.y, r, 0.009f, t * Cycle, 5.4977875f, c);
		Ring(m, p.x, p.y, r * 0.86f, 0.004f, (0f - t) * Cycle * 2f, 5.0265484f, c);
		for (int i = 0; i < 4; i++)
		{
			float num = (float)i * (float)Math.PI / 2f;
			Vector2 val = Local(p, Mathf.Cos(num) * r * 0.9f, Mathf.Sin(num) * r * 0.9f);
			Vector2 val2 = Local(p, Mathf.Cos(num) * r * 1.12f, Mathf.Sin(num) * r * 1.12f);
			Segment(m, val.x, val.y, val2.x, val2.y, 0.012f, c);
		}
	}

	private void Skull(VertexHelper m, Vector2 p, float r, Color c)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		Disc(m, p.x, p.y + r * 0.18f, r * 0.66f, r * 0.62f, c);
		Quad(m, p.x, p.y - r * 0.27f, r * 0.83f * aspect, r * 0.65f, c);
		Disc(m, p.x - r * 0.24f * aspect, p.y + r * 0.17f, r * 0.15f, r * 0.18f, Ink);
		Disc(m, p.x + r * 0.24f * aspect, p.y + r * 0.17f, r * 0.15f, r * 0.18f, Ink);
		Diamond(m, p.x, p.y - r * 0.1f, r * 0.1f, 0f, Ink);
		for (int i = -1; i <= 1; i++)
		{
			Quad(m, p.x + (float)i * r * 0.2f * aspect, p.y - r * 0.52f, r * 0.07f * aspect, r * 0.21f, Ink);
		}
	}

	private void BountyPortrait(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: 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_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_026a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_028e: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.12f, 0.045f, 0.13f, 1f));
		Vector2 val = default(Vector2);
		for (int i = -4; i < 5; i++)
		{
			for (int j = -4; j < 5; j++)
			{
				((Vector2)(ref val))..ctor((float)j * 0.3f + (float)(i % 2) * 0.15f, (float)i * 0.28f);
				Segment(m, val.x - 0.045f, val.y, val.x + 0.045f, val.y, 0.004f, new Color(0.3f, 0.1f, 0.23f, 1f));
				Segment(m, val.x, val.y - 0.045f, val.x, val.y + 0.045f, 0.004f, new Color(0.3f, 0.1f, 0.23f, 1f));
			}
		}
		Vector2 val2 = default(Vector2);
		((Vector2)(ref val2))..ctor(0.06f, -0.1f);
		Rays(m, val2, t * Cycle, new Color(0.16f, 0.055f, 0.18f, 1f), new Color(0.2f, 0.065f, 0.22f, 1f), 10);
		Reticle(m, val2, 0.79f, t, Shade(Purple, 0.75f));
		int num;
		if (t > 4.6f)
		{
			num = ((t < 7.3f) ? 1 : 0);
			if (num != 0)
			{
				Skull(m, val2, 0.52f, Lilac);
				Reticle(m, val2, 0.68f, t, Paper);
				goto IL_01f7;
			}
		}
		else
		{
			num = 0;
		}
		Character(m, new Vector2(-0.3f, -0.58f), 0.57f, Purple, FaceMood.Hunter, new Vector2(0.9f, 0.1f), 0.3f, 0f, 0f, 0.08f, t);
		goto IL_01f7;
		IL_01f7:
		Reticle(m, new Vector2(0.6f, 0.62f), 0.15f, t, Mint);
		if (num == 0)
		{
			Disc(m, 0.6f, 0.62f, 0.075f, 0.075f, Orange);
		}
		float num2 = Mathf.Max(Bell(t, 4.6f, 0.2f), Bell(t, 7.3f, 0.2f));
		if (num2 > 0f)
		{
			Disc(m, val2.x, val2.y, 1.8f * Ease(num2), 1.8f * Ease(num2), Ink);
		}
	}

	private void MacroBullet(VertexHelper m, Vector2 p, float scale, float angle, float fracture, float t)
	{
		//IL_0001: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0189: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		stageX = p.x;
		stageY = p.y;
		stageAngle = angle;
		stageZoom = scale;
		for (int i = 0; i < 5; i++)
		{
			float num = -0.5f + (float)i * 0.22f;
			float num2 = fracture * (float)(i - 2) * 0.035f;
			float num3 = Mathf.Sin((float)i * 1.9f + t * Cycle) * fracture * 0.1f;
			Quad(m, num3, num + num2, 0.37f, 0.18f, (i % 2 == 0) ? Purple : Lilac);
			Segment(m, num3 - 0.18f, num + num2 - 0.065f, num3 + 0.18f, num + num2 - 0.065f, 0.01f, Ink);
		}
		Disc(m, 0f, 0.55f + fracture * 0.1f, 0.185f, 0.28f, Lilac);
		Quad(m, 0f, 0.42f + fracture * 0.1f, 0.37f, 0.12f, Lilac);
		Polygon(m, (Vector2[])(object)new Vector2[5]
		{
			new Vector2(-0.18f * aspect, -0.63f - fracture * 0.1f),
			new Vector2(-0.34f * aspect, -0.83f - fracture * 0.16f),
			new Vector2(0f, -0.73f - fracture * 0.1f),
			new Vector2(0.34f * aspect, -0.83f - fracture * 0.16f),
			new Vector2(0.18f * aspect, -0.63f - fracture * 0.1f)
		}, Shade(Purple, 0.85f));
		Segment(m, -0.085f * aspect, -0.27f, -0.085f * aspect, 0.37f, 0.019f, Paper);
		stageX = (stageY = (stageAngle = 0f));
		stageZoom = 1f;
	}

	private void FracturedRelic(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.17f, 0.1f, 0.22f, 1f));
		for (int i = 0; i < 8; i++)
		{
			float r = 0.34f + (float)i * 0.18f;
			Ring(m, -0.35f, 0.15f, r, 0.006f, t * Cycle + (float)i * 0.33f, 4.3982296f, (i % 2 == 0) ? new Color(0.32f, 0.19f, 0.4f, 1f) : new Color(0.23f, 0.14f, 0.31f, 1f));
		}
		float num = Ease(Bell(t, Duration * 0.52f, Duration * 0.34f));
		MacroBullet(m, new Vector2(0.04f, -0.03f), 1.04f, -0.6f + 0.1f * Mathf.Sin(t * Cycle), num, t);
		for (int j = 0; j < 7; j++)
		{
			float num2 = (float)j * 0.897f + t * Cycle;
			float num3 = 0.38f + num * 0.27f;
			Diamond(m, Mathf.Cos(num2) * num3 * aspect, Mathf.Sin(num2) * num3, 0.018f + num * 0.02f, num2, Lilac);
		}
		for (int k = 0; k < 30; k++)
		{
			float num4 = (float)k / 30f;
			float num5 = -0.7f + num4 * 1.4f;
			float num6 = num4 * 9f + t * Cycle;
			float x = 0.3f * Mathf.Sin(num6);
			float xx = 0.3f * Mathf.Sin(num6 + 0.3f);
			if (Mathf.Cos(num6) > 0f)
			{
				Segment(m, x, num5, xx, num5 + 0.047f, 0.012f, Mint);
			}
		}
	}

	private void BentField(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_025c: Unknown result type (might be due to invalid IL or missing references)
		//IL_027b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0280: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_028b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0308: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.055f, 0.15f, 0.17f, 1f));
		float num = t * Cycle;
		float num2 = 0.045f * Mathf.Sin(num * 2f);
		Vector2 val = default(Vector2);
		((Vector2)(ref val))..ctor(0.54f, 0.26f);
		for (int i = -5; i <= 5; i++)
		{
			float num3 = (float)i * 0.24f;
			for (int j = 0; j < 22; j++)
			{
				float num4 = -1.2f + (float)j * 0.115f;
				float num5 = num4 + 0.115f;
				float y = num3 + 0.2f * Mathf.Sin((num4 + 0.6f) * 2f + num) * Mathf.Max(0f, 1f - Mathf.Abs(num3));
				float yy = num3 + 0.2f * Mathf.Sin((num5 + 0.6f) * 2f + num) * Mathf.Max(0f, 1f - Mathf.Abs(num3));
				Segment(m, num4, y, num5, yy, 0.006f, (i % 2 == 0) ? new Color(0.12f, 0.31f, 0.32f, 1f) : new Color(0.09f, 0.24f, 0.27f, 1f));
			}
		}
		for (int num6 = 4; num6 >= 0; num6--)
		{
			Ring(m, val.x, val.y, 0.24f + (float)num6 * 0.075f + num2, 0.012f, num + (float)num6 * 0.3f, 5.340708f, (num6 % 2 == 0) ? Lilac : Mint);
		}
		Disc(m, val.x, val.y, 0.25f + num2, 0.25f + num2, Ink);
		Character(m, new Vector2(-0.65f, -0.6f), 0.46f, Purple, (t < 4.8f || t > 8.8f) ? FaceMood.Focused : FaceMood.Hunter, new Vector2(0.7f, 0.6f), 0.7f, 0f, 0f, -0.18f, t);
		float num7 = Frac(t / Duration);
		float num8 = 0.52f * (1f - Ease(num7));
		Vector2 val2 = Local(val, Mathf.Cos(num7 * 7f) * num8, Mathf.Sin(num7 * 7f) * num8);
		Disc(m, val2.x, val2.y, 0.06f * (1f - num7 * 0.7f), 0.06f * (1f - num7 * 0.7f), Alpha(Orange, Mathf.Clamp01(num7 / 0.08f) * Mathf.Clamp01((1f - num7) / 0.08f)));
		if (num7 > 0.65f)
		{
			Star(m, val, 0.13f * Bell(num7, 0.8f, 0.18f), num, Lilac);
		}
	}

	private void Coronation(VertexHelper m, float t)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0283: Unknown result type (might be due to invalid IL or missing references)
		//IL_028d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0356: Unknown result type (might be due to invalid IL or missing references)
		Base(m, new Color(0.085f, 0.035f, 0.15f, 1f));
		float num = t * Cycle;
		for (int i = 0; i < 6; i++)
		{
			float radius = 0.3f + (float)i * 0.17f;
			Arch(m, 0f, 0.38f - (float)i * 0.06f, radius, 1.6f, 0.024f, (i % 2 == 0) ? new Color(0.26f, 0.12f, 0.35f, 1f) : new Color(0.17f, 0.07f, 0.25f, 1f));
		}
		for (int j = 0; j < 7; j++)
		{
			float num2 = -1.1f + (float)j * 0.36f;
			Segment(m, num2, -1f, num2, 0.9f, 0.006f, new Color(0.26f, 0.14f, 0.33f, 1f));
			Diamond(m, num2, 0.8f, 0.026f, (float)Math.PI / 4f, Shade(Lilac, 0.7f));
		}
		if (!(t >= 5.4f) || !(t < 10.8f))
		{
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, -0.08f + 0.035f * Mathf.Sin(num));
			Ring(m, val.x, val.y, 0.76f, 0.007f, 0f - num, 5.811947f, Lilac);
			Crown(m, val, 0.54f, t);
			for (int k = 0; k < 3; k++)
			{
				Star(m, new Vector2(-0.65f + (float)k * 0.64f, 0.63f + (float)(k % 2) * 0.14f), 0.04f, num, Paper);
			}
		}
		else
		{
			Character(m, new Vector2(0.06f, -0.61f), 0.56f, Purple, FaceMood.Regal, new Vector2(-0.3f, 0f), 0.4f, 0f, 0f, -0.06f, t);
			Crown(m, new Vector2(0.06f, 0.18f + 0.01f * Mathf.Sin(num * 2f)), 0.27f, t);
			for (int l = 0; l < 3; l++)
			{
				Ring(m, 0.06f, -0.5f, 0.72f + (float)l * 0.075f, 0.004f, num + (float)l * 0.4f, 2.8f, Shade(Lilac, 0.6f));
			}
		}
		float num3 = Mathf.Max(Bell(t, 5.4f, 0.23f), Bell(t, 10.8f, 0.23f));
		if (num3 > 0f)
		{
			Quad(m, 0f, 0.8f * (1f - Ease(num3)), 2.1f, 2.1f * Ease(num3), Ink);
			Segment(m, -1f, 0.8f * (1f - Ease(num3)) - 0.9f * Ease(num3), 1f, 0.8f * (1f - Ease(num3)) - 0.9f * Ease(num3), 0.018f, Lilac);
		}
	}

	private static Color Alpha(Color c, float a)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		return new Color(c.r, c.g, c.b, a);
	}

	private static Color Shade(Color c, float v)
	{
		//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		return new Color(Mathf.Clamp01(c.r * v), Mathf.Clamp01(c.g * v), Mathf.Clamp01(c.b * v), c.a);
	}

	private static Color Blend(Color a, Color b, float p)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		return new Color(Mathf.Lerp(a.r, b.r, p), Mathf.Lerp(a.g, b.g, p), Mathf.Lerp(a.b, b.b, p), Mathf.Lerp(a.a, b.a, p));
	}

	protected override void Awake()
	{
		((UIBehaviour)this).Awake();
		((Graphic)this).raycastTarget = false;
	}

	private void Update()
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		clock = (clock + Mathf.Min(Time.unscaledDeltaTime, 0.1f)) % Duration;
		if (((Component)this).transform.parent is RectTransform)
		{
			((Graphic)this).rectTransform.anchorMin = Vector2.zero;
			((Graphic)this).rectTransform.anchorMax = Vector2.one;
			((Graphic)this).rectTransform.offsetMin = Vector2.zero;
			((Graphic)this).rectTransform.offsetMax = Vector2.zero;
		}
		((Graphic)this).SetVerticesDirty();
	}

	protected override void OnPopulateMesh(VertexHelper mesh)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		mesh.Clear();
		Rect rect = ((Graphic)this).rectTransform.rect;
		sx = ((Rect)(ref rect)).width * 0.5f;
		rect = ((Graphic)this).rectTransform.rect;
		sy = ((Rect)(ref rect)).height * 0.5f;
		if (!(sx <= 0f) && !(sy <= 0f))
		{
			aspect = sy / sx;
			stageZoom = 1f;
			stageX = (stageY = (stageAngle = 0f));
			DrawDirectedScene(mesh, clock);
		}
	}

	private Vector2 Local(Vector2 p, float x, float y)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		return new Vector2(p.x + x * aspect, p.y + y);
	}

	private Vector3 P(float x, float y)
	{
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		float num = x * sx * stageZoom;
		float num2 = y * sy * stageZoom;
		float num3 = Mathf.Cos(stageAngle);
		float num4 = Mathf.Sin(stageAngle);
		return new Vector3(stageX * sx + num3 * num - num4 * num2, stageY * sy + num4 * num + num3 * num2, 0f);
	}

	private void Polygon(VertexHelper m, Vector2[] points, Color c)
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		int currentVertCount = m.currentVertCount;
		foreach (Vector2 val in points)
		{
			m.AddVert(P(val.x, val.y), Color32.op_Implicit(c), Vector2.zero);
		}
		for (int j = 1; j < points.Length - 1; j++)
		{
			Triangle(m, currentVertCount, points[0], currentVertCount + j, points[j], currentVertCount + j + 1, points[j + 1]);
		}
	}

	private static void Triangle(VertexHelper m, int a, Vector2 pa, int b, Vector2 pb, int c, Vector2 pc)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		if ((pb.x - pa.x) * (pc.y - pa.y) - (pb.y - pa.y) * (pc.x - pa.x) <= 0f)
		{
			m.AddTriangle(a, b, c);
		}
		else
		{
			m.AddTriangle(a, c, b);
		}
	}

	private void Quad(VertexHelper m, float x, float y, float w, float h, Color c)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		Polygon(m, (Vector2[])(object)new Vector2[4]
		{
			new Vector2(x - w / 2f, y - h / 2f),
			new Vector2(x - w / 2f, y + h / 2f),
			new Vector2(x + w / 2f, y + h / 2f),
			new Vector2(x + w / 2f, y - h / 2f)
		}, c);
	}

	private void Disc(VertexHelper m, float x, float y, float rx, float ry, Color c)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		int currentVertCount = m.currentVertCount;
		m.AddVert(P(x, y), Color32.op_Implicit(c), Vector2.zero);
		for (int i = 0; i <= 32; i++)
		{
			float num = (float)i * (float)Math.PI / 16f;
			m.AddVert(P(x + Mathf.Cos(num) * rx * aspect, y + Mathf.Sin(num) * ry), Color32.op_Implicit(c), Vector2.zero);
			if (i > 0)
			{
				m.AddTriangle(currentVertCount, currentVertCount + i + 1, currentVertCount + i);
			}
		}
	}

	private void Segment(VertexHelper m, float x, float y, float xx, float yy, float width, Color c)
	{
		//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_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: 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_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = new Vector2(0f - (yy - y), (xx - x) / aspect);
		Vector2 val2 = ((Vector2)(ref val)).normalized * (width * 0.5f);
		Polygon(m, (Vector2[])(object)new Vector2[4]
		{
			new Vector2(x + val2.x * aspect, y + val2.y),
			new Vector2(xx + val2.x * aspect, yy + val2.y),
			new Vector2(xx - val2.x * aspect, yy - val2.y),
			new Vector2(x - val2.x * aspect, y - val2.y)
		}, c);
	}

	private void Stroke(VertexHelper m, Vector2 a, Vector2 b, float width, Color c)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: 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_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		Segment(m, a.x, a.y, b.x, b.y, width, c);
		Disc(m, a.x, a.y, width / 2f, width / 2f, c);
		Disc(m, b.x, b.y, width / 2f, width / 2f, c);
	}

	private void CurvedArm(VertexHelper m, Vector2 a, Vector2 control, Vector2 b, float width, Color c)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)