Decompiled source of Absurd Arsenal v1.5.0

AbsurdArsenal.dll

Decompiled a day ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using UnboundLib;
using UnboundLib.Cards;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("AbsurdArsenal")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AbsurdArsenal")]
[assembly: AssemblyTitle("AbsurdArsenal")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AbsurdArsenal;

public enum Bomb
{
	Explode,
	Napalm,
	Toxic,
	Cryo,
	Void,
	Cluster,
	Mine,
	Shock,
	Sticky,
	Nuke,
	Turret,
	Holy,
	Splinter
}
public sealed class BulletBomb : MonoBehaviour
{
	public int Kind;

	public float A;

	public float B;

	private static readonly Dictionary<string, GameObject> Templates = new Dictionary<string, GameObject>();

	private static bool quitting;

	private SpawnedAttack attack;

	private Vector2 last;

	private bool live;

	private bool dressed;

	private static Color ColorOf(Bomb b)
	{
		//IL_0032: 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_003e: 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_0044: 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_0056: Unknown result type (might be due to invalid IL or missing references)
		switch (b)
		{
		case Bomb.Toxic:
			return Shapes.Toxic;
		case Bomb.Cryo:
			return Shapes.Ice;
		case Bomb.Void:
			return Shapes.Void;
		case Bomb.Mine:
			return Color.red;
		case Bomb.Shock:
			return Shapes.Volt;
		case Bomb.Nuke:
		case Bomb.Holy:
			return Shapes.Holy;
		case Bomb.Turret:
			return Color.cyan;
		default:
			return Shapes.Fire;
		}
	}

	internal static GameObject Template(Bomb kind, float a, float b)
	{
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Expected O, but got Unknown
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		if (BulletFx.Offline)
		{
			return null;
		}
		string text = "ARSNL_Bomb_" + kind.ToString() + "_" + a + "_" + b;
		try
		{
			if (Templates.TryGetValue(text, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			value = new GameObject(text);
			Object.DontDestroyOnLoad((Object)(object)value);
			value.transform.position = new Vector3(0f, -10000f, 0f);
			BulletBomb bulletBomb = value.AddComponent<BulletBomb>();
			bulletBomb.Kind = (int)kind;
			bulletBomb.A = a;
			bulletBomb.B = b;
			Templates[text] = value;
			Application.quitting += delegate
			{
				quitting = true;
			};
			return value;
		}
		catch
		{
			return null;
		}
	}

	private void Update()
	{
		//IL_006f: 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_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)((Component)this).transform.parent == (Object)null))
		{
			if ((Object)(object)attack == (Object)null)
			{
				attack = ((Component)this).GetComponentInParent<SpawnedAttack>();
			}
			if (!dressed)
			{
				dressed = true;
				Glowing.Add(((Component)this).gameObject, ColorOf((Bomb)Kind), 0.4f, 30f, trail: true).GlowAlpha = 0.7f;
			}
			last = Vector2.op_Implicit(((Component)this).transform.position);
			live = true;
		}
	}

	private void OnDestroy()
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if (!live || quitting || (Object)(object)attack == (Object)null)
		{
			return;
		}
		Player spawner = attack.spawner;
		if ((Object)(object)spawner == (Object)null || !spawner.data.isPlaying)
		{
			return;
		}
		try
		{
			Do.Detonate((Bomb)Kind, spawner, last, A, B);
		}
		catch (Exception ex)
		{
			Debug.LogException(ex);
		}
	}
}
public static class Do
{
	internal const float Power = 2f;

	private static readonly Vector2[] Spokes = (Vector2[])(object)new Vector2[6]
	{
		new Vector2(1f, 0f),
		new Vector2(-1f, 0f),
		new Vector2(0.5f, 0.87f),
		new Vector2(-0.5f, 0.87f),
		new Vector2(0.5f, -0.87f),
		new Vector2(-0.5f, -0.87f)
	};

	private const float ForceScale = 100f;

	internal static int Quiet;

	public static Act RearmBlock => delegate(Ctx c)
	{
		c.B.ResetCD(false);
	};

	public static Act Refill => delegate(Ctx c)
	{
		c.A.ReloadAmmo(false);
	};

	public static Act Swap => delegate(Ctx c)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_002a: 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_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: 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)
		Player val = Nearest(c);
		if (!((Object)(object)val == (Object)null))
		{
			Vector2 pos = c.Pos;
			Vector2 val2 = Vector2.op_Implicit(((Component)val).transform.position);
			Fx.Poof(pos, Color.magenta);
			Fx.Poof(val2, Color.magenta);
			if (c.Mine)
			{
				Move(c.P, val2);
			}
			if (val.data.view.IsMine)
			{
				Move(val, pos);
			}
		}
	};

	public static Act Yoink => delegate(Ctx c)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: 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_003d: 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_0047: Unknown result type (might be due to invalid IL or missing references)
		Player val = Nearest(c);
		if (!((Object)(object)val == (Object)null) && val.data.view.IsMine)
		{
			Vector2 pos = c.Pos + Vector2.up * 4f;
			if (IsClear(pos))
			{
				Move(val, pos);
			}
		}
	};

	public static Act Shuffle => delegate(Ctx c)
	{
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		List<Player> list = (from p in PlayerManager.instance.players
			where (Object)(object)p != (Object)null && p.data.isPlaying && !p.data.dead
			orderby p.playerID
			select p).ToList();
		List<Vector2> list2 = list.Select((Player p) => Vector2.op_Implicit(((Component)p).transform.position)).ToList();
		for (int num = list2.Count - 1; num > 0; num--)
		{
			int index = c.R.Next(num + 1);
			Vector2 value = list2[num];
			list2[num] = list2[index];
			list2[index] = value;
		}
		for (int num2 = 0; num2 < list.Count; num2++)
		{
			if (list[num2].data.view.IsMine)
			{
				Move(list[num2], list2[num2]);
			}
		}
	};

	public static Act ScrambleFoes => delegate(Ctx c)
	{
		//IL_00dd: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: 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_0103: 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_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		Camera main = Camera.main;
		if ((Object)(object)main == (Object)null || (Object)(object)PlayerManager.instance == (Object)null)
		{
			return;
		}
		foreach (Player item in (from p in PlayerManager.instance.players
			where (Object)(object)p != (Object)null && p.teamID != c.P.teamID && Alive(p)
			orderby p.playerID
			select p).ToList())
		{
			for (int num = 0; num < 12; num++)
			{
				Vector2 val = Vector2.op_Implicit(main.ViewportToWorldPoint(new Vector3(0.1f + 0.8f * (float)c.R.NextDouble(), 0.15f + 0.7f * (float)c.R.NextDouble(), 10f)));
				if (IsClear(val))
				{
					Fx.Poof(Vector2.op_Implicit(((Component)item).transform.position), Color.magenta);
					Fx.Poof(val, Color.magenta);
					if (item.data.view.IsMine)
					{
						Move(item, val);
					}
					break;
				}
			}
		}
	};

	private static void WarnAt(Player src, Vector2 at, float radius, float delay, Color color, Action then)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: 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_001e: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		Zone zone = Zone.Spawn(src, at, radius, delay, 0f, color);
		zone.Frame = delegate(Zone zz)
		{
			zz.Radius = Mathf.Lerp(radius * 1.6f, radius, zz.Age / delay);
		};
		zone.Sides = 3;
		zone.Star = true;
		zone.Spin = 3f;
		zone.OnEnd = delegate
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Bolt.Spawn(at + Vector2.up * 30f, at, color, 0.6f, 0f, 0.15f);
			then();
		};
	}

	internal static Zone FieldAt(Player src, Vector2 at, float radius, float seconds, float dps, float slow, Color color)
	{
		//IL_001e: 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)
		Zone zone = Zone.Spawn(src, at, radius, seconds, 0.5f, color);
		zone.Tick = delegate(Zone zz)
		{
			//IL_0007: 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)
			foreach (Player item in FoesNear(zz.Team, zz.Pos, radius))
			{
				if (slow > 0f && item.data.view.IsMine)
				{
					item.data.stats.RPCA_AddSlow(slow, false);
				}
				if (zz.Mine && dps > 0f)
				{
					Hurt(item, dps * 0.5f, zz.Owner, zz.Pos);
				}
			}
		};
		return zone;
	}

	internal static void Detonate(Bomb kind, Player src, Vector2 at, float a, float b)
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: 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_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: 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_020b: 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_0246: Unknown result type (might be due to invalid IL or missing references)
		//IL_030c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0320: Unknown result type (might be due to invalid IL or missing references)
		//IL_0351: 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_0361: Unknown result type (might be due to invalid IL or missing references)
		//IL_036b: 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_0496: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_050b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0631: Unknown result type (might be due to invalid IL or missing references)
		//IL_0636: Unknown result type (might be due to invalid IL or missing references)
		//IL_0640: Unknown result type (might be due to invalid IL or missing references)
		//IL_0645: Unknown result type (might be due to invalid IL or missing references)
		//IL_064b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0650: Unknown result type (might be due to invalid IL or missing references)
		//IL_0676: Unknown result type (might be due to invalid IL or missing references)
		//IL_0687: Unknown result type (might be due to invalid IL or missing references)
		//IL_053b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0547: 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_027f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0290: Unknown result type (might be due to invalid IL or missing references)
		//IL_029a: Unknown result type (might be due to invalid IL or missing references)
		//IL_029f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b7: 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_0387: Unknown result type (might be due to invalid IL or missing references)
		//IL_0389: Unknown result type (might be due to invalid IL or missing references)
		//IL_0399: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_05de: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0402: Unknown result type (might be due to invalid IL or missing references)
		//IL_0407: Unknown result type (might be due to invalid IL or missing references)
		//IL_0454: Unknown result type (might be due to invalid IL or missing references)
		//IL_0459: Unknown result type (might be due to invalid IL or missing references)
		//IL_045e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0432: Unknown result type (might be due to invalid IL or missing references)
		bool mine = src.data.view.IsMine;
		switch (kind)
		{
		case Bomb.Explode:
			Blast(src, mine, at, a, b, Shapes.Fire);
			break;
		case Bomb.Napalm:
			Blast(src, mine, at, a * 0.4f, b * 0.7f, Shapes.Fire, 0.3f);
			FieldAt(src, at, b, 3f, a, 0f, Shapes.Fire);
			break;
		case Bomb.Toxic:
			FieldAt(src, at, b, 4f, a, 0.3f, Shapes.Toxic);
			break;
		case Bomb.Cryo:
			Ring.Spawn(at, b, Shapes.Ice, fx: false);
			Fx.Shards(at, b, Shapes.Ice);
			{
				foreach (Player item in FoesNear(src.teamID, at, b))
				{
					item.data.stunHandler.AddStun(a);
					if (item.data.view.IsMine)
					{
						item.data.stats.RPCA_AddSlow(0.6f, false);
					}
				}
				break;
			}
		case Bomb.Void:
			Zone.Spawn(src, at, b, 2f, 0.2f, Shapes.Void).Tick = delegate(Zone zz)
			{
				//IL_0001: 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_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: 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_0081: 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)
				Ring.Spawn(zz.Pos, b * 0.35f, Shapes.Void, fx: false);
				if (!zz.Mine)
				{
					return;
				}
				foreach (Player item2 in FoesNear(zz.Team, zz.Pos, b))
				{
					HealthHandler healthHandler = item2.data.healthHandler;
					Vector2 val3 = zz.Pos - Vector2.op_Implicit(((Component)item2).transform.position);
					Kick(healthHandler, ((Vector2)(ref val3)).normalized * a * 0.25f);
				}
			};
			break;
		case Bomb.Cluster:
		{
			Blast(src, mine, at, a, b, Shapes.Fire);
			for (int num5 = 0; num5 < Spokes.Length; num5++)
			{
				Vector2 p = at + Spokes[num5] * b * 1.3f;
				WarnAt(src, p, b * 0.6f, 0.35f + (float)num5 * 0.07f, Color.red, delegate
				{
					//IL_0017: 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)
					Blast(src, mine, p, a * 0.6f, b * 0.6f, Shapes.Fire, 0.5f);
				});
			}
			break;
		}
		case Bomb.Mine:
			Zone.Spawn(src, at, 0.7f, 12f, 0.1f, Color.red).Tick = delegate(Zone zz)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				if (!(zz.Age < 0.5f) && FoesNear(zz.Team, zz.Pos, 2.4f).Count != 0)
				{
					zz.Finish();
					Blast(zz.Owner, zz.Mine, zz.Pos, a, b, Shapes.Fire);
				}
			};
			break;
		case Bomb.Shock:
		{
			HashSet<Player> hit = new HashSet<Player>();
			Vector2 val = at;
			float num3 = a;
			Ring.Spawn(at, 1.5f, Shapes.Volt);
			for (int num4 = 0; num4 < (int)b; num4++)
			{
				Vector2 f0 = val;
				Player val2 = (from val3 in FoesNear(src.teamID, val, 11f)
					where !hit.Contains(val3)
					orderby Vector2.Distance(Vector2.op_Implicit(((Component)val3).transform.position), f0)
					select val3).FirstOrDefault();
				if (!((Object)(object)val2 == (Object)null))
				{
					Bolt.Spawn(val, Vector2.op_Implicit(((Component)val2).transform.position), Shapes.Volt);
					if (mine)
					{
						Hurt(val2, num3, src, val);
					}
					hit.Add(val2);
					val = Vector2.op_Implicit(((Component)val2).transform.position);
					num3 *= 0.85f;
					continue;
				}
				break;
			}
			break;
		}
		case Bomb.Sticky:
			WarnAt(src, at, b, 1f, Color.red, delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				Blast(src, mine, at, a, b, Shapes.Fire, 1.3f);
			});
			break;
		case Bomb.Nuke:
			WarnAt(src, at, b, 1.4f, Color.yellow, delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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_004b: 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_0067: 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_0089: 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_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				Blast(src, mine, at, a, b, Shapes.Holy, 1.6f);
				Ring.Spawn(at, b * 1.4f, Shapes.Fire, fx: false);
				Fx.Explosion(at, b * 1.5f, Shapes.Fire);
				Fx.Flash(at, b * 2f, Color.white, 0.4f);
				Bolt.Spawn(at, at + Vector2.up * 40f, Shapes.Holy, b * 0.5f, 0f, 0.5f);
				GamefeelManager.GameFeel(Vector2.up * 3f);
				FieldAt(src, at, b * 0.8f, 4f, a * 0.15f, 0f, Shapes.Toxic);
			});
			break;
		case Bomb.Turret:
		{
			Zone zone = Zone.Spawn(src, at + Vector2.up * 0.5f, 0.8f, b, 0.6f, Color.cyan);
			zone.Sides = 4;
			zone.Spin = 1.5f;
			zone.Tick = delegate(Zone zz)
			{
				//IL_001e: 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_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_0069: 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)
				Player val3 = (from val4 in FoesNear(zz.Team, zz.Pos, 16f)
					orderby Vector2.Distance(Vector2.op_Implicit(((Component)val4).transform.position), zz.Pos)
					select val4).FirstOrDefault();
				if (!((Object)(object)val3 == (Object)null))
				{
					Bolt.Spawn(zz.Pos, Vector2.op_Implicit(((Component)val3).transform.position), Color.cyan, 0.15f, 0.3f);
					if (zz.Mine)
					{
						Hurt(val3, a, zz.Owner, zz.Pos);
					}
				}
			};
			break;
		}
		case Bomb.Splinter:
		{
			Fx.Burst(at, 12, 8f, Color.magenta, 0.3f, 0.25f);
			int num = Mathf.Max(1, (int)b);
			float num2 = (at.x * 37f + at.y * 13f) % 360f;
			for (int i = 0; i < num; i++)
			{
				Vector2 dir = Vector2.op_Implicit(Quaternion.Euler(0f, 0f, num2 + (float)i * 360f / (float)num) * Vector2.op_Implicit(Vector2.right));
				Orb(src, at, dir, 22f, 0.3f, 2.5f, Color.magenta, 600f, delegate(Vector2 at2)
				{
					//IL_000c: 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)
					Blast(src, mine, at2, a, 1.8f, Color.magenta, 0.3f);
				});
			}
			break;
		}
		case Bomb.Holy:
			Bolt.Spawn(at + Vector2.up * 35f, at, Shapes.Holy, 0.5f, 2f, 0.35f);
			Blast(src, mine, at, a, b, Shapes.Holy, 0.5f);
			break;
		}
	}

	private static IEnumerable<Player> Foes(Ctx c, float radius)
	{
		return PlayerManager.instance.players.Where((Player p) => (Object)(object)p != (Object)null && p.teamID != c.P.teamID && p.data.isPlaying && !p.data.dead && Vector2.Distance(Vector2.op_Implicit(((Component)p).transform.position), c.Pos) <= radius).ToList();
	}

	private static Player Nearest(Ctx c)
	{
		return (from p in Foes(c, float.MaxValue)
			orderby Vector2.Distance(Vector2.op_Implicit(((Component)p).transform.position), c.Pos)
			select p).FirstOrDefault();
	}

	private static void Kick(HealthHandler h, Vector2 v)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		h.CallTakeForce(v * 100f, (ForceMode2D)1, true, true, 0f);
	}

	private static bool IsClear(Vector2 pos)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		Camera main = Camera.main;
		if ((Object)(object)main != (Object)null)
		{
			Vector3 val = main.WorldToViewportPoint(Vector2.op_Implicit(pos));
			if (val.x < 0.06f || val.x > 0.94f || val.y < 0.08f || val.y > 0.94f)
			{
				return false;
			}
		}
		return (Object)(object)Physics2D.OverlapCircle(pos, 1.5f) == (Object)null;
	}

	private static void Move(Player p, Vector2 pos)
	{
		//IL_0006: 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)
		((Component)p).transform.position = Vector2.op_Implicit(pos);
	}

	public static Act Heal(double amount)
	{
		return delegate(Ctx c)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			c.H.Heal((float)amount);
			Fx.Healing(c.Pos, Shapes.Heal);
		};
	}

	public static Act HealPct(double fraction)
	{
		return delegate(Ctx c)
		{
			//IL_001f: 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)
			c.H.Heal((float)fraction * c.D.maxHealth);
			Fx.Healing(c.Pos, Shapes.Heal);
		};
	}

	public static Act HurtSelf(double amount, bool lethal = false)
	{
		return delegate(Ctx c)
		{
			//IL_000e: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			if (c.Mine)
			{
				((Damagable)c.H).CallTakeDamage(Vector2.up * (float)amount, c.Pos, (GameObject)null, c.P, lethal);
			}
		};
	}

	public static Act Launch(double force)
	{
		return delegate(Ctx c)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_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)
			Fx.Geyser(c.Pos + Vector2.down, 0.8f, new Color(1f, 0.8f, 0.4f));
			if (c.Mine)
			{
				Kick(c.H, Vector2.up * (float)force);
			}
		};
	}

	public static Act Dash(double force)
	{
		return delegate(Ctx c)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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)
			if (c.Mine)
			{
				HealthHandler h = c.H;
				Vector2 val = Vector2.op_Implicit(c.D.aimDirection);
				Kick(h, ((Vector2)(ref val)).normalized * (float)force);
			}
		};
	}

	public static Act Blink(double distance)
	{
		return delegate(Ctx c)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_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_0029: 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_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_0036: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			Vector2 val = Vector2.op_Implicit(c.D.aimDirection);
			Vector2 normalized = ((Vector2)(ref val)).normalized;
			for (float num = (float)distance; num > 2f; num -= 2f)
			{
				Vector2 val2 = c.Pos + normalized * num;
				if (IsClear(val2))
				{
					Fx.Poof(c.Pos, Color.cyan);
					Fx.Poof(val2, Color.cyan);
					if (c.Mine)
					{
						Move(c.P, val2);
					}
					break;
				}
			}
		};
	}

	public static Act Hop(double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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)
			//IL_006c: 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_0072: 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_0080: 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_008b: 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)
			for (int i = 0; i < 10; i++)
			{
				double num = c.R.NextDouble() * Math.PI * 2.0;
				Vector2 val = c.Pos + new Vector2((float)Math.Cos(num), (float)Math.Sin(num)) * (float)(radius * (0.4 + c.R.NextDouble() * 0.6));
				if (IsClear(val))
				{
					Fx.Poof(c.Pos, Shapes.Void);
					Fx.Poof(val, Shapes.Void);
					if (c.Mine)
					{
						Move(c.P, val);
					}
					break;
				}
			}
		};
	}

	public static Act AirJump(int n)
	{
		return delegate(Ctx c)
		{
			c.D.currentJumps = Mathf.Min(c.D.jumps + n, c.D.currentJumps + n);
		};
	}

	public static Act StunSelf(double seconds)
	{
		return delegate(Ctx c)
		{
			c.D.stunHandler.AddStun((float)seconds);
		};
	}

	public static Act Nova(double damage, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0001: 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_0028: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			Ring.Spawn(c.Pos, (float)radius, new Color(1f, 0.45f, 0.1f), fx: false);
			Fx.Explosion(c.Pos, (float)radius, new Color(1f, 0.45f, 0.1f));
			if (!c.Mine)
			{
				return;
			}
			foreach (Player item in Foes(c, (float)radius))
			{
				Hurt(item, (float)damage, c.P, c.Pos);
			}
		};
	}

	public static Act Push(double force, double radius)
	{
		return delegate(Ctx c)
		{
			//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_0019: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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)
			Ring.Spawn(c.Pos, (float)radius, Color.white, fx: false);
			Fx.Radial(c.Pos, (float)radius, new Color(0.8f, 0.9f, 1f), inward: false);
			if (!c.Mine)
			{
				return;
			}
			foreach (Player item in Foes(c, (float)radius))
			{
				HealthHandler healthHandler = item.data.healthHandler;
				Vector2 val = Vector2.op_Implicit(((Component)item).transform.position) - c.Pos;
				Kick(healthHandler, ((Vector2)(ref val)).normalized * (float)force);
			}
		};
	}

	public static Act Pull(double force, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0001: 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_0028: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_009c: 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)
			Ring.Spawn(c.Pos, (float)radius, new Color(0.6f, 0.2f, 1f), fx: false);
			Fx.Radial(c.Pos, (float)radius, new Color(0.6f, 0.2f, 1f), inward: true);
			if (!c.Mine)
			{
				return;
			}
			foreach (Player item in Foes(c, (float)radius))
			{
				HealthHandler healthHandler = item.data.healthHandler;
				Vector2 val = c.Pos - Vector2.op_Implicit(((Component)item).transform.position);
				Kick(healthHandler, ((Vector2)(ref val)).normalized * (float)force);
			}
		};
	}

	public static Act Toss(double force, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			foreach (Player item in Foes(c, (float)radius))
			{
				Fx.Geyser(Vector2.op_Implicit(((Component)item).transform.position), 1.5f, Color.white);
				if (c.Mine)
				{
					Kick(item.data.healthHandler, Vector2.up * (float)force);
				}
			}
		};
	}

	public static Act Stun(double seconds, double radius)
	{
		return delegate(Ctx c)
		{
			//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_0019: 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)
			Ring.Spawn(c.Pos, (float)radius, Color.yellow, fx: false);
			Fx.Stars(c.Pos, (float)radius, Color.yellow);
			foreach (Player item in Foes(c, (float)radius))
			{
				item.data.stunHandler.AddStun((float)seconds);
			}
		};
	}

	public static Act Silence(double seconds, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0001: 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_0028: 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)
			Ring.Spawn(c.Pos, (float)radius, new Color(0.8f, 0.3f, 0.8f), fx: false);
			Fx.Stars(c.Pos, (float)radius, new Color(0.8f, 0.3f, 0.8f));
			foreach (Player item in Foes(c, (float)radius))
			{
				item.data.silenceHandler.RPCA_AddSilence((float)seconds);
			}
		};
	}

	public static Act Frost(double amount, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0001: 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_0028: 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)
			Ring.Spawn(c.Pos, (float)radius, new Color(0.5f, 0.85f, 1f), fx: false);
			Fx.Shards(c.Pos, (float)radius, new Color(0.5f, 0.85f, 1f));
			foreach (Player item in Foes(c, (float)radius))
			{
				item.data.stats.RPCA_AddSlow((float)amount, false);
			}
		};
	}

	public static Act BuffDmg(double m, double s)
	{
		return delegate(Ctx c)
		{
			Gun g = c.G;
			float x = (float)m;
			Buffs.Add((float)s, delegate
			{
				Gun obj = g;
				obj.damage *= x;
			}, delegate
			{
				Gun obj = g;
				obj.damage /= x;
			});
		};
	}

	public static Act BuffRate(double m, double s)
	{
		return delegate(Ctx c)
		{
			Gun g = c.G;
			float x = (float)m;
			Buffs.Add((float)s, delegate
			{
				Gun obj = g;
				obj.attackSpeed *= x;
			}, delegate
			{
				Gun obj = g;
				obj.attackSpeed /= x;
			});
		};
	}

	public static Act BuffMove(double m, double s)
	{
		return delegate(Ctx c)
		{
			CharacterStatModifiers t = c.S;
			float x = (float)m;
			Buffs.Add((float)s, delegate
			{
				CharacterStatModifiers obj = t;
				obj.movementSpeed *= x;
			}, delegate
			{
				CharacterStatModifiers obj = t;
				obj.movementSpeed /= x;
			});
		};
	}

	public static Act BuffJump(double m, double s)
	{
		return delegate(Ctx c)
		{
			CharacterStatModifiers t = c.S;
			float x = (float)m;
			Buffs.Add((float)s, delegate
			{
				CharacterStatModifiers obj = t;
				obj.jump *= x;
			}, delegate
			{
				CharacterStatModifiers obj = t;
				obj.jump /= x;
			});
		};
	}

	public static Act BuffGrav(double m, double s)
	{
		return delegate(Ctx c)
		{
			Gravity t = c.Gr;
			float x = (float)m;
			Buffs.Add((float)s, delegate
			{
				Gravity obj = t;
				obj.gravityForce *= x;
			}, delegate
			{
				Gravity obj = t;
				obj.gravityForce /= x;
			});
		};
	}

	public static Act BuffBullet(double a, double s)
	{
		return delegate(Ctx c)
		{
			Gun g = c.G;
			float x = (float)a;
			Buffs.Add((float)s, delegate
			{
				Gun obj = g;
				obj.size += x;
			}, delegate
			{
				Gun obj = g;
				obj.size -= x;
			});
		};
	}

	public static Act Shake(double amount)
	{
		return delegate
		{
			//IL_0000: 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)
			GamefeelManager.GameFeel(Vector2.up * (float)amount);
		};
	}

	public static Act Say(string text)
	{
		return delegate
		{
			Unbound.BuildInfoPopup(text);
		};
	}

	public static Act OneOf(params Act[] acts)
	{
		return delegate(Ctx c)
		{
			acts[c.R.Next(acts.Length)](c);
		};
	}

	public static Act Maybe(double chance, Act act)
	{
		return delegate(Ctx c)
		{
			if (c.R.NextDouble() < chance)
			{
				act(c);
			}
		};
	}

	internal static bool Alive(Player p)
	{
		if ((Object)(object)p != (Object)null && p.data.isPlaying)
		{
			return !p.data.dead;
		}
		return false;
	}

	internal static List<Player> FoesNear(int team, Vector2 pos, float radius)
	{
		//IL_000e: 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)
		if ((Object)(object)PlayerManager.instance == (Object)null)
		{
			return new List<Player>();
		}
		return PlayerManager.instance.players.Where((Player p) => (Object)(object)p != (Object)null && p.teamID != team && Alive(p) && Vector2.Distance(Vector2.op_Implicit(((Component)p).transform.position), pos) <= radius).ToList();
	}

	internal static void Hurt(Player victim, float amount, Player source, Vector2? from = null)
	{
		//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_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: 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_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: 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_0079: 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_008b: Unknown result type (might be due to invalid IL or missing references)
		if (!Alive(victim) || amount <= 0f)
		{
			return;
		}
		amount *= 2f;
		Vector2 val;
		if (!from.HasValue)
		{
			val = Vector2.up;
		}
		else
		{
			Vector2 val2 = Vector2.op_Implicit(((Component)victim).transform.position) - from.Value;
			val = ((Vector2)(ref val2)).normalized;
		}
		Vector2 val3 = val;
		if (val3 == Vector2.zero)
		{
			val3 = Vector2.up;
		}
		Quiet++;
		try
		{
			((Damagable)victim.data.healthHandler).CallTakeDamage(val3 * amount, Vector2.op_Implicit(((Component)victim).transform.position), (GameObject)null, source, true);
		}
		finally
		{
			Quiet--;
		}
	}

	private static float SegmentDistance(Vector2 p, Vector2 a, Vector2 b)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: 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_002e: 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)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = b - a;
		float num = Mathf.Clamp01(Vector2.Dot(p - a, val) / Mathf.Max(((Vector2)(ref val)).sqrMagnitude, 0.0001f));
		return Vector2.Distance(p, a + val * num);
	}

	internal static void Blast(Player source, bool mine, Vector2 at, float damage, float radius, Color color, float push = 1f)
	{
		//IL_000a: 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_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_0029: 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_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: 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_0079: 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_008d: 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)
		radius *= 1.25f;
		Ring.Spawn(at, radius, color, fx: false);
		Fx.Explosion(at, radius, color);
		if (!mine)
		{
			return;
		}
		foreach (Player item in FoesNear(source.teamID, at, radius))
		{
			Hurt(item, damage, source, at);
			if (push > 0f)
			{
				HealthHandler healthHandler = item.data.healthHandler;
				Vector2 val = Vector2.op_Implicit(((Component)item).transform.position) - at;
				Kick(healthHandler, ((Vector2)(ref val)).normalized * radius * 2f * push);
			}
		}
	}

	private static void Warn(Ctx c, Vector2 at, float radius, float delay, Color color, Action then)
	{
		//IL_000e: 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_0015: 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_002b: 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)
		Zone zone = Zone.Spawn(c.P, at, radius, delay, 0f, color);
		float total = delay;
		zone.Frame = delegate(Zone zz)
		{
			zz.Radius = Mathf.Lerp(radius * 1.6f, radius, zz.Age / total);
		};
		zone.Sides = 3;
		zone.Star = true;
		zone.Spin = 3f;
		zone.OnEnd = delegate
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Bolt.Spawn(at + Vector2.up * 30f, at, color, 0.6f, 0f, 0.15f);
			then();
		};
	}

	private static Vector2 Aim(Ctx c)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: 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_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: 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_0026: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = Vector2.op_Implicit(c.D.aimDirection);
		Vector2 normalized = ((Vector2)(ref val)).normalized;
		if (!(normalized == Vector2.zero))
		{
			return normalized;
		}
		return Vector2.right;
	}

	public static Act Burn(double dps, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Afflict.Apply(c.T, c.P, (float)dps, (float)s, Shapes.Fire, c.Mine);
			}
		};
	}

	public static Act Poison(double dps, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Afflict.Apply(c.T, c.P, (float)dps, (float)s, Shapes.Toxic, c.Mine);
			}
		};
	}

	public static Act Wither(double dps, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Afflict.Apply(c.T, c.P, (float)dps, (float)s, new Color(0.45f, 0.12f, 0.55f), c.Mine);
			}
		};
	}

	public static Act Bleed(double dps, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Afflict.Apply(c.T, c.P, (float)dps, (float)s, Shapes.Blood, c.Mine);
			}
		};
	}

	public static Act Chill(double amount)
	{
		return delegate(Ctx c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 2.4f, Shapes.Ice);
				c.T.data.stats.RPCA_AddSlow((float)amount, false);
			}
		};
	}

	public static Act Freeze(double s)
	{
		return delegate(Ctx c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 3f, Shapes.Ice, fx: false);
				Fx.Shards(Vector2.op_Implicit(((Component)c.T).transform.position), 3f, Shapes.Ice);
				c.T.data.stunHandler.AddStun((float)s);
			}
		};
	}

	public static Act Hex(double s)
	{
		return delegate(Ctx c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 2.4f, Shapes.Void);
				c.T.data.silenceHandler.RPCA_AddSilence((float)s);
			}
		};
	}

	public static Act MarkT(double extra, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 2.8f, Color.red);
				Marks.Add(c.T, c.P, (float)s, (float)extra);
			}
		};
	}

	public static Act ShrinkT(double m, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			if (Alive(c.T))
			{
				CharacterStatModifiers t = c.T.data.stats;
				float x = (float)m;
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 2.2f, Color.magenta);
				Buffs.Add((float)s, delegate
				{
					CharacterStatModifiers obj = t;
					obj.sizeMultiplier *= x;
					Body.Refresh(t);
				}, delegate
				{
					CharacterStatModifiers obj = t;
					obj.sizeMultiplier /= x;
					Body.Refresh(t);
				});
			}
		};
	}

	public static Act WeakenT(double m, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0047: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Gun g = c.T.data.weaponHandler.gun;
				float x = (float)m;
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 2.2f, Shapes.Void);
				Buffs.Add((float)s, delegate
				{
					Gun obj = g;
					obj.damage *= x;
				}, delegate
				{
					Gun obj = g;
					obj.damage /= x;
				});
			}
		};
	}

	public static Act SlowT(double m, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			if (Alive(c.T))
			{
				CharacterStatModifiers t = c.T.data.stats;
				float x = (float)m;
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 2.2f, Shapes.Ice);
				Buffs.Add((float)s, delegate
				{
					CharacterStatModifiers obj = t;
					obj.movementSpeed *= x;
				}, delegate
				{
					CharacterStatModifiers obj = t;
					obj.movementSpeed /= x;
				});
			}
		};
	}

	public static Act Steal(double m, double s)
	{
		return delegate(Ctx c)
		{
			//IL_001f: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Bolt.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), c.Pos, Color.green, 0.15f, 0.4f);
				CharacterStatModifiers mine = c.S;
				CharacterStatModifiers theirs = c.T.data.stats;
				float x = (float)m;
				Buffs.Add((float)s, delegate
				{
					CharacterStatModifiers obj = mine;
					obj.movementSpeed *= x;
					CharacterStatModifiers obj2 = theirs;
					obj2.movementSpeed /= x;
				}, delegate
				{
					CharacterStatModifiers obj = mine;
					obj.movementSpeed /= x;
					CharacterStatModifiers obj2 = theirs;
					obj2.movementSpeed *= x;
				});
			}
		};
	}

	public static Act HealT(double amount)
	{
		return delegate(Ctx c)
		{
			//IL_0018: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 1.8f, Shapes.Heal);
				c.T.data.healthHandler.Heal((float)amount);
			}
		};
	}

	public static Act Combo(params Act[] acts)
	{
		return delegate(Ctx c)
		{
			Act[] array = acts;
			for (int i = 0; i < array.Length; i++)
			{
				array[i](c);
			}
		};
	}

	public static Act Leech(double dmg)
	{
		return delegate(Ctx c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Bolt.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), c.Pos, Shapes.Blood, 0.18f, 0.5f);
				for (int i = 0; i < 14; i++)
				{
					Vector2 val = Vector2.op_Implicit(((Component)c.T).transform.position) + Random.insideUnitCircle;
					Fx.Spark(val, (c.Pos - val) / 0.45f, 0.45f, 0.22f, Shapes.Blood);
				}
				if (c.Mine)
				{
					Hurt(c.T, (float)dmg, c.P);
				}
				c.H.Heal((float)dmg);
			}
		};
	}

	public static Act Zap(double dmg, int jumps)
	{
		return delegate(Ctx c)
		{
			//IL_0020: 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_0044: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a6: 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_00b2: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				HashSet<Player> hit = new HashSet<Player>();
				Vector2 val = c.Pos;
				Player val2 = c.T;
				float num = (float)dmg;
				for (int i = 0; i <= jumps; i++)
				{
					if (!((Object)(object)val2 != (Object)null))
					{
						break;
					}
					Bolt.Spawn(val, Vector2.op_Implicit(((Component)val2).transform.position), Shapes.Volt);
					if (c.Mine)
					{
						Hurt(val2, num, c.P, val);
					}
					hit.Add(val2);
					val = Vector2.op_Implicit(((Component)val2).transform.position);
					num *= 0.85f;
					Vector2 f = val;
					val2 = (from p in FoesNear(c.P.teamID, val, 12f)
						where !hit.Contains(p)
						orderby Vector2.Distance(Vector2.op_Implicit(((Component)p).transform.position), f)
						select p).FirstOrDefault();
				}
			}
		};
	}

	public static Act Thunder(double dmg)
	{
		return delegate(Ctx c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0025: 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)
			//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_003a: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T))
			{
				Vector2 val = Vector2.op_Implicit(((Component)c.T).transform.position);
				Bolt.Spawn(val + Vector2.up * 35f, val, Shapes.Holy, 0.45f, 2f, 0.35f);
				Blast(c.P, c.Mine, val, (float)dmg, 2.5f, Shapes.Holy, 0.5f);
			}
		};
	}

	public static Act Boom(double dmg, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Blast(c.P, c.Mine, c.At, (float)dmg, (float)radius, Shapes.Fire);
		};
	}

	public static Act Execute(double threshold)
	{
		return delegate(Ctx c)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			if (Alive(c.T) && !((double)c.T.data.health > threshold * (double)c.T.data.maxHealth))
			{
				Vector2 val = Vector2.op_Implicit(((Component)c.T).transform.position);
				Bolt.Spawn(val + Vector2.up * 35f, val, Color.red, 0.7f, 0f, 0.4f);
				Ring.Spawn(val, 4f, Color.red, fx: false);
				Fx.Explosion(val, 4f, Color.red);
				if (c.Mine)
				{
					Hurt(c.T, c.T.data.health + 50f, c.P);
				}
			}
		};
	}

	public static Act LaunchT(double force)
	{
		return delegate(Ctx c)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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)
			if (Alive(c.T))
			{
				Ring.Spawn(Vector2.op_Implicit(((Component)c.T).transform.position), 2f, Color.white);
				if (c.Mine)
				{
					Kick(c.T.data.healthHandler, Vector2.up * (float)force);
				}
			}
		};
	}

	public static Act YankT(double force)
	{
		return delegate(Ctx c)
		{
			//IL_000f: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)
			if (Alive(c.T))
			{
				Bolt.Spawn(c.Pos, Vector2.op_Implicit(((Component)c.T).transform.position), Color.white, 0.12f, 0.2f);
				if (c.Mine)
				{
					HealthHandler healthHandler = c.T.data.healthHandler;
					Vector2 val = c.Pos - Vector2.op_Implicit(((Component)c.T).transform.position);
					Kick(healthHandler, ((Vector2)(ref val)).normalized * (float)force);
				}
			}
		};
	}

	public static Act Meteor(double dmg, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			Vector2 at = c.At;
			Warn(c, at, (float)radius, 0.9f, Color.red, delegate
			{
				//IL_0017: 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)
				Blast(c.P, c.Mine, at, (float)dmg, (float)radius, Shapes.Fire);
			});
		};
	}

	public static Act Orbital(double dmg)
	{
		return delegate(Ctx c)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			Vector2 at = c.At;
			Warn(c, at, 3.5f, 1.2f, Color.cyan, delegate
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: 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)
				Bolt.Spawn(at + Vector2.up * 40f, at, Color.cyan, 1.4f, 0f, 0.45f);
				Blast(c.P, c.Mine, at, (float)dmg, 3.5f, Color.cyan);
			});
		};
	}

	public static Act Airstrike(int n, double dmg)
	{
		return delegate(Ctx c)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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)
			Vector2 at = c.At;
			for (int i = 0; i < n; i++)
			{
				Vector2 p = at + new Vector2(((float)i - (float)(n - 1) / 2f) * 3.2f, 0f);
				Warn(c, p, 2.6f, 0.7f + (float)i * 0.15f, Color.red, delegate
				{
					//IL_0021: 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)
					Blast(c.P, c.Mine, p, (float)dmg, 2.6f, Shapes.Fire);
				});
			}
		};
	}

	public static Act Rain(int n, double dmg, Color? color = null)
	{
		return delegate(Ctx c)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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)
			Camera main = Camera.main;
			if (!((Object)(object)main == (Object)null))
			{
				Color col = (Color)(((??)color) ?? Shapes.Fire);
				for (int i = 0; i < n; i++)
				{
					Vector2 p = Vector2.op_Implicit(main.ViewportToWorldPoint(new Vector3(0.1f + 0.8f * (float)c.R.NextDouble(), 0.15f + 0.7f * (float)c.R.NextDouble(), 10f)));
					Warn(c, p, 2.4f, 0.8f + (float)i * 0.18f, col, delegate
					{
						//IL_0021: 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)
						Blast(c.P, c.Mine, p, (float)dmg, 2.4f, col);
					});
				}
			}
		};
	}

	public static Act Fireworks(int n, double dmg)
	{
		return delegate(Ctx c)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < n; i++)
			{
				Vector2 p = c.Pos + new Vector2((float)(c.R.NextDouble() * 12.0 - 6.0), (float)(c.R.NextDouble() * 8.0 - 2.0));
				Color col = Color.HSVToRGB((float)c.R.NextDouble(), 0.8f, 1f);
				Warn(c, p, 1.8f, 0.3f + (float)i * 0.12f, col, delegate
				{
					//IL_0021: 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)
					Blast(c.P, c.Mine, p, (float)dmg, 1.8f, col, 0.3f);
				});
			}
		};
	}

	public static Act Laser(double dmg)
	{
		return delegate(Ctx c)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_004b: 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_004d: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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)
			//IL_0104: 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_010e: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = Aim(c);
			Vector2 val2 = c.Pos + val * 1.2f;
			Vector2 val3 = val2 + val * 45f;
			Bolt.Spawn(val2, val3, Color.red, 0.9f, 0f, 0.3f);
			Bolt.Spawn(val2, val3, Color.white, 0.3f, 0f, 0.3f);
			Fx.Flash(val2, 2f, Color.red, 0.25f);
			for (int i = 0; i < 30; i++)
			{
				Fx.Spark(Vector2.Lerp(val2, val3, Random.value), Random.insideUnitCircle * 6f, 0.35f, 0.25f, Color.Lerp(Color.red, Color.yellow, Random.value));
			}
			if (!c.Mine)
			{
				return;
			}
			foreach (Player item in FoesNear(c.P.teamID, c.Pos, 50f))
			{
				if (SegmentDistance(Vector2.op_Implicit(((Component)item).transform.position), val2, val3) < 1.6f)
				{
					Hurt(item, (float)dmg, c.P, c.Pos);
				}
			}
		};
	}

	public static Act BlackHole(double force, double radius, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0027: 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)
			float r = (float)radius;
			float f = (float)force;
			Zone.Spawn(c.P, c.At, r, (float)s, 0.2f, Shapes.Void).Tick = delegate(Zone zz)
			{
				//IL_0001: 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_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: 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_0081: 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)
				Ring.Spawn(zz.Pos, r * 0.35f, Shapes.Void, fx: false);
				if (!zz.Mine)
				{
					return;
				}
				foreach (Player item in FoesNear(zz.Team, zz.Pos, r))
				{
					HealthHandler healthHandler = item.data.healthHandler;
					Vector2 val = zz.Pos - Vector2.op_Implicit(((Component)item).transform.position);
					Kick(healthHandler, ((Vector2)(ref val)).normalized * f * 0.25f);
				}
			};
		};
	}

	public static Act Mine(double dmg, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			float d = (float)dmg;
			float r = (float)radius;
			Zone.Spawn(c.P, c.Pos, 0.7f, 15f, 0.1f, Color.red).Tick = delegate(Zone zz)
			{
				//IL_0014: 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_0056: Unknown result type (might be due to invalid IL or missing references)
				if (!(zz.Age < 0.7f) && FoesNear(zz.Team, zz.Pos, 2.4f).Count != 0)
				{
					zz.Finish();
					zz.OnEnd = null;
					Blast(zz.Owner, zz.Mine, zz.Pos, d, r, Shapes.Fire);
				}
			};
		};
	}

	public static Act Turret(double dmg, double s)
	{
		return delegate(Ctx c)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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)
			float d = (float)dmg;
			Zone zone = Zone.Spawn(c.P, c.Pos + Vector2.up, 0.9f, (float)s, 0.7f, Color.cyan);
			zone.Sides = 4;
			zone.Spin = 1.5f;
			zone.Tick = delegate(Zone zz)
			{
				//IL_001e: 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_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_0069: 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)
				Player val = (from p in FoesNear(zz.Team, zz.Pos, 18f)
					orderby Vector2.Distance(Vector2.op_Implicit(((Component)p).transform.position), zz.Pos)
					select p).FirstOrDefault();
				if (!((Object)(object)val == (Object)null))
				{
					Bolt.Spawn(zz.Pos, Vector2.op_Implicit(((Component)val).transform.position), Color.cyan, 0.15f, 0.3f);
					if (zz.Mine)
					{
						Hurt(val, d, zz.Owner, zz.Pos);
					}
				}
			};
		};
	}

	public static Act Aura(double dps, double radius, double s, Color? color = null)
	{
		return delegate(Ctx c)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			float d = (float)dps * 0.5f;
			float r = (float)radius;
			Zone.Spawn(c.P, c.Pos, r, (float)s, 0.5f, (Color)(((??)color) ?? Shapes.Fire), follow: true).Tick = delegate(Zone zz)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				if (!zz.Mine)
				{
					return;
				}
				foreach (Player item in FoesNear(zz.Team, zz.Pos, r))
				{
					Hurt(item, d, zz.Owner, zz.Pos);
				}
			};
		};
	}

	public static Act Puddle(double slow, double dps, double radius, double s, Color? color = null)
	{
		return delegate(Ctx c)
		{
			//IL_003a: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			float d = (float)dps * 0.5f;
			float r = (float)radius;
			float sl = (float)slow;
			Zone.Spawn(c.P, c.At, r, (float)s, 0.5f, (Color)(((??)color) ?? Shapes.Toxic)).Tick = delegate(Zone zz)
			{
				//IL_0007: 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)
				foreach (Player item in FoesNear(zz.Team, zz.Pos, r))
				{
					if (sl > 0f && item.data.view.IsMine)
					{
						item.data.stats.RPCA_AddSlow(sl, false);
					}
					if (zz.Mine)
					{
						Hurt(item, d, zz.Owner, zz.Pos);
					}
				}
			};
		};
	}

	public static Act Mend(double hps, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0020: 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)
			float h = (float)hps * 0.5f;
			Zone.Spawn(c.P, c.Pos, 1.5f, (float)s, 0.5f, Shapes.Heal, follow: true).Tick = delegate(Zone zz)
			{
				if (Alive(zz.Owner))
				{
					zz.Owner.data.healthHandler.Heal(h);
				}
			};
		};
	}

	public static Act SawBlades(int n, double dmg, double s)
	{
		return delegate(Ctx c)
		{
			//IL_0007: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			Zone zone = Zone.Spawn(c.P, c.Pos, 3f, (float)s, 0f, new Color(0.8f, 0.8f, 0.85f), follow: true);
			zone.ShowRing = false;
			if ((Object)(object)zone.Glow != (Object)null)
			{
				zone.Glow.GlowAlpha = 0.06f;
				zone.Glow.Rate = 0f;
			}
			Saws saws = ((Component)zone).gameObject.AddComponent<Saws>();
			saws.Zone = zone;
			saws.Count = n;
			saws.Damage = (float)dmg;
			saws.Orbit = 3f;
			saws.Speed = 4f;
			saws.Build(new Color(0.85f, 0.85f, 0.9f));
		};
	}

	public static Act Rewind(double seconds)
	{
		return delegate(Ctx c)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			Fx.Poof(c.Pos, Color.cyan);
			if (c.Mine)
			{
				Vector2? val = History.Ago(c.P, (float)seconds);
				if (val.HasValue)
				{
					Fx.Poof(val.Value, Color.cyan);
					Move(c.P, val.Value);
				}
			}
		};
	}

	public static Act Recall(double seconds, double heal)
	{
		return delegate(Ctx c)
		{
			Rewind(seconds)(c);
			c.H.Heal((float)heal);
		};
	}

	public static Act SayAny(params string[] lines)
	{
		return delegate(Ctx c)
		{
			Say(lines[c.R.Next(lines.Length)])(c);
		};
	}

	public static Act Inflate(double m, double s)
	{
		return delegate(Ctx c)
		{
			CharacterStatModifiers t = c.S;
			float x = (float)m;
			Buffs.Add((float)s, delegate
			{
				CharacterStatModifiers obj = t;
				obj.sizeMultiplier *= x;
				Body.Refresh(t);
			}, delegate
			{
				CharacterStatModifiers obj = t;
				obj.sizeMultiplier /= x;
				Body.Refresh(t);
			});
		};
	}

	public static Act Upsidedown(double s)
	{
		return BuffGrav(-0.7, s);
	}

	public static Act Confetti(int rings = 6)
	{
		return delegate(Ctx c)
		{
			//IL_004f: 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_0055: 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)
			Vector2 val = default(Vector2);
			for (int i = 0; i < rings; i++)
			{
				((Vector2)(ref val))..ctor((float)(c.R.NextDouble() * 10.0 - 5.0), (float)(c.R.NextDouble() * 10.0 - 5.0));
				Ring.Spawn(c.Pos + val, 1f + (float)c.R.NextDouble() * 2.5f, new Color((float)c.R.NextDouble(), (float)c.R.NextDouble(), (float)c.R.NextDouble()));
			}
		};
	}

	public static Act Scatter(double force, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_005d: 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)
			foreach (Player item in Foes(c, (float)radius))
			{
				double num = c.R.NextDouble() * Math.PI * 2.0;
				if (c.Mine)
				{
					Kick(item.data.healthHandler, new Vector2((float)Math.Cos(num), (float)Math.Sin(num)) * (float)force);
				}
			}
		};
	}

	public static Act HealFoes(double amount, double radius)
	{
		return delegate(Ctx c)
		{
			foreach (Player item in Foes(c, (float)radius))
			{
				item.data.healthHandler.Heal((float)amount);
			}
		};
	}

	public static Act Smite(double fraction, double radius)
	{
		return delegate(Ctx c)
		{
			//IL_0001: 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)
			Ring.Spawn(c.Pos, (float)radius, new Color(1f, 0.9f, 0.4f));
			if (!c.Mine)
			{
				return;
			}
			foreach (Player item in Foes(c, (float)radius))
			{
				Hurt(item, (float)fraction * item.data.maxHealth, c.P);
			}
		};
	}

	private static float Rf(float a, float b)
	{
		return Random.Range(a, b);
	}

	private static LineRenderer BeamLine(GameObject host, Color c, float width)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: 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_0045: 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)
		GameObject val = new GameObject("ARSNL_Beam");
		val.transform.SetParent(host.transform, false);
		LineRenderer obj = val.AddComponent<LineRenderer>();
		((Renderer)obj).sharedMaterial = Fx.Additive;
		obj.useWorldSpace = true;
		obj.positionCount = 2;
		obj.widthMultiplier = width;
		Color startColor = (obj.endColor = c);
		obj.startColor = startColor;
		((Renderer)obj).sortingOrder = 103;
		return obj;
	}

	private static Vector2 Rot(Vector2 v, float degrees)
	{
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		return Vector2.op_Implicit(Quaternion.Euler(0f, 0f, degrees) * Vector2.op_Implicit(v));
	}

	public static Act Lighthouse(double dps, double seconds, int beams)
	{
		return delegate(Ctx c)
		{
			//IL_0061: 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_00d4: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			float d = (float)dps;
			int n = Mathf.Max(1, beams);
			float phase = (float)(c.R.NextDouble() * 360.0);
			float speed = 110f + (float)n * 15f;
			Zone zone = Zone.Spawn(c.P, c.Pos, 1f, (float)seconds, 0.15f, Color.red, follow: true);
			zone.ShowRing = false;
			LineRenderer[] outer = (LineRenderer[])(object)new LineRenderer[n];
			LineRenderer[] core = (LineRenderer[])(object)new LineRenderer[n];
			for (int i = 0; i < n; i++)
			{
				Color c2 = Fx.T(Color.HSVToRGB(Mathf.Repeat((float)i / (float)n * 0.5f, 1f), 1f, 1f));
				c2.a = 0.55f;
				outer[i] = BeamLine(((Component)zone).gameObject, c2, 1f);
				core[i] = BeamLine(((Component)zone).gameObject, Color.white, 0.25f);
			}
			Func<Zone, int, Vector2> dirOf = delegate(Zone zz, int num2)
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				float num = (phase + zz.Age * speed + (float)num2 * 360f / (float)n) * ((float)Math.PI / 180f);
				return new Vector2(Mathf.Cos(num), Mathf.Sin(num));
			};
			zone.Frame = delegate(Zone zz)
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0038: 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_003f: 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_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_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: 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_0079: 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_008e: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				float num = Mathf.Clamp01(zz.Age * 4f);
				for (int j = 0; j < n; j++)
				{
					Vector2 val = dirOf(zz, j);
					Vector2 val2 = zz.Pos + val * 1.2f;
					Vector2 val3 = zz.Pos + val * 40f * num;
					outer[j].SetPosition(0, Vector2.op_Implicit(val2));
					outer[j].SetPosition(1, Vector2.op_Implicit(val3));
					core[j].SetPosition(0, Vector2.op_Implicit(val2));
					core[j].SetPosition(1, Vector2.op_Implicit(val3));
					outer[j].widthMultiplier = 0.9f + 0.25f * Mathf.Sin(Time.time * 35f + (float)j);
					if (Random.value < 0.6f)
					{
						Fx.Spark(Vector2.Lerp(val2, val3, Random.value), Random.insideUnitCircle * 4f, 0.25f, 0.22f, outer[j].startColor);
					}
				}
			};
			zone.Tick = delegate(Zone zz)
			{
				//IL_0010: 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_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: 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_0060: 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_006b: 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)
				if (!zz.Mine)
				{
					return;
				}
				foreach (Player item in FoesNear(zz.Team, zz.Pos, 41f))
				{
					for (int j = 0; j < n; j++)
					{
						Vector2 val = dirOf(zz, j);
						if (SegmentDistance(Vector2.op_Implicit(((Component)item).transform.position), zz.Pos, zz.Pos + val * 40f) < 1.3f)
						{
							Hurt(item, d * 0.15f, zz.Owner, zz.Pos);
							break;
						}
					}
				}
			};
		};
	}

	public static Act IonCannon(double dmg)
	{
		return delegate(Ctx c)
		{
			//IL_0027: 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_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_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_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_010d: 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_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			if (!((Object)(object)main == (Object)null))
			{
				float left = main.ViewportToWorldPoint(new Vector3(0f, 0.5f, 10f)).x;
				float right = main.ViewportToWorldPoint(new Vector3(1f, 0.5f, 10f)).x;
				float top = main.ViewportToWorldPoint(new Vector3(0.5f, 1.1f, 10f)).y;
				float bottom = main.ViewportToWorldPoint(new Vector3(0.5f, -0.1f, 10f)).y;
				bool ltr = c.R.NextDouble() < 0.5;
				float d = (float)dmg;
				HashSet<Player> hit = new HashSet<Player>();
				Zone zone = Zone.Spawn(c.P, new Vector2(ltr ? left : right, (top + bottom) / 2f), 0.5f, 2.4f, 0f, Color.cyan);
				zone.ShowRing = false;
				if ((Object)(object)zone.Glow != (Object)null)
				{
					zone.Glow.Rate = 0f;
				}
				Color glowCol = Fx.T(Color.cyan);
				glowCol.a = 0.6f;
				LineRenderer outer = BeamLine(((Component)zone).gameObject, glowCol, 2.4f);
				LineRenderer core = BeamLine(((Component)zone).gameObject, Color.white, 0.7f);
				Say("ION CANNON ONLINE")(c);
				zone.Frame = delegate(Zone zz)
				{
					//IL_0065: 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_0082: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
					//IL_014a: Unknown result type (might be due to invalid IL or missing references)
					//IL_016d: Unknown result type (might be due to invalid IL or missing references)
					//IL_017d: 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_01c1: 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_01f4: Unknown result type (might be due to invalid IL or missing references)
					//IL_01fe: 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_022a: Unknown result type (might be due to invalid IL or missing references)
					//IL_022f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0234: Unknown result type (might be due to invalid IL or missing references)
					float num = Mathf.Clamp01((zz.Age - 0.6f) / 1.8f);
					float num2 = Mathf.Lerp(ltr ? left : right, ltr ? right : left, num);
					((Component)zz).transform.position = Vector2.op_Implicit(new Vector2(num2, (top + bottom) / 2f));
					outer.SetPosition(0, new Vector3(num2, top));
					outer.SetPosition(1, new Vector3(num2, bottom));
					core.SetPosition(0, new Vector3(num2, top));
					core.SetPosition(1, new Vector3(num2, bottom));
					bool flag = zz.Age >= 0.6f;
					outer.widthMultiplier = (flag ? (2.4f + Mathf.Sin(Time.time * 50f) * 0.4f) : 0.15f);
					core.widthMultiplier = (flag ? 0.7f :