PRTCards.dll

Decompiled 10 hours ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using ClassesManagerReborn;
using HarmonyLib;
using InControl;
using Jotunn.Utils;
using PRT;
using PRT.Cards;
using PRT.Core;
using PRT.Objects.Laser;
using PRT.Objects.TNT;
using PRT.Objects.Train;
using PRT.UI;
using Photon.Pun;
using RarityLib.Utils;
using SoundImplementation;
using UnboundLib;
using UnboundLib.Cards;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.SceneManagement;
using WWMO.MonoBehaviours;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PRTCards")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+56b06d826e6aa5ac5f579e0942dbd24c77b4799d")]
[assembly: AssemblyProduct("PRTCards")]
[assembly: AssemblyTitle("PRTCards")]
[assembly: AssemblyVersion("1.0.0.0")]
public class BlockSpawnerEffects : MonoBehaviour
{
	public float blockSpeed = 200f;

	public float blockScale = 2f;

	public float wagons = 0f;

	public bool GodOfTrains = false;

	public bool lava = false;

	public bool boomerang = false;

	public bool DoubleTrain = false;

	public int numberOfTNTs = 10;

	public float timeOfExplosion = 3f;

	public float TNTscale = 1f;

	public int numberofgodtrains = 8;

	public float degreegodtrains = 45f;

	public bool LaserDoDmg = false;
}
public class GunAdditionalData
{
	public bool canShoot = true;
}
public static class GunExtension
{
	private static readonly ConditionalWeakTable<Gun, GunAdditionalData> data = new ConditionalWeakTable<Gun, GunAdditionalData>();

	public static GunAdditionalData GetAdditionalData(this Gun gun)
	{
		return data.GetOrCreateValue(gun);
	}
}
public class ParticleAutoRenderer : MonoBehaviour
{
	private static AssetBundle bundle;

	private void Awake()
	{
		bundle = Assets.Bundle;
		Material maskMaterial = bundle.LoadAsset<Material>("Mat_MeshMaskWrite");
		ApplyToAllExisting(maskMaterial);
	}

	private void OnEnable()
	{
		ParticleSystemCreationWatcher.OnParticleSystemCreated += OnParticleSystemCreated;
	}

	private void OnDisable()
	{
		ParticleSystemCreationWatcher.OnParticleSystemCreated -= OnParticleSystemCreated;
	}

	private void ApplyToAllExisting(Material maskMaterial)
	{
		ParticleSystem[] array = Object.FindObjectsOfType<ParticleSystem>();
		ParticleSystem[] array2 = array;
		foreach (ParticleSystem original in array2)
		{
			DuplicateRenderer(original, maskMaterial);
		}
	}

	private void OnParticleSystemCreated(ParticleSystem ps)
	{
		Material maskMaterial = bundle.LoadAsset<Material>("Mat_MeshMaskWrite");
		DuplicateRenderer(ps, maskMaterial);
	}

	private void DuplicateRenderer(ParticleSystem original, Material maskMaterial)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Expected O, but got Unknown
		//IL_0040: 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_0062: 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_010d: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)original == (Object)null))
		{
			GameObject val = new GameObject(((Object)original).name + "_Mask");
			val.transform.SetParent(((Component)original).transform, false);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			ParticleSystemRenderer val2 = val.AddComponent<ParticleSystemRenderer>();
			ParticleSystemRenderer component = ((Component)original).GetComponent<ParticleSystemRenderer>();
			if ((Object)(object)component != (Object)null)
			{
				val2.renderMode = component.renderMode;
				val2.mesh = component.mesh;
				((Renderer)val2).sortingLayerID = ((Renderer)component).sortingLayerID;
				((Renderer)val2).sortingOrder = ((Renderer)component).sortingOrder + 1;
				((Renderer)val2).material = maskMaterial;
				val2.trailMaterial = component.trailMaterial;
				val2.normalDirection = component.normalDirection;
				val2.cameraVelocityScale = component.cameraVelocityScale;
				val2.velocityScale = component.velocityScale;
				val2.lengthScale = component.lengthScale;
				val2.alignment = component.alignment;
			}
		}
	}
}
[DefaultExecutionOrder(-1000)]
public class ParticleSystemCreationWatcher : MonoBehaviour
{
	public static event Action<ParticleSystem> OnParticleSystemCreated;

	private void Awake()
	{
		ParticleSystem[] array = Object.FindObjectsOfType<ParticleSystem>();
		ParticleSystem[] array2 = array;
		foreach (ParticleSystem ps in array2)
		{
			Notify(ps);
		}
	}

	private void OnTransformChildrenChanged()
	{
		ParticleSystem[] componentsInChildren = ((Component)this).GetComponentsInChildren<ParticleSystem>();
		ParticleSystem[] array = componentsInChildren;
		foreach (ParticleSystem ps in array)
		{
			Notify(ps);
		}
	}

	private void Notify(ParticleSystem ps)
	{
		ParticleSystemCreationWatcher.OnParticleSystemCreated?.Invoke(ps);
	}
}
[HarmonyPatch(typeof(WaterMono), "HandleBox")]
[HarmonyPatch(new Type[] { typeof(Rigidbody2D) })]
public class PatchWaterMono_HandleBox
{
	private static bool Prefix(Rigidbody2D rb)
	{
		if (((Object)((Component)rb).gameObject).name.Contains("IgnoreWater"))
		{
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(BoxTouchingLava_Mono), "FixedUpdate")]
public class Patch_BoxTouchingLava
{
	private static bool Prefix(BoxTouchingLava_Mono __instance)
	{
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: 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_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)((Component)__instance).gameObject).name.Contains("IgnoreWater") && !((Object)((Component)__instance).gameObject).name.Contains("IgnoreLava"))
		{
			return true;
		}
		if (((Object)((Component)__instance).gameObject).name.Contains("IgnoreLava"))
		{
			return false;
		}
		Collider2D component = ((Component)__instance).GetComponent<Collider2D>();
		if ((Object)(object)component == (Object)null)
		{
			return false;
		}
		ContactFilter2D val = default(ContactFilter2D);
		val.useTriggers = false;
		ContactFilter2D val2 = val;
		Collider2D[] array = (Collider2D[])(object)new Collider2D[10];
		int num = component.OverlapCollider(val2, array);
		for (int i = 0; i < num; i++)
		{
			Collider2D obj = array[i];
			Player val3 = ((obj != null) ? ((Component)obj).GetComponent<Player>() : null);
			if ((Object)(object)val3 != (Object)null)
			{
				val3.data.healthHandler.TakeDamageOverTime(Vector2.up * 0.25f * __instance.heatPercent, Vector2.zero, 5f, 0.1f, new Color(1f, 0f, 0f, 0.7f), (GameObject)null, (Player)null, true);
			}
		}
		return false;
	}
}
[HarmonyPatch(typeof(LavaMono), "HandlePlayer")]
[HarmonyPatch(new Type[] { typeof(Player) })]
public class Patch_LavaMono_HandlePlayer
{
	private static bool Prefix(LavaMono __instance, Player player)
	{
		//IL_000e: 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_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_008d: 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_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		HealthHandler healthHandler = player.data.healthHandler;
		((Damagable)healthHandler).TakeDamage(Vector2.up * 0.65f, Vector2.op_Implicit(((Component)player).transform.position), (GameObject)null, (Player)null, true, false);
		FieldInfo field = typeof(HealthHandler).GetField("activeDoTs", BindingFlags.Instance | BindingFlags.NonPublic);
		IList list = (IList)field.GetValue(healthHandler);
		while (list.Count > 1)
		{
			list.RemoveAt(0);
		}
		if (list.Count >= 1)
		{
			return false;
		}
		healthHandler.TakeDamageOverTime(Vector2.up * 0.65f, Vector2.zero, 2.5f, 1f, new Color(1f, 0f, 0f, 0.7f), (GameObject)null, (Player)null, true);
		return false;
	}
}
[HarmonyPatch(typeof(LegRaycasters), "HitGround")]
public class Patch_LegRaycasters_NoTrainOwnerGround
{
	private static bool Prefix(LegRaycasters __instance, RaycastHit2D hit)
	{
		object? value = AccessTools.Field(typeof(LegRaycasters), "data").GetValue(__instance);
		CharacterData val = (CharacterData)((value is CharacterData) ? value : null);
		if ((Object)(object)val == (Object)null)
		{
			return true;
		}
		if (!Object.op_Implicit((Object)(object)((RaycastHit2D)(ref hit)).transform))
		{
			return true;
		}
		TrainOwner componentInParent = ((Component)((RaycastHit2D)(ref hit)).transform).GetComponentInParent<TrainOwner>();
		if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.owner == (Object)(object)val.player)
		{
			return false;
		}
		return true;
	}
}
[HarmonyPatch(typeof(MapObjet_Rope))]
[HarmonyPatch("Update")]
internal class MapObjetRope_Update_Patch
{
	private static Dictionary<MapObjet_Rope, bool> originallyTwoPointsMap = new Dictionary<MapObjet_Rope, bool>();

	private static bool Prefix(MapObjet_Rope __instance)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return true;
		}
		Type typeFromHandle = typeof(MapObjet_Rope);
		FieldInfo field = typeFromHandle.GetField("joint", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field2 = typeFromHandle.GetField("lineRenderer", BindingFlags.Instance | BindingFlags.NonPublic);
		object? obj = field?.GetValue(__instance);
		AnchoredJoint2D val = (AnchoredJoint2D)((obj is AnchoredJoint2D) ? obj : null);
		object? obj2 = field2?.GetValue(__instance);
		LineRenderer val2 = (LineRenderer)((obj2 is LineRenderer) ? obj2 : null);
		if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
		{
			return true;
		}
		if (!originallyTwoPointsMap.ContainsKey(__instance))
		{
			bool value = (Object)(object)((Joint2D)val).attachedRigidbody != (Object)null && (Object)(object)((Joint2D)val).connectedBody != (Object)null;
			originallyTwoPointsMap[__instance] = value;
		}
		if (originallyTwoPointsMap[__instance])
		{
			bool flag = (Object)(object)((Joint2D)val).attachedRigidbody == (Object)null || !((Component)((Joint2D)val).attachedRigidbody).gameObject.activeInHierarchy;
			bool flag2 = (Object)(object)((Joint2D)val).connectedBody == (Object)null || !((Component)((Joint2D)val).connectedBody).gameObject.activeInHierarchy;
			if ((flag || flag2) && ((Renderer)val2).enabled)
			{
				((Renderer)val2).enabled = false;
			}
		}
		return true;
	}
}
[HarmonyPatch(typeof(PlayerCollision), "FixedUpdate")]
public class Patch_PlayerCollision_NoTrainOwnerCollision
{
	private static bool Prefix(PlayerCollision __instance)
	{
		//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_007e: 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_00a9: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: 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_00e8: 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_0108: 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)
		object? value = AccessTools.Field(typeof(PlayerCollision), "data").GetValue(__instance);
		CharacterData val = (CharacterData)((value is CharacterData) ? value : null);
		if ((Object)(object)val == (Object)null)
		{
			return true;
		}
		Vector2 val2 = (Vector2)AccessTools.Field(typeof(PlayerCollision), "lastPos").GetValue(__instance);
		CircleCollider2D component = ((Component)__instance).GetComponent<CircleCollider2D>();
		if ((Object)(object)component == (Object)null)
		{
			return true;
		}
		float num = component.radius * ((Component)__instance).transform.localScale.x;
		LayerMask val3 = (LayerMask)AccessTools.Field(typeof(PlayerCollision), "mask").GetValue(__instance);
		Vector2 val4 = Vector2.op_Implicit(((Component)__instance).transform.position) - val2;
		float magnitude = ((Vector2)(ref val4)).magnitude;
		if (magnitude <= 0.0001f)
		{
			return true;
		}
		RaycastHit2D[] array = Physics2D.CircleCastAll(val2, num, val4, magnitude, LayerMask.op_Implicit(val3));
		RaycastHit2D[] array2 = array;
		for (int i = 0; i < array2.Length; i++)
		{
			RaycastHit2D val5 = array2[i];
			if (Object.op_Implicit((Object)(object)((RaycastHit2D)(ref val5)).transform))
			{
				TrainOwner componentInParent = ((Component)((RaycastHit2D)(ref val5)).transform).GetComponentInParent<TrainOwner>();
				if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.owner == (Object)(object)val.player)
				{
					return false;
				}
			}
		}
		return true;
	}
}
[HarmonyPatch(typeof(Map), "MapMoveOut")]
internal class Patch_Map_MapMoveOut
{
	private static void Prefix()
	{
		GameObject[] array = Object.FindObjectsOfType<GameObject>();
		foreach (GameObject val in array)
		{
			if (((Object)val).name.Contains("Piece"))
			{
				Object.Destroy((Object)(object)val);
			}
		}
	}
}
public class DestroyPieceOutOfCamera : MonoBehaviour
{
	private Camera cam;

	private float zDist;

	private void Start()
	{
		//IL_0013: 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)
		cam = Camera.main;
		zDist = Mathf.Abs(((Component)this).transform.position.z - ((Component)cam).transform.position.z);
	}

	private void Update()
	{
		//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_0030: 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_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: 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)
		if (!((Object)(object)cam == (Object)null))
		{
			Vector3 val = cam.WorldToViewportPoint(((Component)this).transform.position);
			Vector3 val2 = cam.ViewportToWorldPoint(new Vector3(val.x, 0f, zDist));
			if (((Component)this).transform.position.y < val2.y - 20f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
}
public class ExplosionPool : MonoBehaviour
{
	public static ExplosionPool Instance;

	public GameObject effectPrefab;

	public List<GameObject> pool = new List<GameObject>();

	public int poolSize = 40;

	private GameObject container;

	private void Awake()
	{
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Expected O, but got Unknown
		if ((Object)(object)Instance == (Object)null)
		{
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			AssetBundle bundle = Assets.Bundle;
			if ((Object)(object)effectPrefab == (Object)null && (Object)(object)bundle != (Object)null)
			{
				effectPrefab = bundle.LoadAsset<GameObject>("explosion");
			}
			if ((Object)(object)effectPrefab == (Object)null)
			{
				object? obj = typeof(TNTSpawner).GetField("bundle", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null);
				AssetBundle val = (AssetBundle)((obj is AssetBundle) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					effectPrefab = val.LoadAsset<GameObject>("explosion");
				}
			}
			container = new GameObject("ExplosionsContainer");
			container.transform.SetParent(((Component)this).transform);
			if ((Object)(object)effectPrefab != (Object)null)
			{
				for (int i = 0; i < poolSize; i++)
				{
					GameObject val2 = Object.Instantiate<GameObject>(effectPrefab);
					val2.SetActive(false);
					val2.transform.SetParent(container.transform);
					pool.Add(val2);
				}
			}
		}
		else
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}

	public GameObject GetExplosion()
	{
		foreach (GameObject item in pool)
		{
			if (!item.activeInHierarchy)
			{
				return item;
			}
		}
		GameObject val = Object.Instantiate<GameObject>(effectPrefab);
		val.SetActive(false);
		val.transform.SetParent(container.transform);
		pool.Add(val);
		return val;
	}

	public void RegisterExplosion(GameObject explosion)
	{
		explosion.transform.SetParent(container.transform);
		pool.Add(explosion);
	}

	public void ReturnToContainer(GameObject explosion)
	{
		if ((Object)(object)container != (Object)null)
		{
			explosion.transform.SetParent(container.transform);
		}
	}
}
public class PieceData : MonoBehaviour
{
	public Sprite sprite;

	public string OriginalLayer;

	public float createdTime;
}
public static class Cutter2DPhoton
{
	private static List<GameObject> createdPieces = new List<GameObject>();

	private static AssetBundle bundle;

	private static bool usedParentFallback;

	public static List<GameObject> CutAndReturnPieces(GameObject original, Vector2 pointA, Vector2 pointB)
	{
		//IL_006d: 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_007c: 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_0083: 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_0086: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: 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_00de: Unknown result type (might be due to invalid IL or missing references)
		PolygonCollider2D component = original.GetComponent<PolygonCollider2D>();
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		List<Vector2> list = component.points.Select((Vector2 p) => Vector2.op_Implicit(original.transform.TransformPoint(Vector2.op_Implicit(p)))).ToList();
		List<Vector2> list2 = new List<Vector2>();
		List<Vector2> list3 = new List<Vector2>();
		int count = list.Count;
		for (int i = 0; i < count; i++)
		{
			Vector2 val = list[i];
			Vector2 val2 = list[(i + 1) % count];
			bool flag = IsAbove(val, pointA, pointB);
			bool flag2 = IsAbove(val2, pointA, pointB);
			if (flag)
			{
				list2.Add(val);
			}
			else
			{
				list3.Add(val);
			}
			if (flag != flag2 && SegmentIntersect(val, val2, pointA, pointB, out var r))
			{
				list2.Add(r);
				list3.Add(r);
			}
		}
		bool flag3 = (Object)(object)original.GetComponent<Rigidbody2D>() != (Object)null;
		int layer = original.layer;
		int num = LayerMask.NameToLayer("Default");
		MapObjet_Rope val3 = null;
		Rigidbody2D component2 = original.GetComponent<Rigidbody2D>();
		if ((Object)(object)component2 != (Object)null)
		{
			RigidbodyRopeRef component3 = ((Component)component2).GetComponent<RigidbodyRopeRef>();
			if ((Object)(object)component3 != (Object)null)
			{
				val3 = component3.rope;
			}
		}
		List<GameObject> list4 = new List<GameObject>();
		if (list2.Count >= 3)
		{
			list4.Add(CreateNewPiece(original, list2, flag3 || (layer == num && !flag3)));
		}
		if (list3.Count >= 3)
		{
			bool withPhysics = flag3 || (layer != num && flag3);
			if (layer == num && !flag3)
			{
				withPhysics = false;
			}
			list4.Add(CreateNewPiece(original, list3, withPhysics));
		}
		if (usedParentFallback && (Object)(object)original.transform.parent != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)original.transform.parent).gameObject);
		}
		else
		{
			Object.Destroy((Object)(object)original);
		}
		usedParentFallback = false;
		if ((Object)(object)val3 != (Object)null)
		{
			MethodInfo method = typeof(MapObjet_Rope).GetMethod("Leave", BindingFlags.Instance | BindingFlags.NonPublic);
			if (method != null)
			{
				try
				{
					method.Invoke(val3, null);
				}
				catch (Exception)
				{
				}
			}
		}
		return list4;
	}

	private static GameObject CreateNewPiece(GameObject baseObj, List<Vector2> points, bool withPhysics)
	{
		//IL_0851: Unknown result type (might be due to invalid IL or missing references)
		//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_07d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_07e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_027b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Expected O, but got Unknown
		//IL_0280: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Expected O, but got Unknown
		//IL_032e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0335: Expected O, but got Unknown
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		//IL_035a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0372: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0304: Unknown result type (might be due to invalid IL or missing references)
		//IL_0401: Unknown result type (might be due to invalid IL or missing references)
		//IL_0406: Unknown result type (might be due to invalid IL or missing references)
		//IL_040b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0410: Unknown result type (might be due to invalid IL or missing references)
		//IL_069f: Unknown result type (might be due to invalid IL or missing references)
		//IL_06a6: Expected O, but got Unknown
		//IL_06c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0573: Unknown result type (might be due to invalid IL or missing references)
		//IL_057a: Expected O, but got Unknown
		//IL_0598: Unknown result type (might be due to invalid IL or missing references)
		//IL_055e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0608: Unknown result type (might be due to invalid IL or missing references)
		//IL_062a: Unknown result type (might be due to invalid IL or missing references)
		//IL_064d: Unknown result type (might be due to invalid IL or missing references)
		SpriteRenderer val = baseObj.GetComponent<SpriteRenderer>();
		MeshRenderer component = baseObj.GetComponent<MeshRenderer>();
		Sprite val2 = null;
		int layer = baseObj.layer;
		int num = LayerMask.NameToLayer("IgnoreMap");
		int num2 = ((layer == num) ? LayerMask.NameToLayer("Default") : layer);
		PieceData component2 = baseObj.GetComponent<PieceData>();
		if ((Object)(object)component2 != (Object)null && (Object)(object)component2.sprite != (Object)null)
		{
			val2 = component2.sprite;
		}
		if ((Object)(object)val2 == (Object)null && (Object)(object)val != (Object)null)
		{
			val2 = val.sprite;
		}
		if ((Object)(object)val2 == (Object)null)
		{
			foreach (Transform item in baseObj.transform)
			{
				Transform val3 = item;
				SpriteRenderer component3 = ((Component)val3).GetComponent<SpriteRenderer>();
				if ((Object)(object)component3 != (Object)null && (Object)(object)component3.sprite != (Object)null)
				{
					val = component3;
					val2 = component3.sprite;
					break;
				}
			}
		}
		if ((Object)(object)val2 == (Object)null)
		{
			Transform parent = baseObj.transform.parent;
			if ((Object)(object)parent != (Object)null)
			{
				foreach (Transform item2 in parent)
				{
					Transform val4 = item2;
					if (!((Object)(object)val4 == (Object)(object)baseObj.transform))
					{
						SpriteRenderer component4 = ((Component)val4).GetComponent<SpriteRenderer>();
						if ((Object)(object)component4 != (Object)null && (Object)(object)component4.sprite != (Object)null)
						{
							val = component4;
							val2 = component4.sprite;
							usedParentFallback = true;
							break;
						}
						SpriteRenderer componentInChildren = ((Component)val4).GetComponentInChildren<SpriteRenderer>();
						if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.sprite != (Object)null)
						{
							val = componentInChildren;
							val2 = componentInChildren.sprite;
							usedParentFallback = true;
							break;
						}
					}
				}
			}
		}
		Transform val5 = baseObj.transform.Find("Color");
		if ((Object)(object)val5 != (Object)null)
		{
			SpriteRenderer component5 = ((Component)val5).GetComponent<SpriteRenderer>();
			if ((Object)(object)component5 != (Object)null)
			{
				val = component5;
			}
		}
		Color b = default(Color);
		((Color)(ref b))..ctor(0.2157f, 0.2157f, 0.2157f, 1f);
		Color a = (((Object)(object)val != (Object)null) ? val.color : Color.white);
		bool flag = !IsColorEqual(a, b);
		Color? val6 = null;
		if (flag)
		{
			if ((Object)(object)component2 == (Object)null)
			{
				if ((Object)(object)val != (Object)null)
				{
					val6 = val.color;
				}
			}
			else
			{
				MeshRenderer component6 = baseObj.GetComponent<MeshRenderer>();
				if ((Object)(object)component6 != (Object)null && (Object)(object)((Renderer)component6).material != (Object)null)
				{
					val6 = ((Renderer)component6).material.color;
				}
			}
		}
		string text = ((num2 == LayerMask.NameToLayer("IgnorePlayer")) ? "Piece" : "Piece_IgnoreLava");
		GameObject val7 = new GameObject(text);
		val7.transform.position = baseObj.transform.position;
		val7.transform.rotation = baseObj.transform.rotation;
		val7.transform.localScale = baseObj.transform.localScale;
		val7.tag = baseObj.tag;
		val7.layer = num2;
		if ((Object)(object)val2 != (Object)null)
		{
			PieceData pieceData = val7.AddComponent<PieceData>();
			pieceData.sprite = val2;
			pieceData.OriginalLayer = (((Object)(object)component2 != (Object)null && !string.IsNullOrEmpty(component2.OriginalLayer)) ? component2.OriginalLayer : LayerMask.LayerToName(layer));
			pieceData.createdTime = Time.time;
		}
		for (int i = 0; i < points.Count; i++)
		{
			points[i] = Vector2.op_Implicit(val7.transform.InverseTransformPoint(Vector2.op_Implicit(points[i])));
		}
		Mesh mesh = CreateMeshFromPolygon(points, val2);
		MeshFilter val8 = val7.AddComponent<MeshFilter>();
		val8.mesh = mesh;
		MeshRenderer val9 = val7.AddComponent<MeshRenderer>();
		if ((Object)(object)val2 != (Object)null)
		{
			PieceData component7 = baseObj.GetComponent<PieceData>();
			bool flag2 = ((!((Object)(object)component7 == (Object)null)) ? (component7.OriginalLayer == "Default" && (((Object)val2).name.ToLower().Contains("square") || ((Object)val2).name.ToLower().Contains("circe"))) : (layer == LayerMask.NameToLayer("Default") && (((Object)val2).name.ToLower().Contains("square") || ((Object)val2).name.ToLower().Contains("circe"))));
			if (flag)
			{
				flag2 = false;
			}
			Color? val10 = null;
			if ((Object)(object)component7 != (Object)null)
			{
				MeshRenderer component8 = baseObj.GetComponent<MeshRenderer>();
				if ((Object)(object)component8 != (Object)null && (Object)(object)((Renderer)component8).material != (Object)null)
				{
					val10 = ((Renderer)component8).material.color;
				}
			}
			Material val11 = new Material(Shader.Find("Sprites/Default"));
			val11.mainTexture = (Texture)(object)val2.texture;
			if ((Object)(object)val != (Object)null)
			{
				val11.color = val.color;
			}
			if (flag2)
			{
				bundle = Assets.Bundle;
				Material material = bundle.LoadAsset<Material>("Mat_MeshMaskWrite");
				((Renderer)val9).material = material;
				((Renderer)val9).material.renderQueue = 4000;
			}
			else
			{
				((Renderer)val9).material = val11;
			}
			if (val6.HasValue)
			{
				((Renderer)val9).material.color = val6.Value;
			}
			else if ((Object)(object)val != (Object)null)
			{
				((Renderer)val9).material.color = val.color;
			}
			else if (val10.HasValue)
			{
				((Renderer)val9).material.color = val10.Value;
			}
			if ((Object)(object)val != (Object)null)
			{
				((Renderer)val9).sortingLayerID = ((Renderer)val).sortingLayerID;
				((Renderer)val9).sortingOrder = ((Renderer)val).sortingOrder;
			}
		}
		else if ((Object)(object)component != (Object)null)
		{
			Material val12 = new Material(((Renderer)component).material.shader);
			val12.mainTexture = ((Renderer)component).material.mainTexture;
			val12.color = ((Renderer)component).material.color;
			((Renderer)val9).material = val12;
			((Renderer)val9).sortingLayerID = ((Renderer)component).sortingLayerID;
			((Renderer)val9).sortingOrder = ((Renderer)component).sortingOrder;
		}
		PolygonCollider2D val13 = val7.AddComponent<PolygonCollider2D>();
		val13.points = points.ToArray();
		val13.pathCount = 1;
		try
		{
			SFPolygon val14 = val7.AddComponent<SFPolygon>();
			val14.pathCount = 1;
			val14.verts = points.ToArray();
			val14.looped = true;
			val14._UpdateBounds();
		}
		catch (Exception)
		{
		}
		NetworkPhysicsObject val15 = null;
		if (withPhysics)
		{
			Rigidbody2D component9 = baseObj.GetComponent<Rigidbody2D>();
			Rigidbody2D val16 = val7.AddComponent<Rigidbody2D>();
			if ((Object)(object)component9 != (Object)null)
			{
				val16.gravityScale = component9.gravityScale;
				val16.mass = component9.mass;
				val16.drag = component9.drag;
				val16.angularDrag = component9.angularDrag;
				val16.constraints = component9.constraints;
				val16.interpolation = component9.interpolation;
				val16.collisionDetectionMode = component9.collisionDetectionMode;
				val16.bodyType = component9.bodyType;
			}
			else
			{
				val16.gravityScale = 1f;
				val16.mass = 20000f;
			}
			val15 = val7.AddComponent<NetworkPhysicsObject>();
		}
		val7.AddComponent<DestroyPieceOutOfCamera>();
		PhotonView val17 = val7.AddComponent<PhotonView>();
		if (!PhotonNetwork.AllocateViewID(val17))
		{
			Object.Destroy((Object)(object)val7);
			return null;
		}
		val17.observableSearch = (ObservableSearch)2;
		if (val17.ObservedComponents == null)
		{
			val17.ObservedComponents = new List<Component>();
		}
		if ((Object)(object)val15 != (Object)null)
		{
			if (val7.layer == LayerMask.NameToLayer("Default"))
			{
				val7.layer = LayerMask.NameToLayer("IgnorePlayer");
			}
			val15.speed = 8000f;
			val15.maxShake = 8000000f;
			val15.dmgAmount = 0.5f;
			val15.bulletPushMultiplier = 20f;
			val15.collisionThreshold = 200000f;
			val15.forceAmount = 1500f;
			val15.playerColThreshold = 5f;
			val15.photonView = val17;
			if (!val17.ObservedComponents.Contains((Component)(object)val15))
			{
				val17.ObservedComponents.Add((Component)(object)val15);
			}
		}
		Type typeFromHandle = typeof(PhotonView);
		typeFromHandle.GetField("ownerActorNr", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val17, PhotonNetwork.LocalPlayer.ActorNumber);
		typeFromHandle.GetField("<AmOwner>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val17, true);
		typeFromHandle.GetField("amController", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val17, true);
		typeFromHandle.GetField("isRuntimeInstantiated", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val17, true);
		createdPieces.Add(val7);
		return val7;
	}

	private static bool IsColorEqual(Color a, Color b, float epsilon = 0.01f)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: 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)
		return Mathf.Abs(a.r - b.r) < epsilon && Mathf.Abs(a.g - b.g) < epsilon && Mathf.Abs(a.b - b.b) < epsilon && Mathf.Abs(a.a - b.a) < epsilon;
	}

	public static GameObject CreatePieceFromPoints(Vector3 position, Quaternion rotation, Vector3 localScale, int layer, Vector2[] points, Sprite sprite, Color color, int sortingLayerID, int sortingOrder, bool withPhysics)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_0012: 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_002c: 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_00ea: Expected O, but got Unknown
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject("Piece");
		val.transform.position = position;
		val.transform.rotation = rotation;
		val.transform.localScale = localScale;
		val.layer = layer;
		if ((Object)(object)sprite != (Object)null)
		{
			PieceData pieceData = val.AddComponent<PieceData>();
			pieceData.sprite = sprite;
		}
		Mesh mesh = CreateMeshFromPolygon(points.ToList(), sprite);
		MeshFilter val2 = val.AddComponent<MeshFilter>();
		val2.mesh = mesh;
		MeshRenderer val3 = val.AddComponent<MeshRenderer>();
		if ((Object)(object)sprite != (Object)null)
		{
			Material val4 = new Material(Shader.Find("Sprites/Default"));
			val4.mainTexture = (Texture)(object)sprite.texture;
			val4.color = color;
			((Renderer)val3).material = val4;
			((Renderer)val3).sortingLayerID = sortingLayerID;
			((Renderer)val3).sortingOrder = sortingOrder;
		}
		else
		{
			Material material = new Material(Shader.Find("Sprites/Default"));
			((Renderer)val3).material = material;
		}
		PolygonCollider2D val5 = val.AddComponent<PolygonCollider2D>();
		val5.points = points;
		if (withPhysics)
		{
			Rigidbody2D val6 = val.AddComponent<Rigidbody2D>();
			val6.gravityScale = 1f;
		}
		val.AddComponent<DestroyPieceOutOfCamera>();
		PhotonView val7 = val.AddComponent<PhotonView>();
		createdPieces.Add(val);
		return val;
	}

	private static bool IsAbove(Vector2 p, Vector2 a, Vector2 b)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		return (b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x) > 0f;
	}

	public static bool SegmentIntersect(Vector2 p, Vector2 q, Vector2 a, Vector2 b, out Vector2 r)
	{
		//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_0003: 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_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_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_0024: 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_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: 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_0061: 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_0075: 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_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: 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)
		Vector2 val = q - p;
		Vector2 val2 = b - a;
		float num = val.x * val2.y - val.y * val2.x;
		if (Mathf.Approximately(num, 0f))
		{
			r = default(Vector2);
			return false;
		}
		Vector2 val3 = a - p;
		float num2 = (val3.x * val2.y - val3.y * val2.x) / num;
		r = p + num2 * val;
		return num2 >= 0f && num2 <= 1f;
	}

	private static Mesh CreateMeshFromPolygon(List<Vector2> pts, Sprite sprite)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Expected O, but got Unknown
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: 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_00cf: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_020f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0222: Unknown result type (might be due to invalid IL or missing references)
		//IL_0232: Unknown result type (might be due to invalid IL or missing references)
		//IL_0237: Unknown result type (might be due to invalid IL or missing references)
		Mesh val = new Mesh();
		Vector3[] array = pts.Select((Vector2 p) => Vector2.op_Implicit(p)).ToArray();
		int[] array2 = new Triangulator(pts.ToArray()).Triangulate();
		for (int i = 0; i < array2.Length; i += 3)
		{
			int num = array2[i + 1];
			array2[i + 1] = array2[i + 2];
			array2[i + 2] = num;
		}
		val.vertices = array;
		val.triangles = array2;
		Vector2[] array3 = (Vector2[])(object)new Vector2[pts.Count];
		if ((Object)(object)sprite != (Object)null)
		{
			Rect rect = sprite.rect;
			Vector2 pivot = sprite.pivot;
			float pixelsPerUnit = sprite.pixelsPerUnit;
			Texture2D texture = sprite.texture;
			for (int j = 0; j < pts.Count; j++)
			{
				Vector3 val2 = array[j];
				float num2 = val2.x * pixelsPerUnit + pivot.x;
				float num3 = val2.y * pixelsPerUnit + pivot.y;
				float num4 = (((Rect)(ref rect)).x + num2) / (float)((Texture)texture).width;
				float num5 = (((Rect)(ref rect)).y + num3) / (float)((Texture)texture).height;
				array3[j] = new Vector2(num4, num5);
			}
		}
		else
		{
			float num6 = pts.Min((Vector2 p) => p.x);
			float num7 = pts.Max((Vector2 p) => p.x);
			float num8 = pts.Min((Vector2 p) => p.y);
			float num9 = pts.Max((Vector2 p) => p.y);
			float num10 = num7 - num6;
			float num11 = num9 - num8;
			for (int k = 0; k < pts.Count; k++)
			{
				array3[k] = new Vector2((pts[k].x - num6) / num10, (pts[k].y - num8) / num11);
			}
		}
		val.uv = array3;
		val.RecalculateBounds();
		val.RecalculateNormals();
		return val;
	}
}
public class Triangulator
{
	private List<Vector2> m_pts;

	public Triangulator(Vector2[] pts)
	{
		m_pts = new List<Vector2>(pts);
	}

	public int[] Triangulate()
	{
		List<int> list = new List<int>();
		int count = m_pts.Count;
		int[] array = new int[count];
		if (Area() > 0f)
		{
			for (int i = 0; i < count; i++)
			{
				array[i] = i;
			}
		}
		else
		{
			for (int j = 0; j < count; j++)
			{
				array[j] = count - 1 - j;
			}
		}
		int num = count;
		int num2 = 2 * num;
		int num3 = num - 1;
		while (num > 2 && num2-- > 0)
		{
			int num4 = ((num3 < num) ? num3 : 0);
			num3 = ((num4 + 1 < num) ? (num4 + 1) : 0);
			int num5 = ((num3 + 1 < num) ? (num3 + 1) : 0);
			if (Snip(num4, num3, num5, num, array))
			{
				list.Add(array[num4]);
				list.Add(array[num3]);
				list.Add(array[num5]);
				int num6 = num3;
				for (int k = num3 + 1; k < num; k++)
				{
					array[num6] = array[k];
					num6++;
				}
				num--;
				num2 = 2 * num;
			}
		}
		return list.ToArray();
	}

	private float Area()
	{
		//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_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)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: 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)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		float num = 0f;
		int count = m_pts.Count;
		int index = count - 1;
		int num2 = 0;
		while (num2 < count)
		{
			Vector2 val = m_pts[index];
			Vector2 val2 = m_pts[num2];
			num += val.x * val2.y - val2.x * val.y;
			index = num2++;
		}
		return num * 0.5f;
	}

	private bool Snip(int u, int v, int w, int n, int[] V)
	{
		//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_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_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_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: 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_009a: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = m_pts[V[u]];
		Vector2 val2 = m_pts[V[v]];
		Vector2 val3 = m_pts[V[w]];
		if (Mathf.Epsilon > (val2.x - val.x) * (val3.y - val.y) - (val2.y - val.y) * (val3.x - val.x))
		{
			return false;
		}
		for (int i = 0; i < n; i++)
		{
			if (i != u && i != v && i != w && InsideTriangle(val, val2, val3, m_pts[V[i]]))
			{
				return false;
			}
		}
		return true;
	}

	private bool InsideTriangle(Vector2 A, Vector2 B, Vector2 C, Vector2 P)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: 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_0048: 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_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: 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_0077: 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_0087: 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_0097: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		float num = C.x - B.x;
		float num2 = C.y - B.y;
		float num3 = A.x - C.x;
		float num4 = A.y - C.y;
		float num5 = B.x - A.x;
		float num6 = B.y - A.y;
		float num7 = P.x - A.x;
		float num8 = P.y - A.y;
		float num9 = P.x - B.x;
		float num10 = P.y - B.y;
		float num11 = P.x - C.x;
		float num12 = P.y - A.y;
		return num * num10 - num2 * num9 >= 0f && num3 * num12 - num4 * num11 >= 0f && num5 * num8 - num6 * num7 >= 0f;
	}
}
public class LaserCutter2D : MonoBehaviourPun
{
	[Header("References")]
	public LineRenderer line;

	public LineRenderer visibleline;

	[Header("Hit Info (debug / efeitos)")]
	public HitInfo currentHitInfo;

	[Header("Cut Settings")]
	public string[] cutLayerNames = new string[5] { "Default", "IgnorePlayer", "IgnoreMap", "BackgroundObject", "Player" };

	[HideInInspector]
	public Transform Gun2;

	private LayerMask cutLayers;

	private Vector3 startPoint;

	private Vector3 endPoint;

	public bool cutting;

	private float laserLength = 10000000f;

	private Gun gun;

	private bool locked = false;

	private Vector3 lockeddirection;

	private HashSet<Player> Playersdmg = new HashSet<Player>();

	private void Start()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		//IL_00de: 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)
		cutLayers = LayerMask.op_Implicit(LayerMask.GetMask(cutLayerNames));
		line = ((Component)this).GetComponent<LineRenderer>();
		line.positionCount = 2;
		((Renderer)line).enabled = false;
		((Component)this).gameObject.tag = "Laser";
		if ((Object)(object)visibleline == (Object)null)
		{
			GameObject val = new GameObject("LineSempreVisivel");
			val.transform.SetParent(((Component)this).transform);
			visibleline = val.AddComponent<LineRenderer>();
			visibleline.startWidth = 0.05f;
			visibleline.endWidth = 0.05f;
			((Renderer)visibleline).material = ((Renderer)line).material;
			visibleline.startColor = new Color(1f, 1f, 1f, 0.3f);
			visibleline.endColor = new Color(1f, 1f, 1f, 0.3f);
			visibleline.positionCount = 2;
			((Renderer)visibleline).enabled = false;
		}
		gun = ((Component)this).GetComponentInParent<Gun>();
		if ((Object)(object)Gun2 == (Object)null && (Object)(object)gun != (Object)null)
		{
			Gun2 = gun.shootPosition;
		}
		Camera main = Camera.main;
		if ((Object)(object)main != (Object)null && main.orthographic)
		{
			float num = main.orthographicSize * 2f;
			float num2 = num * main.aspect;
			float num3 = Mathf.Sqrt(num2 * num2 + num * num);
			laserLength = num3 + 100f;
		}
		else if ((Object)(object)main != (Object)null)
		{
			float num4 = Mathf.Tan(main.fieldOfView * 0.5f * (MathF.PI / 180f)) * 10f;
			float num5 = num4 * main.aspect;
			float num6 = Mathf.Sqrt(num5 * num5 + num4 * num4);
			laserLength = num6 + 100f;
		}
		cutting = false;
		((Behaviour)this).enabled = true;
	}

	private void Update()
	{
		//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_0048: 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_0054: 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_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)Gun2 == (Object)null) && !((Object)(object)gun == (Object)null))
		{
			if (!locked)
			{
				startPoint = Gun2.position;
				lockeddirection = GetDirecaoDisparo();
				endPoint = startPoint + lockeddirection * laserLength;
			}
			if (!cutting && ((Renderer)visibleline).enabled)
			{
				visibleline.SetPosition(0, startPoint);
				visibleline.SetPosition(1, endPoint);
				((Renderer)line).enabled = false;
			}
			else if (cutting)
			{
				((Renderer)visibleline).enabled = false;
				((Renderer)line).enabled = true;
				line.SetPosition(0, startPoint);
				line.SetPosition(1, endPoint);
				UpdateLaserHitEffect(startPoint, lockeddirection);
				CutObjects();
			}
			else
			{
				((Renderer)visibleline).enabled = false;
				((Renderer)line).enabled = false;
			}
		}
	}

	private void UpdateLaserHitEffect(Vector3 start, Vector3 dir)
	{
		//IL_0016: 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_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_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_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_0036: 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_0040: 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_004f: Expected O, but got Unknown
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		Camera main = Camera.main;
		if (!((Object)(object)main == (Object)null))
		{
			Vector3 laserCameraLimit = GetLaserCameraLimit(main, start, dir);
			HitInfo val = (currentHitInfo = new HitInfo
			{
				point = Vector2.op_Implicit(laserCameraLimit),
				normal = Vector2.op_Implicit(-dir),
				collider = null,
				transform = null
			});
			DynamicParticles.instance.PlayBulletHit(10000f, ((Component)this).transform, val, Color.red);
		}
	}

	private Vector3 GetLaserCameraLimit(Camera cam, Vector3 start, Vector3 dir)
	{
		//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_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_0025: 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_0027: 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_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: 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_005a: 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_0062: 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)
		Plane[] array = GeometryUtility.CalculateFrustumPlanes(cam);
		float num = float.MaxValue;
		Vector3 val = start;
		Plane[] array2 = array;
		float num2 = default(float);
		for (int i = 0; i < array2.Length; i++)
		{
			Plane val2 = array2[i];
			if (((Plane)(ref val2)).Raycast(new Ray(start, dir), ref num2) && num2 > 0f && num2 < num)
			{
				num = num2;
				val = start + dir * num2;
			}
		}
		return val - dir;
	}

	public void ActivateLaser(Transform arma)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//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_0043: 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)
		//IL_0049: 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_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: 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_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		Gun2 = arma;
		Playersdmg.Clear();
		cutting = true;
		((Behaviour)this).enabled = true;
		locked = true;
		startPoint = arma.position;
		lockeddirection = GetDirecaoDisparo();
		Vector3 direcaoDisparo = GetDirecaoDisparo();
		GamefeelManager.GameFeel(Vector2.op_Implicit(direcaoDisparo * 30f));
		endPoint = startPoint + lockeddirection * laserLength;
	}

	public void SwitchOffLaser()
	{
		cutting = false;
		((Behaviour)this).enabled = true;
		SetAimLaser(ativa: true);
		locked = false;
	}

	public void SetAimLaser(bool ativa)
	{
		if ((Object)(object)visibleline != (Object)null)
		{
			((Renderer)visibleline).enabled = ativa;
		}
	}

	private Vector3 GetDirecaoDisparo()
	{
		//IL_0046: 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_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		Quaternion val = (Quaternion)typeof(Gun).InvokeMember("getShootRotation", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, gun, new object[3] { 0, 0, 0f });
		return val * Vector3.forward;
	}

	private void DamagePlayerPercent(Player targetPlayer, float percent)
	{
		//IL_0070: 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_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_0084: 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_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)targetPlayer == (Object)null)
		{
			return;
		}
		CharacterData component = ((Component)targetPlayer).GetComponent<CharacterData>();
		Damagable component2 = ((Component)targetPlayer).GetComponent<Damagable>();
		if (!((Object)(object)component == (Object)null) && !((Object)(object)component2 == (Object)null))
		{
			percent = Mathf.Clamp(percent, 0.1f, 1f);
			float num = component.health * percent;
			if (!(num <= 0f))
			{
				Vector3 val = ((Component)targetPlayer).transform.position - startPoint;
				Vector2 val2 = Vector2.op_Implicit(((Vector3)(ref val)).normalized);
				component2.CallTakeDamage(val2 * num, Vector2.op_Implicit(((Component)targetPlayer).transform.position), (GameObject)null, gun.player, true);
			}
		}
	}

	private bool HitConsomePotencia(Collider2D col)
	{
		int layer = ((Component)col).gameObject.layer;
		return layer == LayerMask.NameToLayer("Player") || layer == LayerMask.NameToLayer("Default") || layer == LayerMask.NameToLayer("IgnorePlayer");
	}

	private void CutObjects()
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0020: 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_0035: 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_0040: 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_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_005a: 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_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02de: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_055d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0562: Unknown result type (might be due to invalid IL or missing references)
		//IL_0566: Unknown result type (might be due to invalid IL or missing references)
		//IL_056b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0582: Unknown result type (might be due to invalid IL or missing references)
		//IL_0587: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_05cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0605: Unknown result type (might be due to invalid IL or missing references)
		//IL_060f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0670: Unknown result type (might be due to invalid IL or missing references)
		//IL_0680: Unknown result type (might be due to invalid IL or missing references)
		//IL_069b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0458: Unknown result type (might be due to invalid IL or missing references)
		//IL_045d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0463: Unknown result type (might be due to invalid IL or missing references)
		//IL_0468: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = endPoint - startPoint;
		Vector2 val2 = Vector2.op_Implicit(((Vector3)(ref val)).normalized);
		float num = laserLength;
		Vector2 val3 = Vector2.op_Implicit(startPoint);
		val = endPoint - startPoint;
		RaycastHit2D[] array = Physics2D.RaycastAll(val3, Vector2.op_Implicit(((Vector3)(ref val)).normalized), laserLength, LayerMask.op_Implicit(cutLayers));
		foreach (RaycastHit2D val4 in array)
		{
			foreach (RopeColliderGenerator allRope in RopeColliderGenerator.AllRopes)
			{
				if ((Object)(object)allRope == (Object)null || !allRope.CheckLaserHit(Vector2.op_Implicit(startPoint), val2, num, out var _))
				{
					continue;
				}
				MapObjet_Rope component = ((Component)allRope).GetComponent<MapObjet_Rope>();
				if ((Object)(object)component != (Object)null)
				{
					MethodInfo method = typeof(MapObjet_Rope).GetMethod("Leave", BindingFlags.Instance | BindingFlags.NonPublic);
					if (method != null)
					{
						method.Invoke(component, null);
					}
				}
			}
		}
		RaycastHit2D[] array2 = Physics2D.RaycastAll(Vector2.op_Implicit(startPoint), val2, num, LayerMask.op_Implicit(cutLayers));
		if (PhotonNetwork.IsMasterClient)
		{
			float num2 = 0.9f;
			RaycastHit2D[] array3 = array2;
			for (int j = 0; j < array3.Length; j++)
			{
				RaycastHit2D val5 = array3[j];
				if ((Object)(object)((RaycastHit2D)(ref val5)).collider == (Object)null || ((RaycastHit2D)(ref val5)).collider.isTrigger)
				{
					continue;
				}
				bool flag = HitConsomePotencia(((RaycastHit2D)(ref val5)).collider);
				if (((Component)((RaycastHit2D)(ref val5)).collider).gameObject.layer == LayerMask.NameToLayer("Player"))
				{
					Player val6 = gun?.player;
					BlockSpawnerEffects blockSpawnerEffects = (((Object)(object)val6 != (Object)null) ? ((Component)val6).GetComponent<BlockSpawnerEffects>() : null);
					if ((Object)(object)blockSpawnerEffects == (Object)null || !blockSpawnerEffects.LaserDoDmg)
					{
						continue;
					}
					Player componentInParent = ((Component)((RaycastHit2D)(ref val5)).collider).GetComponentInParent<Player>();
					if ((Object)(object)componentInParent != (Object)null && !Playersdmg.Contains(componentInParent))
					{
						Playersdmg.Add(componentInParent);
						float percent = Mathf.Max(num2, 0.1f);
						DamagePlayerPercent(componentInParent, percent);
					}
				}
				if (flag)
				{
					num2 -= 0.1f;
					num2 = Mathf.Max(num2, 0.1f);
				}
			}
		}
		List<GameObject> list = new List<GameObject>();
		RaycastHit2D[] array4 = array2;
		for (int k = 0; k < array4.Length; k++)
		{
			RaycastHit2D val7 = array4[k];
			if (!((Object)(object)((RaycastHit2D)(ref val7)).collider == (Object)null) && !((RaycastHit2D)(ref val7)).collider.isTrigger)
			{
				GameObject gameObject = ((Component)((RaycastHit2D)(ref val7)).collider).gameObject;
				if (gameObject.layer != LayerMask.NameToLayer("Player") && !list.Contains(gameObject))
				{
					list.Add(gameObject);
				}
			}
		}
		foreach (GameObject item in list.ToList())
		{
			try
			{
				PieceData component2 = item.GetComponent<PieceData>();
				if ((Object)(object)component2 != (Object)null && Time.time - component2.createdTime < 0.5f)
				{
					continue;
				}
				PolygonCollider2D val8 = item.GetComponent<PolygonCollider2D>();
				if ((Object)(object)val8 == (Object)null)
				{
					BoxCollider2D component3 = item.GetComponent<BoxCollider2D>();
					if ((Object)(object)component3 != (Object)null)
					{
						val8 = ConvertBoxToPolygon(component3);
					}
					else
					{
						CircleCollider2D component4 = item.GetComponent<CircleCollider2D>();
						if ((Object)(object)component4 != (Object)null)
						{
							val8 = ConvertCircleToPolygon(component4);
						}
					}
				}
				MeshFilter component5 = item.GetComponent<MeshFilter>();
				if (((Object)(object)val8 == (Object)null && (Object)(object)component5 == (Object)null) || !PhotonNetwork.IsMasterClient)
				{
					continue;
				}
				List<GameObject> list2 = Cutter2DPhoton.CutAndReturnPieces(item, Vector2.op_Implicit(startPoint), Vector2.op_Implicit(endPoint));
				if (list2 == null || list2.Count == 0)
				{
					continue;
				}
				Collider2D[] components = item.GetComponents<Collider2D>();
				foreach (Collider2D val9 in components)
				{
					if ((Object)(object)val9 != (Object)null)
					{
						((Behaviour)val9).enabled = false;
					}
				}
				foreach (GameObject item2 in list2)
				{
					try
					{
						PhotonView component6 = item2.GetComponent<PhotonView>();
						if ((Object)(object)component6 == (Object)null)
						{
							continue;
						}
						component6.TransferOwnership(((MonoBehaviourPun)this).photonView.OwnerActorNr);
						Sprite val10 = item2.GetComponent<PieceData>()?.sprite;
						if (!((Object)(object)val10 == (Object)null))
						{
							Texture2D texture = val10.texture;
							if (!((Object)(object)texture == (Object)null))
							{
								Rect rect = val10.rect;
								Vector2 pivot = val10.pivot;
								float pixelsPerUnit = val10.pixelsPerUnit;
								Color color = ((Renderer)item2.GetComponent<MeshRenderer>()).material.color;
								int sortingLayerID = ((Renderer)item2.GetComponent<MeshRenderer>()).sortingLayerID;
								int sortingOrder = ((Renderer)item2.GetComponent<MeshRenderer>()).sortingOrder;
								Vector3 position = item2.transform.position;
								Quaternion rotation = item2.transform.rotation;
								Vector3 localScale = item2.transform.localScale;
								int layer = item2.layer;
								Vector2[] points = item2.GetComponent<PolygonCollider2D>().points;
								((MonoBehaviourPun)this).photonView.RPC("RPC_CreatePieceWithSpriteData", (RpcTarget)4, new object[19]
								{
									position,
									rotation,
									localScale,
									layer,
									points,
									ImageConversion.EncodeToPNG(texture),
									((Rect)(ref rect)).x,
									((Rect)(ref rect)).y,
									((Rect)(ref rect)).width,
									((Rect)(ref rect)).height,
									pivot.x,
									pivot.y,
									pixelsPerUnit,
									color,
									sortingLayerID,
									sortingOrder,
									true,
									((MonoBehaviourPun)this).photonView.OwnerActorNr,
									component6.ViewID
								});
							}
						}
					}
					catch (Exception)
					{
					}
				}
			}
			catch (Exception)
			{
			}
		}
	}

	private PolygonCollider2D ConvertCircleToPolygon(CircleCollider2D circle, int segments = 16)
	{
		//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_006d: 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_0082: 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)
		if ((Object)(object)circle == (Object)null)
		{
			return null;
		}
		PolygonCollider2D val = ((Component)circle).gameObject.GetComponent<PolygonCollider2D>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)circle).gameObject.AddComponent<PolygonCollider2D>();
		}
		Vector2 offset = ((Collider2D)circle).offset;
		float radius = circle.radius;
		Vector2[] array = (Vector2[])(object)new Vector2[segments];
		for (int i = 0; i < segments; i++)
		{
			float num = (float)i / (float)segments * MathF.PI * 2f;
			array[i] = offset + new Vector2(Mathf.Cos(num), Mathf.Sin(num)) * radius;
		}
		val.pathCount = 1;
		val.SetPath(0, array);
		return val;
	}

	private PolygonCollider2D ConvertBoxToPolygon(BoxCollider2D box)
	{
		//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_0043: 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)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: 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_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_007c: 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_0084: 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_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_009e: 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_00a6: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: 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_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)box == (Object)null)
		{
			return null;
		}
		PolygonCollider2D val = ((Component)box).gameObject.GetComponent<PolygonCollider2D>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)box).gameObject.AddComponent<PolygonCollider2D>();
		}
		Vector2 size = box.size;
		Vector2 offset = ((Collider2D)box).offset;
		Vector2[] array = (Vector2[])(object)new Vector2[4]
		{
			offset + new Vector2(0f - size.x, 0f - size.y) * 0.5f,
			offset + new Vector2(0f - size.x, size.y) * 0.5f,
			offset + new Vector2(size.x, size.y) * 0.5f,
			offset + new Vector2(size.x, 0f - size.y) * 0.5f
		};
		val.pathCount = 1;
		val.SetPath(0, array);
		return val;
	}

	[PunRPC]
	private void RPC_CreatePieceWithSpriteData(Vector3 position, Quaternion rotation, Vector3 localScale, int layer, Vector2[] points, byte[] texBytes, float rectX, float rectY, float rectW, float rectH, float pivotX, float pivotY, float ppu, Color color, int sortingLayerID, int sortingOrder, bool withPhysics, int ownerActorNr, int viewID)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Expected O, but got Unknown
		//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_0037: 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_0039: 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)
		Texture2D val = new Texture2D(2, 2);
		ImageConversion.LoadImage(val, texBytes);
		Rect val2 = default(Rect);
		((Rect)(ref val2))..ctor(rectX, rectY, rectW, rectH);
		Vector2 val3 = default(Vector2);
		((Vector2)(ref val3))..ctor(pivotX, pivotY);
		Sprite sprite = Sprite.Create(val, val2, val3, ppu);
		GameObject val4 = Cutter2DPhoton.CreatePieceFromPoints(position, rotation, localScale, layer, points, sprite, color, sortingLayerID, sortingOrder, withPhysics);
		if ((Object)(object)val4 != (Object)null)
		{
			PhotonView component = val4.GetComponent<PhotonView>();
			if ((Object)(object)component != (Object)null)
			{
				component.ViewID = viewID;
			}
		}
	}
}
public class LaserGunController : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <InitLaser>d__17 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public LaserGunController <>4__this;

		private GameObject <laserGO>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <InitLaser>d__17(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<laserGO>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//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_00ac: 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)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.laserCutter = ((Component)<>4__this.gun).GetComponentInChildren<LaserCutter2D>();
				if ((Object)(object)<>4__this.laserCutter == (Object)null)
				{
					<laserGO>5__1 = LaserLoader.SpawnLaser(Vector3.zero, Quaternion.identity);
					<laserGO>5__1.transform.SetParent(((Component)<>4__this.gun).transform);
					<laserGO>5__1.transform.localPosition = Vector3.zero;
					<laserGO>5__1.transform.localRotation = Quaternion.identity;
					<>4__this.laserCutter = <laserGO>5__1.GetComponent<LaserCutter2D>();
					<laserGO>5__1 = null;
				}
				<>4__this.laserCutter.SwitchOffLaser();
				<>4__this.laserCutter.SetAimLaser(ativa: false);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public Gun gun;

	private LaserCutter2D laserCutter;

	public Coroutine laserCoroutine;

	private bool ActiveLaser = false;

	private float sinceAttackLaser = 999f;

	private float sinceAttackNormal = 999f;

	private float attackSpeedOriginal;

	private bool dontAllowAutoFireOriginal;

	private float spreadOriginal;

	public float attackSpeedLaser = 5f;

	public bool LoadingLaser = false;

	private AudioSource chargeSource;

	private AudioSource fireSource;

	private static AudioClip laserChargeClip;

	private static AudioClip laserFireClip;

	private void Awake()
	{
		SetupAudio();
		((MonoBehaviour)this).StartCoroutine(InitLaser());
	}

	private void Update()
	{
		if ((Object)(object)gun == (Object)null || (Object)(object)gun.player == (Object)null)
		{
			return;
		}
		float deltaTime = Time.deltaTime;
		if (ActiveLaser)
		{
			sinceAttackLaser += deltaTime;
		}
		else
		{
			sinceAttackNormal += deltaTime;
		}
		PlayerActions playerActions = gun.player.data.playerActions;
		if (playerActions == null)
		{
			return;
		}
		if (((OneAxisInputControl)playerActions.GetAdditionalData().switchWeapon).WasPressed)
		{
			ActiveLaser = !ActiveLaser;
			if (ActiveLaser)
			{
				sinceAttackNormal = ((Weapon)gun).sinceAttack;
				((Weapon)gun).sinceAttack = sinceAttackLaser;
				attackSpeedOriginal = gun.attackSpeed;
				dontAllowAutoFireOriginal = gun.dontAllowAutoFire;
				spreadOriginal = gun.spread;
				gun.attackSpeed = attackSpeedLaser;
				gun.dontAllowAutoFire = true;
				gun.spread = 0f;
			}
			else
			{
				sinceAttackLaser = ((Weapon)gun).sinceAttack;
				((Weapon)gun).sinceAttack = sinceAttackNormal;
				CancelLaser();
				gun.attackSpeed = attackSpeedOriginal;
				gun.dontAllowAutoFire = dontAllowAutoFireOriginal;
				gun.spread = spreadOriginal;
			}
			if ((Object)(object)laserCutter != (Object)null)
			{
				laserCutter.SetAimLaser(ActiveLaser);
			}
		}
		gun.GetAdditionalData().canShoot = !ActiveLaser;
	}

	[IteratorStateMachine(typeof(<InitLaser>d__17))]
	private IEnumerator InitLaser()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <InitLaser>d__17(0)
		{
			<>4__this = this
		};
	}

	private void SetupAudio()
	{
		chargeSource = ((Component)this).gameObject.AddComponent<AudioSource>();
		chargeSource.volume = 0.05f;
		chargeSource.playOnAwake = false;
		fireSource = ((Component)this).gameObject.AddComponent<AudioSource>();
		fireSource.volume = 0.055f;
		fireSource.playOnAwake = false;
		if ((Object)(object)laserChargeClip == (Object)null)
		{
			laserChargeClip = Assets.Bundle.LoadAsset<AudioClip>("laser_charge_loop");
		}
		if ((Object)(object)laserFireClip == (Object)null)
		{
			laserFireClip = Assets.Bundle.LoadAsset<AudioClip>("laserrealease");
		}
		chargeSource.clip = laserChargeClip;
		fireSource.clip = laserFireClip;
		AudioMixerGroup[] array = SoundVolumeManager.Instance.audioMixer.FindMatchingGroups("SFX");
		if (array.Length != 0)
		{
			chargeSource.outputAudioMixerGroup = array[0];
			fireSource.outputAudioMixerGroup = array[0];
		}
	}

	public void PlayChargeSound()
	{
		if (!chargeSource.isPlaying)
		{
			chargeSource.Play();
		}
	}

	public void StopChargeSound()
	{
		if (chargeSource.isPlaying)
		{
			chargeSource.Stop();
		}
	}

	public void PlayFireSound()
	{
		fireSource.PlayOneShot(fireSource.clip);
	}

	public void CancelLaser()
	{
		if (laserCoroutine != null)
		{
			((MonoBehaviour)gun).StopCoroutine(laserCoroutine);
			laserCoroutine = null;
		}
		LoadingLaser = false;
		StopChargeSound();
		if ((Object)(object)laserCutter != (Object)null)
		{
			laserCutter.SwitchOffLaser();
		}
	}

	public bool IsLaserActive()
	{
		return ActiveLaser;
	}

	public bool IsWaitingForCooldown()
	{
		return sinceAttackLaser < 1f / attackSpeedLaser;
	}

	public void ResetLaserCooldown()
	{
		sinceAttackLaser = 0f;
	}

	public LaserCutter2D GetLaserCutter()
	{
		return laserCutter;
	}
}
public class RigidbodyRopeRef : MonoBehaviour
{
	public MapObjet_Rope rope;
}
[HarmonyPatch(typeof(MapObjet_Rope), "AddJoint")]
public class MapRope_AddJoint_Patch
{
	private static void Postfix(MapObjet_Rope __instance, Rigidbody2D target)
	{
		if ((Object)(object)target != (Object)null)
		{
			RigidbodyRopeRef rigidbodyRopeRef = ((Component)target).GetComponent<RigidbodyRopeRef>();
			if ((Object)(object)rigidbodyRopeRef == (Object)null)
			{
				rigidbodyRopeRef = ((Component)target).gameObject.AddComponent<RigidbodyRopeRef>();
			}
			rigidbodyRopeRef.rope = __instance;
		}
	}
}
public class RopeAutoConverter : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <AutoCheckLoop>d__5 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public RopeAutoConverter <>4__this;

		private bool <stillMissing>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <AutoCheckLoop>d__5(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			<stillMissing>5__1 = <>4__this.ConvertAllRopes();
			if (!<stillMissing>5__1)
			{
				<>4__this.autoRoutine = null;
				return false;
			}
			<>2__current = (object)new WaitForSeconds(<>4__this.interval);
			<>1__state = 1;
			return true;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private Coroutine autoRoutine;

	private float interval = 2f;

	private void Awake()
	{
		Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		SceneManager.sceneLoaded += OnSceneLoaded;
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		StartLoop();
	}

	private void StartLoop()
	{
		if (autoRoutine == null)
		{
			autoRoutine = ((MonoBehaviour)this).StartCoroutine(AutoCheckLoop());
		}
	}

	[IteratorStateMachine(typeof(<AutoCheckLoop>d__5))]
	private IEnumerator AutoCheckLoop()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <AutoCheckLoop>d__5(0)
		{
			<>4__this = this
		};
	}

	private bool ConvertAllRopes()
	{
		bool result = false;
		LineRenderer[] array = Object.FindObjectsOfType<LineRenderer>();
		LineRenderer[] array2 = array;
		foreach (LineRenderer val in array2)
		{
			if (((Object)val).name.ToLower().Contains("rope") && (Object)(object)((Component)val).GetComponent<RopeColliderGenerator>() == (Object)null)
			{
				result = true;
				((Component)val).gameObject.AddComponent<RopeColliderGenerator>();
			}
		}
		return result;
	}

	private void Update()
	{
		if (autoRoutine == null && HasUnconvertedRopes())
		{
			StartLoop();
		}
	}

	private bool HasUnconvertedRopes()
	{
		LineRenderer[] array = Object.FindObjectsOfType<LineRenderer>();
		foreach (LineRenderer val in array)
		{
			if (((Object)val).name.ToLower().Contains("rope") && (Object)(object)((Component)val).GetComponent<RopeColliderGenerator>() == (Object)null)
			{
				return true;
			}
		}
		return false;
	}
}
[RequireComponent(typeof(LineRenderer))]
public class RopeColliderGenerator : MonoBehaviour
{
	public static readonly List<RopeColliderGenerator> AllRopes = new List<RopeColliderGenerator>();

	private LineRenderer line;

	private Vector3[] positions;

	private void Awake()
	{
		line = ((Component)this).GetComponent<LineRenderer>();
		AllRopes.Add(this);
	}

	private void OnDestroy()
	{
		AllRopes.Remove(this);
	}

	public bool CheckLaserHit(Vector2 laserStart, Vector2 laserDir, float laserDist, out Vector2 hitPoint)
	{
		//IL_0003: 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_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_006a: 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_007e: 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_0082: 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_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_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		hitPoint = Vector2.zero;
		int positionCount = line.positionCount;
		if (positions == null || positions.Length != positionCount)
		{
			positions = (Vector3[])(object)new Vector3[positionCount];
		}
		line.GetPositions(positions);
		for (int i = 0; i < positionCount - 1; i++)
		{
			Vector2 p = Vector2.op_Implicit(positions[i]);
			Vector2 p2 = Vector2.op_Implicit(positions[i + 1]);
			if (LineIntersect(laserStart, laserStart + laserDir * laserDist, p, p2, out var intersection))
			{
				hitPoint = intersection;
				return true;
			}
		}
		return false;
	}

	private bool LineIntersect(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, out Vector2 intersection)
	{
		//IL_0003: 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_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: 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_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: 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_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: 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)
		intersection = Vector2.zero;
		float num = p2.y - p1.y;
		float num2 = p1.x - p2.x;
		float num3 = num * p1.x + num2 * p1.y;
		float num4 = p4.y - p3.y;
		float num5 = p3.x - p4.x;
		float num6 = num4 * p3.x + num5 * p3.y;
		float num7 = num * num5 - num4 * num2;
		if (Mathf.Abs(num7) < 0.001f)
		{
			return false;
		}
		float num8 = (num5 * num3 - num2 * num6) / num7;
		float num9 = (num * num6 - num4 * num3) / num7;
		Vector2 val = default(Vector2);
		((Vector2)(ref val))..ctor(num8, num9);
		if (PointOnSegment(val, p1, p2) && PointOnSegment(val, p3, p4))
		{
			intersection = val;
			return true;
		}
		return false;
	}

	private bool PointOnSegment(Vector2 p, Vector2 a, Vector2 b)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: 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_0033: 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_003f: 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_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		return p.x >= Mathf.Min(a.x, b.x) && p.x <= Mathf.Max(a.x, b.x) && p.y >= Mathf.Min(a.y, b.y) && p.y <= Mathf.Max(a.y, b.y);
	}
}
public class TeleportUIScript : MonoBehaviour
{
	public Vector3 anchorPosition = Vector3.zero;

	public Vector3 anchorRotation = Vector3.zero;

	private RectTransform rect;

	private void Start()
	{
		rect = ((Component)this).GetComponent<RectTransform>();
	}

	private void Update()
	{
		//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_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: 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)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		if (anchorPosition != Vector3.zero)
		{
			rect.anchoredPosition = Vector2.op_Implicit(anchorPosition);
			((Transform)rect).localEulerAngles = anchorRotation;
			anchorPosition = Vector3.zero;
			anchorRotation = Vector3.zero;
		}
	}
}
public class TNTScript : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <DisableAfterDelay>d__32 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject obj;

		public float delay;

		public TNTScript <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DisableAfterDelay>d__32(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(delay);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				obj.SetActive(false);
				if ((Object)(object)ExplosionPool.Instance != (Object)null)
				{
					ExplosionPool.Instance.ReturnToContainer(obj);
				}
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <ScaleUpAndDestroySprite>d__27 : IEnumerator<object>, IEnumerator, IDisposable
	{
		private int <>1__state;

		private object <>2__current;

		public TNTScript <>4__this;

		private Vector3 <originalScale>5__1;

		private Vector3 <scaleStep>5__2;

		private Vector3 <targetScale>5__3;

		private float <duration>5__4;

		private float <elapsed>5__5;

		private Explosion <exp>5__6;

		private AudioClip <chosenClip>5__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <ScaleUpAndDestroySprite>d__27(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<exp>5__6 = null;
			<chosenClip>5__7 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: