using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using Configgy;
using Configgy.UI;
using GameConsole;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using ULTRAKILL.Cheats;
using UltraFunGuns;
using UltraFunGuns.Components;
using UltraFunGuns.Components.Entity;
using UltraFunGuns.CustomPlacedObjects;
using UltraFunGuns.Datas;
using UltraFunGuns.Logging;
using UltraFunGuns.Patches;
using UltraFunGuns.Properties;
using UltraFunGuns.Util;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[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("Hydraxous")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A mod with fun guns!")]
[assembly: AssemblyFileVersion("1.3.6.0")]
[assembly: AssemblyInformationalVersion("1.3.6+90ca98e83ff13ff2bfadfdbaf61eea9908a954aa")]
[assembly: AssemblyProduct("UltraFunGuns")]
[assembly: AssemblyTitle("UltraFunGuns")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.6.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[UFGWeapon("RocketDagger", "Rocket Dagger", 2, false, WeaponIconColor.Red, false, false)]
[WeaponAbility("Dagger", "Press Fire 1 to throw a dagger", 0, RichTextColors.aqua)]
[WeaponAbility("Daggers", "Press Fire 2 to throw multiple daggers", 0, RichTextColors.aqua)]
public class RocketDagger : UltraFunGunBase
{
	[UFGAsset("RocketDaggerProjectile")]
	public static GameObject RocketDaggerProjectilePrefab;

	private ActionCooldown primaryFireCooldown = new ActionCooldown(0.15f);

	private ActionCooldown secondaryFireCooldown = new ActionCooldown(0.6f);

	public int PelletsPerSecond = 12;

	public float maxShotgunTime = 5f;

	private float shotgunTime = 0f;

	public override void GetInput()
	{
		if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && primaryFireCooldown.CanFire() && !om.paused)
		{
			primaryFireCooldown.AddCooldown();
			Fire();
		}
		if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed)
		{
			if (secondaryFireCooldown.CanFire() && !om.paused)
			{
				shotgunTime += Time.deltaTime;
				shotgunTime = Mathf.Min(maxShotgunTime, shotgunTime);
				if (shotgunTime >= maxShotgunTime)
				{
					Shotgun();
				}
			}
		}
		else if (shotgunTime > 0f)
		{
			Shotgun();
		}
	}

	private void Fire()
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		FirePellet(mainCam.position, mainCam.forward);
	}

	private void Shotgun()
	{
		//IL_000e: 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_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		int pelletCount = GetPelletCount();
		Vector3 position = mainCam.position;
		Quaternion rotation = mainCam.rotation;
		if (shotgunTime == maxShotgunTime)
		{
		}
		for (int i = 0; i < pelletCount; i++)
		{
			Vector3 val = Vector3.forward;
			if (i != 0)
			{
				val = MathTools.GetProjectileSpreadVector(shotgunTime / 20f);
			}
			GameObject val2 = FirePellet(position, rotation * val);
			if (val2.TryFindComponent<RayBasedProjectile>(out var component))
			{
				component.sourceWeapon = ((Component)this).gameObject;
				if (shotgunTime == maxShotgunTime)
				{
					component.damage *= 10f;
					component.ricochet = true;
					component.projectileSpeed *= 10f;
				}
			}
			val2.transform.Rotate(Vector3.forward, (float)Random.Range(0, 360), (Space)1);
		}
		secondaryFireCooldown.AddCooldown(shotgunTime / 2f);
		shotgunTime = 0f;
	}

	private GameObject FirePellet(Vector3 position, Vector3 direction)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//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)
		return Object.Instantiate<GameObject>(RocketDaggerProjectilePrefab, position, Quaternion.LookRotation(direction, Vector3.up));
	}

	private int GetPelletCount()
	{
		float num = shotgunTime * (float)PelletsPerSecond;
		num = Mathf.CeilToInt(num);
		return (int)num;
	}
}
public class RayBasedProjectile : MonoBehaviour, ICleanable
{
	public delegate void OnProjectileDeathHandler(ProjectileDeathEvent projectileDeathEvent);

	public float projectileSpeed;

	public float projectileSize;

	public float imortalTime = 0.001f;

	public bool affectedByGravity;

	public float gravityMultiplier = 1f;

	public bool ricochet;

	public bool hitTriggers;

	public LayerMask hitMask;

	public float damage;

	public float critMultiplier;

	public bool tryForExplode;

	public GameObject spawnAtImpact;

	public GameObject sourceWeapon;

	public string[] eventDataTags;

	private float imortalTimeRemaining;

	private bool dieNextFrame;

	private float distanceToSurface;

	public OnProjectileDeathHandler OnProjectileDeath;

	private ProjectileDeathEvent deathParamters = default(ProjectileDeathEvent);

	private RaycastHit hit;

	private void Start()
	{
		imortalTimeRemaining = imortalTime;
	}

	private void Update()
	{
		//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_0044: Unknown result type (might be due to invalid IL or missing references)
		if (dieNextFrame)
		{
			Impact();
		}
		dieNextFrame = CheckImpact();
		imortalTimeRemaining -= Time.deltaTime;
		Transform transform = ((Component)this).transform;
		transform.position += GetNextPositionStep();
	}

	private Vector3 GetNextPositionStep()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: 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_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e1: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_018f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_0187: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = Vector3.zero;
		Vector3 val2 = ((Component)this).transform.forward;
		Vector3 val3 = ((Component)this).transform.position;
		if (affectedByGravity)
		{
			val += Physics.gravity * gravityMultiplier * Time.deltaTime;
		}
		bool flag = false;
		if ((Object)(object)((RaycastHit)(ref hit)).collider != (Object)null)
		{
			flag = ((Component)((RaycastHit)(ref hit)).collider).tag == "Armor";
		}
		if ((ricochet || flag) && dieNextFrame)
		{
			float num = projectileSpeed * Time.deltaTime;
			RaycastHit val4 = default(RaycastHit);
			while (num > 0f && Physics.Raycast(val3, val2, ref val4, num, LayerMask.op_Implicit(hitMask)))
			{
				SurfaceHitInformation surfaceHitInformation = default(SurfaceHitInformation);
				surfaceHitInformation.hitCollider = ((RaycastHit)(ref val4)).collider;
				surfaceHitInformation.hittingObject = ((Component)this).gameObject;
				surfaceHitInformation.normal = ((RaycastHit)(ref val4)).normal;
				surfaceHitInformation.position = ((RaycastHit)(ref val4)).point;
				surfaceHitInformation.velocity = val2 * projectileSpeed;
				SurfaceHitInformation surfaceHitInformation2 = surfaceHitInformation;
				num -= ((RaycastHit)(ref val4)).distance;
				val3 = ((RaycastHit)(ref val4)).point;
				val2 = Vector3.Reflect(val2, ((RaycastHit)(ref val4)).normal);
				HitCollider(((RaycastHit)(ref hit)).collider);
			}
			if (num > 0f)
			{
				val3 += val2 * num;
			}
			((Component)this).transform.forward = val2;
			val += val3 - ((Component)this).transform.position;
			dieNextFrame = false;
		}
		else
		{
			val += val2 * (dieNextFrame ? distanceToSurface : (projectileSpeed * Time.deltaTime));
		}
		return val;
	}

	private bool CheckImpact()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: 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_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_015b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = ((Component)this).transform.forward * projectileSpeed;
		if (affectedByGravity)
		{
			val += Physics.gravity * gravityMultiplier;
		}
		float num = ((Vector3)(ref val)).magnitude * Time.deltaTime;
		if (projectileSize > 0f)
		{
			if (!Physics.SphereCast(((Component)this).transform.position, projectileSize, ((Vector3)(ref val)).normalized, ref hit, num, LayerMask.op_Implicit(hitMask)))
			{
				return false;
			}
		}
		else if (!Physics.Raycast(((Component)this).transform.position, ((Vector3)(ref val)).normalized, ref hit, num, LayerMask.op_Implicit(hitMask)))
		{
			return false;
		}
		if (!hitTriggers && ((RaycastHit)(ref hit)).collider.isTrigger)
		{
			return false;
		}
		deathParamters.normal = ((RaycastHit)(ref hit)).normal;
		deathParamters.velocity = ((Component)this).transform.forward * projectileSpeed;
		if (imortalTimeRemaining < 0f)
		{
			Vector3 val2 = ((RaycastHit)(ref hit)).point - ((Component)this).transform.position;
			distanceToSurface = ((Vector3)(ref val2)).magnitude;
			return true;
		}
		return false;
	}

	private void Impact()
	{
		//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_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		SurfaceHitInformation surfaceHitInformation = default(SurfaceHitInformation);
		surfaceHitInformation.hitCollider = ((RaycastHit)(ref hit)).collider;
		surfaceHitInformation.normal = ((RaycastHit)(ref hit)).normal;
		surfaceHitInformation.position = ((RaycastHit)(ref hit)).point;
		surfaceHitInformation.hittingObject = ((Component)this).gameObject;
		surfaceHitInformation.velocity = ((Component)this).transform.forward * projectileSpeed;
		SurfaceHitInformation surfaceHitInformation2 = surfaceHitInformation;
		if (!HitCollider(((RaycastHit)(ref hit)).collider))
		{
			((Component)this).transform.forward = Vector3.Reflect(((Component)this).transform.forward, ((RaycastHit)(ref hit)).normal);
			return;
		}
		if ((Object)(object)spawnAtImpact != (Object)null && (Object)(object)((RaycastHit)(ref hit)).collider != (Object)null)
		{
			GameObject val = Object.Instantiate<GameObject>(spawnAtImpact, ((RaycastHit)(ref hit)).point + ((RaycastHit)(ref hit)).normal * 0.01f, Quaternion.LookRotation(((RaycastHit)(ref hit)).normal, Vector3.up));
		}
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}

	private bool HitCollider(Collider col)
	{
		//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)
		//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_0035: 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_004b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)col == (Object)null)
		{
			return false;
		}
		if (col.IsColliderEnemy(out var enemy) && enemy != null)
		{
			enemy.DeliverDamage(((Component)enemy).gameObject, ((Component)this).transform.forward * projectileSpeed, ((RaycastHit)(ref hit)).point, damage, tryForExplode, critMultiplier, sourceWeapon, false, false);
		}
		if (col.TryFindComponent<IUFGInteractionReceiver>(out var component))
		{
			UFGInteractionEventData interaction = default(UFGInteractionEventData);
			interaction.power = damage;
			interaction.direction = ((Component)this).transform.forward;
			interaction.interactorPosition = ((Component)this).transform.position;
			interaction.tags = ((eventDataTags == null) ? new string[0] : eventDataTags);
			component.Interact(interaction);
		}
		return true;
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: 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_0032: 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_004e: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.red;
		Gizmos.DrawRay(((Component)this).transform.position, ((Component)this).transform.forward * projectileSpeed * (1f / 60f));
		Gizmos.color = Color.green;
		Gizmos.DrawWireSphere(((Component)this).transform.position, projectileSize);
	}

	private void OnDestroy()
	{
		//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_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)
		deathParamters.direction = ((Component)this).transform.forward;
		deathParamters.position = ((Component)this).transform.position;
		OnProjectileDeath?.Invoke(deathParamters);
	}

	public void Cleanup()
	{
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}
}
public struct SurfaceHitInformation
{
	public Vector3 position;

	public Vector3 normal;

	public Vector3 velocity;

	public Collider hitCollider;

	public GameObject hittingObject;
}
public struct ProjectileDeathEvent
{
	public Vector3 position;

	public Vector3 direction;

	public Vector3 normal;

	public Vector3 velocity;
}
public class RayProjectile : MonoBehaviour
{
	public float StepDistance;

	public Action<RaycastHit, RayProjectile> OnHit;

	public LayerMask Hitmask;

	private void Update()
	{
		MoveProjectile();
	}

	private void MoveProjectile()
	{
		//IL_0007: 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_001c: 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_0023: 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_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = ((Component)this).transform.forward * StepDistance * Time.deltaTime;
		if (!CheckStep(val, out var hit))
		{
			Transform transform = ((Component)this).transform;
			transform.position += val;
		}
		else
		{
			OnHit(hit, this);
		}
	}

	private bool CheckStep(Vector3 travel, out RaycastHit hit)
	{
		//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_001c: Unknown result type (might be due to invalid IL or missing references)
		return Physics.Raycast(((Component)this).transform.position, ((Vector3)(ref travel)).normalized, ref hit, ((Vector3)(ref travel)).magnitude, LayerMask.op_Implicit(Hitmask));
	}
}
namespace UltraFunGuns
{
	public class AnimationAudioInterface : MonoBehaviour
	{
		[SerializeField]
		private AudioClip[] clips;

		public void PlayClip(int clipIndex)
		{
			if (clipIndex >= clips.Length || clipIndex < 0)
			{
				UltraFunGuns.Log.LogError($"Audio clip index ({clipIndex}) out of range on {((Object)((Component)this).gameObject).name}");
			}
			else
			{
				PlayClip(clips[clipIndex]);
			}
		}

		public void PlayClip(string name)
		{
			if (clips != null)
			{
				AudioClip clip = clips.Where((AudioClip x) => ((Object)x).name == name).First();
				PlayClip(clip);
			}
		}

		private void PlayClip(AudioClip clip)
		{
			if ((Object)(object)clip == (Object)null)
			{
				UltraFunGuns.Log.LogError("Warning audio clip attempted to be played on " + ((Object)((Component)this).gameObject).name + " through animation. The provided clip was null.");
				return;
			}
			Transform transform = ((Component)clip.PlayAudioClip(Random.Range(0.9f, 1.1f))).transform;
			transform.parent = ((Component)this).transform;
		}
	}
	public class AudioSourceRandomizer : MonoBehaviour
	{
		public float minPitch = 0.85f;

		public float maxPitch = 1.15f;

		public float minVolume = 1f;

		public float maxVolume = 1f;

		private AudioSource audioSrc;

		private void Awake()
		{
			audioSrc = ((Component)this).GetComponent<AudioSource>();
			if ((Object)(object)audioSrc == (Object)null)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				RandomizeAudio();
			}
		}

		private void RandomizeAudio()
		{
			if (Object.op_Implicit((Object)(object)audioSrc))
			{
				float pitch = Random.Range(minPitch, maxPitch);
				float volume = Random.Range(minVolume, maxVolume);
				audioSrc.pitch = pitch;
				audioSrc.volume = volume;
			}
		}
	}
	public class BehaviourRelay : MonoBehaviour
	{
		public Action<GameObject> OnAwake;

		public Action<GameObject> OnStart;

		public Action<GameObject> OnUpdate;

		public Action<GameObject> OnLateUpdate;

		public Action<GameObject> OnFixedUpdate;

		public Action<GameObject> OnOnEnable;

		public Action<GameObject> OnOnDisable;

		public Action<GameObject> OnOnDestroy;

		private void Awake()
		{
			OnAwake?.Invoke(((Component)this).gameObject);
		}

		private void Start()
		{
			OnStart?.Invoke(((Component)this).gameObject);
		}

		private void Update()
		{
			OnUpdate?.Invoke(((Component)this).gameObject);
		}

		private void LateUpdate()
		{
			OnLateUpdate?.Invoke(((Component)this).gameObject);
		}

		private void FixedUpdate()
		{
			OnFixedUpdate?.Invoke(((Component)this).gameObject);
		}

		private void OnEnable()
		{
			OnOnEnable?.Invoke(((Component)this).gameObject);
		}

		private void OnDisable()
		{
			OnOnDisable?.Invoke(((Component)this).gameObject);
		}

		private void OnDestroy()
		{
			OnOnDestroy?.Invoke(((Component)this).gameObject);
		}
	}
	public class CoroutineRunner : MonoBehaviour
	{
		private bool coroutineStarted;

		private bool coroutineRunning;

		private void Update()
		{
			if (coroutineStarted && !coroutineRunning)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public Coroutine RunCoroutine(IEnumerator coroutine)
		{
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			return ((MonoBehaviour)this).StartCoroutine(RunExternalCoroutine(coroutine));
		}

		private IEnumerator RunExternalCoroutine(IEnumerator coroutine)
		{
			coroutineStarted = true;
			coroutineRunning = true;
			yield return coroutine;
			coroutineRunning = false;
		}
	}
	public static class StaticCoroutine
	{
		public static Coroutine RunCoroutine(IEnumerator coroutine)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			CoroutineRunner coroutineRunner = new GameObject("New Rebinder").AddComponent<CoroutineRunner>();
			return coroutineRunner.RunCoroutine(coroutine);
		}

		public static void DelayedExecute(Action action, float delayInSeconds)
		{
			RunCoroutine(DelayedExecution(action, delayInSeconds));
		}

		private static IEnumerator DelayedExecution(Action action, float timeInSeconds)
		{
			yield return (object)new WaitForSecondsRealtime(timeInSeconds);
			action?.Invoke();
		}
	}
	public class DebuggingDummy : MonoBehaviour
	{
		private void Awake()
		{
		}

		private void Update()
		{
			//IL_002e: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007d: 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_009d: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!UltraFunGuns.DebugMode)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)256))
			{
				Vector3 position = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
				Vector3 position2 = ((Component)MonoSingleton<CameraController>.Instance).transform.position;
				Vector3 val = Vector3.zero;
				if (HydraUtils.SphereCastMacro(position2, 0.001f, ((Component)MonoSingleton<CameraController>.Instance).transform.forward, float.PositiveInfinity, out var hit))
				{
					val = ((RaycastHit)(ref hit)).point;
					Visualizer.DrawSphere(val, 0.25f, 5f);
					Visualizer.DrawLine(5f, position2, val);
				}
				string obj = $"Player: {position.x}|{position.y}|{position.z}\n" + $"Camera: {position2.x}|{position2.y}|{position2.z}\n" + $"HitPos: {val.x}|{val.y}|{val.z}";
				UltraFunGuns.Log.LogWarning(obj);
			}
			if (!Input.GetKeyDown((KeyCode)260))
			{
				return;
			}
			List<IResourceLocation> list = new List<IResourceLocation>();
			foreach (IResourceLocator resourceLocator in Addressables.ResourceLocators)
			{
				ResourceLocationMap val2 = (ResourceLocationMap)(object)((resourceLocator is ResourceLocationMap) ? resourceLocator : null);
				if (val2 == null)
				{
					continue;
				}
				foreach (IList<IResourceLocation> value in val2.Locations.Values)
				{
					list.AddRange(value);
				}
			}
			string text = "";
			foreach (IResourceLocation item in list)
			{
				text += FormatResourceLocation(item);
			}
		}

		private string FormatResourceLocation(IResourceLocation rlocation)
		{
			string text = "=================================\n";
			text = text + "PKEY: " + rlocation.PrimaryKey + "\n";
			text = text + "INTID: " + rlocation.InternalId + "\n";
			return text + "RTYPE: " + rlocation.ResourceType.Name + "\n";
		}
	}
	public class DebugLine : MonoBehaviour
	{
		private LineRenderer lr;

		private bool initialized;

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

		public void SetLine(Vector3[] points)
		{
			if (!initialized)
			{
				initialized = true;
				lr.positionCount = points.Length;
				lr.SetPositions(points);
			}
		}
	}
	public class DebugTextPopup : MonoBehaviour
	{
		[SerializeField]
		private Text text;

		[SerializeField]
		private DestroyAfterTime destroyAfterTime;

		private void Awake()
		{
			if ((Object)(object)text == (Object)null)
			{
				text = ((Component)this).GetComponentInChildren<Text>();
			}
		}

		public void SetText(string newText, Color color)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)text != (Object)null)
			{
				text.text = newText;
				((Graphic)text).color = color;
			}
		}

		public void SetKillTime(float newTime)
		{
			if ((Object)(object)destroyAfterTime != (Object)null)
			{
				destroyAfterTime.TimeLeft = newTime;
			}
		}

		public void OnDestroy()
		{
			Visualizer.ClearDebugText(this);
		}
	}
	public class HLErrorNotifier : MonoBehaviour
	{
		private void Start()
		{
			UltraFunGuns.Log.LogError(((Object)((Component)this).gameObject).name + " was created, but it was not loaded properly from the assetbundle.");
		}
	}
	public class DeleteAfterTime : MonoBehaviour
	{
		public float TimeLeft = 10f;

		private void Update()
		{
			if (TimeLeft <= 0f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				TimeLeft -= Time.deltaTime;
			}
		}
	}
	public class DestroyAfterTime : MonoBehaviour, ICleanable
	{
		public float TimeLeft = 2f;

		private void Start()
		{
			CheckComponents();
		}

		private void CheckComponents()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			AudioSource val = default(AudioSource);
			if (((Component)this).TryGetComponent<AudioSource>(ref val))
			{
				float maxTime = val.clip.length - val.time;
				SetMaxTime(maxTime);
			}
			TrailRenderer val2 = default(TrailRenderer);
			if (((Component)this).TryGetComponent<TrailRenderer>(ref val2))
			{
				SetMaxTime(val2.time);
				((MonoBehaviour)this).StartCoroutine(FadeOutTrail(val2));
			}
			ParticleSystem val3 = default(ParticleSystem);
			if (((Component)this).TryGetComponent<ParticleSystem>(ref val3))
			{
				EmissionModule emission = val3.emission;
				((EmissionModule)(ref emission)).enabled = false;
				MinMaxCurve rateOverTime = ((EmissionModule)(ref emission)).rateOverTime;
				SetMaxTime(((MinMaxCurve)(ref rateOverTime)).constant);
				MainModule main = val3.main;
				SetMaxTime(((MainModule)(ref main)).duration);
			}
		}

		private IEnumerator FadeOutTrail(TrailRenderer trail)
		{
			float startTime = trail.time;
			float startWidth = trail.widthMultiplier;
			while (trail.time > 0f)
			{
				trail.time -= Time.deltaTime;
				trail.widthMultiplier = Mathf.Lerp(startWidth, 0f, Mathf.InverseLerp(startTime, 0f, trail.time));
				yield return (object)new WaitForEndOfFrame();
			}
		}

		public void SetMaxTime(float newMaxTime)
		{
			TimeLeft = Mathf.Max(TimeLeft, newMaxTime);
		}

		private void Update()
		{
			if (TimeLeft <= 0f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			TimeLeft -= Time.deltaTime;
		}

		public static void PreserveComponents(Transform transf)
		{
			AudioSource[] componentsInChildren = ((Component)transf).GetComponentsInChildren<AudioSource>();
			TrailRenderer[] componentsInChildren2 = ((Component)transf).GetComponentsInChildren<TrailRenderer>();
			ParticleSystem[] componentsInChildren3 = ((Component)transf).GetComponentsInChildren<ParticleSystem>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				PreserveComponent(((Component)componentsInChildren[i]).transform);
			}
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				PreserveComponent(((Component)componentsInChildren2[j]).transform);
			}
			for (int k = 0; k < componentsInChildren3.Length; k++)
			{
				PreserveComponent(((Component)componentsInChildren3[k]).transform);
			}
		}

		private static void PreserveComponent(Transform tf, bool changeParent = true)
		{
			if ((Object)(object)tf != (Object)null)
			{
				((Component)tf).gameObject.AddComponent<DestroyAfterTime>();
				if (changeParent)
				{
					tf.parent = null;
				}
			}
		}

		public void Cleanup()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public class EnemyOverride : MonoBehaviour
	{
		private NavMeshAgent navMeshAgent;

		private Animator animator;

		private Drone drone;

		private Zombie zombie;

		private Machine machine;

		private Statue statue;

		private SpiderBody spiderBody;

		private Rigidbody[] childRigidbodies;

		private Collider primaryCollider;

		private Rigidbody primaryRigidbody;

		private List<Action<Collision>> onCollisionEvents = new List<Action<Collision>>();

		private List<Action> onDeathEvents = new List<Action>();

		private Dictionary<Renderer, Material[]> startMaterials = new Dictionary<Renderer, Material[]>();

		private Renderer[] renderers;

		private List<StyleEntry> styleEntries = new List<StyleEntry>();

		private bool initialized;

		public EnemyIdentifier EnemyIdentifier { get; private set; }

		public bool RagdollEnabled { get; private set; }

		public bool Frozen { get; private set; }

		private void Awake()
		{
			if (!initialized)
			{
				ForceInitialize();
			}
		}

		public void ForceInitialize()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			if (!initialized)
			{
				initialized = true;
				EnemyIdentifier = ((Component)this).GetComponent<EnemyIdentifier>();
				navMeshAgent = ((Component)this).GetComponent<NavMeshAgent>();
				animator = ((Component)this).GetComponent<Animator>();
				drone = ((Component)this).GetComponent<Drone>();
				zombie = ((Component)this).GetComponent<Zombie>();
				machine = ((Component)this).GetComponent<Machine>();
				spiderBody = ((Component)this).GetComponent<SpiderBody>();
				statue = ((Component)this).GetComponent<Statue>();
				EnemyIdentifier.onDeath.AddListener(new UnityAction(ExecuteOnDeathEvents));
				GetPhysicsComponents();
				GetRenderComponents();
			}
		}

		private void GetPhysicsComponents()
		{
			primaryCollider = ((Component)this).GetComponent<Collider>();
			childRigidbodies = ((Component)this).GetComponentsInChildren<Rigidbody>();
		}

		private void GetRenderComponents()
		{
			renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
			Renderer[] array = renderers;
			foreach (Renderer val in array)
			{
				if (!startMaterials.ContainsKey(val))
				{
					startMaterials.Add(val, val.materials);
				}
			}
		}

		public void ResetMaterials()
		{
			Renderer[] array = renderers;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null) && startMaterials.ContainsKey(val))
				{
					val.materials = startMaterials[val];
				}
			}
		}

		public void SetFrozen(bool frozen)
		{
			Frozen = frozen;
			SetComponents(!frozen);
			if (RagdollEnabled && frozen)
			{
				SetKinematic(frozen);
			}
		}

		public void SetAllMaterials(Material[] newMaterials)
		{
			foreach (KeyValuePair<Renderer, Material[]> startMaterial in startMaterials)
			{
				if (!((Object)(object)startMaterial.Key == (Object)null))
				{
					startMaterial.Key.materials = newMaterials;
				}
			}
		}

		public void SetAllMaterial(Material material)
		{
			foreach (KeyValuePair<Renderer, Material[]> startMaterial in startMaterials)
			{
				if (!((Object)(object)startMaterial.Key == (Object)null))
				{
					startMaterial.Key.material = material;
				}
			}
		}

		public void Knockback(Vector3 force)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!RagdollEnabled)
			{
				return;
			}
			Rigidbody[] array = childRigidbodies;
			foreach (Rigidbody val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.velocity = force;
				}
			}
		}

		public void AddStyleEntryOnDeath(StyleEntry entry, bool allowMultiple = false)
		{
			if ((Object)(object)EnemyIdentifier != (Object)null)
			{
				entry.EnemyIdentifier = EnemyIdentifier;
			}
			if (!allowMultiple && styleEntries.Where((StyleEntry x) => x.Key == entry.Key).ToList().Count > 0)
			{
				styleEntries[0].LifeTime += entry.LifeTime;
			}
			else
			{
				styleEntries.Add(entry);
			}
		}

		private void ExecuteStyleEntries()
		{
			styleEntries = styleEntries.Where((StyleEntry x) => x.valid).ToList();
			foreach (StyleEntry entry in styleEntries)
			{
				if (entry.AlreadyCounted)
				{
					continue;
				}
				List<StyleEntry> list = styleEntries.Where((StyleEntry x) => x.Key == entry.Key && x != entry).ToList();
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i] != entry)
					{
						entry.Points += list[i].Points;
						int num = ((list[i].Count < 1) ? 1 : list[i].Count);
						entry.Count = ((entry.Count >= 1) ? (entry.Count + num) : (1 + num));
						list[i].AlreadyCounted = true;
					}
				}
				if (list.Count > 0)
				{
					UltraFunGuns.Log.LogWarning("Combined similar entries");
				}
				WeaponManager.AddStyle(entry);
			}
		}

		public void AddDeathCallback(Action action)
		{
			if (!onDeathEvents.Contains(action))
			{
				onDeathEvents.Add(action);
			}
		}

		private void ExecuteOnDeathEvents()
		{
			foreach (Action onDeathEvent in onDeathEvents)
			{
				onDeathEvent?.Invoke();
			}
			ExecuteStyleEntries();
		}

		public void EnableKnockback()
		{
		}

		public void DisableKnockback()
		{
		}

		public void SetRagdoll(bool active)
		{
			RagdollEnabled = active;
			SetComponents(!active);
			SetKinematic(!active);
		}

		public void SetComponents(bool active)
		{
			if (!((Object)(object)EnemyIdentifier == (Object)null) && !EnemyIdentifier.dead)
			{
				if ((Object)(object)navMeshAgent != (Object)null)
				{
					((Behaviour)navMeshAgent).enabled = active;
				}
				if ((Object)(object)drone != (Object)null)
				{
					((Behaviour)drone).enabled = active;
				}
				if ((Object)(object)machine != (Object)null)
				{
					((Behaviour)machine).enabled = active;
				}
				if ((Object)(object)spiderBody != (Object)null)
				{
					((Behaviour)spiderBody).enabled = active;
				}
				if ((Object)(object)statue != (Object)null)
				{
					((Behaviour)statue).enabled = active;
				}
				if ((Object)(object)zombie != (Object)null)
				{
					((Behaviour)zombie).enabled = active;
				}
				if ((Object)(object)animator != (Object)null)
				{
					((Behaviour)animator).enabled = active;
				}
			}
		}

		public void SetKinematic(bool active)
		{
			if ((Object)(object)primaryCollider != (Object)null)
			{
				primaryCollider.enabled = active;
			}
			Rigidbody[] array = childRigidbodies;
			foreach (Rigidbody val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.isKinematic = active;
					val.useGravity = !active;
				}
			}
		}

		public bool AddCollisionEvent(Action<Collision> collisionCallback)
		{
			if (collisionCallback == null || onCollisionEvents.Contains(collisionCallback))
			{
				return false;
			}
			onCollisionEvents.Add(collisionCallback);
			return true;
		}

		private void OnCollisionEnter(Collision col)
		{
			foreach (Action<Collision> onCollisionEvent in onCollisionEvents)
			{
				onCollisionEvent?.Invoke(col);
			}
		}

		public float GetHealth()
		{
			Enemy val = default(Enemy);
			if (((Component)this).TryGetComponent<Enemy>(ref val))
			{
				return val.health;
			}
			if ((Object)(object)spiderBody != (Object)null)
			{
				return spiderBody.health;
			}
			if ((Object)(object)zombie != (Object)null)
			{
				return ((Enemy)zombie).health;
			}
			if ((Object)(object)machine != (Object)null)
			{
				return ((Enemy)machine).health;
			}
			if ((Object)(object)statue != (Object)null)
			{
				return ((Enemy)statue).health;
			}
			return EnemyIdentifier.health;
		}
	}
	public static class EnemyUtil
	{
		public static EnemyOverride Override(this EnemyIdentifier eid)
		{
			EnemyOverride enemyOverride = ((Component)eid).gameObject.EnsureComponent<EnemyOverride>();
			enemyOverride.ForceInitialize();
			return enemyOverride;
		}
	}
	public class StyleEntry
	{
		public string Key;

		public string Prefix;

		public string Postfix;

		public int Points;

		public float LifeTime;

		public GameObject SourceWeapon;

		public EnemyIdentifier EnemyIdentifier;

		public int Count;

		public bool AlreadyCounted;

		private float timeCreated;

		public bool valid => Time.time - timeCreated < LifeTime;

		public StyleEntry(int points, string key, float lifeTime = 5f, GameObject sourceWeapon = null, EnemyIdentifier eid = null, int count = -1, string prefix = "", string postfix = "")
		{
			Key = key;
			Points = points;
			LifeTime = lifeTime;
			timeCreated = Time.time;
			Count = count;
			SourceWeapon = sourceWeapon;
			EnemyIdentifier = eid;
			Count = count;
			Prefix = prefix;
			Postfix = postfix;
		}

		public StyleEntry()
		{
			timeCreated = Time.time;
		}
	}
	public class EntityStatusEffectHolder : MonoBehaviour, IStatusEffectReceiver
	{
		private List<IStatusEffect> currentEffects = new List<IStatusEffect>();

		public GameObject GetAffectedObject()
		{
			return ((Component)this).gameObject;
		}

		public void AddStatusEffect(IStatusEffect effect)
		{
			currentEffects.Add(effect);
		}

		public IEnumerable<IStatusEffect> GetStatusEffects()
		{
			return currentEffects;
		}

		public void RemoveStatusEffect(IStatusEffect effect)
		{
			currentEffects.Remove(effect);
		}
	}
	public class HydraPlushie : MonoBehaviour
	{
		[SerializeField]
		private MeshRenderer screen;

		[SerializeField]
		private Texture2D blueScreenTex;

		[SerializeField]
		private Texture2D blueScreenFaceMask;

		[SerializeField]
		private AudioClip blueScreenClip;

		[SerializeField]
		private AudioSource toChange;

		[SerializeField]
		private GameObject breakFX;

		private bool damaged;

		private void WaterDamage()
		{
			if (!((Object)(object)screen == (Object)null) && !((Object)(object)blueScreenTex == (Object)null) && !((Object)(object)blueScreenFaceMask == (Object)null) && !damaged)
			{
				damaged = true;
				if (((Renderer)screen).material.HasProperty("_MainTex"))
				{
					((Renderer)screen).material.SetTexture("_MainTex", (Texture)(object)blueScreenTex);
				}
				if (((Renderer)screen).material.HasProperty("_FaceMask"))
				{
					((Renderer)screen).material.SetTexture("_FaceMask", (Texture)(object)blueScreenFaceMask);
				}
				if ((Object)(object)toChange != (Object)null)
				{
					toChange.clip = blueScreenClip;
				}
				AudioSource[] componentsInChildren = ((Component)((Component)this).transform).GetComponentsInChildren<AudioSource>();
				foreach (AudioSource val in componentsInChildren)
				{
					val.pitch -= val.pitch * 0.23f;
				}
				if ((Object)(object)breakFX != (Object)null)
				{
					Object.Instantiate<GameObject>(breakFX, ((Component)this).transform);
				}
				WeaponManager.SetWeaponUnlocked("FizzyGun", unlocked: true);
				WeaponManager.SetWeaponUnlocked("GrabbityGun", unlocked: true);
				WeaponManager.SetWeaponUnlocked("PlushieCannon", unlocked: true);
			}
		}

		private void OnTriggerEnter(Collider col)
		{
			Water val = default(Water);
			if (((Component)col).gameObject.layer == 4 || ((Component)col).tag.ToLower().Contains("water") || ((Component)col).gameObject.TryGetComponent<Water>(ref val))
			{
				WaterDamage();
			}
		}

		private void OnDestroy()
		{
			WaterDamage();
		}
	}
	public interface IStatusEffect
	{
		void OnEffectStart();

		void OnEffectUpdate();

		void OnEffectStop();
	}
	public interface IStatusEffectReceiver
	{
		void AddStatusEffect(IStatusEffect effect);

		void RemoveStatusEffect(IStatusEffect effect);

		IEnumerable<IStatusEffect> GetStatusEffects();

		GameObject GetAffectedObject();
	}
	public class TrainingBot : MonoBehaviour
	{
	}
	public class Explodable : MonoBehaviour, IExplodable
	{
		public Action<Explosion> OnExplode;

		public UnityEvent<Explosion> OnExploded;

		public void Explode(Explosion explosion)
		{
			ExplodeCore(explosion);
		}

		protected virtual void ExplodeCore(Explosion explosion)
		{
			OnExplode?.Invoke(explosion);
			OnExploded?.Invoke(explosion);
		}
	}
	public interface ICleanable
	{
		void Cleanup();
	}
	public class InventoryControllerDeployer : MonoBehaviour
	{
		private RectTransform canvas;

		private Transform configHelpMessage;

		private Transform versionHelpMessage;

		private OptionsManager om;

		private InventoryController invController;

		private Button invControllerButton;

		private Button configHelpButton;

		private GameObject pauseMenu;

		public bool inventoryManagerOpen = false;

		[Configgable("Binds", "Open UFG Inventory", 0, null)]
		public static ConfigKeybind inventoryKey = new ConfigKeybind((KeyCode)105);

		private static bool sentVersionMessage = false;

		private bool displayingHelpMessage = false;

		[UFGAsset("UFGInventoryUI")]
		private static GameObject UFGInventoryUI;

		[UFGAsset("UFGInventoryButton")]
		private static GameObject UFGInventoryButton;

		[UFGAsset("UFGKeybindsMenu")]
		private static GameObject UFGKeybindsUI;

		[Configgable("Advanced", "Show Update Notifications", 0, null)]
		private static ConfigToggle showUpdateNotifications = new ConfigToggle(true);

		private static bool showedUpdateNotification;

		[UFGAsset("WMUINode")]
		public static GameObject UFGInventoryNode { get; private set; }

		private void Awake()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			om = MonoSingleton<OptionsManager>.Instance;
			canvas = ((Component)this).GetComponent<RectTransform>();
			pauseMenu = ((Component)((Component)this).transform.Find("PauseMenu")).gameObject;
			invControllerButton = Object.Instantiate<GameObject>(UFGInventoryButton, (Transform)(object)canvas).GetComponent<Button>();
			((UnityEvent)invControllerButton.onClick).AddListener(new UnityAction(OpenInventory));
			invController = Object.Instantiate<GameObject>(UFGInventoryUI, (Transform)(object)canvas).GetComponent<InventoryController>();
			((Component)invController).gameObject.SetActive(false);
			((Component)invControllerButton).gameObject.SetActive(false);
			configHelpMessage = ((Component)invController).transform.Find("ConfigMessage");
			versionHelpMessage = ((Component)invController).transform.Find("VersionMessage");
			((Component)versionHelpMessage).GetComponentInChildren<Text>().text = string.Format(((Component)versionHelpMessage).GetComponentInChildren<Text>().text, UltraFunGuns.LatestVersion);
			configHelpButton = ((Component)((Component)invController).transform.Find("MenuBorder/SlotNames")).GetComponent<Button>();
			((UnityEvent)configHelpButton.onClick).AddListener((UnityAction)delegate
			{
				CloseInventory();
				ConfigurationMenu.OpenAtPath("UltraFunGuns/Binds");
			});
		}

		private void Update()
		{
			CheckStatus();
		}

		private void CheckStatus()
		{
			//IL_0081: 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)
			if (inventoryManagerOpen)
			{
				if (!UltraFunGuns.UsingLatestVersion && ((ConfigValueElement<bool>)(object)showUpdateNotifications).Value && !showedUpdateNotification)
				{
					showedUpdateNotification = true;
					NotifyUpdateAvailable();
				}
				if (Input.GetKeyDown((KeyCode)27))
				{
					CloseInventory();
				}
			}
			else
			{
				displayingHelpMessage = false;
				if (Data.SaveInfo.Data.firstTimeModLoaded)
				{
					HudMessageReceiver instance = MonoSingleton<HudMessageReceiver>.Instance;
					KeyCode value = ((ConfigValueElement<KeyCode>)(object)inventoryKey).Value;
					instance.SendHudMessage($"UFG: Set a custom loadout for UFG weapons with [<color=orange>{((object)(KeyCode)(ref value)).ToString()}</color>] or in the pause menu.", "", "", 2, false, false, true);
					Data.SaveInfo.Data.firstTimeModLoaded = false;
					Data.SaveInfo.Save();
				}
			}
			bool flag = GameStateManager.Instance.IsStateActive("pause");
			((Component)invControllerButton).gameObject.SetActive(flag && !inventoryManagerOpen);
			if (inventoryKey.WasPeformed() && !om.paused)
			{
				OpenInventory();
			}
		}

		private void NotifyUpdateAvailable()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0085: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			ModalDialogueEvent val = new ModalDialogueEvent();
			val.Title = "Outdated";
			val.Message = "You are using an outdated version of UltraFunGuns: (<color=red>Release-1.3.6</color>). Please consider updating to the latest version: (<color=green>" + UltraFunGuns.LatestVersion + "</color>)";
			val.Options = (DialogueBoxOption[])(object)new DialogueBoxOption[3]
			{
				new DialogueBoxOption
				{
					Name = "Open Browser",
					Color = Color.white,
					OnClick = delegate
					{
						Application.OpenURL("https://github.com/Hydraxous/UltraFunGuns/releases/latest");
					}
				},
				new DialogueBoxOption
				{
					Name = "Later",
					Color = Color.white,
					OnClick = delegate
					{
					}
				},
				new DialogueBoxOption
				{
					Name = "Don't Ask Again.",
					Color = Color.red,
					OnClick = delegate
					{
						((ConfigValueElement<bool>)(object)showUpdateNotifications).SetValue(false);
					}
				}
			};
			ModalDialogue.ShowDialogue(val);
		}

		public void CloseInventory()
		{
			inventoryManagerOpen = false;
			om.paused = false;
			invController.SetCardActive(enabled: false);
			((Component)configHelpMessage).gameObject.SetActive(false);
			((Component)versionHelpMessage).gameObject.SetActive(false);
			displayingHelpMessage = false;
			((Component)invController).gameObject.SetActive(false);
		}

		public void OpenInventory()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0068: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!((Component)invController).gameObject.activeInHierarchy)
			{
				if (om.paused)
				{
					om.UnPause();
				}
				om.paused = true;
				invController.RefreshSlotKeyDisplays();
				GameState val = new GameState("ufg_inv", ((Component)invController).gameObject);
				val.cursorLock = (LockMode)2;
				val.playerInputLock = (LockMode)1;
				val.cameraInputLock = (LockMode)1;
				val.priority = 2;
				GameStateManager.Instance.RegisterState(val);
				if (Data.SaveInfo.Data.firstTimeUsingInventory)
				{
					Data.SaveInfo.Data.firstTimeUsingInventory = false;
					Data.SaveInfo.Save();
				}
				((Component)invControllerButton).gameObject.SetActive(false);
				((Component)invController).gameObject.SetActive(true);
				inventoryManagerOpen = true;
			}
		}

		public void SendConfigHelpMessage()
		{
			if (om.paused && !displayingHelpMessage)
			{
				((MonoBehaviour)this).StartCoroutine(DisplayHelpMessage(configHelpMessage));
			}
		}

		public void SendVersionHelpMessage()
		{
			if (!sentVersionMessage && om.paused && !displayingHelpMessage && !Data.Config.Data.DisableVersionMessages)
			{
				sentVersionMessage = true;
				((MonoBehaviour)this).StartCoroutine(DisplayHelpMessage(versionHelpMessage));
			}
		}

		private IEnumerator DisplayHelpMessage(Transform message)
		{
			displayingHelpMessage = true;
			((Component)message).gameObject.SetActive(true);
			yield return (object)new WaitForSecondsRealtime(4f);
			((Component)message).gameObject.SetActive(false);
			displayingHelpMessage = false;
		}
	}
	public interface IUFGInteractionReceiver
	{
		bool Interact(UFGInteractionEventData interaction);

		bool Targetable(TargetQuery query);

		Vector3 GetPosition();
	}
	public struct UFGInteractionEventData
	{
		public Vector3 interactorPosition;

		public Vector3 direction;

		public float power;

		public string data;

		public Type invokeType;

		public string[] tags;

		public bool ContainsTag(string tag)
		{
			if (tags == null)
			{
				return false;
			}
			for (int i = 0; i < tags.Length; i++)
			{
				if (!Utility.IsNullOrWhiteSpace(tags[i]) && tags[i].Contains(tag))
				{
					return true;
				}
			}
			return false;
		}

		public bool ContainsAnyTag(params string[] checkTags)
		{
			for (int i = 0; i < checkTags.Length; i++)
			{
				if (ContainsTag(checkTags[i]))
				{
					return true;
				}
			}
			return false;
		}

		public bool ContainsAllTags(params string[] checkTags)
		{
			for (int i = 0; i < checkTags.Length; i++)
			{
				if (!ContainsTag(checkTags[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
	public struct TargetQuery
	{
		public Vector3 queryOrigin;

		public Vector3 queryDirection;

		public bool checkLineOfSight;

		public float maxRange;

		public float lineOfSightErrorMargin;

		public Collider lineOfSightCollider;

		public TargetQuery()
		{
			//IL_0007: 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)
			queryOrigin = default(Vector3);
			queryDirection = default(Vector3);
			checkLineOfSight = false;
			lineOfSightCollider = null;
			maxRange = -1f;
			lineOfSightErrorMargin = 1.5f;
		}

		public bool HasLineOfSight(Vector3 targetablePosition)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0086: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!checkLineOfSight)
			{
				return true;
			}
			float num = ((maxRange >= 0f) ? maxRange : float.PositiveInfinity);
			Vector3 point = queryOrigin;
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(targetablePosition, queryOrigin - targetablePosition);
			RaycastHit val2 = default(RaycastHit);
			if ((Object)(object)lineOfSightCollider != (Object)null && lineOfSightCollider.Raycast(val, ref val2, num))
			{
				point = ((RaycastHit)(ref val2)).point;
			}
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(val, ref val3, num, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
			{
				if (Vector3.Distance(((RaycastHit)(ref val3)).point, point) < lineOfSightErrorMargin)
				{
					return true;
				}
				return false;
			}
			return true;
		}

		public bool InRange(Vector3 targetablePosition)
		{
			//IL_0001: 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)
			return Vector3.Distance(targetablePosition, queryOrigin) < ((maxRange >= 0f) ? maxRange : float.PositiveInfinity);
		}

		public bool CheckTargetable(Vector3 targetablePosition)
		{
			//IL_0002: 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)
			return InRange(targetablePosition) && HasLineOfSight(targetablePosition);
		}
	}
	public class Parriable : MonoBehaviour, IParriable
	{
		public Func<Vector3, Vector3, bool> OnParryCheck;

		public Action<Vector3, Vector3> OnParry;

		public UnityEvent OnParried;

		public bool Parry(Vector3 position, Vector3 direction)
		{
			//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)
			return ParryCore(position, direction);
		}

		protected virtual bool ParryCore(Vector3 position, Vector3 direction)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			OnParry(position, direction);
			UnityEvent onParried = OnParried;
			if (onParried != null)
			{
				onParried.Invoke();
			}
			if (OnParryCheck == null)
			{
				return true;
			}
			return OnParryCheck(position, direction);
		}
	}
	public class AnimatedPart : MonoBehaviour
	{
		[SerializeField]
		private float baseRotateSpeed;

		[SerializeField]
		private Vector3 rotateAxis;

		private float speedMultiplier = 1f;

		private Vector3 currentRotation;

		private void Awake()
		{
			//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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Quaternion localRotation = ((Component)this).transform.localRotation;
			currentRotation = ((Quaternion)(ref localRotation)).eulerAngles;
		}

		public void SetRotationSpeed(float rotationSpeed)
		{
			speedMultiplier = rotationSpeed;
		}

		private void Update()
		{
			Rotate();
		}

		private void Rotate()
		{
			//IL_0003: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			currentRotation += rotateAxis * baseRotateSpeed * speedMultiplier * Time.deltaTime;
			((Component)this).transform.localRotation = Quaternion.Euler(currentRotation);
		}
	}
	public class GyroRotator : MonoBehaviour
	{
		[SerializeField]
		private float baseSpeedMultiplier = 1f;

		[SerializeField]
		private Vector3 rotateAxis;

		[SerializeField]
		private float dragRate = 1f;

		[SerializeField]
		private float maxRotationSpeed = 500f;

		[SerializeField]
		private float startRotation = 0f;

		private float angularVelocity = 0f;

		private float currentRot = 0f;

		public bool Spin;

		public float Speed = 0f;

		private void Start()
		{
			currentRot = startRotation;
		}

		private void Update()
		{
			//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)
			if (Spin)
			{
				angularVelocity = Mathf.Clamp(angularVelocity + Speed * baseSpeedMultiplier, 0f, maxRotationSpeed);
			}
			else
			{
				angularVelocity = Mathf.Clamp(angularVelocity - dragRate, 0f, maxRotationSpeed);
			}
			currentRot += angularVelocity * Time.timeScale;
			((Component)this).transform.localRotation = Quaternion.AngleAxis(currentRot, rotateAxis);
		}

		public void AddAngularVelocity(float velocity)
		{
			angularVelocity += velocity;
		}
	}
	public class Vibrator : MonoBehaviour
	{
		private Vector3 startPositon;

		private Vector3 vibrationAxes;

		private float vibrationTime;

		private float automaticVibrationTimer;

		public float CurrentVibration { get; private set; }

		public float MaxDistance { get; private set; }

		private void Start()
		{
			//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)
			startPositon = ((Component)this).transform.localPosition;
		}

		private void Update()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (CurrentVibration > 0f)
			{
				((Component)this).transform.localPosition = GetNewPosition();
			}
			CheckVibrationTime();
		}

		public void AddTime(float t)
		{
			vibrationTime += t;
		}

		private void CheckVibrationTime()
		{
			vibrationTime -= Time.deltaTime;
			vibrationTime = Mathf.Max(vibrationTime, 0f);
			CurrentVibration = vibrationTime * 0.016666f;
		}

		public void SetVibrationAxes(Vector3 localAxes)
		{
			//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)
			vibrationAxes = localAxes.Abs();
		}

		public void SetVibrationValue(float t)
		{
			CurrentVibration = Mathf.Clamp01(t);
		}

		public void SetMaxDistance(float distance)
		{
			MaxDistance = Mathf.Abs(distance);
		}

		public Vector3 GetNewPosition()
		{
			//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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0027: 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_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_0034: 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)
			float num = CurrentVibration * MaxDistance;
			Vector3 val = Vector3.Scale(Random.insideUnitSphere, vibrationAxes);
			val *= num;
			return val + startPositon;
		}

		public void VibrateFor(float seconds, float transitionPaddingNormalized = 0f)
		{
			if (automaticVibrationTimer >= 0f)
			{
				automaticVibrationTimer += seconds;
				return;
			}
			automaticVibrationTimer = seconds;
			transitionPaddingNormalized = ((transitionPaddingNormalized > 0.5f) ? 0.5f : ((transitionPaddingNormalized < 0f) ? 0f : transitionPaddingNormalized));
			((MonoBehaviour)this).StartCoroutine(AutomaticVibration(transitionPaddingNormalized));
		}

		public void ForceStop()
		{
			automaticVibrationTimer = 0f;
			SetVibrationValue(0f);
		}

		private IEnumerator AutomaticVibration(float transitionPaddingNormalized)
		{
			float cachedAutoTime = automaticVibrationTimer;
			float paddingTime = automaticVibrationTimer * transitionPaddingNormalized;
			float vibrateTime = automaticVibrationTimer - paddingTime * 2f;
			while (automaticVibrationTimer > GetCachedTime() - paddingTime)
			{
				yield return (object)new WaitForEndOfFrame();
				automaticVibrationTimer -= Time.deltaTime;
				SetVibrationValue(Mathf.InverseLerp(GetCachedTime(), GetCachedTime() - paddingTime, automaticVibrationTimer));
			}
			SetVibrationValue(1f);
			while (automaticVibrationTimer > GetCachedTime() - vibrateTime)
			{
				yield return (object)new WaitForEndOfFrame();
				automaticVibrationTimer -= Time.deltaTime;
				automaticVibrationTimer = Mathf.Max(automaticVibrationTimer, 0f);
			}
			while (automaticVibrationTimer > 0f)
			{
				yield return (object)new WaitForEndOfFrame();
				automaticVibrationTimer -= Time.deltaTime;
				SetVibrationValue(Mathf.InverseLerp(GetCachedTime(), 0f, automaticVibrationTimer));
			}
			SetVibrationValue(0f);
			float GetCachedTime()
			{
				if (cachedAutoTime <= automaticVibrationTimer)
				{
					cachedAutoTime = automaticVibrationTimer;
				}
				return cachedAutoTime;
			}
		}

		private void OnDisable()
		{
			ForceStop();
		}

		public Vibrator()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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)
			Vector3 one = Vector3.one;
			vibrationAxes = ((Vector3)(ref one)).normalized;
			vibrationTime = 0f;
			((MonoBehaviour)this)..ctor();
		}
	}
	public class SimpleBreakable : MonoBehaviour, IBreakable
	{
		public Action OnBreak;

		public UnityEvent OnBreakEvent;

		public void Break()
		{
			BreakCore();
		}

		protected virtual void BreakCore()
		{
			OnBreak?.Invoke();
			UnityEvent onBreakEvent = OnBreakEvent;
			if (onBreakEvent != null)
			{
				onBreakEvent.Invoke();
			}
		}
	}
	public class InventoryController : MonoBehaviour
	{
		private OptionsManager om;

		private WeaponInfoCard infoCard;

		private ConfigKeybind[] slotKeys;

		private static int maxSlots = 4;

		private List<InventorySlot> slots = new List<InventorySlot>();

		private List<Text> slotKeyNames = new List<Text>();

		private GunControl gc;

		private static InventoryController invController;

		private void Awake()
		{
			slotKeys = (ConfigKeybind[])(object)new ConfigKeybind[4]
			{
				UFGInput.Slot7Key,
				UFGInput.Slot8Key,
				UFGInput.Slot9Key,
				UFGInput.Slot10Key
			};
			om = MonoSingleton<OptionsManager>.Instance;
			gc = MonoSingleton<GunControl>.Instance;
			infoCard = ((Component)((Component)this).transform.Find("InfoCard")).gameObject.AddComponent<WeaponInfoCard>();
		}

		private void Start()
		{
			CreateNewSlots();
			SetSlotKeyDisplays();
		}

		private void CreateNewSlots()
		{
			for (int i = 0; i < maxSlots; i++)
			{
				InventorySlot item = ((Component)((Component)this).transform.Find($"MenuBorder/WeaponSlots/Slot{i}Wrapper")).gameObject.AddComponent<InventorySlot>();
				slots.Add(item);
			}
			for (int j = 0; j < slots.Count; j++)
			{
				slots[j].Initialize(Data.Loadout.Data.slots[j], j, this);
			}
		}

		private void SetSlotKeyDisplays()
		{
			List<Text> list = new List<Text>();
			for (int i = 0; i < slots.Count; i++)
			{
				slotKeyNames.Add(((Component)((Component)this).transform.Find($"MenuBorder/SlotNames/Slot{i}Name")).GetComponent<Text>());
			}
			RefreshSlotKeyDisplays();
		}

		public void RefreshSlotKeyDisplays()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (slotKeyNames.Count > 0)
			{
				for (int i = 0; i < slotKeyNames.Count; i++)
				{
					Text obj = slotKeyNames[i];
					object arg = 7 + i;
					KeyCode value = ((ConfigValueElement<KeyCode>)(object)slotKeys[i]).Value;
					obj.text = $"Slot {arg} [<color=orange>{((object)(KeyCode)(ref value)).ToString()}</color>]";
				}
			}
		}

		public void ButtonPressed(InventoryNode node, InventorySlot slot, string buttonPressed)
		{
			switch (buttonPressed)
			{
			case "Icon":
				node.data.weaponEnabled = !node.data.weaponEnabled;
				node.Refresh();
				break;
			case "Up":
				slot.ChangeNodeOrder(node, -1);
				break;
			case "Down":
				slot.ChangeNodeOrder(node, 1);
				break;
			case "Right":
			{
				slot.RemoveNode(node);
				int num2 = slot.ID + 1;
				if (num2 >= slots.Count)
				{
					num2 = 0;
				}
				else if (num2 < 0)
				{
					num2 = Mathf.Clamp(slots.Count, 0, slots.Count - 1);
				}
				slots[num2].InsertNode(node);
				slot.Refresh();
				break;
			}
			case "Left":
			{
				slot.RemoveNode(node);
				int num = slot.ID - 1;
				if (num >= slots.Count)
				{
					num = 0;
				}
				else if (num < 0)
				{
					num = Mathf.Clamp(slots.Count, 0, slots.Count - 1);
				}
				slots[num].InsertNode(node);
				slot.Refresh();
				break;
			}
			}
			SaveInventoryData();
			Refresh();
			RedeployAllWeapons();
		}

		private void RedeployAllWeapons()
		{
			if ((Object)(object)MonoSingleton<GunSetter>.Instance == (Object)null)
			{
				WeaponManager.DeployWeapons();
			}
			else
			{
				MonoSingleton<GunSetter>.Instance.ResetWeapons(false);
			}
		}

		public void Refresh()
		{
			foreach (InventorySlot slot in slots)
			{
				slot.Refresh();
			}
		}

		public void SaveInventoryData()
		{
			Data.Loadout.Data.slots = GetInventoryLoadout();
			Data.Loadout.Save();
			UltraFunGuns.Log.Log("Inventory saved.");
		}

		public InventorySlotData[] GetInventoryLoadout()
		{
			List<InventorySlotData> list = new List<InventorySlotData>();
			for (int i = 0; i < slots.Count; i++)
			{
				list.Add(slots[i].GetSlotData());
			}
			return list.ToArray();
		}

		public void SetCardWeaponInfo(UFGWeapon info)
		{
			if ((Object)(object)infoCard != (Object)null)
			{
				infoCard.SetWeaponInfo(info);
			}
		}

		public void SetCardActive(bool enabled)
		{
			if (!((Object)(object)infoCard == (Object)null) && enabled != ((Component)infoCard).gameObject.activeInHierarchy)
			{
				((Component)infoCard).gameObject.SetActive(enabled);
			}
		}

		public static void RefreshInventory()
		{
			if ((Object)(object)invController == (Object)null)
			{
				invController = Object.FindObjectOfType<InventoryController>();
			}
			invController?.Refresh();
		}
	}
	[Serializable]
	public class InventoryControllerData
	{
		public string modVersion;

		public bool firstTimeModLoaded;

		public bool firstTimeUsingInventory;

		public InventorySlotData[] slots;

		public InventoryControllerData(InventorySlotData[] slots, string modVersion, bool firstTimeUse = false, bool firstTimeModLoaded = false)
		{
			this.firstTimeModLoaded = firstTimeModLoaded;
			firstTimeUsingInventory = firstTimeUse;
			this.slots = slots;
			this.modVersion = modVersion;
		}

		public InventoryControllerData()
		{
		}
	}
	public class InventoryNode : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public RectTransform nodeTransform;

		public InventorySlot slot;

		public InventoryNodeData data;

		private InventoryController controller;

		public WeaponInfoCard card;

		private UFGWeapon nodeInfo;

		public int slotIndexPosition;

		public Sprite weaponIcon;

		public Button b_up;

		public Button b_down;

		public Button b_left;

		public Button b_right;

		public Button b_icon;

		public Color weaponIcon_Enabled;

		public Color weaponIcon_Disabled;

		public Color nodeBg_Enabled;

		public Color nodeBg_Disabled;

		private bool mousedOver = false;

		public void Initialize(InventoryNodeData data, InventorySlot slot, int slotIndex)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_007f: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Expected O, but got Unknown
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			controller = ((Component)this).GetComponentInParent<InventoryController>();
			weaponIcon_Enabled = new Color(255f, 255f, 255f, 255f);
			weaponIcon_Disabled = new Color(73f, 73f, 73f, 255f);
			nodeBg_Enabled = new Color(185f, 185f, 185f, 110f);
			nodeBg_Disabled = new Color(49f, 49f, 49f, 110f);
			UltraFunGuns.Log.Log(data.weaponKey + " NODE INIT!");
			slotIndexPosition = slotIndex;
			this.data = data;
			this.slot = slot;
			if (!WeaponManager.Weapons.TryGetValue(data.weaponKey, out nodeInfo))
			{
				UltraFunGuns.Log.Log("Inventory node could not get weapon info from key " + data.weaponKey);
			}
			nodeTransform = ((Component)this).GetComponent<RectTransform>();
			HydraLoader.dataRegistry.TryGetValue(this.data.weaponKey + "_weaponIcon", out var value);
			weaponIcon = (Sprite)value;
			if ((Object)(object)weaponIcon == (Object)null)
			{
				HydraLoader.dataRegistry.TryGetValue("debug_weaponIcon", out var value2);
				weaponIcon = (Sprite)value2;
			}
			((Object)((Component)this).gameObject).name = this.data.weaponKey + ".Node";
			b_icon = ((Component)((Component)this).transform.Find("Icon")).GetComponent<Button>();
			((UnityEvent)b_icon.onClick).AddListener((UnityAction)delegate
			{
				ButtonPressed("Icon");
			});
			b_up = ((Component)((Component)this).transform.Find("UpButton")).GetComponent<Button>();
			((UnityEvent)b_up.onClick).AddListener((UnityAction)delegate
			{
				ButtonPressed("Up");
			});
			b_right = ((Component)((Component)this).transform.Find("RightButton")).GetComponent<Button>();
			((UnityEvent)b_right.onClick).AddListener((UnityAction)delegate
			{
				ButtonPressed("Right");
			});
			b_down = ((Component)((Component)this).transform.Find("DownButton")).GetComponent<Button>();
			((UnityEvent)b_down.onClick).AddListener((UnityAction)delegate
			{
				ButtonPressed("Down");
			});
			b_left = ((Component)((Component)this).transform.Find("LeftButton")).GetComponent<Button>();
			((UnityEvent)b_left.onClick).AddListener((UnityAction)delegate
			{
				ButtonPressed("Left");
			});
			Refresh();
		}

		public void RefreshPosition()
		{
		}

		public void ChangeSlot(InventorySlot newSlot, int newSlotIndex)
		{
			slot = newSlot;
			slotIndexPosition = newSlotIndex;
			Refresh();
		}

		public void Refresh()
		{
			//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_002d: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			((Component)b_icon).GetComponent<Image>().sprite = weaponIcon;
			ColorBlock colors = ((Selectable)((Component)b_icon).GetComponent<Button>()).colors;
			((ColorBlock)(ref colors)).normalColor = GetElementColor();
			((ColorBlock)(ref colors)).selectedColor = GetElementColor();
			((Selectable)((Component)b_icon).GetComponent<Button>()).colors = colors;
			((Graphic)((Component)this).gameObject.GetComponent<Image>()).color = GetElementColor(icon: false);
			if (slotIndexPosition == 0 && slot.nodes.Count == 1)
			{
				((Component)b_up).gameObject.SetActive(false);
				((Component)b_down).gameObject.SetActive(false);
			}
			else
			{
				((Component)b_up).gameObject.SetActive(true);
				((Component)b_down).gameObject.SetActive(true);
			}
			((Component)this).gameObject.SetActive(data.weaponUnlocked);
			if (UltraFunGuns.DebugMode)
			{
				((Component)this).gameObject.SetActive(true);
			}
			RefreshPosition();
		}

		public void ButtonPressed(string button)
		{
			slot.ButtonPressed(this, button);
		}

		private Color GetElementColor(bool icon = true)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0073: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_009d: 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_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_00ac: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			Color white = Color.white;
			if (icon)
			{
				white = MonoSingleton<ColorBlindSettings>.Instance.variationColors[(int)nodeInfo.IconColor];
				if (!data.weaponEnabled)
				{
					white *= 0.5f;
				}
				white.a = 255f;
			}
			else
			{
				white = MonoSingleton<ColorBlindSettings>.Instance.variationColors[(int)nodeInfo.IconColor];
				white *= 0.5f;
				if (!data.weaponEnabled)
				{
					white *= 0.4f;
				}
				white.a = 110f;
			}
			return white;
		}

		public void Disappear()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public override string ToString()
		{
			string arg = (data.weaponEnabled ? "(x)" : "( )");
			return string.Format("{2} [{0}] {1}", slot.ID, data.weaponKey, arg);
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (!mousedOver)
			{
				mousedOver = true;
				controller.SetCardWeaponInfo(nodeInfo);
				((MonoBehaviour)this).StartCoroutine(MouseHeldSequence());
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			mousedOver = false;
			((MonoBehaviour)this).StopAllCoroutines();
			if ((Object)(object)controller != (Object)null)
			{
				controller.SetCardActive(enabled: false);
			}
		}

		private IEnumerator MouseHeldSequence()
		{
			yield return (object)new WaitForSecondsRealtime(Data.Config.Data.MouseOverNodeTime);
			while (mousedOver)
			{
				if ((Object)(object)controller != (Object)null)
				{
					controller.SetCardActive(enabled: true);
				}
				yield return (object)new WaitForEndOfFrame();
			}
		}

		private void OnDisable()
		{
			mousedOver = false;
		}
	}
	[Serializable]
	public class InventoryNodeData
	{
		public string weaponKey;

		public bool weaponEnabled;

		public bool weaponUnlocked;

		public InventoryNodeData(string weaponKey, bool enabled = true, bool weaponUnlocked = true)
		{
			this.weaponKey = weaponKey;
			weaponEnabled = enabled;
			this.weaponUnlocked = weaponUnlocked;
		}

		public InventoryNodeData()
		{
		}
	}
	public class InventorySlot : MonoBehaviour
	{
		private InventoryController inventoryController;

		public int ID;

		public List<InventoryNode> nodes = new List<InventoryNode>();

		public RectTransform r_transform;

		public int ActiveNodeCount => nodes.Where((InventoryNode x) => x.data.weaponUnlocked).Count();

		public void Initialize(InventorySlotData slotData, int ID, InventoryController inventoryController)
		{
			this.inventoryController = inventoryController;
			r_transform = ((Component)((Component)this).transform.Find("Slot")).GetComponent<RectTransform>();
			this.ID = ID;
			SetupNodes(slotData.slotNodes);
		}

		public void ChangeNodeOrder(InventoryNode node, int slotsToMove)
		{
			List<InventoryNode> list = nodes;
			int num = node.slotIndexPosition + slotsToMove;
			list.Remove(node);
			if (num > list.Count)
			{
				list.Insert(0, node);
			}
			else if (num < 0)
			{
				list.Add(node);
			}
			else
			{
				list.Insert(num, node);
			}
			nodes = list;
			Refresh();
		}

		public void InsertNode(InventoryNode node)
		{
			RectTransform component = ((Component)node).GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)r_transform);
			int count = nodes.Count;
			int newSlotIndex = node.slotIndexPosition;
			if (node.slotIndexPosition >= count)
			{
				nodes.Add(node);
				newSlotIndex = count;
			}
			else
			{
				nodes.Insert(node.slotIndexPosition, node);
			}
			node.ChangeSlot(this, newSlotIndex);
		}

		public void RemoveNode(InventoryNode node)
		{
			nodes.Remove(node);
		}

		private void CreateNewNode(InventoryNodeData nodeData, int slotIndex)
		{
			InventoryNode component = Object.Instantiate<GameObject>(InventoryControllerDeployer.UFGInventoryNode, (Transform)(object)r_transform).GetComponent<InventoryNode>();
			nodes.Add(component);
			component.Initialize(nodeData, this, slotIndex);
		}

		public void ButtonPressed(InventoryNode node, string button)
		{
			inventoryController.ButtonPressed(node, this, button);
		}

		private void SetupNodes(InventoryNodeData[] nodeDatas)
		{
			if (nodes.Count > 0)
			{
				foreach (InventoryNode node in nodes)
				{
					nodes.Remove(node);
					node.Disappear();
				}
				nodes.Clear();
			}
			for (int i = 0; i < nodeDatas.Length; i++)
			{
				CreateNewNode(nodeDatas[i], i);
			}
			Refresh();
		}

		public void Refresh()
		{
			for (int i = 0; i < nodes.Count; i++)
			{
				int siblingIndex = ((Component)nodes[i]).transform.GetSiblingIndex();
				if (siblingIndex != i)
				{
					((Transform)r_transform).GetChild(i).SetSiblingIndex(siblingIndex);
					((Component)nodes[i]).transform.SetSiblingIndex(i);
				}
				nodes[i].slotIndexPosition = i;
				nodes[i].Refresh();
			}
		}

		public InventorySlotData GetSlotData()
		{
			List<InventoryNodeData> list = new List<InventoryNodeData>();
			foreach (InventoryNode node in nodes)
			{
				InventoryNodeData data = node.data;
				list.Add(data);
			}
			return new InventorySlotData(list.ToArray());
		}

		public override string ToString()
		{
			return $"SLOT{ID} [{nodes.Count}]";
		}
	}
	[Serializable]
	public class InventorySlotData
	{
		public InventoryNodeData[] slotNodes;

		public InventorySlotData(InventoryNodeData[] slotNodes)
		{
			this.slotNodes = slotNodes;
		}

		public InventorySlotData()
		{
			slotNodes = new InventoryNodeData[0];
		}
	}
	public class WeaponInfoCard : MonoBehaviour
	{
		private Canvas canvas;

		public bool useCanvasScaler = true;

		public bool scaleWithDisplaySize = false;

		private Text header;

		private Text body;

		private Image background;

		private Shadow headerShadow;

		private UFGWeapon info;

		private static Vector2 mousePos;

		private const int referenceDpi = 96;

		public RectTransform RectTransform { get; private set; }

		public void Awake()
		{
			canvas = ((Component)this).GetComponentInParent<Canvas>();
			RectTransform = ((Component)this).GetComponent<RectTransform>();
			((Component)this).gameObject.AddComponent<HudOpenEffect>();
			background = ((Component)((Component)this).transform.Find("Container/HeaderBackground")).GetComponent<Image>();
			header = ((Component)((Component)background).transform.Find("HeaderText")).GetComponent<Text>();
			body = ((Component)((Component)this).transform.Find("Container/BodyBackground/BodyText")).GetComponent<Text>();
			headerShadow = ((Component)header).GetComponent<Shadow>();
			((Component)this).gameObject.SetActive(false);
		}

		public void SetWeaponInfo(UFGWeapon info)
		{
			this.info = info;
			Refresh();
		}

		private void Refresh()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_0059: 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_0065: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			header.text = info.DisplayName;
			body.text = info.GetCodexText();
			Color val = info.IconColor.ToColor();
			((Graphic)header).color = val;
			headerShadow.effectColor = new Color(val.r, val.g, val.b, val.a * 0.3803f);
			((Graphic)background).color = new Color(val.r, val.g, val.b, val.a * 0.3568f);
		}

		private void Update()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			mousePos = Vector2.op_Implicit(Input.mousePosition);
			if ((Object)(object)RectTransform != (Object)null)
			{
				UpdatePosition(mousePos);
			}
		}

		private void UpdatePosition(Vector2 mousePos)
		{
			//IL_0021: 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_0049: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			float scaleFactor = canvas.scaleFactor;
			float num = Screen.height;
			float num2 = Screen.width;
			float num3 = Mathf.InverseLerp(0f, num2, mousePos.x);
			float num4 = Mathf.InverseLerp(0f, num, mousePos.y);
			RectTransform.pivot = new Vector2(num3, num4);
			RectTransform.anchoredPosition = mousePos / scaleFactor;
		}

		private void OnEnable()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RectTransform != (Object)null)
			{
				float inventoryInfoCardScale = Data.Config.Data.InventoryInfoCardScale;
				((Transform)RectTransform).localScale = new Vector3(inventoryInfoCardScale, inventoryInfoCardScale, inventoryInfoCardScale);
			}
		}
	}
	public class AbilityMeter : MonoBehaviour
	{
		[SerializeField]
		private Image fillImage;

		[SerializeField]
		private Gradient fillGradient;

		public float AnimateSpeed = 0.34f;

		private float displayedAmount;

		public float Amount { get; private set; }

		public void SetAmount(float newAmount)
		{
			Amount = Mathf.Clamp01(newAmount);
		}

		private void Update()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)fillImage == (Object)null) && (displayedAmount != Amount || fillImage.fillAmount != displayedAmount))
			{
				displayedAmount = Mathf.MoveTowards(displayedAmount, Amount, AnimateSpeed * Time.deltaTime);
				fillImage.fillAmount = displayedAmount;
				((Graphic)fillImage).color = fillGradient.Evaluate(displayedAmount);
			}
		}

		private void OnEnable()
		{
			displayedAmount = Amount;
		}

		private void OnDsiable()
		{
			displayedAmount = Amount;
		}
	}
	public class UFGInformationPage : MonoBehaviour
	{
		private Button bugReportButton;

		private Button githubButton;

		private Button kofiButton;

		private Button thunderstoreButton;

		private Button discordButton;

		private Button twitterButton;

		private Button youtubeButton;

		private Image pfpImage;

		private Text changelogHeaderText;

		private Text changelogBodyText;

		private static Sprite pfpSprite;

		private void Start()
		{
			pfpImage = ((Component)this).transform.LocateComponent<Image>("Image_Profile");
			LoadPFP();
			changelogHeaderText = ((Component)this).transform.LocateComponent<Text>("Text_ChangelogHeader");
			changelogHeaderText.text = "Changelog (1.3.6)";
			changelogBodyText = ((Component)this).transform.LocateComponent<Text>("Text_ChangelogBody");
			changelogBodyText.text = "-- 1.3.6 --\nUpdated for fraud release";
			bugReportButton = ((Component)this).transform.LocateComponent<Button>("Button_BugReport");
			bugReportButton.SetClickAction(delegate
			{
				Application.OpenURL("https://github.com/Hydraxous/UltraFunGuns/issues/new/choose");
			});
			githubButton = ((Component)this).transform.LocateComponent<Button>("Button_Github");
			githubButton.SetClickAction(delegate
			{
				Application.OpenURL("https://github.com/Hydraxous/UltraFunGuns");
			});
			kofiButton = ((Component)this).transform.LocateComponent<Button>("Button_Kofi");
			kofiButton.SetClickAction(delegate
			{
				Application.OpenURL("https://ko-fi.com/Hydraxous/");
			});
			thunderstoreButton = ((Component)this).transform.LocateComponent<Button>("Button_Thunderstore");
			thunderstoreButton.SetClickAction(delegate
			{
				Application.OpenURL("https://thunderstore.io/c/ultrakill/p/Hydraxous/");
			});
			discordButton = ((Component)this).transform.LocateComponent<Button>("Button_Discord");
			discordButton.SetClickAction(delegate
			{
				Application.OpenURL("https://discord.gg/kCHnwMDPt4");
			});
			twitterButton = ((Component)this).transform.LocateComponent<Button>("Button_Twitter");
			twitterButton.SetClickAction(delegate
			{
				Application.OpenURL("https://twitter.com/Hydraxous");
			});
			youtubeButton = ((Component)this).transform.LocateComponent<Button>("Button_Youtube");
			youtubeButton.SetClickAction(delegate
			{
				Application.OpenURL("https://youtube.com/@Hydraxouz");
			});
		}

		private void LoadPFP()
		{
			if ((Object)(object)pfpSprite != (Object)null)
			{
				if ((Object)(object)pfpImage != (Object)null)
				{
					pfpImage.sprite = pfpSprite;
				}
				return;
			}
			TextureLoader.DownloadTexture("https://avatars.githubusercontent.com/hydraxous", delegate(TextureLoader.TextureDownloadResult r)
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				if (r.Success)
				{
					pfpSprite = Sprite.Create(r.Texture, new Rect(0f, 0f, (float)((Texture)r.Texture).width, (float)((Texture)r.Texture).height), Vector2.zero);
					if ((Object)(object)pfpImage != (Object)null)
					{
						pfpImage.sprite = pfpSprite;
					}
				}
				else
				{
					UltraFunGuns.Log.LogError("Error retrieving picture...");
				}
			});
		}
	}
	public class WeaponDeployer : MonoBehaviour
	{
		private static ConfigKeybind[] slotKeys = (ConfigKeybind[])(object)new ConfigKeybind[4]
		{
			UFGInput.Slot7Key,
			UFGInput.Slot8Key,
			UFGInput.Slot9Key,
			UFGInput.Slot10Key
		};

		private GunControl gc;

		private List<List<string>> weaponKeySlots = new List<List<string>>();

		private List<List<GameObject>> customSlots = new List<List<GameObject>>
		{
			new List<GameObject>(),
			new List<GameObject>(),
			new List<GameObject>(),
			new List<GameObject>()
		};

		public int WeaponsDeployed { get; private set; }

		private void Awake()
		{
			gc = ((Component)this).GetComponent<GunControl>();
		}

		public List<List<string>> CreateWeaponKeyset(Loadout invControllerData)
		{
			List<List<string>> list = new List<List<string>>();
			for (int i = 0; i < invControllerData.slots.Length; i++)
			{
				List<string> list2 = new List<string>();
				for (int j = 0; j < invControllerData.slots[i].slotNodes.Length; j++)
				{
					if (invControllerData.slots[i].slotNodes[j].weaponEnabled && (invControllerData.slots[i].slotNodes[j].weaponUnlocked || UltraFunGuns.DebugMode))
					{
						list2.Add(invControllerData.slots[i].slotNodes[j].weaponKey);
					}
				}
				list.Add(list2);
			}
			return list;
		}

		public void DisposeWeapons()
		{
			for (int i = 0; i < customSlots.Count; i++)
			{
				for (int j = 0; j < customSlots[i].Count; j++)
				{
					GameObject val = customSlots[i][j];
					customSlots[i][j] = null;
					Object.Destroy((Object)(object)val);
				}
				customSlots[i].Clear();
			}
		}

		public void DeployWeapons()
		{
			DisposeWeapons();
			weaponKeySlots = CreateWeaponKeyset(Data.Loadout.Data);
			if (weaponKeySlots.Count <= 0)
			{
				return;
			}
			WeaponsDeployed = 0;
			List<UFGWeapon> list = new List<UFGWeapon>();
			string text = "";
			for (int i = 0; i < weaponKeySlots.Count; i++)
			{
				if (weaponKeySlots[i].Count <= 0)
				{
					continue;
				}
				foreach (string item in weaponKeySlots[i])
				{
					if (!WeaponManager.Weapons.TryGetValue(item, out var value))
					{
						UltraFunGuns.Log.LogError("Weaponkey " + item + " doesn't exist. Someone seriously screwed up (it was Hydra).");
						((Behaviour)this).enabled = false;
						return;
					}
					if (!HydraLoader.prefabRegistry.TryGetValue(item, out var value2))
					{
						UltraFunGuns.Log.LogError("Weapon Manager could not retrieve " + item + " from prefab registry. Skipping...");
						continue;
					}
					value2.layer = 13;
					Transform[] componentsInChildren = value2.GetComponentsInChildren<Transform>();
					Transform[] array = componentsInChildren;
					foreach (Transform val in array)
					{
						((Component)val).gameObject.layer = 13;
					}
					GameObject val2 = Object.Instantiate<GameObject>(value2, ((Component)this).transform);
					val2.AddComponent(value.Type);
					val2.SetActive(false);
					customSlots[i].Add(val2);
					text = text + item + " ";
					list.Add(value);
					WeaponsDeployed++;
				}
			}
			for (int k = 0; k < customSlots.Count; k++)
			{
				if (gc.slots.Contains(customSlots[k]))
				{
					gc.slots.Remove(customSlots[k]);
				}
			}
			if (text.Length > 0)
			{
				text = "Weapons given: " + text;
				for (int l = 0; l < customSlots.Count; l++)
				{
					gc.slots.Add(customSlots[l]);
				}
				WeaponManager.OnWeaponsDeployed?.Invoke(list.ToArray());
				UltraFunGuns.Log.Log(text);
			}
		}

		private void Update()
		{
			for (int i = 0; i < slotKeys.Length; i++)
			{
				if (slotKeys[i].WasPeformed() && (customSlots[i].Count > 1 || gc.currentSlotIndex != i + 7) && customSlots[i].Count > 0 && (Object)(object)customSlots[i][0] != (Object)null)
				{
					gc.SwitchWeapon(i + 7, (int?)null, false, false, false);
				}
			}
		}
	}
	public static class WeaponManager
	{
		public delegate void OnWeaponsDeployedHandler(UFGWeapon[] weapons);

		public const int SLOTS = 4;

		public const int SLOT_OFFSET = 7;

		public static OnWeaponsDeployedHandler OnWeaponsDeployed;

		private static WeaponDeployer deployer;

		private static InventoryControllerDeployer inventoryDeployer;

		private static bool inventoryMade;

		private static Dictionary<string, UFGWeapon> weapons;

		public static Dictionary<string, UFGWeapon> Weapons
		{
			get
			{
				if (!WeaponsRegistered || weapons == null)
				{
					RegisterWeapons();
				}
				return weapons;
			}
		}

		public static int WeaponCount => Weapons.Count;

		public static bool WeaponsRegistered { get; private set; }

		public static bool UsingWeapons => DeployedWeapons > 0;

		public static int DeployedWeapons
		{
			get
			{
				if ((Object)(object)deployer == (Object)null)
				{
					return 0;
				}
				return deployer.WeaponsDeployed;
			}
		}

		public static void Init()
		{
			RegisterWeapons();
			InGameCheck.OnLevelChanged = (InGameCheck.OnLevelChangedHandler)Delegate.Combine(InGameCheck.OnLevelChanged, new InGameCheck.OnLevelChangedHandler(OnLevelChanged));
		}

		private static void DeInit()
		{
			InGameCheck.OnLevelChanged = (InGameCheck.OnLevelChangedHandler)Delegate.Remove(InGameCheck.OnLevelChanged, new InGameCheck.OnLevelChangedHandler(OnLevelChanged));
			weapons.Clear();
			WeaponsRegistered = false;
		}

		[Commands.UFGDebugMethod("Deploy Weapons", "Redeploy weapons")]
		public static void DeployWeapons(bool firstTime = false, bool force = false)
		{
			if (InGameCheck.InLevel() || force || inventoryMade || Data.Config.Data.EnableWeaponsInAllScenes)
			{
				if ((Object)(object)deployer == (Object)null && !((Component)MonoSingleton<GunControl>.Instance).TryGetComponent<WeaponDeployer>(ref deployer))
				{
					deployer = ((Component)MonoSingleton<GunControl>.Instance).gameObject.AddComponent<WeaponDeployer>();
				}
				deployer.DeployWeapons();
			}
		}

		private static void OnLevelChanged(InGameCheck.UKLevelType levType)
		{
			inventoryMade = false;
			if (InGameCheck.InLevel())
			{
				Prep();
			}
		}

		private static void Prep()
		{
			if (!inventoryMade)
			{
				InitStyleItems();
				CanvasController instance = MonoSingleton<CanvasController>.Instance;
				if (!((Component)instance).TryGetComponent<InventoryControllerDeployer>(ref inventoryDeployer))
				{
					inventoryDeployer = ((Component)instance).gameObject.AddComponent<InventoryControllerDeployer>();
				}
				inventoryMade = true;
			}
		}

		private static void InitStyleItems()
		{
			NewStyleItem("vaporized", "<color=#0bd6fcff>VAPORIZED</color>");
			NewStyleItem("vibecheck", "VIBE-CHECKED");
			NewStyleItem("v2kill", "<color=#ff33001>OXIDIZED</color>");
			NewStyleItem("gabrielkill", "<color=#ff0051>L-DISTRIBUTED</color>");
			NewStyleItem("wickedkill", "<color=#919191>NOT WICKED ENOUGH</color>");
			NewStyleItem("minoskill", "<color=#03ffa7>JUDGED</color>");
			NewStyleItem("orbited", "ORBITAL LAUNCH");
			NewStyleItem("egged", "EGGED");
			NewStyleItem("eggstrike", "TACTICAL EGG STRIKE");
			NewStyleItem("eggsplosion", "<color=yellow>EGGSPLOSION</color>");
			NewStyleItem("refractionhit", "BUG ZAPPER");
			NewStyleItem("discohit", "DISCO INFERNO");
			NewStyleItem("dodgeballhit", "OUTPLAYED");
			NewStyleItem("dodgeballparry", "BOOST BALL");
			NewStyleItem("dodgeballparryhit", "<color=orange>SLAM DUNK</color>");
			NewStyleItem("dodgeballreversehit", "REBOUND");
			NewStyleItem("fingergunhit", "BANG'D");
			NewStyleItem("fingergunfullpenetrate", "<color=#0bd6fcff>KABOOMA!</color>");
			NewStyleItem("fingergunprojhit", "DENIAL");
			NewStyleItem("admingunkill", "<color=red>GAMING CHAIR</color>");
			NewStyleItem("brickmindkill", "<color=orange>SOUL ASSIMILATION</color>");
			NewStyleItem("brickparrykill", "BRICKED");
			NewStyleItem("tricksniperquickscope", "QUICKSCOPE");
			NewStyleItem("tricksniper360", "<color=#0bd6fcff>TRICKSHOT</color>");
			NewStyleItem("tricksnipernoscope", "<color=orange>NOSCOPE</color>");
			NewStyleItem("tricksniperbankshot", "<color=orange>BANKSHOT</color>");
			NewStyleItem("ultragunsuperchargekill", "<color=#0bd6fcff>EXPRESS BILLING</color>");
			NewStyleItem("ultragunkill", "BILLED");
			NewStyleItem("ultragunrainkill", "<color=red>WHAT GOES UP</color>");
			NewStyleItem("ultragunaerialkill", "DEATH FROM ABOVE");
		}

		public static UFGWeapon[] GetWeapons()
		{
			List<UFGWeapon> list = new List<UFGWeapon>();
			foreach (KeyValuePair<string, UFGWeapon> weapon in Weapons)
			{
				list.Add(weapon.Value);
			}
			return list.ToArray();
		}

		public static UFGWeapon GetWeaponInfo(Type t)
		{
			UFGWeapon uFGWeapon = (UFGWeapon)Attribute.GetCustomAttribute(t, typeof(UFGWeapon));
			if (uFGWeapon == null)
			{
				UltraFunGuns.Log.LogError("Weapon info null when requested for type " + t.ToString());
				throw new Exception($"Type {t} does not have UFGWeapon attribute.");
			}
			return uFGWeapon;
		}

		public static void RegisterWeapons()
		{
			if (WeaponsRegistered)
			{
				return;
			}
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Type[] types = executingAssembly.GetTypes();
			foreach (Type type in types)
			{
				UFGWeapon customAttribute = type.GetCustomAttribute<UFGWeapon>();
				if (customAttribute == null || customAttribute.WeaponKey == "NULL")
				{
					continue;
				}
				if (weapons == null)
				{
					weapons = new Dictionary<string, UFGWeapon>();
				}
				if (weapons.ContainsKey(customAttribute.WeaponKey))
				{
					continue;
				}
				List<WeaponAbility> list = new List<WeaponAbility>();
				IEnumerable<WeaponAbility> customAttributes = type.GetCustomAttributes<WeaponAbility>();
				foreach (WeaponAbility item in customAttributes)
				{
					if (item != null && !list.Contains(item))
					{
						list.Add(item);
					}
				}
				customAttribute.SetAbilities(list.ToArray());
				customAttribute.SetType(type);
				int num = ((customAttribute.Slot >= 0) ? ((customAttribute.Slot > 4) ? 3 : customAttribute.Slot) : 0);
				weapons.Add(customAttribute.WeaponKey, customAttribute);
			}
			WeaponsRegistered = true;
		}

		public static InventorySlotData[] GetDefaultLoadout()
		{
			List<List<InventoryNodeData>> list = new List<List<InventoryNodeData>>();
			for (int i = 0; i < 4; i++)
			{
				list.Add(new List<InventoryNodeData>());
			}
			UFGWeapon[] array = GetWeapons();
			for (int j = 0; j < array.Length; j++)
			{
				int index = ((array[j].Slot >= 0) ? ((array[j].Slot > list.Count) ? (list.Count - 1) : array[j].Slot) : 0);
				InventoryNodeData item = new InventoryNodeData(array[j].WeaponKey, array[j].Equipped, array[j].StartUnlocked);
				if (!list[index].Contains(item))
				{
					list[index].Add(item);
				}
			}
			InventorySlotData[] array2 = new InventorySlotData[list.Count];
			for (int k = 0; k < list.Count; k++)
			{
				if (list[k].Count > 0)
				{
					array2[k] = new InventorySlotData(list[k].ToArray());
				}
				else
				{
					array2[k] = new InventorySlotData();
				}
			}
			return array2;
		}

		public static void NewStyleItem(string name, string text)
		{
			if (MonoSingleton<StyleHUD>.Instance.GetLocalizedName("hydraxous.ultrafunguns." + name) == "hydraxous.ultrafunguns." + name)
			{
				MonoSingleton<StyleHUD>.Instance.RegisterStyleItem("hydraxous.ultrafunguns." + name, text);
			}
		}

		public static void AddStyle(int points, string key, GameObject sourceWeapon = null, EnemyIdentifier eid = null, int count = -1, string prefix = "", string postfix = "")
		{
			if (InGameCheck.InLevel())
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(points, "hydraxous.ultrafunguns." + key, sourceWeapon, eid, count, prefix, postfix);
			}
		}

		public static void AddStyle(StyleEntry entry)
		{
			if (InGameCheck.InLevel())
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(entry.Points, "hydraxous.ultrafunguns." + entry.Key, entry.SourceWeapon, entry.EnemyIdentifier, entry.Count, entry.Prefix, entry.Postfix);
			}
		}

		public static void SetWeaponUnlocked(string weaponKey, bool unlocked)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (Weapons.ContainsKey(weaponKey) && WeaponUnlocked(weaponKey) != unlocked)
			{
				Data.Loadout.Data.SetUnlocked(weaponKey, unlocked);
				Data.Loadout.Save();
				if (unlocked && InGameCheck.InLevel())
				{
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage($"You have unlocked a new weapon. Press [<color=orange>{((ConfigValueElement<KeyCode>)(object)InventoryControllerDeployer.inventoryKey).Value}</color>] to open UFG Inventory.", "", "", 0, false, false, true);
				}
				InventoryController.RefreshInventory();
				DeployWeapons();
			}
		}

		public static bool WeaponUnlocked(string weaponKey)
		{
			if (Weapons.ContainsKey(weaponKey))
			{
				return Data.Loadout.Data.CheckUnlocked(weaponKey);
			}
			return false;
		}

		[Commands.UFGDebugMethod("UnlockAll", "Unlocks all weapons")]
		public static void UnlockAll()
		{
			foreach (KeyValuePair<string, UFGWeapon> weapon in Weapons)
			{
				SetWeaponUnlocked(weapon.Value.WeaponKey, unlocked: true);
			}
		}

		[Commands.UFGDebugMethod("ForceDeploy", "Forcefully deploys weapons")]
		public static void ForceDeploy()
		{
			Prep();
			DeployWeapons(firstTime: false, force: true);
		}

		public static void RemoveAllWeapons()
		{
			if ((InGameCheck.InLevel() || inventoryMade) && !((Object)(object)deployer == (Object)null))
			{
				GunControl instance = MonoSingleton<GunControl>.Instance;
				WeaponDeployer weaponDeployer = default(WeaponDeployer);
				if (((Component)instance).TryGetComponent<WeaponDeployer>(ref weaponDeployer))
				{
					deployer = weaponDeployer;
				}
				else
				{
					deployer = ((Component)instance).gameObject.AddComponent<WeaponDeployer>();
				}
				deployer.DisposeWeapons();
			}
		}
	}
	[WeaponAbility("Full-Auto 16x.50 AE", "Fire a continuous stream of 16 .50 AE cartridges simultaneously.", 0, RichTextColors.red)]
	[WeaponAbility("Full-Auto Explosives", "Fire a continuous stream of explosive bolts.", 1, RichTextColors.red)]
	[UFGWeapon("AdminGun", "Ultra***", 0, true, WeaponIconColor.Red, true, true)]
	public class AdminGun : UltraFunGunBase
	{
		public static UKAsset<GameObject> somethingWicked = new UKAsset<GameObject>("Assets/Prefabs/Enemies/Wicked.prefab");

		[UFGAsset("GunClick1")]
		private static AudioClip switchFireModeSound;

		[Configgable("Weapons/Ultra***", null, 0, null)]
		private static int hitscans = 16;

		[Configgable("Weapons/Ultra***", null, 0, null)]
		private static float bulletSpread = 0.06f;

		[Configgable("Weapons/Ultra***", null, 0, null)]
		private static bool gamerMode;

		[Configgable("Weapons/Ultra***", null, 0, null)]
		private static float primaryFireCooldown = 0.05f;

		[Configgable("Weapons/Ultra***", null, 0, null)]
		private static float secondaryFireCooldown = 0.05f;

		private ActionCooldown primaryFire = new ActionCooldown(primaryFireCooldown);

		private ActionCooldown secondaryFire = new ActionCooldown(secondaryFireCooldown);

		[UFGAsset("")]
		public static AudioClip AdminGun_FireSound { get; private set; }

		public override void GetInput()
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && !om.paused && primaryFire.CanFire())
			{
				primaryFire.AddCooldown();
				animator.Play("Fire", 0, 0f);
				ShootGun();
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed && !om.paused && secondaryFire.CanFire())
			{
				secondaryFire.AddCooldown();
				animator.Play("Fire", 0, 0f);
				Boom();
			}
			if (UFGInput.SecretButton.WasPeformed())
			{
				animator.Play("SelectFire", 0, 0f);
				gamerMode = !gamerMode;
				switchFireModeSound.PlayAudioClip(firePoint.position, Random.Range(0.8f, 1.1f));
			}
		}

		private void ShootGun()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003e: 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)
			if (gamerMode && EnemyTools.TryGetTarget(out var targetDirection))
			{
				HydraUtils.SetPlayerRotation(Quaternion.LookRotation(targetDirection, Vector3.up));
			}
			Vector3 position = firePoint.position;
			for (int i = 0; i < hitscans; i++)
			{
				FireBullet(GetRandomRaycast());
			}
			AdminGun_FireSound.PlayAudioClip(firePoint.position, Random.Range(0.8f, 1.3f));
		}

		private void FireBullet(Ray newShot, bool reflection = false)
		{
			//IL_0003: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Invalid comparison between Unknown and I4
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			if (!HydraUtils.SphereCastAllMacro(((Ray)(ref newShot)).origin, 0.15f, ((Ray)(ref newShot)).direction, float.PositiveInfinity, out var hits))
			{
				return;
			}
			hits = HydraUtils.SortRaycastHitsByDistance(hits);
			int num = 0;
			IUFGInteractionReceiver iUFGInteractionReceiver = default(IUFGInteractionReceiver);
			Breakable val = default(Breakable);
			Glass val2 = default(Glass);
			for (int i = 0; i < hits.Length; i++)
			{
				if (CheckCoin(hits[i]) && !reflection)
				{
					Object.Destroy((Object)(object)((Component)((RaycastHit)(ref hits[i])).collider).gameObject);
					CoinReflect(((RaycastHit)(ref hits[i])).transform.position);
					num = i;
					break;
				}
				if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<IUFGInteractionReceiver>(ref iUFGInteractionReceiver))
				{
					num = i;
					UFGInteractionEventData uFGInteractionEventData = default(UFGInteractionEventData);
					uFGInteractionEventData.tags = new string[2] { "shot", "god" };
					uFGInteractionEventData.direction = ((Ray)(ref newShot)).direction;
					uFGInteractionEventData.interactorPosition = ((Ray)(ref newShot)).origin;
					uFGInteractionEventData.invokeType = typeof(AdminGun);
					uFGInteractionEventData.power = 1000f;
					UFGInteractionEventData interaction = uFGInteractionEventData;
					if (iUFGInteractionReceiver.Interact(interaction) && !gamerMode)
					{
						break;
					}
				}
				if (((Component)((RaycastHit)(ref hits[i])).collider).TryGetComponent<Breakable>(ref val))
				{
					val.Break();
				}
				if (((Component)((RaycastHit)(ref hits[i])).collider).TryGetComponent<Glass>(ref val2))
				{
					val2.Shatter();
				}
				if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 8)
				{
					num = i;
					if (!gamerMode)
					{
						break;
					}
				}
				if (!((RaycastHit)(ref hits[i])).collider.IsColliderEnemy(out var enemy))
				{
					continue;
				}
				num = i;
				if ((int)enemy.enemyType == 10)
				{
					SonicReverberator.vineBoom_Loudest.PlayAudioClip(((Component)enemy).transform.position, 1.3f, 1f, 0.7f);
					if ((Object)(object)Prefabs.SmackFX != (Object)null)
					{
						Transform transform = Object.Instantiate<GameObject>(Prefabs.SmackFX, ((Component)enemy).transform.position + Vector3.up * 2f, Quaternion.identity).transform;
						transform.localScale *= 3f;
					}
					Vector3 val3 = ((Component)MonoSingleton<NewMovement>.Instance).transform.position - ((Component)enemy).transform.position;
					float magnitude = ((Vector3)(ref val3)).magnitude;
					magnitude = Mathf.Lerp(0f, 200f, Mathf.InverseLerp(600f, 0f, magnitude));
					MonoSingleton<NewMovement>.Instance.rb.velocity = ((Vector3)(ref val3)).normalized * magnitude;
					Object.Destroy((Object)(object)((Component)enemy).gameObject);
				}
				else
				{
					Action action = delegate
					{
						WeaponManager.AddStyle(gamerMode ? (-500) : 0, "admingunkill", ((Component)this).gameObject, enemy);
					};
					((Component)enemy).gameObject.EnsureComponent<EnemyOverride>().AddDeathCallback(action);
					EnemyIdentifier obj = enemy;
					GameObject gameObject = ((Component)((RaycastHit)(ref hits[i])).collider).gameObject;
					Vector3 direction = ((Ray)(ref newShot)).direction;
					obj.DeliverDamage(gameObject, ((Vector3)(ref direction)).normalized * 10000f, ((RaycastHit)(ref hits[i])).point, 2f, false, 1f, ((Component)this).gameObject, false, false);
				}
				Visualizer.DrawLine(1f, firePoint.position, ((RaycastHit)(ref hits[i])).point);
			}
			if (reflection)
			{
				HydraUtils.CreateBulletTrail(((Ray)(ref newShot)).origin, ((RaycastHit)(ref hits[num])).point, ((RaycastHit)(ref hits[num])).normal);
				return;
			}
			GameObject val4 = Object.Instantiate<GameObject>(Prefabs.BulletImpactFX, ((RaycastHit)(ref hits[num])).point + ((RaycastHit)(ref hits[num])).normal * 0.01f, Quaternion.identity);
			val4.transform.parent = ((Component)((RaycastHit)(ref hits[num])).collider).transform;
			val4.transform.up = ((RaycastHit)(ref hits[num])).normal;
			Visualizer.DrawLine(1f, firePoint.position, ((RaycastHit)(ref hits[num])).point);
		}

		private bool CheckCoin(RaycastHit hit)
		{
			Coin componentInChildren = default(Coin);
			if (!((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<Coin>(ref componentInChildren))
			{
				componentInChildren = ((Component)((RaycastHit)(ref hit)).collider).GetComponentInChildren<Coin>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					return false;
				}
			}
			if (componentInChildren.shot)
			{
				return false;
			}
			return true;
		}

		private void CoinReflect(Vector3 coinPosition)
		{
			//IL_003a: 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_0051: 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_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_0078: 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)
			EnemyIdentifier[] array = (from x in MonoSingleton<EnemyTracker>.Instance.GetCurrentEnemies()
				where !x.dead && !x.blessed
				select x).ToArray();
			Object.Instantiate<GameObject>(Prefabs.ShittyExplosionFX, coinPosition, Quaternion.identity);
			Prefabs.ShittyExplosionSound?.PlayAudioClip(coinPosition, 1.3f, 1f, 0.7f);
			Ray newShot = default(Ray);
			for (int i = 0; i < array.Length; i++)
			{
				((Ray)(ref newShot))..ctor(coinPosition, array[i].GetTargetPoint() - coinPosition);
				FireBullet(newShot, reflection: true);
			}
		}

		private void Boom()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0161: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			Ray val = mainCam.ToRay();
			if (HydraUtils.SphereCastMacro(((Ray)(ref val)).origin, 0.15f, ((Ray)(ref val)).direction, float.PositiveInfinity, out var hit))
			{
				if (CheckCoin(hit))
				{
					EnemyIdentifier[] array = (from x in MonoSingleton<EnemyTracker>.Instance.GetCurrentEnemies()
						where !x.dead && !x.blessed
						select x).ToArray();
					Vector3 position = ((Component)((RaycastHit)(ref hit)).collider).transform.position;
					Object.Instantiate<GameObject>(Prefabs.ShittyExplosionFX, position, Quaternion.identity);
					Prefabs.ShittyExplosionSound?.PlayAudioClip(position, 1.3f, 1f, 0.7f);
					RaycastHit val3 = default(RaycastHit);
					for (int i = 0; i < array.Length; i++)
					{
						Vector3 targetPoint = array[i].GetTargetPoint();
						Vector3 val2 = targetPoint - position;
						if (Physics.Raycast(position, val2, ref val3, float.PositiveInfinity, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)3))))
						{
							Object.Instantiate<GameObject>(Prefabs.UK_Explosion.Asset, ((RaycastHit)(ref val3)).point, Quaternion.identity);
						}
					}
				}
				else
				{
					Object.Instantiate<GameObject>(Prefabs.UK_Explosion.Asset, ((RaycastHit)(ref hit)).point, Quaternion.identity);
				}
			}
			AdminGun_FireSound.PlayAudioClip(firePoint.position, Random.Range(0.6f, 1f));
		}

		private Ray GetRandomRaycast()
		{
			//IL_0003: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Ray result = default(Ray);
			Vector3 val = Vector2.op_Implicit(Random.insideUnitCircle * bulletSpread);
			val.z = 1f;
			((Ray)(ref result)).origin = mainCam.position;
			((Ray)(ref result)).direction = mainCam.rotation * val;
			return result;
		}

		private void OnEnable()
		{
			animator.Play("Equip", 0, 0f);
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			return debuggingText + $"GAMER_MODE: {gamerMode}\n";
		}
	}
	public class BowlingBall : MonoBehaviour
	{
		private void FixedUpdate()
		{
		}
	}
	public class BowlingBallThrower : UltraFunGunBase
	{
		private void Update()
		{
			if (!MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame)
			{
			}
		}

		private void SpawnBall()
		{
		}
	}
	[WeaponAbility("Brick", "Throw brick with <color=orange>Fire 1</color>.", 0, RichTextColors.aqua)]
	[WeaponAbility("Mind Conduit", "Hold <color=orange>Fire 2</color> to assimilate the brick mind.", 1, RichTextColors.lime)]
	[WeaponAbility("Mortar", "Parry the brick to toss it properly.", 2, RichTextColors.red)]
	[UFGWeapon("Brick", "Brick", 0, true, WeaponIconColor.Red, true, true)]
	public class Brick : UltraFunGunBase
	{
		[UFGAsset("ThrownBrick")]
		private static GameObject thrownBrickPrefab;

		[UFGAsset("Whoosh_22")]
		private static AudioClip whoosh;

		[Configgable("Weapons/Brick", null, 0, null)]
		public static float BrickstormOffset = 3.5f;

		[Configgable("Weapons/Brick", null, 0, null)]
		public static float BrickstormPullSpeed = 15f;

		[Configgable("Weapons/Brick", null, 0, null)]
		public static float BrickstormFlockSpeed = 8f;

		[Configgable("Weapons/Brick", null, 0, null)]
		public static float throwForce = 75f;

		[Configgable("Weapons/Brick", null, 0, null)]
		public static float flockMaxRange = 10f;

		[Configgable("Weapons/Brick", null, 0, null)]
		public static float targetPointSurfaceOffset = 0.3f;

		private bool ready = false;

		private bool throwingBrick = false;

		private List<Rigidbody> thrownBricks = new List<Rigidbody>();

		private ActionCooldown throwCooldown = new ActionCooldown(0.53f, affectedByNoCooldownCheat: true);

		private ActionCooldown stormCooldown = new ActionCooldown(0.45f, affectedByNoCooldownCheat: true);

		private Vector3 flockPosition = default(Vector3);

		public Vector2 BrickstormSpeed { get; private set; } = new Vector2(5f, 5f);


		public float Brickshake { get; private set; } = 0.075f;


		public float BrickParryFlightTime { get; private set; } = 0.85f;


		public bool StormActive { get; private set; }

		public Vector3 PlayerVelocity { get; private set; }

		public override void OnAwakeFinished()
		{
			ready = (Object)(object)thrownBrickPrefab != (Object)null;
		}

		public override void GetInput()
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && throwCooldown.CanFire() && !om.paused && !throwingBrick)
			{
				throwCooldown.AddCooldown();
				throwingBrick = true;
				((MonoBehaviour)this).StartCoroutine(BrickThrower());
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed && stormCooldown.CanFire() && !om.paused && !throwingBrick)
			{
				StormActive = true;
				PlayerVelocity = player.rb.velocity;
				Ray val = default(Ray);
				((Ray)(ref val))..ctor(mainCam.position, mainCam.forward);
				flockPosition = ((Ray)(ref val)).GetPoint(flockMaxRange);
				if (HydraUtils.SphereCastAllMacro(((Ray)(ref val)).origin, 0.18f, ((Ray)(ref val)).direction, float.PositiveInfinity, out var hits) && FilterHitpoint(hits, out var hitPoint))
				{
					flockPosition = hitPoint;
				}
			}
			else if (StormActive)
			{
				StormActive = false;
				stormCooldown.AddCooldown();
			}
		}

		protected override void DoAnimations()
		{
			animator.SetBool("Storm", StormActive);
		}

		private bool FilterHitpoint(RaycastHit[] hits, out Vector3 hitPoint)
		{
			//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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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_009d: 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)
			hitPoint = Vector3.zero;
			if (hits.Length == 0)
			{
				return false;
			}
			ThrownBrick thrownBrick = default(ThrownBrick);
			for (int i = 0; i < hits.Length; i++)
			{
				RaycastHit val = hits[i];
				if (((Component)((RaycastHit)(ref val)).collider).gameObject.TryGetComponent<ThrownBrick>(ref thrownBrick))
				{
					continue;
				}
				if (((RaycastHit)(ref val)).collider.IsColliderEnemy(out var enemy))
				{
					if ((Object)(object)enemy.weakPoint != (Object)null)
					{
						hitPoint = enemy.weakPoint.transform.position;
					}
					else
					{
						hitPoint = ((RaycastHit)(ref val)).point;
					}
					break;
				}
				if (((RaycastHit)(ref val)).distance < flockMaxRange)
				{
					hitPoint = ((RaycastHit)(ref val)).point + ((RaycastHit)(ref val)).normal * targetPointSurfaceOffset;
					break;
				}
			}
			return hitPoint != Vector3.zero;
		}

		private void ThrowBrick()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (ready)
			{
				Ray val = (Ray)(weaponIdentifier.duplicate ? new Ray(firePoint.position, mainCam.forward) : HydraUtils.GetProjectileAimVector(mainCam, firePoint, 0.2f));
				GameObject val2 = Object.Instantiate<GameObject>(thrownBrickPrefab, firePoint.position, Random.rotation);
				val2.transform.forward = ((Ray)(ref val)).direction;
				Rigidbody val3 = default(Rigidbody);
				if (val2.TryGetComponent<Rigidbody>(ref val3))
				{
					if (!thrownBricks.Contains(val3))
					{
						thrownBricks.Add(val3);
						whoosh.PlayAudioClip(Random.Range(0.6f, 0.9f));
					}
					val3.velocity = ((Ray)(ref val)).direction * throwForce;
				}
				ThrownBrick thrownBrick = default(ThrownBrick);
				if (val2.TryGetComponent<ThrownBrick>(ref thrownBrick))
				{
					thrownBrick.SetBrickGun(this);
					thrownBrick.RandomRoll();
				}
			}
			throwingBrick = false;
		}

		private IEnumerator BrickThrower()
		{
			animator.Play("Throw", 0, 0f);
			for (float timer = 7f / 60f; timer > 0f; timer -= Time.deltaTime)
			{
				yield return (object)new WaitForEndOfFrame();
			}
			ThrowBrick();
		}

		public Vector3 GetPointPosition()
		{
			//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_000a: Unknown result type (might be due to invalid IL or missing references)
			return flockPosition;
		}

		private void OnEnable()
		{
			animator.Play("Equip", 0, 0f);
			ThrownBrick[] array = Object.FindObjectsOfType<ThrownBrick>();
			for (int i = 0; i < array.Length; i++)
			{
				if (!((Object)(object)array[i] == (Object)null))
				{
					array[i].SetBrickGun(this);
				}
			}
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"BRICKSTORM: {StormActive}\n";
			debuggingText += $"BRICKS: {thrownBricks.Count}\n";
			debuggingText += $"THROW_CD: {throwCooldown}\n";
			return debuggingText + $"STORM_CD: {stormCooldown}";
		}
	}
	public class ThrownBrick : MonoBehaviour, IUFGInteractionReceiver, ICleanable, IParriable
	{
		[UFGAsset("BrickBreakFX")]
		private static GameObject brickBreakFX;

		[UFGAsset("TennisHit")]
		private static AudioClip tennisHit;

		private Animator thrownBrickAnimator;

		private Transform brickMesh;

		private Brick brickShooter;

		private Rigidbody rb;

		private UltraFunGunBase.ActionCooldown soundCooldown = new UltraFunGunBase.ActionCooldown(0.05f);

		private UltraFunGunBase.ActionCooldown damageCooldown = new UltraFunGunBase.ActionCooldown(0.25f);

		private UltraFunGunBase.ActionCooldown hitLossCooldown = new UltraFunGunBase.ActionCooldown(0.5f);

		private UltraFunGunBase.ActionCooldown guidedCooldown = new UltraFunGunBase.ActionCooldown(0.2f);

		private bool sleeping = false;

		private bool guided = false;

		private int hitsRemaining = 25;

		private int enemyParries = 0;

		private bool parried;

		[Configgable("Weapons/Brick", null, 0, null)]
		private static int MaxHitsPerBrick = 25;

		[UFGAsset("BrickImpactRock")]
		private static AudioClip collisionSound;

		[UFGAsset("BrickImpactFlesh")]
		private static AudioClip fleshHitSound;

		private bool broken;

		[Commands.UFGDebugMethod("Remaining Set", "Set htings")]
		public static void RemainingsSet()
		{
			MaxHitsPerBrick = 50000;
		}

		private void Awake()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
			thrownBrickAnimator = ((Component)this).GetComponent<Animator>();
			MeshRenderer componentInChildren = ((Component)this).GetComponentInChildren<MeshRenderer>();
			brickMesh = ((componentInChildren != null) ? ((Component)componentInChildren).transform : null);
		}

		private void Start()
		{
			hitsRemaining = MaxHitsPerBrick;
		}

		public void SetBrickGun(Brick brickGun)
		{
			brickShooter = brickGun;
			if ((Object)(object)thrownBrickAnimator != (Object)null)
			{
				thrownBrickAnimator.Play("StormPulse", 0, 0f);
			}
		}

		public void Update()
		{
			if (hitsRemaining <= 0)
			{
				Break();
			}
			CheckFlock();
		}

		private void LateUpdate()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)brickShooter == (Object)null || (Object)(object)thrownBrickAnimator == (Object)null)
			{
				return;
			}
			thrownBrickAnimator.SetBool("Storm", brickShooter.StormActive);
			if (!((Object)(object)brickMesh == (Object)null))
			{
				if (brickShooter.StormActive)
				{
					Vector3 insideUnitSphere = Random.insideUnitSphere;
					insideUnitSphere *= brickShooter.Brickshake;
					brickMesh.localPosition = insideUnitSphere;
				}
				else
				{
					brickMesh.localPosition = Vector3.MoveTowards(brickMesh.localPosition, Vector3.zero, 0.015f);
				}
			}
		}

		private void CheckFlock()
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)brickShooter == (Object)null) && !((Object)(object)rb == (Object)null) && brickShooter.StormActive && (enemyParries <= 0 || parried))
			{
				sleeping = false;
				guided = false;
				enemyParries = 0;
				Vector3 pointPosition = brickShooter.GetPointPosition();
				Vector3 val = pointPosition - ((Component)this).transform.position;
				rb.velocity = val * Brick.BrickstormFlockSpeed;
			}
		}

		private void CheckStorm()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_0091: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00df: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: 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)
			if (!((Object)(object)brickShooter == (Object)null) && !((Object)(object)rb == (Object)null) && brickShooter.StormActive)
			{
				Transform transform = ((Component)brickShooter).transform;
				Vector3 position = transform.position;
				Quaternion rotation = transform.rotation;
				Vector3 position2 = ((Component)this).transform.position;
				Vector3 val = position - position2;
				Vector3 val2 = Vector3.Cross(val, Vector3.up);
				((Vector3)(ref val2)).Normalize();
				val2 *= brickShooter.BrickstormSpeed.x;
				val2 += Vector3.up * brickShooter.BrickstormSpeed.y * Mathf.Sign(position.y - position2.y) * Time.deltaTime;
				float magnitude = ((Vector3)(ref val)).magnitude;
				if (magnitude > Brick.BrickstormOffset + 0.35f || magnitude < Brick.BrickstormOffset - 0.35f)
				{
					float num = Brick.BrickstormPullSpeed * (0f - Mathf.Sign(Brick.BrickstormOffset - magnitude));
					val2 += ((Vector3)(ref val)).normalized * num * Time.deltaTime;
				}
				Vector3 playerVelocity = brickShooter.PlayerVelocity;
				playerVelocity += val2;
				rb.velocity = playerVelocity;
			}
		}

		private void OnCollisionEnter(Collision col)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			if (sleeping)
			{
				return;
			}
			if (guided && guidedCooldown.CanFire())
			{
				guided = false;
			}
			Vector3 relativeVelocity = col.relativeVelocity;
			float magnitude = ((Vector3)(ref relativeVelocity)).magnitude;
			if (magnitude <= 3f)
			{
			}
			if (CheckEnemyHit(col))
			{
				return;
			}
			ContactPoint contact;
			if (enemyParries > 0 && !parried && CheckPlayerHit(col))
			{
				MonoSingleton<NewMovement>.Instance.GetHurt(30 * enemyParries, false, 1f, true, true, 0.35f, false);
				AudioClip clip = collisionSound;
				contact = col.GetContact(0);
				clip.PlayAudioClip(((ContactPoint)(ref contact)).point, 1f + Mathf.Clamp(0.15f * (float)enemyParries, 0.5f, 3f));
				Break();
				return;
			}
			if ((Object)(object)collisionSound != (Object)null && soundCooldown.CanFire())
			{
				soundCooldown.AddCooldown();
				AudioClip clip2 = collisionSound;
				contact = col.GetContact(0);
				clip2.PlayAudioClip(((ContactPoint)(ref contact)).point, Random.Range(0.75f, 1.25f), 1f, 1f);
			}
			if (hitLossCooldown.CanFire())
			{
				hitsRemaining--;
				hitLossCooldown.AddCooldown();
			}
			if (!brickShooter.StormActive && (col.gameObject.tag == "Floor" || col.gameObject.layer == LayerMask.GetMask(new string[1] { "Environment" })))
			{
				Sleep();
			}
		}

		private bool CheckPlayerHit(Collision col)
		{
			UltraFunGuns.Log.Log(HydraUtils.CollisionInfo(col));
			if (col.gameObject.tag == "Player")
			{
				return true;
			}
			return false;
		}

		private bool CheckEnemyHit(Collision col)
		{
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			if (!damageCooldown.CanFire())
			{
				return false;
			}
			ContactPoint contact;
			if (col.IsCollisionEnemy(out var enemy))
			{
				if (enemy.bigEnemy && !brickShooter.StormActive && parried && Random.value > Mathf.Clamp(0.75f / (float)(enemyParries - 2), 0f, 0.75f))
				{
					EnemyParry();
					damageCooldown.AddCooldown();
					return false;
				}
				float num = 1f + (float)enemyParries * 50f;
				if (brickShooter.StormActive)
				{
					enemy.Override().AddStyleEntryOnDeath(new StyleEntry(4, "brickmindkill", 2f, ((Component)brickShooter).gameObject));
				}
				EnemyIdentifier obj = enemy;
				GameObject gameObject = ((Component)enemy).gameObject;
				Vector3 velocity = rb.velocity;
				contact = col.GetContact(0);
				obj.DeliverDamage(gameObject, velocity, ((ContactPoint)(ref contact)).point, num, true, 1f, ((Component)brickShooter).gameObject, false, false);
				hitsRemaining -= 5;
				damageCooldown.AddCooldown();
				fleshHitSound.PlayAudioClip(Random.Range(0.8f, 1.1f));
				if (enemy.health <= 0f && hitsRemaining > 0 && parried)
				{
					if (EnemyTools.TryGetHomingTarget(((Component)this).transform.position, out var homingTarget, out var enemyComponent))
					{
						if ((Object)(object)enemyComponent != (Object)(object)enemy)
						{
							GuidedLob(homingTarget, Vector3.up * 0.25f);
						}
					}
					else
					{
						parried = false;
						enemyParries = 0;
						LobAtPlayer();
					}
				}
				return true;
			}
			if ((Object)(object)brickShooter == (Object)null)
			{
				return false;
			}
			ThrownBrick thrownBrick = default(ThrownBrick);
			if (brickShooter.StormActive && col.gameObject.TryGetComponent<ThrownBrick>(ref thrownBrick))
			{
				contact = col.GetContact(0);
				Collider thisCollider = ((ContactPoint)(ref contact)).thisCollider;
				contact = col.GetContact(0);
				Physics.IgnoreCollision(thisCollider, ((ContactPoint)(ref contact)).otherCollider);
			}
			return false;
		}

		public void Break()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!broken)
			{
				broken = true;
				if ((Object)(object)brickBreakFX != (Object)null)
				{
					Object.Instantiate<GameObject>(brickBreakFX, ((Component)this).transform.position, Quaternion.identity);
				}
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void LobAtTarget(Vector3 target)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			Trajectory trajectory = new Trajectory(((Component)this).transform.position, target, brickShooter.BrickParryFlightTime / (float)(enemyParries + 1));
			Vector3 requiredVelocity = trajectory.GetRequiredVelocity();
			rb.velocity = requiredVelocity;
			RandomRoll();
			Visualizer.DrawRay(((Component)this).transform.position, requiredVelocity, brickShooter.BrickParryFlightTime);
		}

		private void LobAtPlayer(bool damage = false)
		{
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				parried = false;
				GuidedLob(((Component)instance.cc).transform);
			}
		}

		private void GuidedLob(Transform target)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			GuidedLob(target, Vector3.zero);
		}

		private void GuidedLob(Transform target, Vector3 relativeOffset)
		{
			//IL_0064: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!guided && (Object)(object)target != (Object)null)
			{
				RandomRoll();
				guided = true;
				guidedCooldown.AddCooldown();
				float airTime = Mathf.Max(brickShooter.BrickParryFlightTime / ((float)enemyParries / 2f + 1f), 0.1f);
				((MonoBehaviour)this).StartCoroutine(FlightComputer(new Trajectory(((Component)this).transform.position, target.position, airTime), target, relativeOffset));
			}
		}

		private IEnumerator FlightComputer(Trajectory trajectory, Transform guidedTarget, Vector3 relativeOffset)
		{
			//IL_001c: 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)
			float timer = trajectory.AirTime;
			trajectory.Origin += Vector3.up * 0.5f;
			((Component)this).transform.position = trajectory.GetPoint(Mathf.InverseLerp(trajectory.AirTime, 0f, timer));
			bool inRange = false;
			Vector3 lastTargetPos = guidedTarget.position;
			while (timer > 0f && guided && (Object)(object)guidedTarget != (Object)null && !inRange)
			{
				lastTargetPos = (trajectory.End = guidedTarget.position + relativeOffset);
				rb.position = trajectory.GetPoint(Mathf.InverseLerp(trajectory.AirTime, 0f, timer));
				inRange = 1.5f > Vector3.Distance(rb.position, trajectory.End);
				yield return (object)new WaitForEndOfFrame();
				timer -= Time.deltaTime;
			}
			Rigidbody obj = rb;
			Vector3 val = lastTargetPos + relativeOffset - rb.position;
			obj.velocity = ((Vector3)(ref val)).normalized * (float)(enemyParries + 1) * 40f;
		}

		public void RandomRoll()
		{
			//IL_0001: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Random.insideUnitSphere * 90f;
			rb.AddTorque(val, (ForceMode)1);
		}

		private void Parry(Vector3 inDirection)
		{
			//IL_006b: 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_004f: 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_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_00a5: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			parried = true;
			if (guided)
			{
				guided = false;
			}
			if ((Object)(object)Prefabs.SmackFX != (Object)null)
			{
				Transform transform = Object.Instantiate<GameObject>(Prefabs.SmackFX, ((Component)this).transform.position, Quaternion.identity).transform;
				transform.localScale *= 3f;
			}
			if (EnemyTools.TryGetHomingTarget(((Component)this).transform.position, out var homingTarget, out var _))
			{
				GuidedLob(homingTarget);
				return;
			}
			Vector3 val = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation * Vector3.up;
			Vector3 val2 = ((Vector3)(ref inDirection)).normalized + val * 0.25f;
			Vector3 velocity = val2 * Brick.BrickstormFlockSpeed * 25f;
			rb.velocity = velocity;
			RandomRoll();
		}

		public void EnemyParry()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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)
			hitsRemaining += hitsRemaining;
			if ((Object)(object)Prefabs.SmackFX != (Object)null)
			{
				Transform transform = Object.Instantiate<GameObject>(Prefabs.SmackFX, ((Component)this).transform.position, Quaternion.identity).transform;
				transform.localScale *= 3f;
			}
			MonoSingleton<TimeController>.Instance.ParryFlash();
			enemyParries++;
			float pitch = Mathf.Clamp(0.85f + 0.15f * (float)enemyParries, 1f, 3f);
			if ((Object)(object)tennisHit != (Object)null)
			{
				tennisHit.PlayAudioClip(pitch);
			}
			LobAtPlayer();
		}

		private void Sleep()
		{
			sleeping = true;
			parried = false;
			enemyParries = 0;
		}

		public bool Parry(Vector3 origin, Vector3 aimVector)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rb == (Object)null || (Object)(object)brickShooter == (Object)null || parried)
			{
				return false;
			}
			if (sleeping)
			{
				return false;
			}
			Parry(aimVector);
			return true;
		}

		public bool Interact(UFGInteractionEventData interaction)
		{
			return false;
		}

		public Vector3 GetPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public bool Targetable(TargetQuery query)
		{
			return false;
		}

		public void Cleanup()
		{
			Break();
		}
	}
	[UFGWeapon("Bulletstorm", "Bulletstorm", 3, true, WeaponIconColor.Green, false, true)]
	public class Bulletstorm : UltraFunGunBase
	{
		public float spreadTightness = 1.5f;

		public float fireRateSpeed = 0.02f;

		public float maxRange = 200f;

		public int fireAmount = 5;

		private ActionCooldown fireCooldown = new ActionCooldown(0.75f, affectedByNoCooldownCheat: true);

		private ActionCooldown fireRate = new ActionCooldown(0.02f, affectedByNoCooldownCheat: true);

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && fireCooldown.CanFire() && !om.paused)
			{
				Shoot();
			}
		}

		private void Shoot()
		{
			//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_0025: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_00dd: 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_00ed: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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)
			if (!fireRate.CanFire())
			{
				return;
			}
			Ray hitRay = default(Ray);
			Vector2 insideUnitCircle = Random.insideUnitCircle;
			((Ray)(ref hitRay)).origin = ((Component)mainCam).transform.position;
			((Ray)(ref hitRay)).direction = mainCam.TransformDirection(insideUnitCircle.x, insideUnitCircle.y, spreadTightness);
			for (int i = 0; i < fireAmount; i++)
			{
				Vector3[] array = HydraUtils.DoRayHit(hitRay, maxRange, penetration: false, 0.05f, explodeEnemyLimb: false, 0f, ((Component)this).gameObject, explodeGrenade: true, explodeEgg: true);
				if (array.Length != 2)
				{
					array = (Vector3[])(object)new Vector3[2]
					{
						((Ray)(ref hitRay)).GetPoint(maxRange),
						((Ray)(ref hitRay)).direction * -1f
					};
				}
				CreateBulletTrail(firePoint.position, array[0], array[1]);
			}
		}

		private void CreateBulletTrail(Vector3 startPosition, Vector3 endPosition, Vector3 normal)
		{
			//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_0029: 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_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_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Prefabs.BulletTrail == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(Prefabs.BulletTrail, endPosition, Quaternion.identity);
				val.transform.up = normal;
				LineRenderer component = val.GetComponent<LineRenderer>();
				Vector3[] positions = (Vector3[])(object)new Vector3[2] { startPosition, endPosition };
				component.SetPositions(positions);
			}
		}
	}
	[UFGWeapon("Gigahammer", "Giga Hammer", 0, true, WeaponIconColor.Red, true, true)]
	[WeaponAbility("Smash", "Press <color=orange>Fire 1</color> to smack things with a giant hammer.", 0, RichTextColors.aqua)]
	public class ColossalHammer : UltraFunGunBase
	{
		private Animator anim;

		private float charge;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float chargeRate = 1f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float hitstop = 0.06f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float camShake = 0.75f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float maxCharge = 1f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float maxRange = 4f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float minCharge = 0.6f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float fireDelay = 0.14f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float damage = 15f;

		[Configgable("Weapons/GigaHammer", null, 0, null)]
		private static float scalar = 1f;

		[UFGAsset("CrowbarHitEnemy")]
		private static AudioClip crowbarSound;

		private AudioSource source;

		private bool startedCharge;

		private bool swinging;

		private float chargeNormalized;

		private List<EnemyIdentifier> hitEnemies = new List<EnemyIdentifier>();

		public override void OnAwakeFinished()
		{
			base.OnAwakeFinished();
			anim = ((Component)this).GetComponentInChildren<Animator>();
			source = ((Component)this).gameObject.AddComponent<AudioSource>();
			source.clip = crowbarSound;
			source.pitch = 0.5f;
			source.spatialBlend = 0f;
			source.playOnAwake = false;
		}

		private void Update()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (swinging)
			{
				AnimatorStateInfo currentAnimatorStateInfo = anim.GetCurrentAnimatorStateInfo(0);
				swinging = !((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName("Idle");
				if (swinging)
				{
					return;
				}
			}
			bool isPressed = MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed;
			if (isPressed)
			{
				startedCharge = true;
				anim.SetBool("Raising", true);
			}
			if (!startedCharge)
			{
				return;
			}
			charge = Mathf.Clamp(charge + Time.deltaTime * chargeRate, 0f, maxCharge);
			if (charge > minCharge)
			{
				if (!isPressed)
				{
					chargeNormalized = charge / maxCharge;
					DelayFired();
				}
			}
			else if (!isPressed)
			{
				charge = 0f;
				anim.SetBool("Raising", false);
				anim.Play("Idle", 0, 0f);
				startedCharge = false;
			}
		}

		private IEnumerator FireCoroutine()
		{
			yield return (object)new WaitForSeconds(fireDelay);
			Fire();
		}

		private void DelayFired()
		{
			anim.SetBool("Raising", false);
			anim.Play("Slam", 0, 0f);
			swinging = true;
			startedCharge = false;
			((MonoBehaviour)this).StartCoroutine(FireCoroutine());
		}

		private void OnDisable()
		{
			charge = 0f;
			startedCharge = false;
			swinging = false;
			anim.SetBool("Raising", false);
		}

		private void OnEnable()
		{
			anim.Play("Recover", 0, 0.5f);
			startedCharge = false;
			charge = 0f;
		}

		private void Fire()
		{
			//IL_002f: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			hitEnemies.Clear();
			source.Play();
			MonoSingleton<CameraController>.Instance.CameraShake(camShake);
			if (HydraUtils.SphereCastAllMacro(mainCam.position, 0.75f, mainCam.forward, maxRange, out var hits))
			{
				RaycastHit[] array = hits;
				foreach (RaycastHit hit in array)
				{
					ProcessHit(hit);
				}
			}
		}

		private void ProcessHit(RaycastHit hit)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00eb: 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_00fb: 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)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			Breakable val = default(Breakable);
			if (((Component)((RaycastHit)(ref hit)).collider).TryGetComponent<Breakable>(ref val))
			{
				val.Break();
			}
			Glass val2 = default(Glass);
			if (((Component)((RaycastHit)(ref hit)).collider).TryGetComponent<Glass>(ref val2))
			{
				val2.Shatter();
			}
			EnemyIdentifier enemy;
			if (((RaycastHit)(ref hit)).collider.IsColliderEnvironment())
			{
				GameObject val3 = Object.Instantiate<GameObject>(Prefabs.BulletImpactFX, ((RaycastHit)(ref hit)).point + ((RaycastHit)(ref hit)).normal * 0.01f, Quaternion.identity);
				val3.transform.up = ((RaycastHit)(ref hit)).normal;
			}
			else if (((RaycastHit)(ref hit)).collider.IsColliderEnemy(out enemy, filterDead: false) && !hitEnemies.Contains(enemy))
			{
				((Component)enemy).transform.localScale = Vector3.Scale(new Vector3(1f, scalar * (1f - chargeNormalized), 1f), ((Component)enemy).transform.localScale);
				GameObject gore = MonoSingleton<BloodsplatterManager>.Instance.GetGore((GoreType)2, enemy, false);
				gore.transform.position = ((RaycastHit)(ref hit)).point;
				Transform transform = gore.transform;
				transform.localScale *= 2f;
				gore.transform.SetParent(GoreZone.ResolveGoreZone(((Component)enemy).transform).goreZone, true);
				enemy.DeliverDamage(((Component)enemy).gameObject, mainCam.forward * 5000f, ((RaycastHit)(ref hit)).point, damage, true, 1f, ((Component)this).gameObject, false, false);
				MonoSingleton<TimeController>.Instance.HitStop(hitstop);
				hitEnemies.Add(enemy);
			}
		}
	}
	public class WeaponDef : ScriptableObject
	{
		public string DisplayName;

		public GameObject Prefab;

		public GameObject Model;

		public int VariantColorIndex;

		public Sprite HUDIcon;

		public Sprite HUDIconGlow;

		[TextArea(20, 60)]
		public string Lore;

		[TextArea(20, 60)]
		public string Usage;
	}
	public class DiceGun : UltraFunGunBase
	{
		[Configgable("Weapons/Deterministic Observer/Deterministic Observer", null, 0, null)]
		private static int startingDice = 3;

		[Configgable("Weapons/Deterministic Observer/Deterministic Observer", null, 0, null)]
		private static int maxDice = 12;

		[Configgable("Weapons/Deterministic Observer/Deterministic Observer", null, 0, null)]
		private static float diceSpawnFloorOffset = 4f;

		[Configgable("Weapons/Deterministic Observer/Deterministic Observer", null, 0, null)]
		private static int diceDropCount = 1;

		[Configgable("Weapons/Deterministic Observer/Deterministic Observer", "debug_all_spells", 0, null)]
		private static bool addSpellsOnEnable = false;

		private int diceLeft;

		private float timeUntilAction = 0f;

		private List<DiceGunSpell> currentSpellPool = new List<DiceGunSpell>();

		private DiceGunSpell chamberedSpell;

		private static readonly DiceGunSpell[] allSpells = new DiceGunSpell[1]
		{
			new DisintigrateSpell()
		};

		private bool primaryPressedThisFrame => MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && !om.paused;

		private bool secondaryPressedThisFrame => MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && !om.paused;

		public Transform CameraTransform => mainCam;

		public Transform FirePoint => firePoint;

		public override void OnAwakeFinished()
		{
			diceLeft = startingDice;
		}

		private void Update()
		{
			HandlePrimaryAction();
		}

		private void HandlePrimaryAction()
		{
			if (!(timeUntilAction > 0f))
			{
				if (primaryPressedThisFrame && chamberedSpell != null)
				{
					Fire();
				}
				else if (secondaryPressedThisFrame)
				{
					RollDice();
				}
			}
		}

		private void Fire()
		{
			if (chamberedSpell != null)
			{
				chamberedSpell.ExecuteSpell(this);
				DiceGunSpell diceGunSpell = chamberedSpell;
				chamberedSpell = null;
				diceGunSpell?.OnSpellDiscarded();
			}
		}

		private void RollDice()
		{
			currentSpellPool = currentSpellPool.Where((DiceGunSpell x) => x != null).ToList();
			if (currentSpellPool.Count > 0)
			{
				DiceGunSpell diceGunSpell = chamberedSpell;
				chamberedSpell = currentSpellPool.RandomEntry();
				currentSpellPool.Remove(chamberedSpell);
				chamberedSpell.OnSpellRolled(Random.Range(0, 20));
				diceGunSpell?.OnSpellDiscarded();
			}
		}

		public bool CanPickupSpells()
		{
			return currentSpellPool.Count < maxDice;
		}

		public void PickupRandomSpell(DiceGunSpell spell)
		{
			currentSpellPool.Add(spell);
			spell.OnSpellAddedToPool(this);
		}

		[Configgable("Weapons/Deterministic Observer/Deterministic Observer", "Add random spell to pool", 0, null)]
		public static void PickupRandomSpellStatic()
		{
			Object.FindObjectOfType<DiceGun>()?.PickupRandomSpell();
		}

		public void PickupRandomSpell()
		{
			PickupRandomSpell(allSpells.RandomEntry());
		}

		private void OnEnable()
		{
			UKEvents.Enemy.OnEnemyDeath += Enemy_OnEnemyDeath;
			if (addSpellsOnEnable)
			{
				currentSpellPool.Clear();
				for (int i = 0; i < allSpells.Length; i++)
				{
					PickupRandomSpell(allSpells[i]);
				}
			}
		}

		private void Enemy_OnEnemyDeath(UKEvents.Enemy.EnemyDeathEvent enemyDeath)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!enemyDeath.LastHit.IsValid())
			{
				SpawnDice(((Component)enemyDeath.EnemyIdentifier).transform.position);
			}
		}

		private void SpawnDice(Vector3 position)
		{
			//IL_0001: 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_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)
			NavMeshHit val = default(NavMeshHit);
			if (NavMesh.SamplePosition(position, ref val, 10f, -1))
			{
				position = ((NavMeshHit)(ref val)).position + Vector3.up * diceSpawnFloorOffset;
			}
			for (int i = 0; i < diceDropCount; i++)
			{
			}
		}

		private void OnDisable()
		{
			UKEvents.Enemy.OnEnemyDeath -= Enemy_OnEnemyDeath;
		}
	}
	public abstract class DiceGunSpell
	{
		protected int spellPower;

		public void ExecuteSpell(DiceGun diceGun)
		{
			ExecuteSpellCore(diceGun);
		}

		protected abstract void ExecuteSpellCore(DiceGun diceGun);

		public void OnSpellRolled(int spellPower)
		{
			OnSpellRolledCore(spellPower);
		}

		protected virtual void OnSpellRolledCore(int spellPower)
		{
			this.spellPower = spellPower;
		}

		public void OnSpellAddedToPool(DiceGun diceGun)
		{
			OnSpellRolledCore(spellPower);
		}

		protected virtual void OnSpellAddedToPoolCore(DiceGun diceGun)
		{
		}

		public void OnSpellDiscarded()
		{
			OnSpellDiscardedCore();
		}

		protected virtual void OnSpellDiscardedCore()
		{
		}
	}
	public class DisintigrateSpell : DiceGunSpell
	{
		[Configgable("Weapons/Deterministic Observer/Outcomes/Disintigrate", null, 0, null)]
		private static float maxRange = 1000f;

		[Configgable("Weapons/Deterministic Observer/Outcomes/Disintigrate", null, 0, null)]
		private static float damagePerLevel = 0.25f;

		[Configgable("Weapons/Deterministic Observer/Outcomes/Disintigrate", null, 0, null)]
		private static float powerDivisor = 38.5f;

		protected override void ExecuteSpellCore(DiceGun diceGun)
		{
			//IL_0009: 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_0026: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(diceGun.CameraTransform.position, diceGun.CameraTransform.forward);
			Ray val2 = default(Ray);
			((Ray)(ref val2))..ctor(diceGun.FirePoint.position, diceGun.FirePoint.forward);
			Vector3 point = ((Ray)(ref val)).GetPoint(maxRange);
			if (spellPower <= 0)
			{
				RaycastHit val3 = default(RaycastHit);
				if (Physics.Raycast(val, ref val3, maxRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
				{
					point = ((RaycastHit)(ref val3)).point;
				}
				DrawLine(((Ray)(ref val2)).origin, point);
				return;
			}
			RaycastHit val4 = default(RaycastHit);
			if (!Physics.Raycast(val, ref val4, maxRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)3))))
			{
				DrawLine(((Ray)(ref val2)).origin, point);
				return;
			}
			RaycastHit[] source = Physics.RaycastAll(val, maxRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)3)));
			foreach (RaycastHit item in source.OrderBy((RaycastHit x) => ((RaycastHit)(ref x)).distance))
			{
				RaycastHit current = item;
				if (((RaycastHit)(ref current)).collider.IsColliderEnvironment())
				{
					DrawLine(((Ray)(ref val2)).origin, ((RaycastHit)(ref current)).point);
					break;
				}
				if (!((RaycastHit)(ref val4)).collider.IsColliderEnemy(out var enemy) || enemy.dead)
				{
					continue;
				}
				float num = CalculateDamage(spellPower);
				float health = enemy.Override().GetHealth();
				if (health - num <= 0f || spellPower >= 19)
				{
					int frameCount = 0;
					enemy.InstaKill();
					DrawVaporizeEffect(((RaycastHit)(ref val4)).point);
					BehaviourRelay behaviourRelay = ((Component)enemy).gameObject.AddComponent<BehaviourRelay>();
					behaviourRelay.OnUpdate = (Action<GameObject>)Delegate.Combine(behaviourRelay.OnUpdate, (Action<GameObject>)delegate(GameObject g)
					{
						if (frameCount == 1)
						{
							Object.Destroy((Object)(object)g);
						}
						int num2 = frameCount + 1;
						frameCount = num2;
					});
				}
				else
				{
					enemy.DeliverDamage(((Component)((RaycastHit)(ref current)).collider).gameObject, -((RaycastHit)(ref current)).normal, ((RaycastHit)(ref current)).point, num, false, 0f, ((Component)diceGun).gameObject, false, false);
				}
				break;
			}
		}

		private float CalculateDamage(int power)
		{
			return (float)(power * (power + power)) / 38.5f;
		}

		private void DrawVaporizeEffect(Vector3 origin)
		{
		}

		private void DrawLine(Vector3 origin, Vector3 end)
		{
		}

		private void DrawDirectionFX(GameObject prefab, Vector3 position, Vector3 direction)
		{
			//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_0004: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(prefab, position, Quaternion.LookRotation(direction));
		}
	}
	[UFGWeapon("Dodgeball", "ULTRABALLER", 1, true, WeaponIconColor.Red, true, true)]
	[WeaponAbility("Recall", "Pull the thrown ball back to you by holing <color=orange>Fire 2</color>", 2, RichTextColors.lime)]
	[WeaponAbility("Soft-Ball", "Press <color=orange>Fire 2</color> while holding the ball to throw the ball softly.", 1, RichTextColors.aqua)]
	[WeaponAbility("Full-Ball", "Press <color=orange>Fire 1</color> to throw the ball. Holding the button will throw the ball faster and harder.", 0, RichTextColors.aqua)]
	[WeaponAbility("Excite", "Firing upon or punching the ball will send it into a fit of excitement.", 3, RichTextColors.red)]
	public class Dodgeball : UltraFunGunBase
	{
		private ActionCooldown pullCooldown = new ActionCooldown(0.25f, affectedByNoCooldownCheat: true);

		public ThrownDodgeball activeDodgeball;

		private GameObject catcherCollider;

		private bool throwingBall = false;

		private bool pullingBall = false;

		private bool chargingBall = false;

		public bool dodgeBallActive = false;

		[Configgable("Weapons/Dodgeball", null, 0, null)]
		public static float throwForce = 90f;

		[Configgable("Weapons/Dodgeball", null, 0, null)]
		public static float softThrowForce = 30f;

		[Configgable("Weapons/Dodgeball", null, 0, null)]
		public static float pullForce = 150f;

		[Configgable("Weapons/Dodgeball", null, 0, null)]
		private static float chargeMultiplier = 1.42f;

		[Configgable("Weapons/Dodgeball", null, 0, null)]
		private static float minCharge = 1f;

		private float currentCharge = 1f;

		[Configgable("Weapons/Dodgeball", null, 0, null)]
		private static float maxCharge = 4f;

		private float pullTimer = 0f;

		public bool basketBallMode = false;

		private Material standardSkin;

		[UFGAsset("BasketballMaterial")]
		private static Material basketballSkin;

		[UFGAsset("ThrownDodgeball")]
		public static GameObject ThrownDodgeballPrefab { get; private set; }

		public override void OnAwakeFinished()
		{
			basketBallMode = Data.Config.Data.BasketBallMode;
			standardSkin = ((Renderer)((Component)((Component)this).transform.Find("viewModelWrapper/Armature/Upper_Arm/Forearm/Hand/DodgeballMesh")).GetComponent<MeshRenderer>()).material;
			SetSkin(!basketBallMode);
			catcherCollider = ((Component)((Component)this).transform.Find("firePoint/DodgeballCatcher")).gameObject;
			catcherCollider.SetActive(false);
			catcherCollider.gameObject.layer = 14;
		}

		public override void GetInput()
		{
			if (!om.paused)
			{
				if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && !throwingBall && !pullingBall && !dodgeBallActive)
				{
					chargingBall = true;
					currentCharge = Mathf.Clamp(currentCharge + Time.deltaTime * chargeMultiplier, minCharge, maxCharge);
				}
				else if (chargingBall && !throwingBall && !pullingBall)
				{
					((MonoBehaviour)this).StartCoroutine(ThrowDodgeball(softThrow: false));
					pullCooldown.AddCooldown(0.5f);
				}
				if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && !throwingBall && !pullingBall && !dodgeBallActive && !chargingBall)
				{
					((MonoBehaviour)this).StartCoroutine(ThrowDodgeball(softThrow: true));
					pullCooldown.AddCooldown(0.5f);
				}
				if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed && !chargingBall && !throwingBall && dodgeBallActive && pullCooldown.CanFire())
				{
					ForceDodgeball(pull: true);
					pullTimer += Time.deltaTime;
				}
				else if (pullingBall && dodgeBallActive)
				{
					pullCooldown.AddCooldown();
					ForceDodgeball(pull: false);
				}
				else
				{
					pullTimer = 0f;
					pullingBall = false;
					catcherCollider.SetActive(false);
				}
				if (UFGInput.SecretButton.WasPeformed())
				{
					DoSecret();
				}
				if (Input.GetKeyDown((KeyCode)61) && !chargingBall && !throwingBall && dodgeBallActive && UltraFunGuns.DebugMode)
				{
					activeDodgeball.ExciteBall();
				}
			}
		}

		public override void DoSecret()
		{
			if (Data.SaveInfo.Data.basketballHighScore >= 100)
			{
				basketBallMode = !basketBallMode;
				Data.Config.Data.BasketBallMode = basketBallMode;
				Data.Config.Save();
				SetSkin(basketBallMode);
			}
		}

		private void SetSkin(bool standard)
		{
			Material val = ((!standard) ? basketballSkin : standardSkin);
			if ((Object)(object)val != (Object)null)
			{
				((Renderer)((Component)((Component)this).transform.Find("viewModelWrapper/Armature/Upper_Arm/Forearm/Hand/DodgeballMesh")).GetComponent<MeshRenderer>()).material = val;
				((Renderer)((Component)ThrownDodgeballPrefab.transform.Find("DodgeballMesh")).GetComponent<MeshRenderer>()).material = val;
			}
		}

		private void FixedUpdate()
		{
			if (dodgeBallActive && (Object)(object)activeDodgeball == (Object)null)
			{
				dodgeBallActive = false;
			}
			if (dodgeBallActive)
			{
				activeDodgeball.beingPulled = pullingBall;
			}
			if (pullTimer >= 6f && dodgeBallActive)
			{
				CatchBall();
				Object.Destroy((Object)(object)((Component)activeDodgeball).gameObject);
			}
		}

		private void ForceDodgeball(bool pull)
		{
			//IL_0020: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)activeDodgeball != (Object)null)
			{
				Vector3 val = catcherCollider.transform.position - ((Component)activeDodgeball).gameObject.transform.position;
				Vector3 val2 = ((Vector3)(ref val)).normalized * pullForce;
				MonoSingleton<CameraController>.Instance.CameraShake(0.025f);
				if (!pull)
				{
					val2 *= -1f;
				}
				pullingBall = pull;
				catcherCollider.SetActive(pull);
				((Component)activeDodgeball).transform.forward = val2;
				activeDodgeball.SetSustainVelocity(val2, pull);
			}
			else
			{
				dodgeBallActive = false;
			}
		}

		private IEnumerator ThrowDodgeball(bool softThrow, bool skipTiming = false)
		{
			throwingBall = true;
			chargingBall = false;
			animator.Play("DodgeballThrow");
			if (!skipTiming)
			{
				yield return (object)new WaitForSeconds(0.15f);
			}
			MonoSingleton<CameraController>.Instance.CameraShake(0.35f);
			dodgeBallActive = true;
			activeDodgeball = Object.Instantiate<GameObject>(ThrownDodgeballPrefab, firePoint.position, Quaternion.identity).GetComponent<ThrownDodgeball>();
			activeDodgeball.dodgeballWeapon = this;
			Ray ballDirection = HydraUtils.GetProjectileAimVector(mainCam, firePoint);
			((Component)activeDodgeball).gameObject.transform.forward = mainCam.forward;
			float currentThrowForce = throwForce;
			if (softThrow)
			{
				currentThrowForce = softThrowForce;
				currentCharge = 1f;
			}
			Vector3 dodgeBallVelocity = ((Ray)(ref ballDirection)).direction * currentThrowForce * currentCharge;
			activeDodgeball.SetSustainVelocity(dodgeBallVelocity, overrideCalculation: true);
			if (!softThrow)
			{
				activeDodgeball.AddBounces((int)(4f * currentCharge));
			}
			throwingBall = false;
			currentCharge = 0f;
		}

		public void CatchBall()
		{
			MonoSingleton<CameraController>.Instance.CameraShake(0.35f);
			pullingBall = false;
			pullCooldown.TimeToFire = 0f;
			pullTimer = 0f;
			animator.Play("DodgeballCatchball");
			((Component)((Component)this).transform.Find("Audios/CatchSound")).GetComponent<AudioSource>().Play();
		}

		protected override void DoAnimations()
		{
			animator.SetBool("ChargingBall", chargingBall);
			animator.SetBool("PullingBall", pullingBall);
			animator.SetBool("CantThrow", dodgeBallActive);
		}

		private void OnDisable()
		{
			if (chargingBall && !throwingBall && !pullingBall)
			{
				((MonoBehaviour)this).StartCoroutine(ThrowDodgeball(softThrow: false, skipTiming: true));
			}
			if (dodgeBallActive)
			{
				activeDodgeball.beingPulled = false;
			}
			throwingBall = false;
			chargingBall = false;
			pullingBall = false;
		}

		private void OnDestroy()
		{
			if (dodgeBallActive && (Object)(object)activeDodgeball != (Object)null)
			{
				activeDodgeball.Pop();
			}
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"BALL_OUT: {dodgeBallActive}\n";
			if (dodgeBallActive)
			{
				debuggingText += $"BALL_LEVEL: {activeDodgeball.timesExcited}\n";
			}
			debuggingText += $"THROW_CHARGE: {currentCharge}\n";
			debuggingText += $"PULL_TIMER: {pullTimer}\n";
			debuggingText += $"PULL_CD: {pullCooldown}\n";
			return debuggingText + $"BBALL: {basketBallMode}\n";
		}
	}
	public class ThrownDodgeball : MonoBehaviour, IUFGInteractionReceiver, ICleanable, ICoinTarget, ISharpshooterTarget, IRevolverBeamShootable
	{
		private UltraFunGunBase.ActionCooldown hurtCooldown = new UltraFunGunBase.ActionCooldown(0.1f);

		private UltraFunGunBase.ActionCooldown hitSoundCooldown = new UltraFunGunBase.ActionCooldown(0.015f);

		private UltraFunGunBase.ActionCooldown maxRangeReflectCooldown = new UltraFunGunBase.ActionCooldown(0.5f);

		[UFGAsset("DodgeballPopFX")]
		private static GameObject dodgeballPopFXPrefab;

		[UFGAsset("DodgeballImpactSound")]
		private static GameObject impactSound;

		public Transform ballMesh;

		public Transform homingTarget;

		public EnemyIdentifier homingTargetEID;

		public Dodgeball dodgeballWeapon;

		public Rigidbody rb;

		private Animator animator;

		private Vector3 sustainedVelocity = Vector3.zero;

		private Vector3 oldSustainedVelocity = Vector3.zero;

		private NewMovement player;

		public float reboundVelocityMultiplier = 2.5f;

		public int remainingBounces = 50;

		public int timesBounced = 19;

		public float lifeTime = 15f;

		public float hitDamageMultiplier = 0.03f;

		public float exciteSpeedMultiplier = 1.15f;

		public float exciteDamageMultiplier = 1.35f;

		public int timesExcited = 0;

		public float maxBallDistance = 4000000f;

		public bool isHoming = false;

		public bool isExcited = false;

		public bool beingPulled = false;

		private bool dead;

		private AudioSource bigHitSound;

		private AudioSource homingSound;

		private AudioSource exciteSound;

		private AudioSource recallBonkSound;

		private AudioSource excitedHitSound;

		private AudioSource glassImpactSound;

		private AudioSource altExciteHitSound;

		private void Awake()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
			animator = ((Component)this).GetComponent<Animator>();
			ballMesh = ((Component)this).transform.Find("DodgeballMesh");
			bigHitSound = ((Component)((Component)this).transform.Find("Audios/BigHit")).GetComponent<AudioSource>();
			homingSound = ((Component)((Component)this).transform.Find("Audios/HomingSound")).GetComponent<AudioSource>();
			exciteSound = ((Component)((Component)this).transform.Find("Audios/ExciteSound")).GetComponent<AudioSource>();
			recallBonkSound = ((Component)((Component)this).transform.Find("Audios/RecallBonk")).GetComponent<AudioSource>();
			excitedHitSound = ((Component)((Component)this).transform.Find("Audios/ExcitedHit")).GetComponent<AudioSource>();
			glassImpactSound = ((Component)((Component)this).transform.Find("Audios/GlassImpact")).GetComponent<AudioSource>();
			altExciteHitSound = ((Component)((Component)this).transform.Find("Audios/BallinHitSound")).GetComponent<AudioSource>();
		}

		private void Start()
		{
			player = MonoSingleton<NewMovement>.Instance;
			homingSound.Play();
			homingSound.Pause();
			GameObject gameObject = ((Component)((Component)this).transform.Find("LimbHitbox")).gameObject;
			gameObject.tag = "Breakable";
		}

		private void Update()
		{
			lifeTime -= Time.deltaTime;
			if ((lifeTime <= 0f && !beingPulled && !isHoming) || (Object)(object)dodgeballWeapon == (Object)null)
			{
				Pop();
			}
		}

		private void FixedUpdate()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (isHoming && !beingPulled)
			{
				DoHomingAttack();
			}
			rb.velocity = sustainedVelocity;
		}

		private void LateUpdate()
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			oldSustainedVelocity = sustainedVelocity;
			animator.SetBool("Excited", isExcited);
			Vector3 velocity = ((Component)player).transform.position - ((Component)this).transform.position;
			if (((Vector3)(ref velocity)).sqrMagnitude >= maxBallDistance && maxRangeReflectCooldown.CanFire())
			{
				maxRangeReflectCooldown.AddCooldown();
				SetSustainVelocity(velocity);
			}
		}

		public void AddBounces(int bouncesToAdd)
		{
			timesBounced += bouncesToAdd;
		}

		public void ExciteBall(int excitementToAdd = 1, bool doHitstop = true)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			MonoSingleton<CameraController>.Instance.CameraShake(2.5f);
			exciteSound.Play();
			if (doHitstop)
			{
				MonoSingleton<TimeController>.Instance.HitStop(0.2f);
			}
			timesExcited += excitementToAdd;
			lifeTime += 3f;
			MonoSingleton<StyleHUD>.Instance.AddPoints(0, "hydraxous.ultrafunguns.dodgeballparry", ((Component)dodgeballWeapon).gameObject, (EnemyIdentifier)null, timesExcited, "", "");
			isExcited = true;
			remainingBounces = (int)((float)remainingBounces * (1.25f * (float)excitementToAdd));
			SetSustainVelocity(sustainedVelocity);
			isHoming = TryGetHomingTarget();
		}

		private bool TryGetHomingTarget()
		{
			//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_001d: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			BasketballHoop basketballHoop = Object.FindObjectOfType<BasketballHoop>();
			if ((Object)(object)basketballHoop != (Object)null)
			{
				Vector3 hoopPos = basketballHoop.GetHoopPos();
				Vector3 velocity = hoopPos - ((Component)this).transform.position;
				SetSustainVelocity(velocity);
				return true;
			}
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			List<Transform> list2 = new List<Transform>();
			GameObject[] array = GameObject.FindGameObjectsWithTag("Enemy");
			GameObject[] array2 = array;
			EnemyIdentifier val2 = default(EnemyIdentifier);
			RaycastHit val5 = default(RaycastHit);
			EnemyIdentifier val6 = default(EnemyIdentifier);
			EnemyIdentifierIdentifier val7 = default(EnemyIdentifierIdentifier);
			foreach (GameObject val in array2)
			{
				if (val.TryGetComponent<EnemyIdentifier>(ref val2) && !val2.dead && !list.Contains(val2))
				{
					list.Add(val2);
					Transform val3;
					if ((Object)(object)val2.weakPoint != (Object)null && val2.weakPoint.activeInHierarchy)
					{
						val3 = val2.weakPoint.transform;
					}
					else
					{
						EnemyIdentifierIdentifier componentInChildren = ((Component)val2).GetComponentInChildren<EnemyIdentifierIdentifier>();
						val3 = ((!Object.op_Implicit((Object)(object)componentInChildren)) ? ((Component)val2).transform : ((Component)componentInChildren).transform);
					}
					Vector3 val4 = val3.position - ((Component)this).transform.position;
					if (Physics.Raycast(((Component)this).transform.position, val4, ref val5, ((Vector3)(ref val4)).magnitude, LayerMask.GetMask(new string[5] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default" })) && (((Component)((RaycastHit)(ref val5)).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val6) || ((Component)((RaycastHit)(ref val5)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val7)))
					{
						list2.Add(val3);
					}
				}
			}
			int num = -1;
			float num2 = float.PositiveInfinity;
			for (int j = 0; j < list2.Count; j++)
			{
				Vector3 val8 = list2[j].position - ((Component)this).transform.position;
				if (((Vector3)(ref val8)).sqrMagnitude < num2)
				{
					num = j;
					num2 = ((Vector3)(ref val8)).sqrMagnitude;
				}
			}
			if (num > -1)
			{
				homingTarget = list2[num];
				homingTargetEID = ((Component)homingTarget).GetComponent<EnemyIdentifier>();
				return true;
			}
			return false;
		}

		private void DoHomingAttack()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)homingTarget == (Object)null)
			{
				StopHomingAttack();
				return;
			}
			if ((Object)(object)homingTargetEID == (Object)null && !((Component)homingTarget).TryGetComponent<EnemyIdentifier>(ref homingTargetEID))
			{
				EnemyIdentifierIdentifier val = default(EnemyIdentifierIdentifier);
				if (!((Component)homingTarget).TryGetComponent<EnemyIdentifierIdentifier>(ref val))
				{
					StopHomingAttack();
					return;
				}
				homingTargetEID = val.eid;
			}
			if (homingTargetEID.dead)
			{
				StopHomingAttack();
				return;
			}
			SetSustainVelocity(homingTarget.position - ((Component)this).transform.position);
			homingSound.UnPause();
		}

		private void StopHomingAttack()
		{
			homingTarget = null;
			homingTargetEID = null;
			homingSound.Pause();
			isHoming = false;
		}

		public void Pop()
		{
			//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)
			if (!dead)
			{
				dead = true;
				Object.Instantiate<GameObject>(dodgeballPopFXPrefab, ((Component)this).transform.position, Quaternion.identity);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void DoHit(Collision col)
		{
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			animator.Play("ThrownDodgeballSquish");
			EnemyIdentifier val = null;
			GameObject val2 = null;
			AudioSource val3 = null;
			if (((Component)col.collider).TryGetComponent<EnemyIdentifier>(ref val))
			{
				val2 = ((Component)val).gameObject;
			}
			EnemyIdentifierIdentifier val4 = default(EnemyIdentifierIdentifier);
			if (((Component)col.collider).TryGetComponent<EnemyIdentifierIdentifier>(ref val4))
			{
				val = val4.eid;
				val2 = ((Component)val4).gameObject;
			}
			Breakable val5 = default(Breakable);
			if (((Component)col.collider).TryGetComponent<Breakable>(ref val5))
			{
				val5.Break();
			}
			Glass val6 = default(Glass);
			if (((Component)col.collider).TryGetComponent<Glass>(ref val6))
			{
				val6.Shatter();
				glassImpactSound.Play();
			}
			if ((Object)(object)val != (Object)null && hurtCooldown.CanFire())
			{
				if (!val.dead)
				{
					int num = 0;
					string text = "hydraxous.ultrafunguns.dodgeballhit";
					bool flag = false;
					hurtCooldown.AddCooldown();
					if (beingPulled)
					{
						num += 10;
						text = "hydraxous.ultrafunguns.dodgeballreversehit";
						val3 = recallBonkSound;
					}
					if (isExcited)
					{
						num += 20;
						val3 = bigHitSound;
						flag = true;
					}
					if (isHoming)
					{
						num += 30;
						text = "hydraxous.ultrafunguns.dodgeballparryhit";
						if (dodgeballWeapon.basketBallMode)
						{
							altExciteHitSound.Play();
						}
						else
						{
							excitedHitSound.Play();
						}
						MonoSingleton<TimeController>.Instance.HitStop(Mathf.Clamp(0.1f * (float)timesExcited, 0f, 1.4f));
					}
					float num2 = Mathf.Clamp(exciteDamageMultiplier * (float)timesExcited, 1f, float.PositiveInfinity);
					EnemyIdentifier obj = val;
					GameObject obj2 = val2;
					Vector3 normalized = ((Vector3)(ref sustainedVelocity)).normalized;
					ContactPoint contact = col.GetContact(0);
					obj.DeliverDamage(obj2, normalized, ((ContactPoint)(ref contact)).point, ((Vector3)(ref sustainedVelocity)).magnitude * hitDamageMultiplier * num2, flag, 0f, ((Component)dodgeballWeapon).gameObject, false, false);
					MonoSingleton<StyleHUD>.Instance.AddPoints(num, text, ((Component)dodgeballWeapon).gameObject, val, -1, "", "");
					StopHomingAttack();
				}
				else
				{
					Physics.IgnoreCollision(col.collider, (Collider)(object)((Component)this).GetComponent<SphereCollider>());
				}
			}
			if (hitSoundCooldown.CanFire())
			{
				remainingBounces--;
				timesBounced++;
				hitSoundCooldown.AddCooldown();
				if ((Object)(object)val3 != (Object)null)
				{
					val3.Play();
				}
				else
				{
					Object.Instantiate<GameObject>(impactSound, ((Component)this).transform);
				}
			}
		}

		private void OnCollisionEnter(Collision col)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_0070: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if (!(((Object)col.gameObject).name == "Player"))
			{
				DoHit(col);
				ContactPoint contact;
				if (col.contacts.Length > 1)
				{
					int num = Random.Range(0, col.contacts.Length);
					contact = col.GetContact(num);
					Vector3 normal = ((ContactPoint)(ref contact)).normal;
				}
				else
				{
					contact = col.GetContact(0);
					Vector3 normal = ((ContactPoint)(ref contact)).normal;
				}
				Vector3 val = sustainedVelocity;
				contact = col.GetContact(0);
				SetSustainVelocity(Vector3.Reflect(val, ((ContactPoint)(ref contact)).normal));
				if (remainingBounces <= 0)
				{
					Pop();
				}
			}
		}

		public void SetSustainVelocity(Vector3 velocity, bool overrideCalculation = false)
		{
			//IL_0014: 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_001a: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			if (overrideCalculation)
			{
				sustainedVelocity = velocity;
			}
			else
			{
				sustainedVelocity = CalculateVelocity(velocity);
			}
			((Component)this).transform.forward = sustainedVelocity;
		}

		private Vector3 CalculateVelocity(Vector3 direction)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (isExcited)
			{
				return ((Vector3)(ref direction)).normalized * (reboundVelocityMultiplier * (float)timesBounced + 1f) * (exciteSpeedMultiplier * (float)timesExcited);
			}
			return ((Vector3)(ref direction)).normalized * (reboundVelocityMultiplier * (float)timesBounced + 1f);
		}

		private void OnTriggerEnter(Collider col)
		{
			DeathZone val = default(DeathZone);
			OutOfBounds val2 = default(OutOfBounds);
			if (((Object)((Component)col).gameObject).name == "DodgeballCatcher")
			{
				StopHomingAttack();
				dodgeballWeapon.CatchBall();
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else if (((Component)col).gameObject.TryGetComponent<DeathZone>(ref val) || ((Component)col).gameObject.TryGetComponent<OutOfBounds>(ref val2))
			{
				StopHomingAttack();
				Pop();
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)dodgeballWeapon != (Object)null)
			{
				dodgeballWeapon.dodgeBallActive = false;
			}
		}

		public bool Parry(Vector3 origin, Vector3 aimVector)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			SetSustainVelocity(aimVector);
			ExciteBall(2);
			return true;
		}

		public bool Interact(UFGInteractionEventData interaction)
		{
			//IL_0084: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			UltraFunGuns.Log.Log(((Object)((Component)this).gameObject).name + " shot by " + interaction.invokeType.Name);
			switch (interaction.invokeType.Name)
			{
			case "Focalyzer":
			case "FocalyzerAlternate":
				SetSustainVelocity(Vector3.Reflect(((Vector3)(ref sustainedVelocity)).normalized, ((Vector3)(ref interaction.direction)).normalized));
				return true;
			case "FingerGun":
			case "AdminGun":
				Pop();
				return true;
			case "SonicReverberator":
				ExciteBall(4);
				return true;
			default:
				if (interaction.ContainsAnyTag("shot"))
				{
					ExciteBall(Mathf.CeilToInt(interaction.power));
					return true;
				}
				return false;
			}
		}

		public Vector3 GetPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public bool Targetable(TargetQuery query)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (dead)
			{
				return false;
			}
			return query.CheckTargetable(((Component)this).transform.position);
		}

		public void Cleanup()
		{
			Pop();
		}

		public Transform GetCoinTargetPoint(Coin coin)
		{
			return ((Component)this).transform;
		}

		public bool CanBeCoinTargeted(Coin coin)
		{
			return !dead;
		}

		public void OnCoinReflect(Coin coin, RevolverBeam beam)
		{
		}

		public int GetCoinTargetPriority(Coin coin)
		{
			return 1;
		}

		public bool CanBeSharpshot(RevolverBeam beam, RaycastHit hit)
		{
			return !dead;
		}

		public Vector3 GetSharpshooterTargetPoint()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public void OnSharpshooterTargeted(RevolverBeam beam, RaycastHit hit)
		{
		}

		public int GetSharpshooterTargetPriority()
		{
			return 1;
		}

		public void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			BeamType beamType = beam.beamType;
			BeamType val = beamType;
			switch ((int)val)
			{
			case 1:
				ExciteBall(6);
				break;
			case 0:
				ExciteBall();
				break;
			case 2:
				ExciteBall(2);
				break;
			case 3:
				Pop();
				break;
			}
		}

		public bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			return !dead;
		}
	}
	public class EggSplosion : MonoBehaviour
	{
		public float explosionSize = 50f;

		public float eggSpeedModifier = 50f;

		public float sourceOffset = 1.45f;

		private List<EnemyIdentifier> targetedEnemies = new List<EnemyIdentifier>();

		private void Start()
		{
			//IL_0009: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			RaycastHit[] array = Physics.SphereCastAll(((Component)this).transform.position, explosionSize, ((Component)this).transform.position, float.PositiveInfinity);
			if (array.Length != 0)
			{
				RaycastHit[] array2 = array;
				EnemyIdentifierIdentifier val3 = default(EnemyIdentifierIdentifier);
				for (int i = 0; i < array2.Length; i++)
				{
					RaycastHit val = array2[i];
					EnemyIdentifier val2 = null;
					if (((Component)((RaycastHit)(ref val)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val3))
					{
						val2 = val3.eid;
					}
					if ((Object)(object)val2 == (Object)null)
					{
						((Component)((RaycastHit)(ref val)).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val2);
					}
					if ((Object)(object)val2 != (Object)null && !val2.dead && !targetedEnemies.Contains(val2))
					{
						targetedEnemies.Add(val2);
					}
				}
				List<Ray> list = new List<Ray>();
				foreach (EnemyIdentifier targetedEnemy in targetedEnemies)
				{
					Ray item = default(Ray);
					Vector3 position = ((Component)targetedEnemy).transform.position;
					position.y += 2f;
					Vector3 direction = position - ((Component)this).transform.position;
					Vector3 val4 = ((Component)this).transform.TransformPoint(((Vector3)(ref direction)).normalized * sourceOffset);
					direction = ((Component)targetedEnemy).transform.position - val4;
					((Ray)(ref item)).origin = val4;
					((Ray)(ref item)).direction = direction;
					list.Add(item);
				}
				foreach (Ray item2 in list)
				{
					Ray current2 = item2;
					ThrownEgg component = Object.Instantiate<GameObject>(EggToss.ThrownEggPrefab, ((Ray)(ref current2)).origin, Quaternion.identity).GetComponent<ThrownEgg>();
					((Component)component).transform.forward = ((Ray)(ref current2)).direction;
					((Component)component).gameObject.GetComponent<Rigidbody>().velocity = ((Ray)(ref current2)).direction * eggSpeedModifier;
					component.oldVelocity = ((Ray)(ref current2)).direction * eggSpeedModifier;
					component.isEggsplosionEgg = true;
					num++;
				}
			}
			UltraFunGuns.Log.Log($"Eggsplosion spawned eggs: {num}");
		}
	}
	[UFGWeapon("EggToss", "Egg", 1, true, WeaponIconColor.Yellow, true, true)]
	[WeaponAbility("Egg", "Press <color=orange>Fire 1</color> to throw an egg.", 0, RichTextColors.aqua)]
	[WeaponAbility("Egg Drop", "Press <color=orange>Fire 2</color> to drop an egg.", 1, RichTextColors.aqua)]
	[WeaponAbility("EGGSPLOSION", "Shoot an egg to release an <color=red>EGGSLPOSION</color>.", 2, RichTextColors.red)]
	public class EggToss : UltraFunGunBase
	{
		[Configgable("Weapons/Egg Toss/Egg Toss", null, 0, null)]
		private static float primaryFireCooldown = 0.6f;

		[Configgable("Weapons/Egg Toss/Egg Toss", null, 0, null)]
		private static float secondaryFireCooldown = 0.3f;

		private ActionCooldown throwEgg = new ActionCooldown(primaryFireCooldown, affectedByNoCooldownCheat: true);

		private ActionCooldown dropEgg = new ActionCooldown(secondaryFireCooldown, affectedByNoCooldownCheat: true);

		[Configgable("Weapons/Egg Toss/Egg Toss", null, 0, null)]
		private static float forceMultiplier = 59f;

		private bool throwingEgg = false;

		[UFGAsset("ThrownEgg")]
		public static GameObject ThrownEggPrefab { get; private set; }

		protected override void DoAnimations()
		{
			bool flag = throwEgg.CanFire() || dropEgg.CanFire();
			animator.SetBool("CanShoot", flag);
		}

		private IEnumerator DropEgg()
		{
			throwingEgg = true;
			animator.Play("EggTossDrop");
			yield return (object)new WaitForSeconds(0.15f);
			GameObject newThrownEgg = Object.Instantiate<GameObject>(ThrownEggPrefab, ((Component)player).transform.TransformPoint(0f, -1.5f, 0f), Quaternion.identity);
			newThrownEgg.transform.forward = mainCam.forward;
			newThrownEgg.GetComponent<ThrownEgg>().dropped = true;
			newThrownEgg.GetComponent<Rigidbody>().velocity = Vector3.down;
			throwingEgg = false;
		}

		private IEnumerator ThrowEgg()
		{
			throwingEgg = true;
			animator.Play("EggTossThrow");
			yield return (object)new WaitForSeconds(0.16f);
			GameObject newThrownEgg = Object.Instantiate<GameObject>(ThrownEggPrefab, firePoint.position, Quaternion.identity);
			newThrownEgg.transform.forward = mainCam.forward;
			Vector3 newVelocity2 = mainCam.TransformDirection(0f, 0f, 1f * forceMultiplier);
			newVelocity2 += player.rb.velocity;
			newThrownEgg.GetComponent<Rigidbody>().velocity = newVelocity2;
			throwingEgg = false;
		}

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && throwEgg.CanFire() && !throwingEgg)
			{
				throwEgg.AddCooldown();
				((MonoBehaviour)this).StartCoroutine(ThrowEgg());
			}
			else if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && dropEgg.CanFire() && !throwingEgg)
			{
				dropEgg.AddCooldown();
				((MonoBehaviour)this).StartCoroutine(DropEgg());
			}
		}

		private void OnDisable()
		{
			throwingEgg = false;
		}
	}
	public class ThrownEgg : MonoBehaviour, IUFGInteractionReceiver, ICoinTarget, IRevolverBeamShootable, ISharpshooterTarget
	{
		[UFGAsset("EggImpactFX")]
		private static GameObject impactFX;

		[UFGAsset("EggSplosion")]
		private static GameObject eggsplosionPrefab;

		[Configgable("Weapons/Egg Toss/Egg", null, 0, null)]
		private static float velocityDamageMultiplier = 0.035f;

		[Configgable("Weapons/Egg Toss/Egg/Eggsplosion", "Damage Multiplier", 0, null)]
		private static float eggsplosionEggDamageMultiplier = 0.75f;

		[Configgable("Weapons/Egg Toss/Egg/Eggsplosion", "Velocity Damage Multiplier", 0, null)]
		private static float eggsplosionEggDamageVelocityMultiplier = 0.25f;

		private Rigidbody rb;

		private CapsuleCollider eggCollider;

		public Vector3 oldVelocity;

		private float invicibleTimer = 0.015f;

		private bool canImpact = false;

		private bool impacted = false;

		public bool isEggsplosionEgg = false;

		public bool dropped = false;

		private void Awake()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
			eggCollider = ((Component)this).GetComponent<CapsuleCollider>();
			GameObject gameObject = ((Component)((Component)this).transform.Find("Sphere")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				gameObject.layer = 10;
				gameObject.tag = "Breakable";
			}
		}

		private void Start()
		{
			//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)
			float num = Random.Range(0, 360);
			((Component)this).transform.rotation = Quaternion.AngleAxis(num, ((Component)this).transform.forward);
		}

		private void FixedUpdate()
		{
			invicibleTimer -= Time.fixedDeltaTime;
			if (invicibleTimer < 0f)
			{
				canImpact = true;
			}
			if (!isEggsplosionEgg)
			{
			}
		}

		private void LateUpdate()
		{
			//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)
			oldVelocity = rb.velocity;
		}

		public void Explode()
		{
			//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)
			if (!isEggsplosionEgg && !impacted)
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(50, "hydraxous.ultrafunguns.eggsplosion", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
				MonoSingleton<TimeController>.Instance.ParryFlash();
				Object.Instantiate<GameObject>(eggsplosionPrefab, ((Component)this).transform.position, Quaternion.identity).GetComponent<EggSplosion>();
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void Collide(Collision col)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_004c: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (!impacted)
			{
				impacted = true;
				EnemyIdentifier val = null;
				GameObject obj = impactFX;
				ContactPoint contact = col.GetContact(0);
				GameObject val2 = Object.Instantiate<GameObject>(obj, ((ContactPoint)(ref contact)).point, Quaternion.identity);
				Transform transform = val2.transform;
				contact = col.GetContact(0);
				transform.up = ((ContactPoint)(ref contact)).normal;
				val2.transform.parent = col.transform;
				Vector3 velocity = rb.velocity;
				float num = ((Vector3)(ref velocity)).magnitude * velocityDamageMultiplier;
				EnemyIdentifierIdentifier val3 = default(EnemyIdentifierIdentifier);
				if (col.gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val3))
				{
					val = val3.eid;
				}
				if ((Object)(object)val != (Object)null)
				{
					if (!val.dead)
					{
						if (!isEggsplosionEgg)
						{
							EnemyIdentifier obj2 = val;
							GameObject gameObject = ((Component)val).gameObject;
							Vector3 val4 = oldVelocity;
							contact = col.GetContact(0);
							obj2.DeliverDamage(gameObject, val4, ((ContactPoint)(ref contact)).point, num, false, 0f, (GameObject)null, false, false);
							if (dropped)
							{
								MonoSingleton<StyleHUD>.Instance.AddPoints(110, "hydraxous.ultrafunguns.eggstrike", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
							}
							else
							{
								MonoSingleton<StyleHUD>.Instance.AddPoints(110, "hydraxous.ultrafunguns.egged", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
							}
						}
						else
						{
							EnemyIdentifier obj3 = val;
							GameObject gameObject2 = ((Component)val).gameObject;
							Vector3 val5 = oldVelocity * eggsplosionEggDamageVelocityMultiplier;
							contact = col.GetContact(0);
							obj3.DeliverDamage(gameObject2, val5, ((ContactPoint)(ref contact)).point, num * eggsplosionEggDamageMultiplier, false, 0f, (GameObject)null, false, false);
							MonoSingleton<StyleHUD>.Instance.AddPoints(10, "hydraxous.ultrafunguns.egged", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
						}
					}
					else
					{
						Physics.IgnoreCollision((Collider)(object)eggCollider, col.collider, true);
						impacted = false;
					}
				}
			}
			if (impacted)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void Collide(Collider col)
		{
			//IL_0026: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0078: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			if (!impacted)
			{
				impacted = true;
				EnemyIdentifier val = null;
				GameObject val2 = Object.Instantiate<GameObject>(impactFX, ((Component)this).transform.position, Quaternion.identity);
				((Component)val2.transform.Find("impactSpotQuad")).gameObject.SetActive(false);
				Vector3 up = ((Component)MonoSingleton<NewMovement>.Instance).transform.position - ((Component)this).transform.position;
				val2.transform.up = up;
				val2.transform.parent = ((Component)col).transform;
				Vector3 velocity = rb.velocity;
				float num = ((Vector3)(ref velocity)).magnitude * velocityDamageMultiplier;
				EnemyIdentifierIdentifier val3 = default(EnemyIdentifierIdentifier);
				if (((Component)col).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val3))
				{
					val = val3.eid;
				}
				else
				{
					((Component)col).gameObject.TryGetComponent<EnemyIdentifier>(ref val);
				}
				if ((Object)(object)val != (Object)null)
				{
					if (!val.dead)
					{
						if (!isEggsplosionEgg)
						{
							val.DeliverDamage(((Component)val).gameObject, oldVelocity, ((Component)this).transform.position, num, false, 0f, (GameObject)null, false, false);
							if (dropped)
							{
								MonoSingleton<StyleHUD>.Instance.AddPoints(110, "hydraxous.ultrafunguns.eggstrike", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
							}
							else
							{
								MonoSingleton<StyleHUD>.Instance.AddPoints(110, "hydraxous.ultrafunguns.egged", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
							}
						}
						else
						{
							val.DeliverDamage(((Component)val).gameObject, oldVelocity * eggsplosionEggDamageVelocityMultiplier, ((Component)this).transform.position, num * eggsplosionEggDamageMultiplier, false, 0f, (GameObject)null, false, false);
							MonoSingleton<StyleHUD>.Instance.AddPoints(10, "hydraxous.ultrafunguns.egged", (GameObject)null, (EnemyIdentifier)null, -1, "", "");
						}
					}
					else
					{
						Physics.IgnoreCollision((Collider)(object)eggCollider, col, true);
						impacted = false;
					}
				}
			}
			if (impacted)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnCollisionEnter(Collision col)
		{
			ThrownEgg thrownEgg = default(ThrownEgg);
			if (col.gameObject.TryGetComponent<ThrownEgg>(ref thrownEgg))
			{
				Physics.IgnoreCollision((Collider)(object)eggCollider, col.collider, true);
			}
			else if (canImpact || isEggsplosionEgg)
			{
				Collide(col);
			}
		}

		private void OnTriggerEnter(Collider col)
		{
			if ((canImpact || isEggsplosionEgg) && ((Component)col).gameObject.layer != 20 && (((Component)col).gameObject.layer == 10 || ((Component)col).gameObject.layer == 11) && !col.isTrigger)
			{
				Collide(col);
			}
		}

		public bool Interact(UFGInteractionEventData interaction)
		{
			if (interaction.ContainsTag("shot"))
			{
				Explode();
				return true;
			}
			return false;
		}

		public Vector3 GetPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public bool Targetable(TargetQuery targetQuery)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return targetQuery.CheckTargetable(((Component)this).transform.position);
		}

		public Transform GetCoinTargetPoint(Coin coin)
		{
			return ((Component)this).transform;
		}

		public bool CanBeCoinTargeted(Coin coin)
		{
			return !isEggsplosionEgg;
		}

		public void OnCoinReflect(Coin coin, RevolverBeam beam)
		{
			Explode();
		}

		public int GetCoinTargetPriority(Coin coin)
		{
			return 2;
		}

		public void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			Explode();
		}

		public bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			return !isEggsplosionEgg;
		}

		public bool CanBeSharpshot(RevolverBeam beam, RaycastHit hit)
		{
			return !isEggsplosionEgg;
		}

		public Vector3 GetSharpshooterTargetPoint()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public void OnSharpshooterTargeted(RevolverBeam beam, RaycastHit hit)
		{
		}

		public int GetSharpshooterTargetPriority()
		{
			return 1;
		}
	}
	[WeaponAbility("Finger Blast", "Press <color=orange>Fire 1</color> to shoot an explosive bolt from your finger that can penetrate enemies.", 0, RichTextColors.aqua)]
	[WeaponAbility("Air-Denial", "Weapon can destroy projectiles.", 1, RichTextColors.yellow)]
	[UFGWeapon("FingerGun", "Hand Gun", 0, true, WeaponIconColor.Red, true, true)]
	public class FingerGun : UltraFunGunBase
	{
		[UFGAsset("BulletPierceTrail")]
		private static GameObject bulletTrailPrefab;

		[UFGAsset("FingerGun_ImpactExplosion")]
		private static GameObject hitExplodeFX;

		private int currentAmmo = 8;

		[Configgable("Weapons/Handgun", null, 0, null)]
		public static int maxAmmo = 8;

		[Configgable("Weapons/Handgun", null, 0, null)]
		public static int penetrations = 4;

		[Configgable("Weapons/Handgun", null, 0, null)]
		public static float forceMultiplier = 5f;

		[Configgable("Weapons/Handgun", null, 0, null)]
		public static float damageMultipler = 2.2f;

		[Configgable("Weapons/Handgun", null, 0, null)]
		public static float explosionRadius = 2.5f;

		[Configgable("Weapons/Handgun", null, 0, null)]
		public static float explosionDamageMultiplier = 0.5f;

		private bool reloading = false;

		private bool shooting = false;

		[Configgable("Weapons/Handgun", null, 0, null)]
		public static float hitRayWidth = 0.5f;

		[Configgable("Weapons/Handgun", null, 0, null)]
		private static float maxRange = 350f;

		private Text ammoCounter;

		public int CurrentAmmo
		{
			get
			{
				return currentAmmo;
			}
			set
			{
				currentAmmo = value;
				if ((Object)(object)ammoCounter != (Object)null)
				{
					ammoCounter.text = currentAmmo.ToString();
				}
			}
		}

		public override void OnAwakeFinished()
		{
			AddSFX("BangSound", "GunReady", "Reload", "Kabooma");
			ammoCounter = ((Component)((Component)this).transform).GetComponentInChildren<Text>();
		}

		public override void GetInput()
		{
			if (CurrentAmmo < 1 && !reloading && !shooting)
			{
				((MonoBehaviour)this).StartCoroutine(Reload());
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && !om.paused && !reloading && !shooting && (CurrentAmmo > 0 || NoWeaponCooldown.NoCooldown))
			{
				((MonoBehaviour)this).StartCoroutine(Shoot());
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && !om.paused && !reloading && !shooting && CurrentAmmo < maxAmmo)
			{
				((MonoBehaviour)this).StartCoroutine(Reload());
			}
		}

		private IEnumerator Shoot()
		{
			shooting = true;
			animator.Play("Shoot", 0, 0f);
			PlaySFX("BangSound", 0.85f);
			if (!NoWeaponCooldown.NoCooldown)
			{
				int num = CurrentAmmo - 1;
				CurrentAmmo = num;
			}
			Ray direction = default(Ray);
			((Ray)(ref direction)).origin = ((Component)mainCam).transform.position;
			((Ray)(ref direction)).direction = mainCam.TransformDirection(0f, 0f, 1f);
			bool penetration = true;
			List<EnemyIdentifier> hitEnemies2 = new List<EnemyIdentifier>();
			RaycastHit[] hits = Physics.SphereCastAll(direction, hitRayWidth, maxRange, LayerMask.GetMask(new string[6] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default", "Projectile" }));
			hits = HydraUtils.SortRaycastHitsByDistance(hits);
			if (hits.Length != 0)
			{
				if (hits.Length != 1 || !(((Object)((Component)((RaycastHit)(ref hits[0])).collider).gameObject).name == "CameraCollisionChecker"))
				{
					int endingHit = 0;
					hits = HydraUtils.SortRaycastHitsByDistance(hits);
					EnemyIdentifierIdentifier enemyIDID = default(EnemyIdentifierIdentifier);
					EnemyIdentifier enemyID = default(EnemyIdentifier);
					Breakable breakable = default(Breakable);
					IUFGInteractionReceiver ufgInteractable = default(IUFGInteractionReceiver);
					ThrownDodgeball dodgeBall = default(ThrownDodgeball);
					Grenade grenade = default(Grenade);
					Projectile projectile = default(Projectile);
					for (int i = 0; i < hits.Length; i++)
					{
						Ray hitRay = default(Ray);
						((Ray)(ref hitRay)).origin = ((Component)mainCam).transform.position;
						((Ray)(ref hitRay)).direction = ((RaycastHit)(ref hits[i])).point - ((Component)mainCam).transform.position;
						if (hitEnemies2.Count > penetrations)
						{
							penetration = false;
						}
						endingHit = i;
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 8)
						{
							break;
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref enemyIDID))
						{
							if (!hitEnemies2.Contains(enemyIDID.eid))
							{
								hitEnemies2.Add(enemyIDID.eid);
								enemyIDID.eid.DeliverDamage(((Component)((RaycastHit)(ref hits[i])).collider).gameObject, ((Ray)(ref hitRay)).direction * forceMultiplier, ((RaycastHit)(ref hits[i])).point, damageMultipler, true, 0f, ((Component)this).gameObject, false, false);
								GoBoom(hits[i]);
							}
							if (!penetration)
							{
								break;
							}
						}
						else
						{
							if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref enemyID))
							{
								if (!hitEnemies2.Contains(enemyID))
								{
									hitEnemies2.Add(enemyID);
									enemyID.DeliverDamage(((Component)((RaycastHit)(ref hits[i])).collider).gameObject, ((Ray)(ref hitRay)).direction * forceMultiplier, ((RaycastHit)(ref hits[i])).point, damageMultipler, true, 0f, ((Component)this).gameObject, false, false);
									GoBoom(hits[i]);
								}
								if (!penetration)
								{
									break;
								}
							}
							enemyID = null;
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<Breakable>(ref breakable))
						{
							breakable.Break();
							if (!penetration)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<IUFGInteractionReceiver>(ref ufgInteractable))
						{
							ufgInteractable.Interact(new UFGInteractionEventData
							{
								tags = new string[3] { "explode", "shot", "heavy" },
								direction = ((Ray)(ref hitRay)).direction,
								interactorPosition = ((Ray)(ref hitRay)).origin,
								power = 2f,
								invokeType = ((object)this).GetType()
							});
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<ThrownDodgeball>(ref dodgeBall))
						{
							dodgeBall.ExciteBall();
							if (!penetration)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<Grenade>(ref grenade))
						{
							MonoSingleton<TimeController>.Instance.ParryFlash();
							grenade.Explode(false, false, false, 1f, false, (GameObject)null, false);
							if (!penetration)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<Projectile>(ref projectile))
						{
							projectile.Explode();
							if (!projectile.friendly)
							{
								MonoSingleton<TimeController>.Instance.ParryFlash();
								MonoSingleton<StyleHUD>.Instance.AddPoints(10, "hydraxous.ultrafunguns.fingergunprojhit", ((Component)this).gameObject, (EnemyIdentifier)null, -1, "", "");
							}
							if (!penetration)
							{
								break;
							}
						}
						hitRay = default(Ray);
						enemyIDID = null;
						breakable = null;
						ufgInteractable = null;
						dodgeBall = null;
						grenade = null;
						projectile = null;
					}
					CreateBulletTrail(firePoint.position, ((RaycastHit)(ref hits[endingHit])).point, ((RaycastHit)(ref hits[endingHit])).normal, ((Component)((RaycastHit)(ref hits[endingHit])).collider).transform);
				}
				else
				{
					Ray missray2 = default(Ray);
					((Ray)(ref missray2)).origin = ((Component)mainCam).transform.position;
					((Ray)(ref missray2)).direction = mainCam.TransformDirection(0f, 0f, 1f);
					CreateBulletTrail(endPosition: ((Ray)(ref missray2)).GetPoint(maxRange), startPosition: firePoint.position, normal: ((Ray)(ref missray2)).direction * -1f, parent: null);
					missray2 = default(Ray);
				}
			}
			else
			{
				Ray missray = default(Ray);
				((Ray)(ref missray)).origin = ((Component)mainCam).transform.position;
				((Ray)(ref missray)).direction = mainCam.TransformDirection(0f, 0f, 1f);
				CreateBulletTrail(endPosition: ((Ray)(ref missray)).GetPoint(maxRange), startPosition: firePoint.position, normal: ((Ray)(ref missray)).direction * -1f, parent: null);
				missray = default(Ray);
			}
			List<EnemyIdentifier> hitListCopy = new List<EnemyIdentifier>();
			foreach (EnemyIdentifier enemee in hitEnemies2)
			{
				if (!enemee.dead && !enemee.exploded)
				{
					hitListCopy.Add(enemee);
				}
			}
			hitEnemies2 = hitListCopy;
			if (hitEnemies2.Count > penetrations)
			{
				PlaySFX("Kabooma");
				MonoSingleton<TimeController>.Instance.HitStop(0.1f);
				MonoSingleton<StyleHUD>.Instance.AddPoints(250, "hydraxous.ultrafunguns.fingergunfullpenetrate", ((Component)this).gameObject, (EnemyIdentifier)null, -1, "", "");
			}
			else if (hitEnemies2.Count > 0)
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(10 * hitEnemies2.Count, "hydraxous.ultrafunguns.fingergunhit", ((Component)this).gameObject, (EnemyIdentifier)null, hitEnemies2.Count, "", "");
			}
			yield return (object)new WaitForSeconds(0.36f);
			PlaySFX("GunReady", 0.95f);
			shooting = false;
		}

		private IEnumerator Reload()
		{
			reloading = true;
			animator.Play("Reload");
			yield return (object)new WaitForSeconds(0.4f);
			PlaySFX("Reload", 0.85f);
			CurrentAmmo = maxAmmo;
			yield return (object)new WaitForSeconds(0.66f);
			reloading = false;
		}

		protected override void DoAnimations()
		{
		}

		private void CreateBulletTrail(Vector3 startPosition, Vector3 endPosition, Vector3 normal, Transform parent)
		{
			//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_000f: 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_0021: 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_003f: 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)
			GoBoom(endPosition, normal);
			GameObject val = Object.Instantiate<GameObject>(bulletTrailPrefab, endPosition, Quaternion.identity);
			val.transform.up = normal;
			LineRenderer component = val.GetComponent<LineRenderer>();
			Vector3[] positions = (Vector3[])(object)new Vector3[2] { startPosition, endPosition };
			component.SetPositions(positions);
			val.transform.parent = parent;
		}

		private void GoBoom(RaycastHit hit)
		{
			//IL_0004: 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)
			GoBoom(((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal);
		}

		private void GoBoom(Vector3 position, Vector3 normal)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(hitExplodeFX, position, Quaternion.identity);
			val.transform.up = normal;
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			RaycastHit[] array = Physics.SphereCastAll(position, explosionRadius, normal, explosionRadius / 2f, LayerMask.GetMask(new string[6] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default", "Projectile" }));
			if (array.Length == 0 || (array.Length == 1 && ((Object)((Component)((RaycastHit)(ref array[0])).collider).gameObject).name == "CameraCollisionChecker"))
			{
				return;
			}
			array = HydraUtils.SortRaycastHitsByDistance(array);
			EnemyIdentifierIdentifier val2 = default(EnemyIdentifierIdentifier);
			EnemyIdentifier val3 = default(EnemyIdentifier);
			Breakable val4 = default(Breakable);
			ThrownEgg thrownEgg = default(ThrownEgg);
			IUFGInteractionReceiver iUFGInteractionReceiver = default(IUFGInteractionReceiver);
			Grenade val5 = default(Grenade);
			for (int i = 0; i < array.Length; i++)
			{
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val2))
				{
					if (!list.Contains(val2.eid) && !val2.eid.dead)
					{
						list.Add(val2.eid);
						val2.eid.DeliverDamage(((Component)((RaycastHit)(ref array[i])).collider).gameObject, ((RaycastHit)(ref array[i])).normal * -1f, ((RaycastHit)(ref array[i])).point, explosionDamageMultiplier, true, 0f, ((Component)this).gameObject, false, false);
					}
				}
				else if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val3) && !list.Contains(val3) && !val3.dead)
				{
					list.Add(val3);
					val3.DeliverDamage(((Component)((RaycastHit)(ref array[i])).collider).gameObject, ((RaycastHit)(ref array[i])).normal * -1f, ((RaycastHit)(ref array[i])).point, explosionDamageMultiplier, true, 0f, ((Component)this).gameObject, false, false);
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<Breakable>(ref val4))
				{
					val4.Break();
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<ThrownEgg>(ref thrownEgg))
				{
					thrownEgg.Explode();
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<IUFGInteractionReceiver>(ref iUFGInteractionReceiver))
				{
					iUFGInteractionReceiver.Interact(new UFGInteractionEventData
					{
						tags = new string[1] { "explode" },
						direction = iUFGInteractionReceiver.GetPosition() - position,
						interactorPosition = position,
						power = 2f,
						invokeType = ((object)this).GetType()
					});
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<Grenade>(ref val5))
				{
					MonoSingleton<TimeController>.Instance.ParryFlash();
					val5.Explode(false, false, false, 1f, false, (GameObject)null, false);
				}
			}
		}

		private void OnEnable()
		{
		}

		private void OnDisable()
		{
			shooting = false;
			reloading = false;
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			return debuggingText + $"AMMO: {CurrentAmmo}\n";
		}
	}
	[UFGWeapon("FocalyzerAlternate", "Focalyzer V2", 2, true, WeaponIconColor.Blue, true, true)]
	[WeaponAbility("Cutter", "Hold <color=orange>Fire 1</color> to fire <color=aqua>Cutter</color> beam.", 0, RichTextColors.aqua)]
	[WeaponAbility("Deploy Pylon", "Press <color=orange>Fire 2</color> to deploy a laser pylon.", 1, RichTextColors.aqua)]
	[WeaponAbility("Command", "Pylons will fire at your command.", 2, RichTextColors.yellow)]
	public class FocalyzerAlternate : UltraFunGunBase
	{
		public FocalyzerLaserControllerAlternate laser;

		public FocalyzerTubeControllerAlternate tubeController;

		public Transform aimSpot;

		private StyleHUD style;

		public int maxStoredPylons = 3;

		public int pylonsRemaining = 3;

		public float pylonRechargeTime = 6f;

		public float pylonRechargeTimeRemaining = 0f;

		private bool throwingPylon = false;

		public bool laserActive = false;

		public float laserWidth = 0.3f;

		public float laserMaxRange = 2000f;

		private LayerMask laserHitMask;

		private ActionCooldown fireCooldown = new ActionCooldown(0.16f, affectedByNoCooldownCheat: true);

		private ActionCooldown damageTick = new ActionCooldown(0.2f);

		private ActionCooldown throwPylonCooldown = new ActionCooldown(0.25f, affectedByNoCooldownCheat: true);

		[UFGAsset("FocalyzerPylonAlternate")]
		public static GameObject pylonPrefab { get; private set; }

		[UFGAsset("FocalyzerLaserAlternate")]
		public static GameObject laserPrefab { get; private set; }

		public override void OnAwakeFinished()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			style = MonoSingleton<StyleHUD>.Instance;
			tubeController = ((Component)((Component)this).transform.Find("viewModelWrapper/FocalyzerGunModel/Tubes")).gameObject.AddComponent<FocalyzerTubeControllerAlternate>();
			aimSpot = Object.Instantiate<GameObject>(new GameObject(), Vector3.zero, Quaternion.identity).transform;
			((Object)aimSpot).name = "PylonTarget";
		}

		private void Start()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			laserHitMask = LayerMask.op_Implicit(LayerMask.GetMask(new string[7] { "Projectile", "Limb", "BigCorpse", "Environment", "Outdoors", "Armor", "Default" }));
			laser = Object.Instantiate<GameObject>(laserPrefab, Vector3.zero, Quaternion.identity).GetComponent<FocalyzerLaserControllerAlternate>();
			laser.focalyzer = this;
		}

		public override void GetInput()
		{
			//IL_008a: 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_00ba: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && !throwingPylon && fireCooldown.CanFire() && !om.paused)
			{
				laserActive = true;
				FireLaser();
				MonoSingleton<CameraController>.Instance.CameraShake(0.05f);
			}
			else if (laserActive)
			{
				laserActive = false;
				fireCooldown.AddCooldown();
			}
			else
			{
				Ray val = default(Ray);
				((Ray)(ref val)).origin = firePoint.position;
				((Ray)(ref val)).direction = mainCam.TransformDirection(0f, 0f, 1f);
				Vector3 point = ((Ray)(ref val)).GetPoint(laserMaxRange);
				Vector3 normal = ((Component)mainCam).transform.position - point;
				DrawLaser(firePoint.position, point, normal);
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && throwPylonCooldown.CanFire() && !om.paused && !throwingPylon && (pylonsRemaining > 0 || NoWeaponCooldown.NoCooldown))
			{
				((MonoBehaviour)this).StartCoroutine(ThrowPylon());
			}
			CheckPylonRecharge();
		}

		protected override void DoAnimations()
		{
			if ((Object)(object)laser != (Object)null)
			{
				laser.laserActive = laserActive;
			}
			if ((Object)(object)tubeController != (Object)null)
			{
				tubeController.crystalsRemaining = pylonsRemaining;
			}
			animator.SetBool("LaserActive", laserActive);
		}

		public void FireLaser()
		{
			//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_0027: 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_003a: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0543: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_054c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: 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)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = mainCam.TransformDirection(0f, 0f, 1f);
			List<RaycastHit> list = (from x in Physics.SphereCastAll(((Component)mainCam).transform.position, laserWidth, val, laserMaxRange, LayerMask.op_Implicit(laserHitMask))
				orderby ((RaycastHit)(ref x)).distance
				select x).ToList();
			RaycastHit val2;
			for (int i = 0; i < list.Count; i++)
			{
				val2 = list[i];
				if (!(((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name == "CameraCollisionChecker"))
				{
					val2 = list[i];
					if (!(((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name == "Projectile Parry Zone"))
					{
						continue;
					}
				}
				list.RemoveAt(i);
				i--;
			}
			if (list.Count <= 0)
			{
				Ray val3 = default(Ray);
				((Ray)(ref val3)).origin = firePoint.position;
				((Ray)(ref val3)).direction = mainCam.TransformDirection(0f, 0f, 1f);
				Vector3 point = ((Ray)(ref val3)).GetPoint(laserMaxRange);
				Vector3 normal = ((Component)mainCam).transform.position - point;
				DrawLaser(firePoint.position, point, normal);
				return;
			}
			bool flag = false;
			int index = 0;
			EnemyIdentifierIdentifier val4 = default(EnemyIdentifierIdentifier);
			EnemyIdentifier val5 = default(EnemyIdentifier);
			IUFGInteractionReceiver iUFGInteractionReceiver = default(IUFGInteractionReceiver);
			Breakable val6 = default(Breakable);
			Coin val7 = default(Coin);
			Grenade val9 = default(Grenade);
			FocalyzerPylon focalyzerPylon = default(FocalyzerPylon);
			for (int j = 0; j < list.Count; j++)
			{
				index = j;
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 24)
				{
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 25)
				{
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 8)
				{
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val4))
				{
					if (damageTick.CanFire())
					{
						damageTick.AddCooldown();
						EnemyIdentifier eid = val4.eid;
						val2 = list[j];
						GameObject gameObject = ((Component)((RaycastHit)(ref val2)).collider).gameObject;
						val2 = list[j];
						eid.DeliverDamage(gameObject, val, ((RaycastHit)(ref val2)).point, 0.75f, false, 0f, (GameObject)null, false, false);
					}
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val5))
				{
					if (damageTick.CanFire())
					{
						damageTick.AddCooldown();
						EnemyIdentifier obj = val5;
						val2 = list[j];
						GameObject gameObject2 = ((Component)((RaycastHit)(ref val2)).collider).gameObject;
						val2 = list[j];
						obj.DeliverDamage(gameObject2, val, ((RaycastHit)(ref val2)).point, 0.75f, false, 0f, (GameObject)null, false, false);
					}
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<IUFGInteractionReceiver>(ref iUFGInteractionReceiver))
				{
					iUFGInteractionReceiver.Interact(new UFGInteractionEventData
					{
						invokeType = ((object)this).GetType(),
						direction = val,
						interactorPosition = ((Component)mainCam).transform.position,
						power = 1f,
						tags = new string[2] { "shot", "laser" }
					});
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<Breakable>(ref val6))
				{
					val6.Break();
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).TryGetComponent<Coin>(ref val7) && EnemyTools.TryGetHomingTarget(((Component)val7).transform.position, out var _, out var enemyComponent) && (Object)(object)enemyComponent != (Object)null && !enemyComponent.dead && damageTick.CanFire())
				{
					damageTick.AddCooldown();
					Vector3 val8 = ((Component)enemyComponent).transform.position - ((Component)val7).transform.position;
					enemyComponent.DeliverDamage(((Component)enemyComponent).gameObject, val8, ((Component)enemyComponent).transform.position, 1.5f, false, 0f, (GameObject)null, false, false);
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<Grenade>(ref val9))
				{
					MonoSingleton<TimeController>.Instance.ParryFlash();
					val9.Explode(false, false, false, 1f, false, (GameObject)null, false);
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<FocalyzerPylon>(ref focalyzerPylon))
				{
					focalyzerPylon.DoRefraction(focalyzerPylon, playerLaser: true);
					flag = true;
					break;
				}
			}
			Vector3 position = firePoint.position;
			val2 = list[index];
			Vector3 point2 = ((RaycastHit)(ref val2)).point;
			val2 = list[index];
			DrawLaser(position, point2, ((RaycastHit)(ref val2)).normal);
		}

		private void DrawLaser(Vector3 origin, Vector3 endPoint, Vector3 normal)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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)
			if (laserActive)
			{
				aimSpot.position = endPoint;
			}
			laser.AddLinePosition(origin);
			laser.AddLinePosition(endPoint);
			laser.BuildLine(normal);
		}

		private void CheckPylonRecharge()
		{
			if (pylonRechargeTimeRemaining - (float)style.rankIndex < Time.time)
			{
				pylonRechargeTimeRemaining = Time.time + pylonRechargeTime;
				pylonsRemaining = Mathf.Clamp(pylonsRemaining + 1, 0, maxStoredPylons);
			}
		}

		private IEnumerator ThrowPylon()
		{
			throwingPylon = true;
			throwPylonCooldown.AddCooldown();
			animator.Play("Focalyzer_ThrowPylon", 0, 0f);
			yield return (object)new WaitForSeconds(0.3f);
			GameObject newPylon = Object.Instantiate<GameObject>(pylonPrefab, firePoint.position, Quaternion.identity);
			GameObject pylonFX = Object.Instantiate<GameObject>(Prefabs.CanLauncher_MuzzleFX, firePoint);
			pylonFX.transform.position = firePoint.position;
			pylonFX.transform.forward = firePoint.forward;
			pylonFX.AddComponent<DestroyOnDisable>();
			pylonRechargeTimeRemaining = Time.time + pylonRechargeTime;
			pylonsRemaining = Mathf.Clamp(pylonsRemaining - 1, 0, maxStoredPylons);
			MonoSingleton<CameraController>.Instance.CameraShake(0.2f);
			FocalyzerPylonAlternate pylon = newPylon.GetComponent<FocalyzerPylonAlternate>();
			pylon.laserHitMask = laserHitMask;
			pylon.focalyzer = this;
			pylon.targetPoint = aimSpot;
			newPylon.GetComponent<Rigidbody>().velocity = mainCam.TransformDirection(0f, 0f, 1f) * 40f;
			throwingPylon = false;
		}

		private void OnDisable()
		{
			laserActive = false;
			DoAnimations();
			throwingPylon = false;
		}

		private void OnEnable()
		{
			animator.Play("Focalyzer_Equip");
		}

		public void OnPylonDeath()
		{
			pylonsRemaining = Mathf.Clamp(pylonsRemaining + 1, 0, maxStoredPylons);
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"LASER: {laserActive}\n";
			return debuggingText + $"PYLONS_LEFT: {pylonsRemaining}";
		}
	}
	public class FocalyzerLaserControllerAlternate : MonoBehaviour
	{
		private List<FocalyzerPylonAlternate> pylonList = new List<FocalyzerPylonAlternate>();

		private List<Vector3> laserPoints = new List<Vector3>();

		public FocalyzerAlternate focalyzer;

		public LineRenderer lineRenderer;

		public Animator animator;

		public bool laserActive = false;

		private void Start()
		{
			lineRenderer = ((Component)this).GetComponent<LineRenderer>();
			animator = ((Component)this).GetComponent<Animator>();
		}

		private void Update()
		{
			animator.SetBool("Active", laserActive);
			if ((Object)(object)focalyzer == (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public void AddPylon(FocalyzerPylonAlternate pylon)
		{
			if (!pylonList.Contains(pylon))
			{
				pylonList.Add(pylon);
			}
		}

		public void RemovePylon(FocalyzerPylonAlternate pylon)
		{
			if (pylonList.Contains(pylon))
			{
				pylonList.Remove(pylon);
			}
		}

		public int GetPylonCount()
		{
			return pylonList.Count;
		}

		public void AddLinePosition(Vector3 position)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			laserPoints.Add(position);
		}

		public void BuildLine(Vector3 normal)
		{
			//IL_0031: 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)
			lineRenderer.SetPositions(laserPoints.ToArray());
			((Component)this).transform.position = laserPoints[laserPoints.Count - 1];
			((Component)this).transform.up = normal;
			laserPoints.Clear();
		}

		private bool LineOfSightCheck(FocalyzerPylonAlternate pylon1, FocalyzerPylonAlternate pylon2)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_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)
			Vector3 val = ((Component)pylon2).transform.position - ((Component)pylon1).transform.position;
			RaycastHit[] hits = Physics.RaycastAll(((Component)pylon1).transform.position, val, ((Vector3)(ref val)).magnitude);
			hits = HydraUtils.SortRaycastHitsByDistance(hits);
			RaycastHit[] array = hits;
			FocalyzerPylonAlternate focalyzerPylonAlternate = default(FocalyzerPylonAlternate);
			for (int i = 0; i < array.Length; i++)
			{
				RaycastHit val2 = array[i];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 8 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 0)
				{
					return false;
				}
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<FocalyzerPylonAlternate>(ref focalyzerPylonAlternate))
				{
					return true;
				}
			}
			return false;
		}
	}
	public class FocalyzerPylonAlternate : MonoBehaviour, ICleanable
	{
		private enum LaserHitType
		{
			enemy,
			nothing,
			solid,
			interactable
		}

		public Animator laserAnimator;

		public FocalyzerAlternate focalyzer;

		public LineRenderer refractedLaser;

		public Transform targetPoint;

		public Transform laserOriginPoint;

		private UltraFunGunBase.ActionCooldown damageCooldown = new UltraFunGunBase.ActionCooldown(0.25f);

		private UltraFunGunBase.ActionCooldown pylonChecker = new UltraFunGunBase.ActionCooldown(0.25f);

		private UltraFunGunBase.ActionCooldown sphereDamageCooldown = new UltraFunGunBase.ActionCooldown(0.05f);

		public LayerMask laserHitMask;

		public int refractionCount = 0;

		public float laserBeamWidth = 0.1f;

		private float lifeTime = 12f;

		private float lifeTimeLeft = 0f;

		private bool dying = false;

		[UFGAsset("FocalyzerPylonShatterFX_Blue")]
		public static GameObject PylonShatterFX { get; private set; }

		private void Start()
		{
			lifeTimeLeft = lifeTime + Time.time;
			refractedLaser = ((Component)this).GetComponentInChildren<LineRenderer>();
			laserAnimator = ((Component)refractedLaser).GetComponent<Animator>();
			laserOriginPoint = ((Component)this).transform.Find("FocalyzerPylonRemake/RefractorVisual");
			((Component)laserOriginPoint).gameObject.AddComponent<AlwaysLookAtCamera>().speed = 0f;
		}

		private void Update()
		{
			laserAnimator.SetBool("Active", true);
			if (lifeTimeLeft < Time.time || (Object)(object)focalyzer == (Object)null)
			{
				Shatter();
			}
			FireLaser();
		}

		private LaserHitType LaserHit(RaycastHit hit, Vector3 castDirection, float damageMultiplier, float critMultiplier = 0f, bool tryExplode = false)
		{
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			LaserHitType result = LaserHitType.nothing;
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 8 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 0)
			{
				return LaserHitType.solid;
			}
			Breakable val = default(Breakable);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<Breakable>(ref val))
			{
				val.Break();
			}
			ThrownEgg thrownEgg = default(ThrownEgg);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<ThrownEgg>(ref thrownEgg))
			{
				thrownEgg.Explode();
				result = LaserHitType.interactable;
			}
			Grenade val2 = default(Grenade);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<Grenade>(ref val2))
			{
				val2.Explode(false, false, false, 1f, false, (GameObject)null, false);
				result = LaserHitType.interactable;
			}
			EnemyIdentifierIdentifier val3 = default(EnemyIdentifierIdentifier);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val3) && damageCooldown.CanFire() && !val3.eid.dead)
			{
				damageCooldown.AddCooldown();
				val3.eid.DeliverDamage(((Component)val3.eid).gameObject, castDirection, ((RaycastHit)(ref hit)).point, damageMultiplier, tryExplode, critMultiplier, (GameObject)null, false, false);
				result = LaserHitType.enemy;
			}
			return result;
		}

		public void FireLaser()
		{
			//IL_0012: 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_0027: 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_0039: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_00b4: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			int num3 = -1;
			Vector3 val = ((Component)targetPoint).transform.position - ((Component)this).transform.position;
			RaycastHit[] hits = Physics.SphereCastAll(((Component)this).transform.position, laserBeamWidth, val, focalyzer.laserMaxRange, LayerMask.op_Implicit(laserHitMask));
			hits = HydraUtils.SortRaycastHitsByDistance(hits);
			RaycastHit[] array = hits;
			foreach (RaycastHit hit in array)
			{
				num3++;
				if (LaserHit(hit, val, 0.3f) != LaserHitType.nothing)
				{
					break;
				}
			}
			((Component)this).transform.forward = ((Vector3)(ref val)).normalized;
			Vector3[] array2 = (Vector3[])(object)new Vector3[2]
			{
				laserOriginPoint.position,
				Vector3.zero
			};
			Vector3 normal;
			if (num3 > -1 && ((Object)((RaycastHit)(ref hits[num3])).collider).name != ((Object)((Component)this).gameObject).name)
			{
				array2[1] = ((RaycastHit)(ref hits[num3])).point;
				normal = ((RaycastHit)(ref hits[num3])).normal;
			}
			else
			{
				Ray val2 = default(Ray);
				((Ray)(ref val2)).origin = laserOriginPoint.position;
				((Ray)(ref val2)).direction = val;
				array2[1] = ((Ray)(ref val2)).GetPoint(focalyzer.laserMaxRange);
				normal = val * -1f;
			}
			BuildLaser(array2, normal);
			if (num <= 0 && num2 <= 0)
			{
			}
		}

		private void BuildLaser(Vector3[] laser, Vector3 normal)
		{
			//IL_0020: 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)
			refractedLaser.SetPositions(laser);
			((Component)refractedLaser).gameObject.transform.position = laser[1];
			((Component)refractedLaser).gameObject.transform.up = normal;
		}

		private void Shatter()
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!dying)
			{
				dying = true;
				Object.Instantiate<GameObject>(PylonShatterFX, ((Component)this).transform.position, Quaternion.identity);
				Prefabs.BonusBreakSound.Asset.PlayAudioClip(((Component)this).transform.position, 1.2f, 1f, 0.6f);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)focalyzer != (Object)null)
			{
				focalyzer.OnPylonDeath();
			}
		}

		public void Cleanup()
		{
			Shatter();
		}
	}
	public class FocalyzerTubeControllerAlternate : MonoBehaviour
	{
		private Animator[] crystals = (Animator[])(object)new Animator[3];

		public int crystalsRemaining = 3;

		private int lastCrystalsLeft;

		private bool initialized = false;

		private void Awake()
		{
			for (int i = 0; i < 3; i++)
			{
				crystals[i] = ((Component)((Component)this).transform.Find($"Crystal{i}")).GetComponent<Animator>();
			}
			initialized = true;
		}

		private void Update()
		{
			if (crystalsRemaining != lastCrystalsLeft)
			{
				lastCrystalsLeft = crystalsRemaining;
				UpdateCrystals();
			}
		}

		private void UpdateCrystals()
		{
			for (int i = 0; i < crystals.Length; i++)
			{
				if (crystalsRemaining - 1 >= i)
				{
					crystals[i].SetBool("Active", true);
				}
				else
				{
					crystals[i].SetBool("Active", false);
				}
			}
		}

		private void OnDisable()
		{
			if (initialized)
			{
				UpdateCrystals();
			}
		}

		private void OnEnable()
		{
			if (initialized)
			{
				UpdateCrystals();
			}
		}
	}
	[WeaponAbility("Focus", "Hold <color=orange>Fire 1</color> to fire a continuous beam of light.", 0, RichTextColors.aqua)]
	[WeaponAbility("Deploy Pylon", "Press <color=orange>Fire 2</color> deploy a pylon which can refract the <color=aqua>Focus</color> beam.", 1, RichTextColors.lime)]
	[WeaponAbility("Refract", "Fire a <color=aqua>Focus</color> beam into a <color=lime>Pylon</color> to refract it.", 2, RichTextColors.yellow)]
	[UFGWeapon("Focalyzer", "Focalyzer", 2, true, WeaponIconColor.Red, true, true)]
	public class Focalyzer : UltraFunGunBase
	{
		public FocalyzerLaserController laser;

		public FocalyzerTubeController tubeController;

		private bool throwingPylon = false;

		public bool laserActive = false;

		public bool hittingAPylon = false;

		public float laserWidth = 0.3f;

		public float laserMaxRange = 2000f;

		private LayerMask laserHitMask;

		private ActionCooldown fireCooldown = new ActionCooldown(0.16f, affectedByNoCooldownCheat: true);

		private ActionCooldown damageTick = new ActionCooldown(0.25f);

		private ActionCooldown throwPylonCooldown = new ActionCooldown(1f, affectedByNoCooldownCheat: true);

		private GameObject sphereDebugger;

		private string objectHitName = "NULL";

		private Vector3 hitpoint = Vector3.zero;

		private Vector3 hitnormal = Vector3.zero;

		[UFGAsset("FocalyzerPylon")]
		public static GameObject pylonPrefab { get; private set; }

		[UFGAsset("FocalyzerLaser")]
		public static GameObject laserPrefab { get; private set; }

		public override void OnAwakeFinished()
		{
			tubeController = ((Component)((Component)this).transform.Find("viewModelWrapper/FocalyzerGunModel/Tubes")).gameObject.AddComponent<FocalyzerTubeController>();
		}

		private void Start()
		{
			//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_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)
			laserHitMask = LayerMask.op_Implicit(LayerMask.GetMask(new string[8] { "Projectile", "Limb", "BigCorpse", "Environment", "EnvironmentBaked", "OutdoorsBaked", "Armor", "Default" }));
			laser = Object.Instantiate<GameObject>(laserPrefab, Vector3.zero, Quaternion.identity).GetComponent<FocalyzerLaserController>();
			laser.focalyzer = this;
		}

		public override void GetInput()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00d9: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && !throwingPylon && fireCooldown.CanFire() && !om.paused)
			{
				laserActive = true;
				FireLaser();
				MonoSingleton<CameraController>.Instance.CameraShake(0.05f);
			}
			else if (laserActive)
			{
				laserActive = false;
				hittingAPylon = false;
				fireCooldown.AddCooldown();
			}
			else
			{
				Ray val = default(Ray);
				((Ray)(ref val)).origin = firePoint.position;
				((Ray)(ref val)).direction = mainCam.TransformDirection(0f, 0f, 1f);
				Vector3 point = ((Ray)(ref val)).GetPoint(laserMaxRange);
				Vector3 normal = ((Component)mainCam).transform.position - point;
				DrawLaser(firePoint.position, point, normal);
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && throwPylonCooldown.CanFire() && !om.paused && (laser.GetPylonCount() < laser.maxPylons || NoWeaponCooldown.NoCooldown) && !throwingPylon)
			{
				((MonoBehaviour)this).StartCoroutine(ThrowPylon());
			}
		}

		protected override void DoAnimations()
		{
			if ((Object)(object)laser != (Object)null)
			{
				laser.laserActive = laserActive;
			}
			if ((Object)(object)tubeController != (Object)null && (Object)(object)laser != (Object)null)
			{
				tubeController.crystalsUsed = Mathf.Clamp(laser.GetPylonCount() - 1, 0, laser.maxPylons);
			}
			animator.SetBool("LaserActive", laserActive);
		}

		public void FireLaser()
		{
			//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_0027: 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_003a: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0543: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = mainCam.TransformDirection(0f, 0f, 1f);
			List<RaycastHit> list = (from x in Physics.SphereCastAll(((Component)mainCam).transform.position, laserWidth, val, laserMaxRange, LayerMask.op_Implicit(laserHitMask))
				orderby ((RaycastHit)(ref x)).distance
				select x).ToList();
			RaycastHit val2;
			for (int i = 0; i < list.Count; i++)
			{
				val2 = list[i];
				if (!(((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name == "CameraCollisionChecker"))
				{
					val2 = list[i];
					if (!(((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name == "Projectile Parry Zone"))
					{
						continue;
					}
				}
				list.RemoveAt(i);
				i--;
			}
			if (list.Count <= 0)
			{
				hittingAPylon = false;
				Ray val3 = default(Ray);
				((Ray)(ref val3)).origin = firePoint.position;
				((Ray)(ref val3)).direction = mainCam.TransformDirection(0f, 0f, 1f);
				Vector3 point = ((Ray)(ref val3)).GetPoint(laserMaxRange);
				Vector3 normal = ((Component)mainCam).transform.position - point;
				DrawLaser(firePoint.position, point, normal);
				return;
			}
			val2 = list[0];
			objectHitName = ((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name;
			val2 = list[0];
			hitpoint = ((RaycastHit)(ref val2)).point;
			val2 = list[0];
			hitnormal = ((RaycastHit)(ref val2)).normal;
			bool flag = false;
			int index = 0;
			EnemyIdentifierIdentifier val4 = default(EnemyIdentifierIdentifier);
			EnemyIdentifier val5 = default(EnemyIdentifier);
			IUFGInteractionReceiver iUFGInteractionReceiver = default(IUFGInteractionReceiver);
			Breakable val6 = default(Breakable);
			Coin val7 = default(Coin);
			Grenade val9 = default(Grenade);
			FocalyzerPylon focalyzerPylon = default(FocalyzerPylon);
			for (int j = 0; j < list.Count; j++)
			{
				index = j;
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 24)
				{
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 25)
				{
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 8)
				{
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val4))
				{
					if (damageTick.CanFire())
					{
						damageTick.AddCooldown();
						EnemyIdentifier eid = val4.eid;
						val2 = list[j];
						GameObject gameObject = ((Component)((RaycastHit)(ref val2)).collider).gameObject;
						val2 = list[j];
						eid.DeliverDamage(gameObject, val, ((RaycastHit)(ref val2)).point, 0.75f, false, 0f, (GameObject)null, false, false);
					}
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val5))
				{
					if (damageTick.CanFire())
					{
						damageTick.AddCooldown();
						EnemyIdentifier obj = val5;
						val2 = list[j];
						GameObject gameObject2 = ((Component)((RaycastHit)(ref val2)).collider).gameObject;
						val2 = list[j];
						obj.DeliverDamage(gameObject2, val, ((RaycastHit)(ref val2)).point, 0.75f, false, 0f, (GameObject)null, false, false);
					}
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<IUFGInteractionReceiver>(ref iUFGInteractionReceiver))
				{
					iUFGInteractionReceiver.Interact(new UFGInteractionEventData
					{
						invokeType = ((object)this).GetType(),
						direction = val,
						interactorPosition = ((Component)mainCam).transform.position,
						power = 1f,
						tags = new string[2] { "shot", "laser" }
					});
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<Breakable>(ref val6))
				{
					val6.Break();
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).TryGetComponent<Coin>(ref val7) && EnemyTools.TryGetHomingTarget(((Component)val7).transform.position, out var _, out var enemyComponent) && (Object)(object)enemyComponent != (Object)null && !enemyComponent.dead && damageTick.CanFire())
				{
					damageTick.AddCooldown();
					Vector3 val8 = ((Component)enemyComponent).transform.position - ((Component)val7).transform.position;
					enemyComponent.DeliverDamage(((Component)enemyComponent).gameObject, val8, ((Component)enemyComponent).transform.position, 1.5f, false, 0f, (GameObject)null, false, false);
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<Grenade>(ref val9))
				{
					MonoSingleton<TimeController>.Instance.ParryFlash();
					val9.Explode(false, false, false, 1f, false, (GameObject)null, false);
					break;
				}
				val2 = list[j];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<FocalyzerPylon>(ref focalyzerPylon))
				{
					hittingAPylon = true;
					focalyzerPylon.DoRefraction(focalyzerPylon, playerLaser: true);
					flag = true;
					break;
				}
			}
			hittingAPylon = flag;
			Vector3 position = firePoint.position;
			val2 = list[index];
			Vector3 point2 = ((RaycastHit)(ref val2)).point;
			val2 = list[index];
			DrawLaser(position, point2, ((RaycastHit)(ref val2)).normal);
		}

		private void DrawLaser(Vector3 origin, Vector3 endPoint, Vector3 normal)
		{
			//IL_002a: 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_0044: 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)
			if (Object.op_Implicit((Object)(object)sphereDebugger))
			{
				sphereDebugger.transform.position = endPoint;
			}
			laser.AddLinePosition(origin);
			laser.AddLinePosition(endPoint);
			laser.BuildLine(normal);
		}

		private IEnumerator ThrowPylon()
		{
			throwingPylon = true;
			throwPylonCooldown.AddCooldown();
			animator.Play("Focalyzer_ThrowPylon", 0, 0f);
			yield return (object)new WaitForSeconds(0.3f);
			GameObject newPylon = Object.Instantiate<GameObject>(pylonPrefab, firePoint.position, Quaternion.identity);
			GameObject pylonFX = Object.Instantiate<GameObject>(Prefabs.CanLauncher_MuzzleFX, firePoint);
			pylonFX.transform.position = firePoint.position;
			pylonFX.transform.forward = firePoint.forward;
			pylonFX.AddComponent<DestroyOnDisable>();
			MonoSingleton<CameraController>.Instance.CameraShake(0.2f);
			FocalyzerPylon pylon = newPylon.GetComponent<FocalyzerPylon>();
			pylon.laserHitMask = laserHitMask;
			pylon.focalyzer = this;
			pylon.pylonManager = laser;
			newPylon.GetComponent<Rigidbody>().velocity = mainCam.TransformDirection(0f, 0f, 1f) * 40f;
			throwingPylon = false;
		}

		private void OnDisable()
		{
			laserActive = false;
			DoAnimations();
			hittingAPylon = false;
			throwingPylon = false;
		}

		private void OnEnable()
		{
			animator.Play("Focalyzer_Equip");
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)sphereDebugger))
			{
				Object.Destroy((Object)(object)sphereDebugger);
			}
		}

		public override string GetDebuggingText()
		{
			//IL_008f: 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)
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"LASER: {laserActive}\n";
			debuggingText += $"REFRACTING: {hittingAPylon}\n";
			if ((Object)(object)laser != (Object)null)
			{
				debuggingText += $"PYLONS: {laser.GetPylonCount()}\n";
			}
			debuggingText = debuggingText + "HIT: " + objectHitName + "\n";
			debuggingText += $"HITPOINT: {hitpoint}\n";
			return debuggingText + $"HITNORMAL: {hitnormal}\n";
		}
	}
	public class FocalyzerLaserController : MonoBehaviour
	{
		private List<FocalyzerPylon> pylonList = new List<FocalyzerPylon>();

		private List<Vector3> laserPoints = new List<Vector3>();

		public Focalyzer focalyzer;

		public LineRenderer lineRenderer;

		public Animator animator;

		public bool laserActive = false;

		public int maxPylonRefractions = 4;

		public int maxPylons = 6;

		public float maxPylonRange = 500f;

		private void Start()
		{
			lineRenderer = ((Component)this).GetComponent<LineRenderer>();
			animator = ((Component)this).GetComponent<Animator>();
		}

		private void Update()
		{
			animator.SetBool("Active", laserActive);
			if ((Object)(object)focalyzer == (Object)null)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public void AddPylon(FocalyzerPylon pylon)
		{
			if (!pylonList.Contains(pylon))
			{
				pylonList.Add(pylon);
			}
		}

		public void RemovePylon(FocalyzerPylon pylon)
		{
			if (pylonList.Contains(pylon))
			{
				pylonList.Remove(pylon);
			}
		}

		public int GetPylonCount()
		{
			return pylonList.Count;
		}

		public void AddLinePosition(Vector3 position)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			laserPoints.Add(position);
		}

		public void BuildLine(Vector3 normal)
		{
			//IL_0031: 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)
			lineRenderer.SetPositions(laserPoints.ToArray());
			((Component)this).transform.position = laserPoints[laserPoints.Count - 1];
			((Component)this).transform.up = normal;
			laserPoints.Clear();
		}

		private bool LineOfSightCheck(FocalyzerPylon pylon1, FocalyzerPylon pylon2)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_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)
			Vector3 val = ((Component)pylon2).transform.position - ((Component)pylon1).transform.position;
			RaycastHit[] hits = Physics.RaycastAll(((Component)pylon1).transform.position, val, ((Vector3)(ref val)).magnitude);
			hits = HydraUtils.SortRaycastHitsByDistance(hits);
			RaycastHit[] array = hits;
			FocalyzerPylon focalyzerPylon = default(FocalyzerPylon);
			for (int i = 0; i < array.Length; i++)
			{
				RaycastHit val2 = array[i];
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 8 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 0)
				{
					return false;
				}
				if (((Component)((RaycastHit)(ref val2)).collider).gameObject.TryGetComponent<FocalyzerPylon>(ref focalyzerPylon))
				{
					return true;
				}
			}
			return false;
		}

		public FocalyzerPylon GetRefractorTarget(FocalyzerPylon originPylon)
		{
			//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)
			FocalyzerPylon result = originPylon;
			if (pylonList.Count > 1)
			{
				int num = -1;
				float magnitude = maxPylonRange;
				for (int i = 0; i < pylonList.Count; i++)
				{
					if (!((Object)(object)originPylon != (Object)(object)pylonList[i]))
					{
						continue;
					}
					Vector3 val = ((Component)pylonList[i]).transform.position - ((Component)originPylon).transform.position;
					if (!pylonList[i].refracting && LineOfSightCheck(originPylon, pylonList[i]) && (Object)(object)pylonList[i] != (Object)(object)originPylon.targetPylon)
					{
						result = pylonList[i];
						if (((Vector3)(ref val)).sqrMagnitude < magnitude * magnitude)
						{
							magnitude = ((Vector3)(ref val)).magnitude;
							num = i;
						}
					}
				}
				if (num > -1)
				{
					result = pylonList[num];
				}
			}
			return result;
		}
	}
	public class FocalyzerPylon : MonoBehaviour, IUFGInteractionReceiver, ICleanable, IRevolverBeamShootable
	{
		private enum LaserHitType
		{
			enemy,
			nothing,
			solid,
			interactable
		}

		public Animator animator;

		public Animator laserAnimator;

		public bool refracting = false;

		public Focalyzer focalyzer;

		public FocalyzerLaserController pylonManager;

		public LineRenderer refractedLaser;

		public FocalyzerPylon targetPylon;

		private Vector3 randomizedDirection = Vector3.forward;

		private UltraFunGunBase.ActionCooldown damageCooldown = new UltraFunGunBase.ActionCooldown(0.25f);

		private UltraFunGunBase.ActionCooldown randomDirectionCooldown = new UltraFunGunBase.ActionCooldown(0.025f);

		private UltraFunGunBase.ActionCooldown pylonChecker = new UltraFunGunBase.ActionCooldown(0.25f);

		private UltraFunGunBase.ActionCooldown sphereDamageCooldown = new UltraFunGunBase.ActionCooldown(0.05f);

		public LayerMask laserHitMask;

		public int refractionCount = 0;

		public float AOERadius = 3.5f;

		public float parryForce = 200f;

		private float lifeTime = 16f;

		private float lifeTimeLeft = 0f;

		public bool disco = false;

		private bool dying = false;

		private AudioSource discoAudio;

		private Rigidbody rb;

		[UFGAsset("FocalyzerPylonShatterFX_Red")]
		public static GameObject PylonShatterFX { get; private set; }

		private void Start()
		{
			discoAudio = ((Component)((Component)this).transform.Find("DiscoAudio")).gameObject.GetComponent<AudioSource>();
			lifeTimeLeft = lifeTime + Time.time;
			animator = ((Component)this).GetComponent<Animator>();
			refractedLaser = ((Component)this).GetComponentInChildren<LineRenderer>();
			laserAnimator = ((Component)refractedLaser).GetComponent<Animator>();
			((Component)((Component)this).transform.Find("FocalyzerCrystalVisual/RefractorVisual")).gameObject.AddComponent<AlwaysLookAtCamera>().speed = 0f;
			pylonManager.AddPylon(this);
			disco = Random.Range(0f, 100f) <= 5f;
			discoAudio.Play();
			rb = ((Component)this).GetComponent<Rigidbody>();
		}

		private void Update()
		{
			animator.SetBool("Refracting", refracting);
			laserAnimator.SetBool("Active", refracting);
			if (lifeTimeLeft < Time.time || (Object)(object)focalyzer == (Object)null)
			{
				Shatter();
			}
			if (disco && refracting && (Object)(object)targetPylon == (Object)(object)this)
			{
				discoAudio.UnPause();
			}
			else
			{
				discoAudio.Pause();
			}
		}

		public void DoRefraction(FocalyzerPylon hitPylon, bool playerLaser = false)
		{
			if (!refracting)
			{
				((MonoBehaviour)this).StartCoroutine(RefractLaser(hitPylon, playerLaser));
			}
		}

		private IEnumerator RefractLaser(FocalyzerPylon pylonHit, bool playerLaser = false)
		{
			refracting = true;
			while (focalyzer.hittingAPylon)
			{
				try
				{
					if (pylonChecker.CanFire())
					{
						pylonChecker.AddCooldown();
						targetPylon = pylonManager.GetRefractorTarget(pylonHit);
					}
					FireLaser();
				}
				catch (Exception)
				{
				}
				yield return (object)new WaitForEndOfFrame();
			}
			refracting = false;
		}

		private LaserHitType LaserHit(RaycastHit hit, Vector3 castDirection, float damageMultiplier, float critMultiplier = 0f, bool tryExplode = false)
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			LaserHitType result = LaserHitType.nothing;
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 8 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 0)
			{
				return LaserHitType.solid;
			}
			Breakable val = default(Breakable);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<Breakable>(ref val))
			{
				val.Break();
			}
			ThrownEgg thrownEgg = default(ThrownEgg);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<ThrownEgg>(ref thrownEgg))
			{
				thrownEgg.Explode();
				result = LaserHitType.interactable;
			}
			Grenade val2 = default(Grenade);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<Grenade>(ref val2))
			{
				val2.Explode(false, false, false, 1f, false, (GameObject)null, false);
				result = LaserHitType.interactable;
			}
			EnemyIdentifierIdentifier val3 = default(EnemyIdentifierIdentifier);
			if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val3) && damageCooldown.CanFire())
			{
				damageCooldown.AddCooldown();
				val3.eid.DeliverDamage(((Component)val3.eid).gameObject, castDirection, ((RaycastHit)(ref hit)).point, damageMultiplier, tryExplode, critMultiplier, (GameObject)null, false, false);
				result = LaserHitType.enemy;
			}
			return result;
		}

		public void FireLaser()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: 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_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0510: Unknown result type (might be due to invalid IL or missing references)
			//IL_0515: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			RaycastHit[] array = Physics.SphereCastAll(((Component)this).transform.position, AOERadius, ((Component)this).transform.position);
			if (array.Length != 0)
			{
				RaycastHit[] array2 = array;
				ThrownEgg thrownEgg = default(ThrownEgg);
				Grenade val2 = default(Grenade);
				EnemyIdentifierIdentifier val3 = default(EnemyIdentifierIdentifier);
				for (int i = 0; i < array2.Length; i++)
				{
					RaycastHit val = array2[i];
					if (((Component)((RaycastHit)(ref val)).collider).gameObject.TryGetComponent<ThrownEgg>(ref thrownEgg))
					{
						thrownEgg.Explode();
					}
					if (((Component)((RaycastHit)(ref val)).collider).gameObject.TryGetComponent<Grenade>(ref val2))
					{
						val2.Explode(false, false, false, 1f, false, (GameObject)null, false);
					}
					if (((Component)((RaycastHit)(ref val)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val3) && sphereDamageCooldown.CanFire() && !val3.eid.dead)
					{
						sphereDamageCooldown.AddCooldown();
						Vector3 val4 = ((Component)val3.eid).gameObject.transform.position - ((Component)this).transform.position;
						val3.eid.DeliverDamage(((Component)val3.eid).gameObject, val4, ((Component)val3.eid).gameObject.transform.position, 0.35f, false, 0f, (GameObject)null, false, false);
						num++;
					}
				}
			}
			if ((Object)(object)targetPylon != (Object)(object)this)
			{
				Vector3 val5 = ((Component)targetPylon).transform.position - ((Component)this).transform.position;
				RaycastHit[] array3 = Physics.RaycastAll(((Component)this).transform.position, val5, ((Vector3)(ref val5)).magnitude, LayerMask.op_Implicit(laserHitMask));
				RaycastHit[] array4 = array3;
				foreach (RaycastHit hit in array4)
				{
					switch (LaserHit(hit, val5, 0.3f))
					{
					case LaserHitType.enemy:
						num++;
						continue;
					case LaserHitType.interactable:
						num2++;
						continue;
					default:
						continue;
					case LaserHitType.solid:
						break;
					}
					break;
				}
				targetPylon.DoRefraction(this);
				Vector3[] points = (Vector3[])(object)new Vector3[2]
				{
					((Component)this).transform.position,
					((Component)targetPylon).transform.position
				};
				BuildLaser(points, val5 * -1f);
			}
			else if ((Object)(object)targetPylon == (Object)(object)this)
			{
				if (randomDirectionCooldown.CanFire())
				{
					randomDirectionCooldown.AddCooldown();
					float num4 = Random.Range(-1f, 1f);
					float num5 = Random.Range(-1f, 1f);
					float num6 = Random.Range(-1f, 1f);
					Vector3 val6 = ((Component)this).transform.TransformDirection(num4, num5, num6);
					randomizedDirection = ((Vector3)(ref val6)).normalized;
					randomizedDirection *= 500f;
				}
				RaycastHit[] array5 = Physics.RaycastAll(((Component)this).transform.position, randomizedDirection, ((Vector3)(ref randomizedDirection)).sqrMagnitude, LayerMask.op_Implicit(laserHitMask));
				RaycastHit hit3 = default(RaycastHit);
				if (array5.Length != 0)
				{
					array5 = HydraUtils.SortRaycastHitsByDistance(array5);
					int num7 = -1;
					RaycastHit[] array6 = array5;
					foreach (RaycastHit hit2 in array6)
					{
						num7++;
						switch (LaserHit(hit2, randomizedDirection, 6f / (float)pylonManager.GetPylonCount(), 2f, tryExplode: true))
						{
						case LaserHitType.enemy:
							num3++;
							continue;
						case LaserHitType.interactable:
							num3++;
							continue;
						default:
							continue;
						case LaserHitType.solid:
							break;
						}
						break;
					}
					Vector3[] points2 = (Vector3[])(object)new Vector3[2]
					{
						((Component)this).transform.position,
						((RaycastHit)(ref array5[num7])).point
					};
					BuildLaser(points2, ((RaycastHit)(ref array5[num7])).normal);
				}
				else if (Physics.Raycast(((Component)this).transform.position, ((Component)this).transform.TransformDirection(Vector3.down), ref hit3, float.PositiveInfinity, LayerMask.op_Implicit(laserHitMask)))
				{
					LaserHit(hit3, randomizedDirection, 3f / (float)pylonManager.GetPylonCount(), 1f, tryExplode: true);
					BuildLaser((Vector3[])(object)new Vector3[2]
					{
						((Component)this).transform.position,
						((RaycastHit)(ref hit3)).point
					}, ((RaycastHit)(ref hit3)).normal);
				}
				else
				{
					Vector3 normal = ((Component)MonoSingleton<CameraController>.Instance).transform.position - ((Component)this).transform.position;
					BuildLaser((Vector3[])(object)new Vector3[2]
					{
						((Component)this).transform.position,
						((Component)this).transform.position
					}, normal);
				}
			}
			else if ((Object)(object)targetPylon == (Object)null)
			{
				targetPylon = pylonManager.GetRefractorTarget(this);
			}
			if (num3 > 0)
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(15, "hydraxous.ultrafunguns.discohit", ((Component)focalyzer).gameObject, (EnemyIdentifier)null, num3, "", "");
			}
			if (num > 0 || num2 > 0)
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(2 + 50 * (num2 / 1), "hydraxous.ultrafunguns.refractionhit", ((Component)focalyzer).gameObject, (EnemyIdentifier)null, num + num2, "", "");
			}
		}

		private void BuildLaser(Vector3[] points, Vector3 normal)
		{
			//IL_0020: 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)
			refractedLaser.SetPositions(points);
			((Component)refractedLaser).gameObject.transform.position = points[1];
			((Component)refractedLaser).gameObject.transform.up = normal;
		}

		private void Shatter()
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!dying)
			{
				dying = true;
				Object.Instantiate<GameObject>(PylonShatterFX, ((Component)this).transform.position, Quaternion.identity);
				Prefabs.BonusBreakSound.Asset.PlayAudioClip(((Component)this).transform.position, 1.1f, 1f, 0.6f);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnDisable()
		{
			if ((Object)(object)pylonManager != (Object)null)
			{
				pylonManager.RemovePylon(this);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)pylonManager != (Object)null)
			{
				pylonManager.RemovePylon(this);
			}
		}

		public bool Interact(UFGInteractionEventData interaction)
		{
			string name = interaction.invokeType.Name;
			if (name != "Focalyzer" && name != "FocalyzerAlternate")
			{
				Shatter();
				return true;
			}
			return false;
		}

		public bool Parry(Vector3 origin, Vector3 aimVector)
		{
			//IL_0009: 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)
			rb.AddForce(((Vector3)(ref aimVector)).normalized * parryForce, (ForceMode)1);
			return true;
		}

		public Vector3 GetPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public bool Targetable(TargetQuery targetQuery)
		{
			return false;
		}

		public void Cleanup()
		{
			Shatter();
		}

		public void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			Shatter();
		}

		public bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			return true;
		}
	}
	public class FocalyzerTubeController : MonoBehaviour
	{
		private Animator[] crystals = (Animator[])(object)new Animator[6];

		public int crystalsUsed = 6;

		private int lastCrystalsLeft;

		private bool initialized = false;

		private void Awake()
		{
			for (int i = 0; i < 6; i++)
			{
				crystals[i] = ((Component)((Component)this).transform.Find($"Crystal{i}")).GetComponent<Animator>();
			}
			initialized = true;
		}

		private void Update()
		{
			if (crystalsUsed != lastCrystalsLeft)
			{
				lastCrystalsLeft = crystalsUsed;
				UpdateCrystals();
			}
		}

		private void UpdateCrystals()
		{
			for (int i = 0; i < crystals.Length; i++)
			{
				if (crystalsUsed >= i)
				{
					crystals[i].SetBool("Active", false);
				}
				else
				{
					crystals[i].SetBool("Active", true);
				}
			}
		}

		private void OnDisable()
		{
			if (initialized)
			{
				UpdateCrystals();
			}
		}

		private void OnEnable()
		{
			if (initialized)
			{
				UpdateCrystals();
			}
		}
	}
	[WeaponAbility("Manipulate", "Manipulate a physics object <color=orange>Fire 1</color>", 0, RichTextColors.aqua)]
	[WeaponAbility("Lock", "Lock a physics object in place <color=orange>Fire 2</color>", 1, RichTextColors.aqua)]
	[WeaponAbility("Rotat-e", "Rotate held object <color=orange>secret</color>", 2, RichTextColors.aqua)]
	[UFGWeapon("FizzyGun", "Fizix Applicator (Experimental)", 3, true, WeaponIconColor.Blue, false, true)]
	public class FizzyGun : UltraFunGunBase
	{
		public float forceOnRb = 150f;

		public float forwardBias = 5f;

		public float groupForce = 2f;

		public float groupMaxRange = 10f;

		public float rotateSpeed = 15f;

		public float stopRange = 0.2f;

		public float manipulateSpeed = 400f;

		public bool setVelo = false;

		public float maxRange = 10f;

		public float minAngle = 0.6f;

		private Transform objectHolder;

		private Rigidbody heldObjectRigidbody;

		private Transform heldObjectParent;

		private bool waitForPrimaryFireReleased;

		private Dictionary<Rigidbody, RigidbodySettings> oldKinematicStates = new Dictionary<Rigidbody, RigidbodySettings>();

		private RigidbodySettings manipulatedSettings = new RigidbodySettings((RigidbodyConstraints)112, (RigidbodyInterpolation)0, isKinematic: false);

		private bool checking;

		private bool hittingSomething;

		private bool rotating;

		private Vector3 holderPositionLastFrame;

		private Quaternion lookRot = Quaternion.identity;

		private float lastDistFromCamera = 0f;

		public bool IsHoldingObject => (Object)(object)heldObjectRigidbody != (Object)null;

		private Transform ObjectHolder
		{
			get
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)objectHolder == (Object)null)
				{
					objectHolder = new GameObject("PhysicsObjectHolder").transform;
				}
				return objectHolder;
			}
		}

		public override void GetInput()
		{
			if (IsHoldingObject)
			{
				UpdateHolderPosition();
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed)
			{
				FireBeam();
			}
			else
			{
				waitForPrimaryFireReleased = false;
				if (IsHoldingObject)
				{
					EndManipulation();
				}
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && IsHoldingObject)
			{
				PhysicsLockObject();
			}
			if (UFGInput.SecretButton.IsPressed() && IsHoldingObject)
			{
				RotateManipulation();
			}
			else if (rotating)
			{
				rotating = false;
			}
			if (Input.GetKeyDown((KeyCode)61) && UltraFunGuns.DebugMode)
			{
				setVelo = !setVelo;
			}
		}

		private void FixedUpdate()
		{
			//IL_0016: 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_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_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_006a: 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)
			if (IsHoldingObject)
			{
				Vector3 val = ObjectHolder.position - (heldObjectRigidbody.centerOfMass + heldObjectRigidbody.position);
				float magnitude = manipulateSpeed;
				if (((Vector3)(ref val)).magnitude < manipulateSpeed)
				{
					magnitude = ((Vector3)(ref val)).magnitude;
				}
				heldObjectRigidbody.velocity = ((Vector3)(ref val)).normalized * magnitude;
			}
		}

		private void FireBeam()
		{
			if (!IsHoldingObject && !waitForPrimaryFireReleased && CheckForCollider(out var col))
			{
				BeginManipulation(col);
			}
		}

		private void RotateManipulation()
		{
			//IL_002d: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!rotating)
			{
				lookRot = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation;
				rotating = true;
			}
			HydraUtils.SetPlayerRotation(lookRot);
			Vector2 val = MonoSingleton<InputManager>.Instance.InputSource.Look.ReadValue<Vector2>();
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(val.y, 0f - val.x, 0f);
			val2 = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation * val2;
			((Component)heldObjectRigidbody).transform.RotateAround(ObjectHolder.position, val2, ((Vector2)(ref val)).magnitude * Time.deltaTime * rotateSpeed);
		}

		private bool CheckForCollider(out Collider col)
		{
			//IL_0011: 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)
			col = null;
			hittingSomething = false;
			RaycastHit[] array = Physics.SphereCastAll(mainCam.position, 0.015f, mainCam.forward, (float)LayerMask.GetMask(new string[8] { "Environment", "Outdoors", "Outdoors Non-solid", "Default", "Limb", "Gib", "Armor", "Projectile" }));
			if (array.Length == 0)
			{
				return false;
			}
			array = array.OrderBy((RaycastHit x) => ((RaycastHit)(ref x)).distance).ToArray();
			array = array.Where((RaycastHit x) => (Object)(object)((RaycastHit)(ref x)).collider.attachedRigidbody != (Object)null && ((Object)((Component)((RaycastHit)(ref x)).collider).gameObject).name != "CameraCollisionChecker").ToArray();
			array = array.Where((RaycastHit x) => !((Object)((Component)((RaycastHit)(ref x)).collider.attachedRigidbody).gameObject).name.Contains("Player")).ToArray();
			if (array.Length != 0)
			{
				UltraFunGuns.Log.LogWarning(((Object)((Component)((RaycastHit)(ref array[0])).collider).gameObject).name);
				hittingSomething = true;
				lastDistFromCamera = ((RaycastHit)(ref array[0])).distance;
				UpdateHolderPosition();
				BeginManipulation(((RaycastHit)(ref array[0])).collider);
				return true;
			}
			return false;
		}

		private void UpdateHolderPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_006a: 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_0076: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = mainCam.position;
			Vector3 forward = mainCam.forward;
			Vector3 val = position + forward * lastDistFromCamera;
			if (IsHoldingObject)
			{
				holderPositionLastFrame = heldObjectRigidbody.position + heldObjectRigidbody.centerOfMass;
			}
			ObjectHolder.position = val;
			position.y = val.y;
			Vector3 val2 = position - val;
			Quaternion rotation = Quaternion.LookRotation(val2, Vector3.up);
			ObjectHolder.rotation = rotation;
		}

		private void BeginManipulation(Collider col)
		{
			if (!((Object)(object)col == (Object)null) && !((Object)(object)col.attachedRigidbody == (Object)null))
			{
				heldObjectRigidbody = col.attachedRigidbody;
				UltraFunGuns.Log.LogWarning("Beginning manipulation on object " + ((Object)heldObjectRigidbody).name);
				if (!oldKinematicStates.ContainsKey(heldObjectRigidbody))
				{
					oldKinematicStates.Add(heldObjectRigidbody, new RigidbodySettings(heldObjectRigidbody));
					manipulatedSettings.ApplySettings(heldObjectRigidbody);
				}
				else
				{
					oldKinematicStates[heldObjectRigidbody].ApplySettings(heldObjectRigidbody);
					oldKinematicStates.Remove(heldObjectRigidbody);
				}
				if ((Object)(object)((Component)heldObjectRigidbody).transform.parent != (Object)null)
				{
					heldObjectParent = ((Component)heldObjectRigidbody).transform.parent;
				}
				((Component)heldObjectRigidbody).transform.parent = ObjectHolder;
			}
		}

		private void EndManipulation()
		{
			//IL_0075: 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)
			if (IsHoldingObject)
			{
				UltraFunGuns.Log.LogWarning("Ending manipulation on object " + ((Object)heldObjectRigidbody).name);
				((Component)heldObjectRigidbody).transform.parent = heldObjectParent;
				heldObjectParent = null;
				if (!heldObjectRigidbody.isKinematic)
				{
					heldObjectRigidbody.velocity = ((Component)ObjectHolder).transform.position - holderPositionLastFrame;
				}
				heldObjectRigidbody = null;
			}
		}

		private void PhysicsLockObject()
		{
			if (IsHoldingObject)
			{
				waitForPrimaryFireReleased = true;
				heldObjectRigidbody.isKinematic = true;
				EndManipulation();
			}
		}

		public void OnDisable()
		{
			EndManipulation();
		}

		public override string GetDebuggingText()
		{
			//IL_00a0: 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)
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"CHECKING: {MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed}\n";
			debuggingText += $"ISHOLD: {IsHoldingObject}\n";
			debuggingText += $"HITTING: {hittingSomething}\n";
			if (IsHoldingObject)
			{
				debuggingText = debuggingText + "HELD: " + ((Object)heldObjectRigidbody).name + "\n";
				debuggingText += $"VELO: {heldObjectRigidbody.velocity}\n";
				string text = debuggingText;
				Vector3 velocity = heldObjectRigidbody.velocity;
				debuggingText = text + $"SPEED: {((Vector3)(ref velocity)).magnitude}\n";
				debuggingText += $"KINEMATIC: {heldObjectRigidbody.isKinematic}\n";
			}
			return debuggingText;
		}
	}
	public struct RigidbodySettings
	{
		public RigidbodyConstraints constraints;

		public RigidbodyInterpolation interpolation;

		public bool isKinematic;

		public RigidbodySettings(Rigidbody rigidbody)
		{
			//IL_0003: 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)
			constraints = (RigidbodyConstraints)0;
			interpolation = (RigidbodyInterpolation)0;
			isKinematic = false;
			SetSettings(rigidbody);
		}

		public RigidbodySettings(RigidbodyConstraints constraints, RigidbodyInterpolation interpolation, bool isKinematic)
		{
			//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_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)
			this.constraints = constraints;
			this.interpolation = interpolation;
			this.isKinematic = isKinematic;
		}

		public void ApplySettings(Rigidbody rigidbody)
		{
			//IL_0010: 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)
			rigidbody.isKinematic = isKinematic;
			rigidbody.interpolation = interpolation;
			rigidbody.constraints = constraints;
		}

		public void SetSettings(Rigidbody rigidbody)
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			constraints = rigidbody.constraints;
			interpolation = rigidbody.interpolation;
			isKinematic = rigidbody.isKinematic;
		}
	}
	[WeaponAbility("Discharge", "Launch physics objects <color=orange>Fire 1</color>", 0, RichTextColors.aqua)]
	[WeaponAbility("Grabbity Well", "Pull physics objects <color=orange>Fire 2</color>", 1, RichTextColors.aqua)]
	[UFGWeapon("GrabbityGun", "Grabbity Gun (Experimental)", 3, true, WeaponIconColor.Yellow, false, true)]
	public class GrabbityGun : UltraFunGunBase
	{
		public float forceOnRb = 150f;

		public float forwardBias = 5f;

		public float groupForce = 2f;

		public float groupMaxRange = 10f;

		public bool setVelo = false;

		public float maxRange = 10f;

		public float minAngle = 0.6f;

		private ActionCooldown primaryFireDelay = new ActionCooldown(0.4f, affectedByNoCooldownCheat: true);

		private ActionCooldown secondaryDelay = new ActionCooldown(0.2f, affectedByNoCooldownCheat: true);

		private bool grabbiting = false;

		private List<EnemyOverride> enemyOverrides = new List<EnemyOverride>();

		public override void GetInput()
		{
			if (primaryFireDelay.CanFire() && MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame)
			{
				primaryFireDelay.AddCooldown();
				FirePrimary();
			}
			if (UFGInput.SecretButton.WasPeformed())
			{
				setVelo = !setVelo;
			}
		}

		private void FixedUpdate()
		{
			bool isPressed = MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed;
			if (secondaryDelay.CanFire())
			{
				if (isPressed)
				{
					grabbiting = true;
					SuckInStuff();
				}
				else if (grabbiting)
				{
					ResetEnemies();
					secondaryDelay.AddCooldown();
				}
			}
		}

		private void SuckInStuff()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0057: 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)
			Vector3 position = mainCam.position;
			Vector3 forward = mainCam.forward;
			position += forward * maxRange;
			Visualizer.DrawLine(0.02f, mainCam.position, position);
			Collider[] array = Physics.OverlapSphere(position, groupMaxRange);
			for (int i = 0; i < array.Length; i++)
			{
				Pull(array[i], position);
			}
		}

		private void ResetEnemies()
		{
			if (enemyOverrides.Count <= 0)
			{
				return;
			}
			foreach (EnemyOverride enemyOverride in enemyOverrides)
			{
				if (!((Object)(object)enemyOverride.EnemyIdentifier == (Object)null) && !((Object)(object)enemyOverride == (Object)null) && !enemyOverride.EnemyIdentifier.dead)
				{
					enemyOverride.SetRagdoll(active: false);
				}
			}
			enemyOverrides.Clear();
		}

		public override void FirePrimary()
		{
			//IL_000c: 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_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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)mainCam).transform.position;
			Vector3 val = ((Component)mainCam).transform.rotation * Vector3.forward;
			position += val * maxRange;
			Collider[] array = Physics.OverlapSphere(position, maxRange);
			MonoSingleton<CameraController>.Instance.CameraShake(0.0075f * forceOnRb);
			for (int i = 0; i < array.Length; i++)
			{
				DoHit(array[i], position);
			}
		}

		private void Pull(Collider collider, Vector3 checkOrigin)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ea: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody val = default(Rigidbody);
			if (!((Component)collider).TryGetComponent<Rigidbody>(ref val) || (Object)(object)val == (Object)(object)MonoSingleton<NewMovement>.Instance.rb)
			{
				return;
			}
			Vector3 position = mainCam.position;
			Vector3 zero = Vector3.zero;
			if (collider.IsColliderEnemy(out var eid))
			{
				EnemyOverride enemyOverride = eid.Override();
				if (!enemyOverrides.Contains(enemyOverride))
				{
					enemyOverrides.Add(enemyOverride);
					enemyOverride.SetRagdoll(active: true);
					enemyOverride.AddCollisionEvent(delegate(Collision col)
					{
						if (enemyOverrides.Contains(enemyOverride))
						{
							int layer = col.gameObject.layer;
							int num = layer;
							if (num == 0 || num == 8)
							{
								TryDamage();
							}
						}
					});
				}
			}
			zero = checkOrigin - (val.centerOfMass + ((Component)val).transform.position);
			if (setVelo)
			{
				val.velocity = zero * groupForce;
			}
			else
			{
				Rigidbody obj = val;
				obj.velocity += zero * groupForce;
			}
			Visualizer.DrawRay(((Component)val).transform.position + val.centerOfMass, val.velocity, 0.5f);
			void TryDamage()
			{
				//IL_001c: 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_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				if (eid.CanBeDamaged())
				{
					Vector3 relativeVelocity = P_0.col.relativeVelocity;
					float magnitude = ((Vector3)(ref relativeVelocity)).magnitude;
					if (!(magnitude < 5f))
					{
						EnemyIdentifier obj2 = eid;
						GameObject gameObject = ((Component)eid).gameObject;
						Vector3 relativeVelocity2 = P_0.col.relativeVelocity;
						ContactPoint contact = P_0.col.GetContact(0);
						obj2.DeliverDamage(gameObject, relativeVelocity2, ((ContactPoint)(ref contact)).point, magnitude, false, 0f, ((Component)this).gameObject, false, false);
					}
				}
			}
		}

		private void DoHit(Collider collider, Vector3 checkOrigin)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0021: 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_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_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_0064: 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_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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = mainCam.position;
			Vector3 forward = mainCam.forward;
			Vector3 val = collider.ClosestPointOnBounds(checkOrigin);
			Vector3 val2 = val - position;
			float num = Vector3.Dot(((Vector3)(ref val2)).normalized, forward);
			Rigidbody val3 = default(Rigidbody);
			if (!(num < minAngle) && ((Component)collider).TryGetComponent<Rigidbody>(ref val3))
			{
				Vector3 val4 = ((Vector3)(ref val2)).normalized + ((Vector3)(ref forward)).normalized * forwardBias;
				val4 = ((Vector3)(ref val4)).normalized * forceOnRb;
				Projectile val5 = default(Projectile);
				if (((Component)collider).TryGetComponent<Projectile>(ref val5))
				{
					((Component)val5).transform.forward = val4;
					Projectile obj = val5;
					obj.speed *= forceOnRb * 0.01f;
				}
				val3.AddForceAtPosition(val4, val, (ForceMode)1);
			}
		}
	}
	public class HolySword : UltraFunGunBase
	{
	}
	[UFGWeapon("JetSpear", "Jet Spear", 3, true, WeaponIconColor.Yellow, false, true)]
	public class JetSpear : UltraFunGunBase
	{
		public float jetForce = 1.5f;

		public float fuelRemaining = 0.75f;

		public float maxFuel = 0.75f;

		public float smoothing;

		public float smoothingSpeed = 0.15f;

		public float upforce = 150f;

		public float reboundDampen = 0.25f;

		private Rigidbody rb;

		private bool jetEnabled;

		public override void OnAwakeFinished()
		{
			rb = player.rb;
		}

		public override void GetInput()
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && fuelRemaining > 0f)
			{
				fuelRemaining = Mathf.Clamp(fuelRemaining - Time.deltaTime, 0f, maxFuel);
				smoothing = Mathf.Clamp(smoothing + Time.deltaTime, 0f, smoothingSpeed);
				jetEnabled = true;
			}
			else if (smoothing > 0f)
			{
				smoothing = Mathf.Clamp(smoothing - Time.deltaTime, 0f, smoothingSpeed);
				jetEnabled = true;
			}
			else
			{
				fuelRemaining = Mathf.Clamp(fuelRemaining + Time.deltaTime, 0f, maxFuel);
				jetEnabled = false;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame)
			{
				Vector3 velocity = rb.velocity;
				float num = ((Vector3)(ref velocity)).magnitude * reboundDampen;
				Vector3 val = -mainCam.forward;
				val += Vector3.up * upforce;
				val = ((Vector3)(ref val)).normalized * num;
				rb.velocity = val;
			}
		}

		private void FixedUpdate()
		{
			//IL_0013: 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_0029: 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)
			if (jetEnabled)
			{
				Rigidbody obj = rb;
				obj.velocity += mainCam.forward * jetForce * (smoothing / smoothingSpeed);
			}
		}

		protected override void DoAnimations()
		{
		}
	}
	[WeaponAbility("Cat Power", "Explodes everything in existence it's kind of funny if you think about it.", 0, RichTextColors.fuchsia)]
	[UFGWeapon("Maxwell", "Maxwell", 3, false, WeaponIconColor.Yellow, false, true)]
	public class Maxwell : UltraFunGunBase
	{
		private ActionCooldown killCooldown = new ActionCooldown(3f, affectedByNoCooldownCheat: true);

		private float maxPower = 2f;

		private float power;

		private float maxRange = 25f;

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed)
			{
				power += Time.deltaTime;
				if (power >= maxPower && killCooldown.CanFire())
				{
					Kill();
				}
			}
			else
			{
				power -= Time.deltaTime;
			}
			power = Mathf.Clamp(power, 0f, maxPower);
		}

		private void Kill()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			EnemyIdentifier enemy2;
			Collider[] array = (from x in Physics.OverlapSphere(mainCam.position, maxRange)
				where x.IsColliderEnemy(out enemy2)
				select x).ToArray();
			if (array.Length != 0 && array[Random.Range(0, array.Length)].IsColliderEnemy(out var enemy))
			{
				enemy.Explode(false);
				killCooldown.AddCooldown(Random.Range(killCooldown.FireDelay - killCooldown.FireDelay * 0.5f, killCooldown.FireDelay + killCooldown.FireDelay));
			}
		}
	}
	[UFGWeapon("MysticFlare", "Mystic Flare", 0, true, WeaponIconColor.Red, false, true)]
	[WeaponAbility("Flare", "Throw a flare using <color=orange>Fire 1</color>.", 6, RichTextColors.red)]
	public class MysticFlare : UltraFunGunBase
	{
		[UFGAsset("MysticFlareProjectile")]
		private static GameObject flareProjectilePrefab;

		public float maxRange = 13f;

		private MysticFlareProjectile deployedFlare;

		[UFGAsset("MysticFlareExplosion")]
		public static GameObject MysticFlareExplosion { get; private set; }

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed)
			{
				if ((Object)(object)deployedFlare == (Object)null)
				{
					DeployFlare();
				}
			}
			else if ((Object)(object)deployedFlare != (Object)null)
			{
				ExplodeFlare();
			}
		}

		private void DeployFlare()
		{
			//IL_000c: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(flareProjectilePrefab, firePoint.position, Quaternion.identity);
			val.transform.forward = mainCam.forward;
			deployedFlare = val.GetComponent<MysticFlareProjectile>();
		}

		private void ExplodeFlare()
		{
			if (!((Object)(object)deployedFlare == (Object)null))
			{
				deployedFlare.Detonate();
				deployedFlare = null;
			}
		}

		public override string GetDebuggingText()
		{
			//IL_004c: 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)
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"FLARE: {(Object)(object)deployedFlare != (Object)null}\n";
			if ((Object)(object)deployedFlare != (Object)null)
			{
				debuggingText += $"FLARE_DIST: {Vector3.Distance(((Component)deployedFlare).transform.position, ((Component)mainCam).transform.position)}\n";
				debuggingText = debuggingText + "FLARE_SPEED: " + deployedFlare.MoveSpeed.ToString("0.000") + "\n";
			}
			return debuggingText;
		}
	}
	public class MysticFlareProjectile : MonoBehaviour
	{
		private bool dying = false;

		public float MoveSpeed { get; private set; } = 1f;


		private void FixedUpdate()
		{
			//IL_001b: 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_0031: 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)
			MoveSpeed += Time.fixedDeltaTime;
			Transform transform = ((Component)this).transform;
			transform.position += ((Component)this).transform.forward * MoveSpeed * Time.fixedDeltaTime;
			MoveSpeed += Time.fixedDeltaTime;
		}

		public void Detonate()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			if (!dying)
			{
				dying = true;
				Vector3 pos = ((Component)this).transform.position;
				SonicReverberator.vineBoom_Loudest.PlayAudioClip(pos, -0.7f);
				StaticCoroutine.DelayedExecute(delegate
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					SonicReverberator.vineBoom_Loudest.PlayAudioClip(pos, 0.8f);
				}, 0.24f);
				Object.Instantiate<GameObject>(MysticFlare.MysticFlareExplosion, ((Component)this).transform.position, Quaternion.identity);
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
	public class CanExplosion : MonoBehaviour
	{
		public class CanExplosionProfile
		{
			public float rayWidth;

			public int rayAmount;

			public float rayChoke;

			public bool sphere;

			public CanExplosionProfile(float rayWidth, int rayAmount, float rayChoke, bool sphere)
			{
				this.rayWidth = rayWidth;
				this.rayAmount = rayAmount;
				this.rayChoke = rayChoke;
				this.sphere = sphere;
			}
		}

		public int explosionType;

		public Transform[] explosionFX;

		public int penetrations = 2;

		public float forceMultiplier = 1f;

		public float shrapnelDamage = 1f;

		public float aoeDamage = 0.15f;

		public float aoeRange = 1f;

		public float maxShrapnelRange = 200f;

		public float shrapnelSize = 0.25f;

		public int explosionSize = 0;

		private CanExplosionProfile[] explosionProfiles = new CanExplosionProfile[4]
		{
			null,
			new CanExplosionProfile(0.15f, 24, 5f, sphere: false),
			new CanExplosionProfile(0.2f, 128, 3f, sphere: false),
			new CanExplosionProfile(0.3f, 512, 1f, sphere: true)
		};

		private void Awake()
		{
			List<Transform> list = new List<Transform>();
			for (int i = 0; i < 4; i++)
			{
				list.Add(((Component)this).transform.Find($"FX/{i}"));
			}
			explosionFX = list.ToArray();
		}

		public void Explode(int size)
		{
			explosionSize = size;
			((Component)explosionFX[size]).gameObject.SetActive(true);
			DoBoom();
			if (explosionSize > 0)
			{
				DoRays(explosionProfiles[explosionSize]);
			}
		}

		private void DoBoom()
		{
			UltraFunGuns.Log.Log("Can explosion - Size:" + explosionSize);
		}

		private void DoRays(CanExplosionProfile profile)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_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_0073: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < profile.rayAmount; i++)
			{
				Vector3 zero = Vector3.zero;
				if (profile.sphere)
				{
					zero = Random.insideUnitSphere;
				}
				else
				{
					Vector2 insideUnitCircle = Random.insideUnitCircle;
					insideUnitCircle *= Mathf.Sign(Random.Range(-10f, 10f));
					zero = ((Component)this).transform.TransformDirection(new Vector3(insideUnitCircle.x, insideUnitCircle.y, profile.rayChoke));
				}
				Shoot(new Ray(((Component)this).transform.position, zero));
			}
		}

		private void Shoot(Ray direction)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0522: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0534: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: 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_00c6: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			bool flag = true;
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			RaycastHit[] hits = Physics.SphereCastAll(direction, shrapnelSize, maxShrapnelRange, LayerMask.GetMask(new string[6] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default", "Projectile" }));
			hits = HydraUtils.SortRaycastHitsByDistance(hits);
			if (hits.Length != 0)
			{
				if (hits.Length != 1 || !(((Object)((Component)((RaycastHit)(ref hits[0])).collider).gameObject).name == "CameraCollisionChecker"))
				{
					int num = 0;
					hits = HydraUtils.SortRaycastHitsByDistance(hits);
					EnemyIdentifierIdentifier val2 = default(EnemyIdentifierIdentifier);
					EnemyIdentifier val3 = default(EnemyIdentifier);
					Breakable val4 = default(Breakable);
					ThrownEgg thrownEgg = default(ThrownEgg);
					ThrownDodgeball thrownDodgeball = default(ThrownDodgeball);
					Grenade val5 = default(Grenade);
					CanProjectile canProjectile = default(CanProjectile);
					for (int i = 0; i < hits.Length; i++)
					{
						Ray val = default(Ray);
						((Ray)(ref val)).origin = ((Component)this).transform.position;
						((Ray)(ref val)).direction = ((RaycastHit)(ref hits[i])).point - ((Component)this).transform.position;
						if (list.Count > penetrations)
						{
							flag = false;
						}
						num = i;
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref hits[i])).collider).gameObject.layer == 8)
						{
							break;
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val2))
						{
							if (!list.Contains(val2.eid))
							{
								list.Add(val2.eid);
								val2.eid.DeliverDamage(((Component)((RaycastHit)(ref hits[i])).collider).gameObject, ((Ray)(ref val)).direction * forceMultiplier, ((RaycastHit)(ref hits[i])).point, shrapnelDamage, true, 0f, ((Component)this).gameObject, false, false);
							}
							if (!flag)
							{
								break;
							}
						}
						else if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val3))
						{
							if (!list.Contains(val3))
							{
								list.Add(val3);
								val3.DeliverDamage(((Component)((RaycastHit)(ref hits[i])).collider).gameObject, ((Ray)(ref val)).direction * forceMultiplier, ((RaycastHit)(ref hits[i])).point, shrapnelDamage, true, 0f, ((Component)this).gameObject, false, false);
							}
							if (!flag)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<Breakable>(ref val4))
						{
							val4.Break();
							if (!flag)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<ThrownEgg>(ref thrownEgg))
						{
							thrownEgg.Explode();
							if (!flag)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<ThrownDodgeball>(ref thrownDodgeball))
						{
							thrownDodgeball.ExciteBall();
							if (!flag)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<Grenade>(ref val5))
						{
							MonoSingleton<TimeController>.Instance.ParryFlash();
							val5.Explode(false, false, false, 1f, false, (GameObject)null, false);
							if (!flag)
							{
								break;
							}
						}
						if (((Component)((RaycastHit)(ref hits[i])).collider).gameObject.TryGetComponent<CanProjectile>(ref canProjectile))
						{
							MonoSingleton<TimeController>.Instance.ParryFlash();
							canProjectile.Explode(-((RaycastHit)(ref hits[i])).normal, 1);
							if (!flag)
							{
								break;
							}
						}
					}
					CreateBulletTrail(((Component)this).transform.position, ((RaycastHit)(ref hits[num])).point, ((RaycastHit)(ref hits[num])).normal, ((Component)((RaycastHit)(ref hits[num])).collider).transform);
				}
				else
				{
					Ray val6 = default(Ray);
					((Ray)(ref val6)).origin = ((Component)this).transform.position;
					((Ray)(ref val6)).direction = ((Component)this).transform.TransformDirection(0f, 0f, 1f);
					Vector3 point = ((Ray)(ref val6)).GetPoint(maxShrapnelRange);
					CreateBulletTrail(((Component)this).transform.position, point, ((Ray)(ref val6)).direction * -1f);
				}
			}
			else
			{
				Ray val7 = default(Ray);
				((Ray)(ref val7)).origin = ((Component)this).transform.position;
				((Ray)(ref val7)).direction = ((Component)this).transform.TransformDirection(0f, 0f, 1f);
				Vector3 point2 = ((Ray)(ref val7)).GetPoint(maxShrapnelRange);
				CreateBulletTrail(((Component)this).transform.position, point2, ((Ray)(ref val7)).direction * -1f);
			}
			List<EnemyIdentifier> list2 = new List<EnemyIdentifier>();
			foreach (EnemyIdentifier item in list)
			{
				if (!item.dead && !item.exploded)
				{
					list2.Add(item);
				}
			}
			list = list2;
			if (list.Count <= penetrations && list.Count <= 0)
			{
			}
		}

		private void CreateBulletTrail(Vector3 startPosition, Vector3 endPosition, Vector3 normal)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Prefabs.BulletTrail, endPosition, Quaternion.identity);
			val.transform.up = normal;
			LineRenderer component = val.GetComponent<LineRenderer>();
			Vector3[] positions = (Vector3[])(object)new Vector3[2] { startPosition, endPosition };
			component.SetPositions(positions);
		}

		private void CreateBulletTrail(Vector3 startPosition, Vector3 endPosition, Vector3 normal, Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Prefabs.BulletTrail, endPosition, Quaternion.identity);
			val.transform.up = normal;
			LineRenderer component = val.GetComponent<LineRenderer>();
			Vector3[] positions = (Vector3[])(object)new Vector3[2] { startPosition, endPosition };
			component.SetPositions(positions);
			val.transform.parent = parent;
		}
	}
	[UFGWeapon("CanLauncher", "CANnon", 3, true, WeaponIconColor.Blue, true, true)]
	[WeaponAbility("Can Cannon", "Press <color=orange>Fire 1</color> to fire a can.", 0, RichTextColors.aqua)]
	[WeaponAbility("Boosted Output", "Parry a can after firing to accelerate it's velocity.", 0, RichTextColors.yellow)]
	[WeaponAbility("Kick It", "Shoot a can with a low power weapon to <color=orange>Kick it</color>.", 1, RichTextColors.yellow)]
	[WeaponAbility("Fragment", "After sufficient damage, a Can can be <color=orange>fragmented</color> with a swift punch.", 2, RichTextColors.yellow)]
	[WeaponAbility("Super Fragment", "Shoot a can with a high power weapon to <color=orange>fragment</color> it.", 3, RichTextColors.red)]
	public class CanLauncher : UltraFunGunBase
	{
		public float shootForce = 80f;

		public float targetBeamThickness = 0.5f;

		public float maxBeamDistance = 500f;

		public Vector3 shootVector;

		private Material[] canMaterials;

		private int canMaterialCount = 10;

		private MeshRenderer canPrefabMeshRenderer;

		private ActionCooldown fireCanCooldown = new ActionCooldown(0.75f, affectedByNoCooldownCheat: true);

		[UFGAsset("CanLauncher_CanProjectile")]
		public static GameObject CanProjectile { get; private set; }

		public override void OnAwakeFinished()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			List<Material> list = new List<Material>();
			for (int i = 0; i < canMaterialCount; i++)
			{
				HydraLoader.dataRegistry.TryGetValue($"CanLauncher_CanProjectile_Material_{i}", out var value);
				Material item = (Material)value;
				list.Add(item);
			}
			canMaterials = list.ToArray();
			canPrefabMeshRenderer = CanProjectile.GetComponentInChildren<MeshRenderer>();
		}

		private void Start()
		{
		}

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && fireCanCooldown.CanFire() && !om.paused)
			{
				fireCanCooldown.AddCooldown();
				Shoot();
			}
		}

		private void Shoot(Ray direction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_004e: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0098: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			Ray val = (Ray)(weaponIdentifier.duplicate ? new Ray(firePoint.position, mainCam.forward) : HydraUtils.GetProjectileAimVector(mainCam, firePoint, targetBeamThickness, maxBeamDistance));
			Vector3 direction2 = ((Ray)(ref val)).direction * shootForce;
			MonoSingleton<CameraController>.Instance.CameraShake(0.15f);
			GameObject val2 = Object.Instantiate<GameObject>(CanProjectile, firePoint.position, Quaternion.identity);
			GameObject val3 = Object.Instantiate<GameObject>(Prefabs.CanLauncher_MuzzleFX, firePoint.position, Quaternion.identity);
			val3.AddComponent<DestroyOnDisable>();
			val3.transform.forward = firePoint.forward;
			val2.transform.forward = ((Vector3)(ref direction2)).normalized;
			val3.transform.parent = firePoint.parent;
			val2.GetComponent<CanProjectile>().AlterVelocity(direction2, add: false);
			animator.Play("CanLauncher_Fire", 0, 0f);
		}

		private void Shoot()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_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)
			Vector3 position = mainCam.position;
			Vector3 val = mainCam.TransformDirection(new Vector3(0f, 0f, 1f));
			int num = Random.Range(0, canMaterials.Length);
			((Renderer)canPrefabMeshRenderer).material = canMaterials[num];
			Shoot(new Ray(position, val));
		}

		private void OnEnable()
		{
			animator.Play("CanLauncher_Equip");
		}
	}
	public class CanProjectile : MonoBehaviour, IUFGInteractionReceiver, ICleanable, ICoinTarget, IRevolverBeamShootable, IParriable
	{
		[UFGAsset("CanLauncher_CanExplosion")]
		private static GameObject canExplosion;

		[UFGAsset("CanLauncher_CanProjectile_BounceFX")]
		private static GameObject bounceFX;

		public bool trackInsteadOfPredict = true;

		public bool impactedEnemy = false;

		public bool canBeParried = true;

		public bool parried = false;

		public bool impactedOtherCan = false;

		public bool sleeping = false;

		public bool bounced = false;

		public bool dead = false;

		public bool tracking = false;

		public bool superCharge = false;

		public bool banked = false;

		public float bankVelocityMultiplier = 0.5f;

		public float trackTargetReachDistance = 1f;

		public float trackSpeed = 60f;

		public float enemyHitDamage = 1.3f;

		public float reviveParryThrowForce = 180f;

		private float lastParryTime;

		private static float parryCooldown = 0.5f;

		public float killTime = 4.5f;

		private float killTimer = 0f;

		private UltraFunGunBase.ActionCooldown damageCD = new UltraFunGunBase.ActionCooldown(0.15f);

		private Rigidbody rb;

		public Vector3 bounceForce = new Vector3(0f, 16f, 0f);

		public float returnToPlayerForce = 80f;

		public float playerPredictTime = 0.25f;

		public float upwardsForceToPlayer = 0.05f;

		public Vector3 oldVelocity;

		private Transform lastEnemyHit;

		private void Awake()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
			GameObject gameObject = ((Component)((Component)this).transform.Find("Sphere")).gameObject;
			if ((Object)(object)gameObject != (Object)null)
			{
				gameObject.layer = 10;
				gameObject.tag = "Breakable";
			}
		}

		private void Start()
		{
			killTimer = killTime;
		}

		private void Update()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			killTimer -= Time.deltaTime;
			if (killTimer <= 0f)
			{
				Explode(((Component)this).transform.up);
			}
		}

		private void LateUpdate()
		{
			//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)
			oldVelocity = rb.velocity;
		}

		public void FlyTowards(Vector3 point, float multiplier = 1f, float speed = 1f)
		{
			//IL_0001: 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_0035: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = point - ((Component)this).transform.position;
			if (speed != 1f)
			{
				((Vector3)(ref val)).Normalize();
				val *= speed;
			}
			AlterVelocity(val * multiplier, add: false);
		}

		public void AlterVelocity(Vector3 direction, bool add = true)
		{
			//IL_0029: 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_0013: 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)
			if (add)
			{
				Rigidbody obj = rb;
				obj.velocity += direction;
			}
			else
			{
				rb.velocity = direction;
			}
		}

		private Vector3 PathToPlayer()
		{
			//IL_001a: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_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_0050: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)
			Vector3 val = ((Component)MonoSingleton<CameraController>.Instance).transform.TransformPoint(0f, 0f, 0.25f) + MonoSingleton<NewMovement>.Instance.rb.velocity * playerPredictTime;
			Vector3 val2 = val - ((Component)this).transform.position;
			Vector3 result = ((Vector3)(ref val2)).normalized * returnToPlayerForce;
			result.y += upwardsForceToPlayer * ((Vector3)(ref result)).magnitude;
			return result;
		}

		public void TrackLastEnemy()
		{
			if ((Object)(object)lastEnemyHit != (Object)null)
			{
				TrackTarget(lastEnemyHit);
			}
		}

		private void SendToPlayer()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!trackInsteadOfPredict)
			{
				Vector3 val = PathToPlayer();
				((Component)this).transform.forward = val;
				canBeParried = true;
				AlterVelocity(val, add: false);
			}
			else
			{
				TrackTarget(((Component)MonoSingleton<CameraController>.Instance).transform);
			}
		}

		public void TrackTarget(Transform target)
		{
			if (!tracking)
			{
				((MonoBehaviour)this).StartCoroutine(DoTargetTrack(target));
			}
		}

		private IEnumerator DoTargetTrack(Transform target)
		{
			tracking = true;
			Vector3 targetDistance = target.position - ((Component)this).transform.position;
			while (((Vector3)(ref targetDistance)).magnitude > trackTargetReachDistance && tracking)
			{
				AlterVelocity(((Vector3)(ref targetDistance)).normalized * trackSpeed, add: false);
				yield return (object)new WaitForEndOfFrame();
				targetDistance = target.position - ((Component)this).transform.position;
			}
			tracking = false;
		}

		public void HitEnemy(EnemyIdentifier enemy, Vector3 impactSpot)
		{
			//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)
			UltraFunGuns.Log.Log("(" + ((Object)((Component)this).gameObject).name + ") can hit enemy (" + ((Object)enemy).name + ")");
			if (!dead && !enemy.dead && !((Object)(object)enemy == (Object)null))
			{
				impactedEnemy = true;
				banked = true;
				if (damageCD.CanFire())
				{
					damageCD.AddCooldown();
					enemy.DeliverDamage(((Component)enemy).gameObject, oldVelocity, impactSpot, enemyHitDamage, false, 0f, (GameObject)null, false, false);
				}
				lastEnemyHit = ((Component)enemy).transform;
				SendToPlayer();
			}
		}

		public void HitOtherCan(CanProjectile otherCan)
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			if (dead || sleeping || impactedEnemy || otherCan.sleeping || otherCan.dead)
			{
				return;
			}
			tracking = false;
			otherCan.tracking = false;
			otherCan.banked = true;
			impactedOtherCan = true;
			otherCan.impactedOtherCan = true;
			otherCan.TrackLastEnemy();
			if (parried && banked)
			{
				Explode(-oldVelocity, 2);
				if (otherCan.impactedEnemy)
				{
					otherCan.Explode(oldVelocity, 2);
				}
				UltraFunGuns.Log.Log("Parried and hit other can");
			}
			else
			{
				banked = true;
				((Component)this).transform.forward = -oldVelocity;
				killTimer += killTime;
				((Component)otherCan).transform.forward = oldVelocity;
				otherCan.AlterVelocity(oldVelocity, add: false);
				SendToPlayer();
			}
		}

		public void Bounce()
		{
			//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_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!dead)
			{
				tracking = false;
				bounced = true;
				sleeping = false;
				killTimer += killTime;
				Object.Instantiate<GameObject>(bounceFX, ((Component)this).transform.position, Quaternion.identity);
				AlterVelocity(bounceForce, add: false);
			}
		}

		public bool Parry(Vector3 origin, Vector3 aimVector)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			if (dead || !canBeParried || sleeping)
			{
				return false;
			}
			if (Time.time - lastParryTime < parryCooldown)
			{
				return false;
			}
			lastParryTime = Time.time;
			tracking = false;
			killTimer += killTime;
			if (!banked && !bounced)
			{
				AlterVelocity(((Vector3)(ref aimVector)).normalized * reviveParryThrowForce, add: false);
				rb.AddTorque(200f, 0f, 0f);
				if (!impactedOtherCan)
				{
					return true;
				}
			}
			parried = true;
			Vector3 val;
			if (impactedOtherCan || (!banked && bounced))
			{
				val = ((Component)MonoSingleton<CameraController>.Instance).transform.TransformDirection(0f, 0f, 1f);
				Explode(((Vector3)(ref val)).normalized, 2);
			}
			else
			{
				val = ((Component)MonoSingleton<CameraController>.Instance).transform.TransformDirection(0f, 0f, 1f);
				Explode(((Vector3)(ref val)).normalized, 1);
			}
			return true;
		}

		public void Explode(Vector3 direction, int strength = 0)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (strength == 3)
			{
				MonoSingleton<TimeController>.Instance.ParryFlash();
			}
			GameObject val = Object.Instantiate<GameObject>(canExplosion, ((Component)this).transform.position, Quaternion.identity);
			val.transform.forward = direction;
			Die();
			val.gameObject.GetComponent<CanExplosion>().Explode(strength);
		}

		private void OnCollisionEnter(Collision col)
		{
			//IL_008d: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00b5: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			if (tracking)
			{
				tracking = false;
			}
			if (sleeping || dead)
			{
				return;
			}
			ContactPoint contact;
			CanProjectile otherCan = default(CanProjectile);
			EnemyIdentifierIdentifier val2 = default(EnemyIdentifierIdentifier);
			EnemyIdentifier val3 = default(EnemyIdentifier);
			if (col.gameObject.tag == "Floor" || col.gameObject.layer == LayerMask.GetMask(new string[1] { "Environment" }))
			{
				if (!banked)
				{
					banked = true;
					Vector3 val = oldVelocity * bankVelocityMultiplier;
					contact = col.GetContact(0);
					Vector3 direction = Vector3.Reflect(val, ((ContactPoint)(ref contact)).normal);
					AlterVelocity(direction, add: false);
				}
				else
				{
					UltraFunGuns.Log.Log("(" + ((Object)((Component)this).gameObject).name + ") can is sleeping!");
					sleeping = true;
				}
			}
			else if (((Component)col.collider).TryGetComponent<CanProjectile>(ref otherCan))
			{
				HitOtherCan(otherCan);
			}
			else if (((Component)col.collider).TryGetComponent<EnemyIdentifierIdentifier>(ref val2) && !val2.eid.dead)
			{
				EnemyIdentifier eid = val2.eid;
				contact = col.GetContact(0);
				HitEnemy(eid, ((ContactPoint)(ref contact)).point);
			}
			else if (((Component)col.collider).TryGetComponent<EnemyIdentifier>(ref val3) && !val3.dead)
			{
				EnemyIdentifier enemy = val3;
				contact = col.GetContact(0);
				HitEnemy(enemy, ((ContactPoint)(ref contact)).point);
			}
		}

		private void Die()
		{
			if (!dead)
			{
				dead = true;
				((Component)this).gameObject.SetActive(false);
				Object.Destroy((Object)(object)((Component)this).gameObject, 4f);
			}
		}

		public bool Interact(UFGInteractionEventData interaction)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (interaction.ContainsTag("god"))
			{
				Explode(Vector3.up, 3);
				return true;
			}
			if (interaction.ContainsAnyTag("explode", "heavy", "pierce"))
			{
				Explode(interaction.direction, 1);
				return true;
			}
			if (interaction.ContainsTag("shot"))
			{
				Bounce();
				return true;
			}
			return false;
		}

		public Vector3 GetPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public bool Targetable(TargetQuery targetQuery)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (sleeping || dead)
			{
				return false;
			}
			return targetQuery.CheckTargetable(((Component)this).transform.position);
		}

		public void Cleanup()
		{
			Die();
		}

		public Transform GetCoinTargetPoint(Coin coin)
		{
			return ((Component)this).transform;
		}

		public bool CanBeCoinTargeted(Coin coin)
		{
			return !sleeping && !dead;
		}

		public void OnCoinReflect(Coin coin, RevolverBeam beam)
		{
		}

		public int GetCoinTargetPriority(Coin coin)
		{
			return 1;
		}

		public void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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)
			BeamType beamType = beam.beamType;
			BeamType val = beamType;
			switch ((int)val)
			{
			case 1:
				Explode(Vector3.up, 3);
				break;
			case 0:
				if (!beam.strongAlt)
				{
					Bounce();
				}
				else if (sleeping)
				{
					Explode(Vector3.up, 2);
				}
				else if (bounced)
				{
					Vector3 direction = ((Component)this).transform.position - ((Component)beam).transform.position;
					Explode(direction, 2);
				}
				break;
			case 2:
				Explode(Vector3.up, 3);
				break;
			case 3:
				Bounce();
				break;
			}
		}

		public bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			return !dead;
		}
	}
	public class DeadlyPlushie : MonoBehaviour, IUFGInteractionReceiver, ICleanable, IRevolverBeamShootable, ICoinTarget
	{
		private UltraFunGunBase.ActionCooldown impactCooldown = new UltraFunGunBase.ActionCooldown(0.1f);

		private Rigidbody rb;

		public GameObject sourceWeapon = null;

		public float damage = 1f;

		private bool dying = false;

		private AudioSource plushAudioSrc;

		private Vector3 lastVelo;

		private void Awake()
		{
			Fix();
		}

		private void Fix()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).gameObject.AddComponent<DestroyAfterTime>().TimeLeft = 20f;
			rb = ((Component)this).gameObject.GetComponent<Rigidbody>();
			impactCooldown.AddCooldown();
			ItemIdentifier val = default(ItemIdentifier);
			if (((Component)((Component)this).transform).TryGetComponent<ItemIdentifier>(ref val))
			{
				Object.Destroy((Object)(object)val);
			}
			AudioSource val2 = default(AudioSource);
			if (((Component)((Component)this).transform.Find("SpecialPutDownSound")).TryGetComponent<AudioSource>(ref val2))
			{
				plushAudioSrc = val2;
				plushAudioSrc.spatialBlend = 0.87f;
				PlayPlushieAudio();
			}
			Collider componentInChildren = ((Component)this).gameObject.GetComponentInChildren<Collider>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Component)componentInChildren).gameObject.layer = 14;
			}
			GameObject val3 = new GameObject(((Object)((Component)this).gameObject).name + " Hitbox");
			val3.transform.parent = ((Component)this).transform;
			val3.transform.localPosition = Vector3.zero;
			val3.transform.localRotation = Quaternion.identity;
			val3.layer = 10;
			SphereCollider val4 = val3.AddComponent<SphereCollider>();
			((Collider)val4).isTrigger = true;
			val4.radius = 1f;
		}

		private void PlayPlushieAudio()
		{
			if ((Object)(object)plushAudioSrc != (Object)null)
			{
				plushAudioSrc.Play();
			}
		}

		private void LateUpdate()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rb != (Object)null)
			{
				lastVelo = rb.velocity;
			}
		}

		private void OnCollisionEnter(Collision collision)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			ContactPoint contact;
			if (collision.IsCollisionEnemy(out var enemy))
			{
				EnemyIdentifier obj = enemy;
				GameObject gameObject = ((Component)enemy).gameObject;
				Vector3 relativeVelocity = collision.relativeVelocity;
				contact = collision.GetContact(0);
				obj.DeliverDamage(gameObject, relativeVelocity, ((ContactPoint)(ref contact)).normal, damage, true, 0.5f, sourceWeapon, false, false);
			}
			if (impactCooldown.CanFire())
			{
				Impact(collision);
				return;
			}
			Rigidbody obj2 = rb;
			Vector3 val = lastVelo;
			contact = collision.GetContact(0);
			obj2.velocity = Vector3.Reflect(val, ((ContactPoint)(ref contact)).normal) + Vector3.up * 0.25f * ((Vector3)(ref lastVelo)).magnitude;
		}

		private void Impact(Collision col)
		{
			//IL_0023: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			if (!dying)
			{
				dying = true;
				Vector3[] array = new Vector3[1];
				Vector3 position = ((Component)this).transform.position;
				ContactPoint contact = col.GetContact(0);
				array[0] = position + ((ContactPoint)(ref contact)).normal * 0.24f;
				Explode((Vector3[])(object)array);
			}
		}

		private void Explode(params Vector3[] positions)
		{
			//IL_0017: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (positions == null)
			{
				positions = (Vector3[])(object)new Vector3[1] { ((Component)this).transform.position };
			}
			for (int i = 0; i < positions.Length; i++)
			{
				GameObject val = Object.Instantiate<GameObject>(Prefabs.ShittyExplosionFX, positions[i], Quaternion.identity);
				Prefabs.ShittyExplosionSound?.PlayAudioClip(positions[i], 1f, 1f, 0.6f);
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		private void Shot(BeamType beamType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0060: 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)
			dying = true;
			VirtualExplosion virtualExplosion = new VirtualExplosion(((Component)this).transform.position, 30f);
			EnemyIdentifier[] affectedEnemies = virtualExplosion.GetAffectedEnemies();
			EnemyIdentifier[] array = affectedEnemies;
			foreach (EnemyIdentifier val in array)
			{
				val.DeliverDamage(((Component)val).gameObject, ((Component)val).transform.position - ((Component)this).transform.position, ((Component)val).transform.position, damage, true, 1f, sourceWeapon, false, false);
			}
			List<Vector3> list = affectedEnemies.Select((EnemyIdentifier x) => ((Component)x).transform.position).ToList();
			list.Add(((Component)this).transform.position);
			Explode(list.ToArray());
		}

		public bool Interact(UFGInteractionEventData interaction)
		{
			return false;
		}

		public Vector3 GetPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		public bool Targetable(TargetQuery targetQuery)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return targetQuery.CheckTargetable(((Component)this).transform.position);
		}

		public void Cleanup()
		{
			Explode();
		}

		public void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			Shot(beam.beamType);
		}

		public bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			return true;
		}

		public Transform GetCoinTargetPoint(Coin coin)
		{
			return ((Component)this).transform;
		}

		public bool CanBeCoinTargeted(Coin coin)
		{
			return true;
		}

		public void OnCoinReflect(Coin coin, RevolverBeam beam)
		{
		}

		public int GetCoinTargetPriority(Coin coin)
		{
			return 2;
		}
	}
	[UFGWeapon("PlushieCannon", "dev_cannon", 3, true, WeaponIconColor.Yellow, false, true)]
	[WeaponAbility("DeliverDamage<color=white>();</color>", "Fire a plushie with <color=orange>Fire 1</color>", 0, RichTextColors.aqua)]
	[WeaponAbility("Fray<color=white>();</color>", "Firing upon a plushie will result in a frayed explosion.", 1, RichTextColors.red)]
	public class PlushieCannon : UltraFunGunBase
	{
		private GameObject[] plushies = (GameObject[])(object)new GameObject[28]
		{
			Prefabs.HakitaPlush.Asset,
			Prefabs.MakoPlush.Asset,
			Prefabs.GianniPlush.Asset,
			Prefabs.DaliaPlush.Asset,
			Prefabs.PITRPlush.Asset,
			Prefabs.BigRockPlush.Asset,
			Prefabs.CameronPlush.Asset,
			Prefabs.VvizardPlush.Asset,
			Prefabs.DawgPlush.Asset,
			Prefabs.FrancisPlush.Asset,
			Prefabs.SaladPlush.Asset,
			Prefabs.HeckPlush.Asset,
			Prefabs.KGCPlush.Asset,
			Prefabs.MegaNekoPlush.Asset,
			Prefabs.LucasPlush.Asset,
			Prefabs.JoyPlush.Asset,
			Prefabs.JerichoPlush.Asset,
			Prefabs.MandyPlush.Asset,
			Prefabs.V1Plush.Asset,
			Prefabs.ScottPlush.Asset,
			Prefabs.CabalCrowPlush.Asset,
			Prefabs.QuetzalPlush.Asset,
			Prefabs.HealthBJPlush.Asset,
			Prefabs.HealthJakePlush.Asset,
			Prefabs.HealthJohnPlush.Asset,
			Prefabs.LenvalPlush.Asset,
			Prefabs.WeytePlush.Asset,
			Prefabs.HydraPlushie
		};

		private float targetBeamThickness = 0.5f;

		private float maxBeamDistance = 50f;

		[Configgable("Weapons/dev_cannon", null, 0, null)]
		private static float shootForce = 130f;

		[Configgable("Weapons/dev_cannon", null, 0, null)]
		private static float plushieSpinSpeed = 90f;

		[Configgable("Weapons/dev_cannon", null, 0, null)]
		private static float damage = 1f;

		private ActionCooldown fireCooldown = new ActionCooldown(0.6f, affectedByNoCooldownCheat: true);

		private GameObject lastFired;

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && !om.paused && fireCooldown.CanFire())
			{
				fireCooldown.AddCooldown();
				Fire();
			}
		}

		private void Fire()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			Ray val = (Ray)(weaponIdentifier.duplicate ? new Ray(firePoint.position, mainCam.forward) : HydraUtils.GetProjectileAimVector(mainCam, firePoint, targetBeamThickness, maxBeamDistance));
			Vector3 velocity = ((Ray)(ref val)).direction * shootForce;
			lastFired = PickPlushie();
			GameObject val2 = Object.Instantiate<GameObject>(lastFired, firePoint.position + firePoint.forward * 0.35f, Quaternion.identity);
			val2.transform.forward = ((Vector3)(ref velocity)).normalized;
			DeadlyPlushie deadlyPlushie = val2.AddComponent<DeadlyPlushie>();
			deadlyPlushie.sourceWeapon = ((Component)this).gameObject;
			deadlyPlushie.damage = damage;
			Rigidbody val3 = default(Rigidbody);
			if (((Component)deadlyPlushie).TryGetComponent<Rigidbody>(ref val3))
			{
				val3.velocity = velocity;
				float num = (Random.value - 0.5f) * 2f;
				val3.AddRelativeTorque(Vector3.forward * plushieSpinSpeed * num);
			}
			GameObject val4 = Object.Instantiate<GameObject>(Prefabs.CanLauncher_MuzzleFX, firePoint.position, Quaternion.identity);
			val4.AddComponent<DestroyOnDisable>();
			val4.transform.forward = firePoint.forward;
			val4.transform.parent = firePoint.parent;
			MonoSingleton<CameraController>.Instance.CameraShake(0.3f);
			animator.Play("CanLauncher_Fire", 0, 0f);
		}

		private GameObject PickPlushie()
		{
			GameObject[] array = plushies;
			if ((Object)(object)lastFired != (Object)null && plushies.Length > 1)
			{
				array = plushies.Where((GameObject x) => (Object)(object)x != (Object)(object)lastFired && (Object)(object)x != (Object)null).ToArray();
			}
			return array[Random.Range(0, array.Length)];
		}

		private void OnEnable()
		{
			animator.Play("CanLauncher_Equip");
		}

		public override string GetDebuggingText()
		{
			string text = base.GetDebuggingText();
			if ((Object)(object)lastFired != (Object)null)
			{
				text = text + "LAST_FIRED: " + ((Object)lastFired).name + "\n";
			}
			return text;
		}
	}
	public class PlutonRifle : UltraFunGunBase
	{
		[Configgable("Weapons/Pluton Rifle", null, 0, null)]
		private static int shotBurstCount = 3;

		[Configgable("Weapons/Pluton Rifle", null, 0, null)]
		private static float maxShotWindowTime = 0.75f;

		[Configgable("Weapons/Pluton Rifle", null, 0, null)]
		private static float minShotWindowTime = 0.25f;

		[Configgable("Weapons/Pluton Rifle", null, 0, null)]
		private static float ventCooldownPerShot = 1.25f;

		[Configgable("Weapons/Pluton Rifle", null, 0, null)]
		private static float minimumBurstCooldown = 0.5f;

		[Configgable("Weapons/Pluton Rifle", null, 0, null)]
		private static float maxRange = 2000f;

		[Configgable("Weapons/Pluton Rifle", null, 0, null)]
		private static float projectileSpeed = 14f;

		private float lastFireTime;

		private float ventTimeLeft;

		private int burstShotsRemaining = 0;

		private static GameObject plutonProjectilePrefab;

		[UFGAsset("PlutonShot")]
		private static GameObject plutonProjectileVisualPrefab;

		private float timeSinceLastFire => Time.time - lastFireTime;

		private LayerMask hitMask => LayerMaskDefaults.Get((LMD)3);

		private bool firePressedThisFrame => MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && !om.paused;

		private void Update()
		{
			HandlePrimaryAction();
			HandleVenting();
		}

		private void HandlePrimaryAction()
		{
			if (!(ventTimeLeft > 0f))
			{
				if (firePressedThisFrame)
				{
					FireUser();
				}
				else if (burstShotsRemaining > 0 && burstShotsRemaining < shotBurstCount)
				{
					CheckOverheat();
				}
			}
		}

		private void HandleVenting()
		{
			if (!(ventTimeLeft <= 0f))
			{
				ventTimeLeft = Mathf.Max(0f, ventTimeLeft - Time.deltaTime);
				if (!(ventTimeLeft > 0f))
				{
					burstShotsRemaining = shotBurstCount;
				}
			}
		}

		private void CheckOverheat()
		{
			if (!(timeSinceLastFire < maxShotWindowTime))
			{
				float ventCooldownTime = minimumBurstCooldown + (float)burstShotsRemaining * ventCooldownPerShot;
				AddVentCooldown(ventCooldownTime);
			}
		}

		private void AddVentCooldown(float ventCooldownTime)
		{
			ventTimeLeft = Mathf.Max(0f, ventTimeLeft + ventCooldownTime);
		}

		private void FireUser()
		{
			if (timeSinceLastFire < minShotWindowTime)
			{
				return;
			}
			FireProjectile(delegate(GameObject p, GameObject v)
			{
				//IL_0015: 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_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
				RayProjectile rayProjectile = p.AddComponent<RayProjectile>();
				rayProjectile.StepDistance = projectileSpeed;
				rayProjectile.Hitmask = hitMask;
				rayProjectile.OnHit = (Action<RaycastHit, RayProjectile>)Delegate.Combine(rayProjectile.OnHit, new Action<RaycastHit, RayProjectile>(LogicHit));
				RayProjectile rayProjectile2 = v.AddComponent<RayProjectile>();
				rayProjectile2.StepDistance = projectileSpeed;
				rayProjectile2.Hitmask = hitMask;
				rayProjectile2.OnHit = (Action<RaycastHit, RayProjectile>)Delegate.Combine(rayProjectile2.OnHit, new Action<RaycastHit, RayProjectile>(VisualHit));
				Vector3 forward = firePoint.forward;
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(mainCam.position, mainCam.forward, ref val, maxRange, LayerMask.op_Implicit(hitMask)))
				{
					Vector3 val2 = ((RaycastHit)(ref val)).point - firePoint.position;
					forward = ((Vector3)(ref val2)).normalized;
				}
				v.transform.position = firePoint.position;
				v.transform.forward = forward;
			});
			UltraFunGuns.Log.Log("Pluton: Bang!");
			lastFireTime = Time.time;
			burstShotsRemaining--;
			if (burstShotsRemaining <= 0)
			{
				AddVentCooldown(minimumBurstCooldown);
			}
		}

		private void FireProjectile(Action<GameObject, GameObject> onIntance)
		{
			//IL_000c: 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_001c: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			GameObject arg = Object.Instantiate<GameObject>(plutonProjectilePrefab, mainCam.position, Quaternion.LookRotation(mainCam.forward));
			GameObject arg2 = Object.Instantiate<GameObject>(plutonProjectileVisualPrefab, firePoint.position, Quaternion.LookRotation(mainCam.forward));
			onIntance?.Invoke(arg, arg2);
		}

		private void LogicHit(RaycastHit hit, RayProjectile projectile)
		{
			if (!((RaycastHit)(ref hit)).collider.IsColliderEnemy(out var _))
			{
			}
		}

		private void VisualHit(RaycastHit hit, RayProjectile projectile)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			((Component)projectile).transform.position = ((RaycastHit)(ref hit)).point;
			Object.Destroy((Object)(object)((Component)projectile).gameObject);
		}

		private void OnEnable()
		{
			burstShotsRemaining = shotBurstCount;
			ventTimeLeft = Mathf.Max(0f, ventTimeLeft - (Time.time - lastFireTime));
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"BSR: {burstShotsRemaining}\n";
			debuggingText += $"VTL: {ventTimeLeft}\n";
			return debuggingText + $"LFT: {lastFireTime}\n";
		}
	}
	public class Praime : UltraFunGunBase
	{
	}
	public abstract class PraimeBeam
	{
		public abstract bool Initialize();

		public abstract bool CanFire();

		public abstract bool Fire();

		public virtual void OnSwitcOn()
		{
		}

		public virtual void OnSwitchOff()
		{
		}
	}
	[UFGWeapon("TrainGun", "Conductor", 2, true, WeaponIconColor.Red, false, true)]
	public class TrainGun : UltraFunGunBase
	{
		[UFGAsset("TrainGun_Train")]
		private static GameObject TrainPrefab;

		[UFGAsset("TrainGunWarningLoop")]
		private static AudioClip trainWarningClip;

		[Configgable("Weapons/Conductor", null, 0, null)]
		private static float arrivalDelay = 2.5f;

		[Configgable("Weapons/Conductor", null, 0, null)]
		private static float cooldown = 5f;

		private List<TrainGunTrain> instancedTrains = new List<TrainGunTrain>();

		private bool pickingDirection;

		private Vector3 targetPoint;

		private Vector3 endPoint;

		private Vector3 observedDirection;

		private float currentCooldown = 0f;

		private float timeDisabled;

		private GameObject primitiveSphereTargeter;

		private GameObject primitiveSphereTargeter2;

		private void Start()
		{
			primitiveSphereTargeter = GameObject.CreatePrimitive((PrimitiveType)0);
			Collider val = default(Collider);
			if (primitiveSphereTargeter.TryGetComponent<Collider>(ref val))
			{
				val.enabled = false;
			}
			primitiveSphereTargeter.SetActive(false);
			primitiveSphereTargeter2 = GameObject.CreatePrimitive((PrimitiveType)0);
			Collider val2 = default(Collider);
			if (primitiveSphereTargeter2.TryGetComponent<Collider>(ref val2))
			{
				val2.enabled = false;
			}
			primitiveSphereTargeter2.SetActive(false);
		}

		private void Update()
		{
			//IL_005a: 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)
			InputUpdate();
			currentCooldown -= Time.deltaTime;
			GameObject obj = primitiveSphereTargeter;
			if (obj != null)
			{
				obj.SetActive(pickingDirection);
			}
			if (pickingDirection && (Object)(object)primitiveSphereTargeter != (Object)null)
			{
				primitiveSphereTargeter.transform.position = endPoint;
			}
			GameObject obj2 = primitiveSphereTargeter2;
			if (obj2 != null)
			{
				obj2.SetActive(pickingDirection);
			}
			if (pickingDirection && (Object)(object)primitiveSphereTargeter2 != (Object)null)
			{
				primitiveSphereTargeter2.transform.position = targetPoint;
			}
		}

		private void InputUpdate()
		{
			//IL_00a9: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_0088: 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_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)
			if (om.paused || !CanFire())
			{
				return;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed)
			{
				if (!pickingDirection)
				{
					targetPoint = GetLookPoint();
					pickingDirection = true;
				}
				else
				{
					Vector3 lookPoint = GetLookPoint();
					lookPoint.y = targetPoint.y;
					observedDirection = lookPoint;
					endPoint = lookPoint;
				}
			}
			else if (pickingDirection)
			{
				pickingDirection = false;
				Vector3 lookPoint2 = GetLookPoint();
				lookPoint2.y = targetPoint.y;
				observedDirection = lookPoint2;
				endPoint = lookPoint2;
				FireTrain();
				return;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame)
			{
				if (pickingDirection)
				{
					pickingDirection = false;
				}
				else
				{
					FireTrain();
				}
			}
		}

		private Vector3 GetLookPoint()
		{
			//IL_0007: 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_001f: 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_0064: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_007f: 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_0091: 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_00b5: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(mainCam.position, mainCam.forward, ref val, float.PositiveInfinity, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
			{
				return ((Component)player).transform.position + Random.onUnitSphere * 0.02f;
			}
			if (Vector3.Dot(Vector3.up, ((RaycastHit)(ref val)).normal) <= 0.25f)
			{
				RaycastHit val2 = default(RaycastHit);
				if (!Physics.Raycast(((RaycastHit)(ref val)).point, Vector3.down, ref val2, float.PositiveInfinity, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
				{
					return ((RaycastHit)(ref val)).point;
				}
				return ((RaycastHit)(ref val2)).point;
			}
			return ((RaycastHit)(ref val)).point;
		}

		private bool CanFire()
		{
			if (NoWeaponCooldown.NoCooldown)
			{
				return true;
			}
			return currentCooldown <= 0f;
		}

		private void FireTrain()
		{
			//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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_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_0088: 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)
			float moveSpeed = TrainGunTrain.moveSpeed;
			Vector3 val = endPoint - targetPoint;
			Vector3 val2 = Vector3.Lerp(targetPoint, endPoint, 0.5f);
			Vector3 val3 = val2 - moveSpeed * arrivalDelay * ((Vector3)(ref val)).normalized;
			currentCooldown = cooldown;
			GameObject val4 = Object.Instantiate<GameObject>(TrainPrefab, val3, Quaternion.LookRotation(((Vector3)(ref val)).normalized));
			GameObject trainWarningSound = CreateTrainWarning(targetPoint + Vector3.up * 4f, arrivalDelay);
			BehaviourRelay behaviourRelay = val4.AddComponent<BehaviourRelay>();
			behaviourRelay.OnOnDestroy = (Action<GameObject>)Delegate.Combine(behaviourRelay.OnOnDestroy, (Action<GameObject>)delegate
			{
				if ((Object)(object)trainWarningSound != (Object)null)
				{
					Object.Destroy((Object)(object)trainWarningSound);
				}
			});
			TrainGunTrain trainGunTrain = default(TrainGunTrain);
			if (val4.TryGetComponent<TrainGunTrain>(ref trainGunTrain))
			{
				trainGunTrain.SetOwner(((Component)this).gameObject);
				instancedTrains.Add(trainGunTrain);
			}
		}

		private GameObject CreateTrainWarning(Vector3 position, float delay)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_001f: 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)
			GameObject val = new GameObject("TrainWarning");
			val.transform.position = position;
			val.AddComponent<Cleanable>();
			Light i = val.AddComponent<Light>();
			i.color = Color.red;
			i.range = 20f;
			AudioSource source = val.AddComponent<AudioSource>();
			source.clip = trainWarningClip;
			source.loop = true;
			source.spatialBlend = 0.8f;
			source.Play();
			float timer = delay;
			val.AddComponent<BehaviourRelay>().OnUpdate = delegate
			{
				timer -= Time.deltaTime;
				float num = 1f - timer / delay;
				num = Mathf.Clamp01(num);
				i.intensity = Mathf.Lerp(0f, 5f, num);
				source.volume = 1f - num;
			};
			return val;
		}

		private void OnEnable()
		{
			currentCooldown = Mathf.Min(currentCooldown, Time.time - timeDisabled);
		}

		private void OnDisable()
		{
			pickingDirection = false;
			timeDisabled = Time.time;
			GameObject obj = primitiveSphereTargeter;
			if (obj != null)
			{
				obj.SetActive(false);
			}
		}
	}
	public class TrainGunTrain : MonoBehaviour, ICleanable
	{
		[SerializeField]
		private BoxCollider boxcastRef;

		[Configgable("Weapons/Conductor", null, 0, null)]
		public static float moveSpeed = 150f;

		[Configgable("Weapons/Conductor", null, 0, null)]
		private static float hitCooldownTime = 0.35f;

		[Configgable("Weapons/Conductor", null, 0, null)]
		private static float enemyDamage = 3f;

		[Configgable("Weapons/Conductor", null, 0, null)]
		private static float rbLaunchForce = 85f;

		[Configgable("Weapons/Conductor", null, 0, null)]
		private static float travelDistance = 1000f;

		private Dictionary<Collider, float> hits = new Dictionary<Collider, float>();

		private float distanceTraveled = 0f;

		private GameObject owner;

		public void SetOwner(GameObject owner)
		{
			this.owner = owner;
		}

		private void FixedUpdate()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002a: 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_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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_007d: 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_00a4: 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_00ab: 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)
			Vector3 position = ((Component)this).transform.position;
			float num = moveSpeed * Time.fixedDeltaTime;
			Vector3 val = num * ((Component)this).transform.forward;
			Vector3 val2 = Vector3.Scale(boxcastRef.size, ((Component)boxcastRef).transform.localScale);
			RaycastHit[] array = Physics.BoxCastAll(((Component)boxcastRef).transform.position, val2 * 0.5f, ((Component)this).transform.forward, ((Component)boxcastRef).transform.rotation, ((Vector3)(ref val)).magnitude, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)4)));
			HitObjects(array);
			position += val;
			((Component)this).transform.position = position;
			distanceTraveled += num;
			if (distanceTraveled >= travelDistance)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void HitObjects(RaycastHit[] hits)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			foreach (RaycastHit hit in hits)
			{
				HitObject(hit);
			}
		}

		private void HitObject(RaycastHit hit)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			if (!hits.ContainsKey(((RaycastHit)(ref hit)).collider) || !(Time.time - hits[((RaycastHit)(ref hit)).collider] < hitCooldownTime))
			{
				Vector3 val = ((RaycastHit)(ref hit)).point - ((Component)boxcastRef).transform.position;
				Vector3 val2 = ((Vector3)(ref val)).normalized * rbLaunchForce;
				val2.y = 1.25f * Mathf.Abs(val2.y);
				if (((Component)((RaycastHit)(ref hit)).collider).tag == "Player")
				{
					MonoSingleton<NewMovement>.Instance.Launch(val2, 8f, false);
					MonoSingleton<NewMovement>.Instance.GetHurt(30, false, 2f, false, true, 0.35f, false);
					hits[((RaycastHit)(ref hit)).collider] = Time.time;
				}
				if ((((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 10 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 11 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 12 || ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer == 20) && ((RaycastHit)(ref hit)).collider.IsColliderEnemy(out var enemy))
				{
					hits[((RaycastHit)(ref hit)).collider] = Time.time;
					enemy.hitter = "TrainGun";
					enemy.DeliverDamage(((Component)enemy).gameObject, ((Vector3)(ref val)).normalized, ((RaycastHit)(ref hit)).point, enemyDamage, true, 0f, owner, false, false);
				}
			}
		}

		public void Cleanup()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	[UFGWeapon("RemoteBomb", "Radio Explosive", 3, true, WeaponIconColor.Red, true, true)]
	[WeaponAbility("Throw", "Press <color=orange>Fire 1</color> to throw an explosive.", 0, RichTextColors.aqua)]
	[WeaponAbility("Detonate", "Press <color=orange>Fire 2</color> detonate armed explosives.", 1, RichTextColors.lime)]
	[WeaponAbility("Mortar", "Parry a thrown bomb to boost your throw.", 2, RichTextColors.yellow)]
	[WeaponAbility("Demolition", "Clumps of bombs have increased yield.", 3, RichTextColors.yellow)]
	public class RemoteBomb : UltraFunGunBase
	{
		[Configgable("Weapons/Radio Explosive", null, 0, null)]
		private static float bombDetonationDelay = 0.035f;

		[Configgable("Weapons/Radio Explosive", null, 0, null)]
		private static float throwForce = 50f;

		[Configgable("Weapons/Radio Explosive", null, 0, null)]
		private static float primaryFireCooldown = 0.45f;

		[Configgable("Weapons/Radio Explosive", null, 0, null)]
		private static float secondaryFireCooldown = 0.25f;

		private List<RemoteBombExplosive> thrownExplosives = new List<RemoteBombExplosive>();

		private bool throwingExplosive = false;

		private ActionCooldown throwBombCD = new ActionCooldown(primaryFireCooldown, affectedByNoCooldownCheat: true);

		private ActionCooldown detonateBombCD = new ActionCooldown(secondaryFireCooldown, affectedByNoCooldownCheat: true);

		[UFGAsset("RemoteBomb_Explosive")]
		public static GameObject RemoteExplosivePrefab { get; private set; }

		public override void OnAwakeFinished()
		{
			AddSFX("Throw", "Detonate");
		}

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && !om.paused)
			{
				FirePrimary();
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && !om.paused)
			{
				FireSecondary();
			}
		}

		public override void FirePrimary()
		{
			UltraFunGuns.Log.Log("Remote bomb fired primary");
			if (throwBombCD.CanFire() && !throwingExplosive)
			{
				throwBombCD.AddCooldown();
				((MonoBehaviour)this).StartCoroutine(ThrowExplosive());
			}
		}

		public override void FireSecondary()
		{
			if (!detonateBombCD.CanFire())
			{
				return;
			}
			if (thrownExplosives.Count > 0)
			{
				detonateBombCD.AddCooldown();
				animator.Play("RemoteBomb_Anim_Detonate", 0, 0f);
				PlaySFX("Detonate", 0.85f);
				List<RemoteBombExplosive> list = new List<RemoteBombExplosive>();
				List<RemoteBombExplosive> list2 = new List<RemoteBombExplosive>(thrownExplosives);
				foreach (RemoteBombExplosive item in list2)
				{
					if ((Object)(object)item != (Object)null)
					{
						if (item.CanDetonate())
						{
							list.Add(item);
						}
					}
					else
					{
						thrownExplosives.Remove(item);
					}
				}
				foreach (RemoteBombExplosive item2 in list)
				{
					thrownExplosives.Remove(item2);
				}
				DetonateExplosives(list);
			}
			else
			{
				UltraFunGuns.Log.Log("(" + ((Object)((Component)this).gameObject).name + ") No bombs to detonate");
			}
		}

		private IEnumerator ThrowExplosive()
		{
			UltraFunGuns.Log.Log("(" + ((Object)((Component)this).gameObject).name + ") Throwing explosive");
			animator.Play("RemoteBomb_Anim_Throw", 0, 0f);
			throwingExplosive = true;
			yield return (object)new WaitForSeconds(0.1666f);
			PlaySFX("Throw", 0.95f, 1.15f);
			Ray aimRay = (Ray)(weaponIdentifier.duplicate ? new Ray(firePoint.position, mainCam.forward) : HydraUtils.GetProjectileAimVector(mainCam, firePoint, 0.25f, 40f));
			GameObject newExplosive = Object.Instantiate<GameObject>(RemoteExplosivePrefab, firePoint.position, Quaternion.identity);
			RemoteBombExplosive newBomb = newExplosive.GetComponent<RemoteBombExplosive>();
			newBomb.Initiate(this, player);
			((Component)newBomb).transform.forward = -((Ray)(ref aimRay)).direction;
			newBomb.SetVelocity(((Ray)(ref aimRay)).direction * throwForce);
			thrownExplosives.Add(newBomb);
			throwingExplosive = false;
		}

		private async void DetonateExplosives(List<RemoteBombExplosive> bombs)
		{
			while (bombs.Count > 0)
			{
				RemoteBombExplosive bomb = bombs[0];
				bombs.Remove(bomb);
				if ((Object)(object)bomb != (Object)null)
				{
					bomb.Detonate();
					float timer = bombDetonationDelay;
					while (timer > 0f)
					{
						timer -= Time.deltaTime;
						await Task.Yield();
					}
				}
			}
		}

		protected override void DoAnimations()
		{
		}

		public void BombDetonated(RemoteBombExplosive bomb)
		{
			if (thrownExplosives.Contains(bomb))
			{
				thrownExplosives.Remove(bomb);
			}
		}

		private void OnDisable()
		{
			throwingExplosive = false;
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			return debuggingText + $"BOMBCOUNT: {thrownExplosives.Count}\n" + $"THROW_CD: {throwBombCD}\n" + $"DETONATE_CD: {detonateBombCD}";
		}
	}
	public class RemoteBombExplosive : MonoBehaviour, ICleanable, IRevolverBeamShootable, IUFGShootable
	{
		private RemoteBomb weapon;

		private NewMovement player;

		private EnemyIdentifier stuckTarget;

		private Rigidbody rb;

		private Renderer indicatorLight;

		public float armTime = 0.05f;

		public float blinkInterval = 0.75f;

		public float blinkTime = 0.05f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float parryForce = 150f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float playerKnockbackMultiplier = 70f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float rigidbodyForceMultiplier = 70f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float explosionRadius = 6f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float explosionDamage = 1.6f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float explosionChainDelay = 0.2f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float stuckDamageMultiplier = 1.5f;

		[Configgable("Weapons/Radio Explosive/Bomb", null, 0, null)]
		private static float stickDamage = 0.05f;

		private bool thrown = false;

		private bool armed = false;

		private bool landed = false;

		private bool alive = true;

		private bool pushedPlayer = false;

		private AudioSource AC_armingBeep;

		private AudioSource AC_ambientBeep;

		private static Vector3 lastExplosionPosition = Vector3.zero;

		private List<RemoteBombExplosive> chainedExplosives = new List<RemoteBombExplosive>();

		private bool waitingToExplode = false;

		[UFGAsset("RemoteBomb_Explosive_Explosion")]
		public static GameObject ExplosionPrefab { get; private set; }

		private void Awake()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
			indicatorLight = ((Component)((Component)this).transform.Find("BombMesh/Blinker")).GetComponent<Renderer>();
			AC_armingBeep = ((Component)((Component)this).transform.Find("Audios/Arm_Beep")).GetComponent<AudioSource>();
			AC_ambientBeep = ((Component)((Component)this).transform.Find("Audios/Beep")).GetComponent<AudioSource>();
		}

		public void Initiate(RemoteBomb remoteBomb, NewMovement newMovement)
		{
			weapon = remoteBomb;
			player = newMovement;
			Thrown();
		}

		private void Update()
		{
			if (alive && thrown && (Object)(object)weapon == (Object)null)
			{
				Detonate(force: true);
			}
		}

		public void SetVelocity(Vector3 newVelocity)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)rb))
			{
				rb.velocity = newVelocity;
			}
		}

		public bool Parriable()
		{
			return !landed && !armed;
		}

		public bool Parry(Vector3 origin, Vector3 direction)
		{
			//IL_0024: 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)
			if (!landed && !armed)
			{
				Arm();
				SetVelocity(((Vector3)(ref direction)).normalized * parryForce);
				return true;
			}
			return false;
		}

		private void Thrown()
		{
			thrown = true;
			((MonoBehaviour)this).StartCoroutine(ArmExplosive());
			((MonoBehaviour)this).StartCoroutine(DoIndicator());
		}

		private IEnumerator ArmExplosive()
		{
			float timer = armTime;
			while (timer > 0f && !armed)
			{
				timer -= Time.deltaTime;
				yield return (object)new WaitForEndOfFrame();
			}
			Arm();
		}

		private IEnumerator DoIndicator()
		{
			if (!((Object)(object)indicatorLight != (Object)null))
			{
				yield break;
			}
			while (alive)
			{
				if (!armed)
				{
					indicatorLight.material.SetColor("_EmissiveColor", Color.green);
					yield return (object)new WaitForEndOfFrame();
					continue;
				}
				float timer2 = blinkInterval;
				indicatorLight.material.SetColor("_EmissiveColor", Color.black);
				while (timer2 > 0f)
				{
					timer2 -= Time.deltaTime;
					yield return (object)new WaitForEndOfFrame();
				}
				timer2 = blinkTime;
				indicatorLight.material.SetColor("_EmissiveColor", Color.red);
				AC_ambientBeep.Play();
				while (timer2 > 0f)
				{
					timer2 -= Time.deltaTime;
					yield return (object)new WaitForEndOfFrame();
				}
			}
		}

		public bool CanDetonate()
		{
			return armed && alive;
		}

		private bool ChainDetonate(RemoteBombExplosive source, float delay)
		{
			if (chainedExplosives.Contains(source) || !alive || waitingToExplode)
			{
				return false;
			}
			UltraFunGuns.Log.Log($"Detonating after time! {delay}");
			waitingToExplode = true;
			((MonoBehaviour)this).StartCoroutine(DetonateAfterTime(delay));
			return true;
		}

		private IEnumerator DetonateAfterTime(float seconds)
		{
			yield return (object)new WaitForSeconds(seconds);
			Detonate(force: true);
		}

		public bool Detonate(bool force = false)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if ((force || armed) && alive)
			{
				Events.OnPlayerDeath = (Events.EventHandler)Delegate.Remove(Events.OnPlayerDeath, (Events.EventHandler)delegate
				{
					Detonate(force: true);
				});
				alive = false;
				GameObject val = Object.Instantiate<GameObject>(ExplosionPrefab, ((Component)this).transform.position, Quaternion.identity);
				val.transform.up = ((Component)this).transform.forward;
				weapon.BombDetonated(this);
				DoExplosion();
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return true;
			}
			return false;
		}

		private void Arm()
		{
			armed = true;
			AC_armingBeep.Play();
		}

		private void DoExplosion()
		{
			//IL_000f: 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_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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: 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_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: 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_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05de: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			Rigidbody val = null;
			Visualizer.DrawSphere(((Component)this).transform.position, explosionRadius, 2f);
			Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, explosionRadius, LayerMask.GetMask(new string[6] { "Limb", "Projectile", "BigCorpse", "Armor", "Default", "Ignore Raycast" }));
			if (array == null)
			{
				return;
			}
			Collider[] array2 = array;
			EnemyIdentifierIdentifier val5 = default(EnemyIdentifierIdentifier);
			EnemyIdentifier val6 = default(EnemyIdentifier);
			IUFGInteractionReceiver iUFGInteractionReceiver = default(IUFGInteractionReceiver);
			NewMovement val7 = default(NewMovement);
			Breakable val9 = default(Breakable);
			Glass val10 = default(Glass);
			Rigidbody val11 = default(Rigidbody);
			foreach (Collider val2 in array2)
			{
				if (((Component)val2).tag == "Floor")
				{
					continue;
				}
				Vector3 val3 = val2.ClosestPoint(((Component)this).transform.position);
				Vector3 val4 = val3 - ((Component)this).transform.position;
				float magnitude = ((Vector3)(ref val4)).magnitude;
				if (((Component)val2).TryGetComponent<EnemyIdentifierIdentifier>(ref val5) && !list.Contains(val5.eid) && !val5.eid.dead)
				{
					float num = Mathf.InverseLerp(explosionRadius, 0f, magnitude);
					float num2 = (((Object)(object)val5.eid == (Object)(object)stuckTarget) ? (explosionDamage * num * stuckDamageMultiplier) : (explosionDamage * num));
					val5.eid.DeliverDamage(((Component)val5.eid).gameObject, ((Vector3)(ref val4)).normalized, val3, num2, true, 0f, ((Component)weapon).gameObject, false, false);
					list.Add(val5.eid);
				}
				if (((Component)val2).TryGetComponent<EnemyIdentifier>(ref val6) && !list.Contains(val6) && !val6.dead)
				{
					float num3 = Mathf.InverseLerp(explosionRadius, 0f, magnitude);
					float num4 = (((Object)(object)val6 == (Object)(object)stuckTarget) ? (explosionDamage * num3 * stuckDamageMultiplier) : (explosionDamage * num3));
					val6.DeliverDamage(((Component)val6).gameObject, ((Vector3)(ref val4)).normalized, val3, num4, true, 0f, ((Component)weapon).gameObject, false, false);
					list.Add(val6);
				}
				if (val2.TryFindComponent<RemoteBombExplosive>(out var component))
				{
					float num5 = Mathf.InverseLerp(0f, explosionRadius, magnitude);
					if (chainedExplosives.Count > 100)
					{
						Object.Destroy((Object)(object)((Component)component).gameObject);
					}
					else if (component.ChainDetonate(this, explosionChainDelay * num5))
					{
						chainedExplosives.Add(component);
					}
				}
				else if (((Component)val2).TryGetComponent<IUFGInteractionReceiver>(ref iUFGInteractionReceiver))
				{
					UFGInteractionEventData uFGInteractionEventData = default(UFGInteractionEventData);
					uFGInteractionEventData.data = "";
					uFGInteractionEventData.tags = new string[2] { "explode", "fire" };
					uFGInteractionEventData.direction = ((Component)this).transform.forward;
					uFGInteractionEventData.interactorPosition = ((Component)this).transform.position;
					uFGInteractionEventData.invokeType = typeof(RemoteBombExplosive);
					uFGInteractionEventData.power = chainedExplosives.Count;
					UFGInteractionEventData uFGInteractionEventData2 = uFGInteractionEventData;
				}
				if (((Component)val2).TryGetComponent<NewMovement>(ref val7) && !pushedPlayer)
				{
					float num6 = Mathf.InverseLerp(explosionRadius * 4f, 0f, magnitude);
					MonoSingleton<CameraController>.Instance.CameraShake(num6 * 1.5f);
					Vector3 position = ((Component)val7).transform.position;
					position.y += 1.25f;
					Vector3 val8 = position - ((Component)this).transform.position;
					val = val7.rb;
					Rigidbody obj = val;
					obj.velocity += ((Vector3)(ref val8)).normalized * (explosionDamage * num6) * playerKnockbackMultiplier;
					pushedPlayer = true;
				}
				if (((Component)val2).TryGetComponent<Breakable>(ref val9))
				{
					val9.Break();
				}
				if (((Component)val2).TryGetComponent<Glass>(ref val10))
				{
					val10.Shatter();
				}
				if (((Component)val2).TryGetComponent<Rigidbody>(ref val11))
				{
					bool flag = true;
					if ((Object)(object)val != (Object)null && (Object)(object)val11 == (Object)(object)val)
					{
						flag = false;
					}
					if (!val11.isKinematic && flag)
					{
						float num7 = Mathf.InverseLerp(explosionRadius, 0f, magnitude);
						val11.AddExplosionForce(explosionDamage * 50f * num7 * rigidbodyForceMultiplier, ((Component)this).transform.position, explosionRadius);
					}
				}
			}
			int count = chainedExplosives.Count;
			if (waitingToExplode && Vector3.Distance(lastExplosionPosition, ((Component)this).transform.position) < 8f)
			{
				return;
			}
			int num8 = count;
			int num9 = num8;
			if (num9 == 0)
			{
				return;
			}
			if (count > 2 && count < 6)
			{
				Object.Instantiate<GameObject>(Prefabs.UK_Explosion.Asset, ((Component)this).transform.position, Quaternion.identity);
				lastExplosionPosition = ((Component)this).transform.position;
				return;
			}
			int num10 = num9;
			if (count > 6 && count < 100)
			{
				Object.Instantiate<GameObject>(Prefabs.UK_ExplosionMalicious.Asset, ((Component)this).transform.position, Quaternion.identity);
				lastExplosionPosition = ((Component)this).transform.position;
				return;
			}
			int num11 = num9;
			if (count > 100)
			{
				Object.Instantiate<GameObject>(MysticFlare.MysticFlareExplosion, ((Component)this).transform.position, Quaternion.identity);
				lastExplosionPosition = ((Component)this).transform.position;
			}
		}

		private void StickToEnemy(Transform newParent, EnemyIdentifier enemy, Vector3 normal)
		{
			//IL_000f: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			stuckTarget = enemy;
			enemy.DeliverDamage(((Component)enemy).gameObject, -normal, ((Component)this).transform.position, stickDamage, false, 0f, ((Component)weapon).gameObject, false, false);
			StickToThing(newParent, normal);
		}

		private void StickToThing(Transform newParent, Vector3 normal)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			landed = true;
			if (Object.op_Implicit((Object)(object)rb))
			{
				rb.isKinematic = true;
				rb.detectCollisions = false;
				((Component)rb).GetComponent<Collider>().enabled = false;
			}
			((Component)this).transform.parent = newParent;
			((Component)this).transform.forward = normal;
		}

		private bool CanStickToThing(GameObject thing)
		{
			if (thing.tag == "Floor" || thing.tag == "Wall")
			{
				return true;
			}
			return thing.layer switch
			{
				8 => true, 
				10 => true, 
				11 => true, 
				24 => true, 
				25 => true, 
				26 => true, 
				_ => false, 
			};
		}

		private void OnCollisionEnter(Collision col)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (!landed && armed)
			{
				ContactPoint contact;
				if (CanStickToThing(col.gameObject))
				{
					Transform transform = col.transform;
					contact = col.GetContact(0);
					StickToThing(transform, ((ContactPoint)(ref contact)).normal);
				}
				EnemyIdentifierIdentifier val = default(EnemyIdentifierIdentifier);
				EnemyIdentifier val2 = default(EnemyIdentifier);
				if (((Component)col.collider).TryGetComponent<EnemyIdentifierIdentifier>(ref val) && !val.eid.dead)
				{
					Transform transform2 = ((Component)col.collider).transform;
					EnemyIdentifier eid = val.eid;
					contact = col.GetContact(0);
					StickToEnemy(transform2, eid, ((ContactPoint)(ref contact)).normal);
				}
				else if (((Component)col.collider).TryGetComponent<EnemyIdentifier>(ref val2) && !val2.dead)
				{
					Transform transform3 = ((Component)col.collider).transform;
					EnemyIdentifier enemy = val2;
					contact = col.GetContact(0);
					StickToEnemy(transform3, enemy, ((ContactPoint)(ref contact)).normal);
				}
			}
		}

		private void OnTriggerEnter(Collider col)
		{
			if (((Component)col).gameObject.layer == 23 && col.isTrigger)
			{
				Detonate(force: true);
			}
		}

		public void Cleanup()
		{
			Detonate(force: true);
		}

		public void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			BeamType beamType = beam.beamType;
			BeamType val = beamType;
			if (val - 1 <= 2)
			{
				Detonate(force: true);
			}
			else
			{
				Detonate();
			}
		}

		public bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			return alive;
		}

		public bool CanBeShot(GameObject sourceWeapon)
		{
			return alive;
		}

		public void OnShot(GameObject sourceWeapon)
		{
			Detonate();
		}
	}
	[UFGWeapon("Nikita", "GuidedMissle", 0, true, WeaponIconColor.Green, false, true)]
	public class Nikita : UltraFunGunBase
	{
		[UFGAsset("NikitaRocket")]
		private static GameObject rocketPrefab;

		private NikitaRocket activeRocket;

		private ActionCooldown rocketCooldown = new ActionCooldown(1.4f, affectedByNoCooldownCheat: true);

		private Quaternion playerLook;

		public bool RocketActive => (Object)(object)activeRocket != (Object)null;

		public override void GetInput()
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && !om.paused)
			{
				if ((Object)(object)activeRocket == (Object)null)
				{
					if (rocketCooldown.CanFire())
					{
						FireRocket();
					}
				}
				else
				{
					ControlRocket();
				}
			}
			if (Object.op_Implicit((Object)(object)activeRocket) && activeRocket.Controlled)
			{
				HydraUtils.SetPlayerRotation(playerLook);
			}
		}

		private void FireRocket()
		{
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)rocketPrefab == (Object)null))
			{
				playerLook = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation;
				rocketCooldown.AddCooldown();
				activeRocket = Object.Instantiate<GameObject>(rocketPrefab, ((Component)mainCam).transform.forward * 0.25f + ((Component)mainCam).transform.position, ((Component)mainCam).transform.rotation).GetComponent<NikitaRocket>();
			}
		}

		private void ControlRocket()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)activeRocket == (Object)null) && !activeRocket.Controlled)
			{
				playerLook = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation;
				activeRocket.SetControlState(control: true, cam: true);
			}
		}

		public override string GetDebuggingText()
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"ROCKET_ACTIVE: {RocketActive}\n";
			if (RocketActive)
			{
				debuggingText += $"ROCKET_SPEED: {activeRocket.currentSpeed}\n";
				debuggingText += $"ROCKET_CONTROL: {activeRocket.Controlled}\n";
				debuggingText += $"R_LOOK: {activeRocket.lookInput}\n";
				debuggingText += $"R_MOVE: {activeRocket.moveInput}\n";
			}
			return debuggingText;
		}
	}
	public class NikitaRocket : MonoBehaviour, ICleanable
	{
		[SerializeField]
		private Image[] speedMeter;

		[SerializeField]
		private Camera camera;

		[NonSerialized]
		public float minSpeed = 5f;

		[NonSerialized]
		public float maxSpeed = 150f;

		[NonSerialized]
		public float startSpeed = 80f;

		[NonSerialized]
		public float speedChangeDelta = 50f;

		[NonSerialized]
		public float speedChangeAcceleration = 50f;

		[NonSerialized]
		public float steerSpeed = 120f;

		[NonSerialized]
		public float rollSpeed = 65f;

		[NonSerialized]
		public float steerSmoothing = 0.05f;

		[NonSerialized]
		public float rollSmoothing = 0.06f;

		[NonSerialized]
		public float currentSpeed;

		private float minFov = 77f;

		private float maxFov = 130f;

		[NonSerialized]
		public Vector2 lookInput;

		[NonSerialized]
		public Vector2 moveInput;

		private Vector2 smoothedLook;

		private float smoothedRoll;

		private Camera[] altCams;

		public bool Controlled { get; private set; } = true;


		private void Start()
		{
			altCams = ((Component)MonoSingleton<CameraController>.Instance).GetComponentsInChildren<Camera>();
			currentSpeed = startSpeed;
			SetCameraActive(enabled: true);
		}

		private void Update()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b5: 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)
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && Controlled)
			{
				Detonate();
				return;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && Controlled)
			{
				SetControlState(control: false, cam: false);
				return;
			}
			lookInput = Vector2.zero;
			moveInput = Vector2.zero;
			if (Controlled)
			{
				UpdateUI();
				lookInput = MonoSingleton<InputManager>.Instance.InputSource.Look.ReadValue<Vector2>();
				moveInput = MonoSingleton<InputManager>.Instance.InputSource.Move.ReadValue<Vector2>();
			}
			Move();
			if ((Object)(object)camera != (Object)null)
			{
				camera.fieldOfView = Mathf.Lerp(minFov, maxFov, currentSpeed / maxSpeed);
			}
		}

		private void Move()
		{
			//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_0095: 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_00a0: 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_00b5: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(currentSpeed + speedChangeAcceleration * moveInput.y, minSpeed, maxSpeed);
			currentSpeed = Mathf.MoveTowards(currentSpeed, num, speedChangeDelta * Time.deltaTime);
			float num2 = (0f - moveInput.x) * rollSpeed * Time.deltaTime;
			smoothedRoll = Mathf.MoveTowards(smoothedRoll, num2, rollSmoothing) * Time.deltaTime;
			smoothedLook = Vector2.MoveTowards(smoothedLook, lookInput, steerSmoothing);
			Vector2 val = smoothedLook * steerSpeed * Time.deltaTime;
			((Component)this).transform.Rotate(new Vector3(0f - val.y, val.x, smoothedRoll), (Space)1);
			Transform transform = ((Component)this).transform;
			transform.position += ((Component)this).transform.forward * currentSpeed * Time.deltaTime;
		}

		public void Detonate()
		{
			Controlled = false;
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public void SetControlState(bool control, bool cam)
		{
			Controlled = control;
			SetCameraActive(cam);
		}

		private void SetCameraActive(bool enabled)
		{
			if ((Object)(object)camera != (Object)null)
			{
				((Behaviour)camera).enabled = enabled;
			}
			((Behaviour)MonoSingleton<CameraController>.Instance.cam).enabled = !enabled;
			for (int i = 0; i < altCams.Length; i++)
			{
				((Behaviour)altCams[i]).enabled = !enabled;
			}
		}

		private void UpdateUI()
		{
			for (int i = 0; i < speedMeter.Length; i++)
			{
				if (!((Object)(object)speedMeter[i] == (Object)null))
				{
					speedMeter[i].fillAmount = currentSpeed / maxSpeed;
				}
			}
		}

		private void OnDestroy()
		{
			SetCameraActive(enabled: false);
		}

		private void OnDisable()
		{
			SetCameraActive(enabled: false);
		}

		public void Cleanup()
		{
			Detonate();
		}
	}
	public class NikitaRocketPP : MonoBehaviour
	{
		[SerializeField]
		private Material mat;

		private void OnRenderImage(RenderTexture src, RenderTexture dest)
		{
			Graphics.Blit((Texture)(object)src, dest, mat);
		}
	}
	public class SonicBoom : MonoBehaviour
	{
		[SerializeField]
		private MeshRenderer[] quads;

		public float Size;

		public float Range;

		public float LifeTime;

		private Vector3 startPosition;

		private Vector3 startScale;

		private float fallOffRange;

		private float currentTime;

		private void Start()
		{
			//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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			startPosition = ((Component)this).transform.position;
			startScale = ((Component)this).transform.localScale;
			currentTime = LifeTime;
			fallOffRange = Range * 1.5f;
		}

		private void Update()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			float lifeRemaining = GetLifeRemaining();
			if (lifeRemaining >= 1f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			UpdateMeshRenderers();
			((Component)this).transform.position = Vector3.Lerp(startPosition, startPosition + ((Component)this).transform.forward * fallOffRange, lifeRemaining);
			((Component)this).transform.localScale = Vector3.one * Size;
			currentTime -= Time.deltaTime;
		}

		public float GetLifeRemaining()
		{
			LifeTime = ((LifeTime == 0f) ? 1f : LifeTime);
			return 1f - currentTime / LifeTime;
		}

		private void UpdateMeshRenderers()
		{
			//IL_002e: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			float lifeRemaining = GetLifeRemaining();
			MeshRenderer[] array = quads;
			foreach (MeshRenderer val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Color color = ((Renderer)val).material.color;
					color.a = Mathf.Lerp(1f, 0f, lifeRemaining);
					((Renderer)val).material.color = color;
				}
			}
		}
	}
	[WeaponAbility("Reverberate", "Release the stored power of Moyai with <color=orange>Fire 2</color>", 0, RichTextColors.aqua)]
	[WeaponAbility("Stockpile", "Excite Moyai by holding <color=orange>Fire 1</color>", 1, RichTextColors.aqua)]
	[UFGWeapon("SonicReverberator", "Sonic Reverberator", 0, true, WeaponIconColor.Blue, true, true)]
	public class SonicReverberator : UltraFunGunBase
	{
		private AudioSource chargeIncrease;

		private AudioSource chargeDecrease;

		private AudioSource chargeFinal;

		private List<float> chargeMilestones = new List<float> { 2f, 5f, 10f, 20f, 60f };

		public bool skipConeCheck = true;

		public bool enablePlayerKnockback = true;

		public float baseGyroRotationSpeed = 0.01f;

		public float gyroRotationSpeedModifier = 0.1f;

		public float chargeLevel = 0f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float chargeSpeedMultiplier = 2.8f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float chargeDecayMultiplier = 0.25f;

		private float maxTargetAngle = 80f;

		private float minTargetAngle = 18f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float maxRange = 2000f;

		private int lastChargeState = 0;

		public Vector3 playerKnockbackVector = new Vector3(0f, 2f, 8f);

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float playerKnockbackMultiplier = 0.8f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float playerKnockbackVerticalMultiplier = 1.2f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float playerKnockbackJumpMultiplier = 1.5f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float playerKnockbackMaxRange = 5000f;

		public bool charging = false;

		private VisualCounterAnimator pistons;

		private Animator moyaiAnimator;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float cooldownRate = 0.17f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float minimumCooldown = 0.75f;

		[Configgable("Weapons/Sonic Reverberator", null, 0, null)]
		private static float maximumCooldown = 600f;

		private float lastKnownCooldownTime = 0f;

		private ActionCooldown fireCooldown = new ActionCooldown(minimumCooldown, affectedByNoCooldownCheat: true);

		private GyroRotator[] rotators;

		[UFGAsset("SonicBoom")]
		public static GameObject ReverbProjectile { get; private set; }

		[UFGAsset("vB_standard")]
		public static AudioClip vineBoom_Standard { get; private set; }

		[UFGAsset("vB_loud")]
		public static AudioClip vineBoom_Loud { get; private set; }

		[UFGAsset("vB_loud")]
		public static AudioClip vineBoom_Loudest { get; private set; }

		public override void OnAwakeFinished()
		{
			pistons = ((Component)((Component)this).transform.Find("viewModelWrapper/MoyaiGun/Animated/PistonBase")).gameObject.AddComponent<VisualCounterAnimator>();
			pistons.Initialize(4, "PistonHolder{0}/Pusher", descending: true);
			chargeIncrease = ((Component)((Component)this).transform.Find("viewModelWrapper/Audios/ChargeIncrease")).GetComponent<AudioSource>();
			chargeDecrease = ((Component)((Component)this).transform.Find("viewModelWrapper/Audios/ChargeDecrease")).GetComponent<AudioSource>();
			chargeFinal = ((Component)((Component)this).transform.Find("viewModelWrapper/Audios/ChargeFinal")).GetComponent<AudioSource>();
			rotators = ((Component)this).GetComponentsInChildren<GyroRotator>();
			moyaiAnimator = ((Component)((Component)this).transform.Find("viewModelWrapper/MoyaiGun/Animated/OuterGyroBearing/InnerGyroBearing/OuterGyro/MiddleGyro/InnerGyro/Moyai")).GetComponent<Animator>();
		}

		private void SetGyroSpeed(float newSpeed)
		{
			for (int i = 0; i < rotators.Length; i++)
			{
				if (!((Object)(object)rotators[i] == (Object)null))
				{
					rotators[i].Speed = newSpeed;
				}
			}
		}

		private void SetGyroEnable(bool newState)
		{
			for (int i = 0; i < rotators.Length; i++)
			{
				if (!((Object)(object)rotators[i] == (Object)null))
				{
					rotators[i].Spin = newState;
				}
			}
		}

		private void AddGyroSpin(float velocity)
		{
			for (int i = 0; i < rotators.Length; i++)
			{
				rotators[i]?.AddAngularVelocity(velocity);
			}
		}

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && fireCooldown.CanFire() && !om.paused)
			{
				charging = true;
				chargeLevel += Time.deltaTime * chargeSpeedMultiplier;
				MonoSingleton<CameraController>.Instance.CameraShake((!(chargeLevel > chargeMilestones[0])) ? 0f : ((chargeLevel > chargeMilestones[chargeMilestones.Count - 1]) ? 0f : (chargeLevel * 0.01f)));
			}
			else
			{
				charging = false;
				chargeLevel = Mathf.Clamp(chargeLevel - Time.deltaTime * chargeDecayMultiplier, 0f, float.PositiveInfinity);
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && fireCooldown.CanFire() && !om.paused && chargeLevel >= 2f)
			{
				Fire();
			}
			if (UFGInput.SecretButton.WasPeformed())
			{
				SecretAnimation();
			}
		}

		private void SecretAnimation()
		{
		}

		protected override void DoAnimations()
		{
			SetGyroSpeed(baseGyroRotationSpeed * (chargeLevel * gyroRotationSpeedModifier));
			SetGyroEnable(charging);
			animator.SetBool("CanShoot", fireCooldown.CanFire());
			animator.SetBool("Charging", charging);
			int chargeState = GetChargeState(chargeLevel);
			if (chargeState > lastChargeState)
			{
				if (chargeState == chargeMilestones.Count + 1)
				{
					chargeFinal.Play();
				}
				else
				{
					chargeIncrease.Play();
				}
			}
			else if (chargeState < lastChargeState)
			{
				chargeDecrease.Play();
			}
			lastChargeState = chargeState;
			animator.SetFloat("ChargeLevel", Mathf.Clamp(chargeLevel / 5f, 1f, 6f));
			animator.SetInteger("ChargeState", chargeState);
			pistons.DisplayCount = chargeState;
			moyaiAnimator.SetFloat("ChargeLevel", chargeLevel + 0.5f);
		}

		private float CalcDistance(float scalar)
		{
			float num = scalar * 0.45f;
			num *= scalar;
			num /= scalar;
			num += scalar;
			num *= 2f;
			return Mathf.Min(num, maxRange);
		}

		private float CalcRadius(float scalar)
		{
			float num = scalar * 0.45f;
			num *= scalar;
			num /= scalar;
			num += scalar;
			num *= 0.8f;
			return Mathf.Min(num, maxRange);
		}

		private void Fire()
		{
			//IL_0059: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			float num = CalcRadius(chargeLevel);
			float range = CalcDistance(chargeLevel);
			VineBoom();
			int chargeState = GetChargeState();
			MonoSingleton<TimeController>.Instance.HitStop(0.25f * (float)(chargeState - 1));
			MonoSingleton<CameraController>.Instance.CameraShake(1.5f * (float)(chargeState - 1));
			Visualizer.DrawSphereCast(mainCam.position, num, mainCam.forward, range, 3f);
			if (HydraUtils.SphereCastAllMacro(mainCam.position, num, mainCam.forward, range, out var hits))
			{
				RaycastHit[] array = hits;
				foreach (RaycastHit hit in array)
				{
					ProcessHit(hit);
				}
			}
			if ((Object)(object)ReverbProjectile != (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(ReverbProjectile, firePoint.position, Quaternion.identity);
				val.transform.forward = mainCam.forward;
				SonicBoom component = val.GetComponent<SonicBoom>();
				component.Size = num;
				component.Range = range;
				component.LifeTime = 0.36f;
			}
			KnockbackPlayer();
			animator.Play("SonicReverberator_Shoot");
			pistons.DisplayCount = chargeState;
			AddGyroSpin(chargeLevel);
			fireCooldown.AddCooldown(Mathf.Clamp(chargeLevel * (cooldownRate + chargeLevel * (cooldownRate - cooldownRate / 1.03f)), minimumCooldown, maximumCooldown));
			chargeLevel = 0f;
			lastChargeState = 0;
			charging = false;
		}

		private void ProcessHit(RaycastHit hit)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_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_0062: 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_00c3: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			if (!HydraUtils.LineOfSightCheck(mainCam.position, ((RaycastHit)(ref hit)).point))
			{
			}
			Vector3 direction = ((RaycastHit)(ref hit)).point - mainCam.position;
			if (!(Vector3.Dot(((Component)((RaycastHit)(ref hit)).collider).transform.position - mainCam.position, mainCam.forward) < 0f) || skipConeCheck)
			{
				if (((RaycastHit)(ref hit)).collider.IsColliderEnemy(out var enemy))
				{
					EnemyOverride enemyOverride = enemy.Override();
					enemy.DeliverDamage(((Component)enemy).gameObject, ((Vector3)(ref direction)).normalized * 2000f, ((RaycastHit)(ref hit)).point, chargeLevel * 0.1f, true, 0f, ((Component)this).gameObject, false, false);
					enemyOverride.Knockback(((Vector3)(ref direction)).normalized * chargeLevel * 20f);
				}
				else if ((Object)(object)((RaycastHit)(ref hit)).collider.attachedRigidbody != (Object)null)
				{
					((RaycastHit)(ref hit)).collider.attachedRigidbody.velocity = ((Vector3)(ref direction)).normalized * chargeLevel;
					UltraFunGuns.Log.Log("Affected RB");
				}
				Vector3 position = mainCam.position;
				Bounds bounds = ((RaycastHit)(ref hit)).collider.bounds;
				Vector3 direction2 = Vector3.Reflect(position - ((Bounds)(ref bounds)).center, mainCam.forward);
				ParryTool.TryParryProjectile(((RaycastHit)(ref hit)).collider, direction2, out var _);
				ParryTool.TryParryCannonball(((RaycastHit)(ref hit)).collider, direction2, out var _);
				IUFGInteractionReceiver iUFGInteractionReceiver = default(IUFGInteractionReceiver);
				if (((Component)((RaycastHit)(ref hit)).collider).gameObject.TryGetComponent<IUFGInteractionReceiver>(ref iUFGInteractionReceiver))
				{
					UFGInteractionEventData uFGInteractionEventData = default(UFGInteractionEventData);
					uFGInteractionEventData.invokeType = typeof(SonicReverberator);
					uFGInteractionEventData.interactorPosition = mainCam.position;
					uFGInteractionEventData.direction = direction;
					uFGInteractionEventData.tags = new string[3] { "turn", "sonic", "shatter" };
					uFGInteractionEventData.power = chargeLevel;
					UFGInteractionEventData interaction = uFGInteractionEventData;
					iUFGInteractionReceiver.Interact(interaction);
				}
			}
		}

		public int GetChargeState(float charge)
		{
			for (int i = 0; i < chargeMilestones.Count; i++)
			{
				if (charge < chargeMilestones[i])
				{
					return i;
				}
			}
			return chargeMilestones.Count + 1;
		}

		public int GetChargeState()
		{
			return GetChargeState(chargeLevel);
		}

		private void OnDisable()
		{
			lastKnownCooldownTime = Time.time;
		}

		private void OnEnable()
		{
			if (fireCooldown.TimeToFire - Time.time > 0f)
			{
				fireCooldown.TimeToFire += Mathf.Clamp(lastKnownCooldownTime - Time.time, 0f, maximumCooldown);
			}
		}

		private void KnockbackPlayer()
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (enablePlayerKnockback)
			{
				int chargeState = GetChargeState();
				float num = 1f;
				float num2 = playerKnockbackVerticalMultiplier;
				if (player.jumping)
				{
					num = playerKnockbackJumpMultiplier;
				}
				if (!player.gc.onGround)
				{
					num2 = 0f;
				}
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(0f, 0f, 0f);
				val.x = playerKnockbackVector.x * (float)(chargeState - 1) * (chargeLevel * playerKnockbackMultiplier);
				val.y = playerKnockbackVector.y * (float)(chargeState - 1) * (chargeLevel * num2);
				val.z = num * ((0f - playerKnockbackVector.z) * ((float)chargeState - Mathf.Clamp01(1f * num2)) * (chargeLevel * playerKnockbackMultiplier));
				Vector3 val2 = Vector3.ClampMagnitude(((Component)mainCam).transform.TransformDirection(val), playerKnockbackMaxRange);
				Rigidbody rb = player.rb;
				rb.velocity += val2;
			}
		}

		private void VineBoom()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(new GameObject(), ((Component)this).transform);
			Object.Destroy((Object)(object)val, 3f);
			AudioSource val2 = val.AddComponent<AudioSource>();
			val.AddComponent<DestroyAfterTime>();
			val2.playOnAwake = false;
			val2.loop = false;
			switch (GetChargeState())
			{
			case 1:
				val2.clip = vineBoom_Standard;
				val2.volume = 0.75f;
				break;
			case 2:
				val2.clip = vineBoom_Standard;
				val2.volume = 1f;
				break;
			case 3:
				val2.clip = vineBoom_Loud;
				val2.volume = 0.8f;
				break;
			case 4:
				val2.clip = vineBoom_Loud;
				val2.volume = 1f;
				break;
			case 5:
				val2.clip = vineBoom_Loudest;
				val2.volume = 1.2f;
				break;
			case 6:
				val2.clip = vineBoom_Loudest;
				val2.volume = 2f;
				break;
			default:
				val2.clip = vineBoom_Standard;
				val2.volume = 0.75f;
				break;
			}
			val2.pitch = 1f;
			val2.spatialBlend = 1f;
			val2.maxDistance = 100000f;
			val2.dopplerLevel = 0.05f;
			val2.Play();
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"CHARGE: {chargeLevel}\n";
			debuggingText += $"MILESTONE: {GetChargeState(chargeLevel)}\n";
			debuggingText += $"CHARGING: {charging}\n";
			return debuggingText + $"FIRE_CD: {fireCooldown}\n";
		}
	}
	public class SplatOnImpact : MonoBehaviour
	{
		private EnemyIdentifier enemy;

		public float velocityToSplatThreshold = 17f;

		public float gravityTimer = 1f;

		public float invincibilityTimer = 0.01f;

		private float timeElapsed = 0f;

		private int collisions = 0;

		private bool orbited = false;

		private void Start()
		{
			enemy = ((Component)this).gameObject.GetComponent<EnemyIdentifier>();
		}

		private void FixedUpdate()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			timeElapsed += Time.fixedDeltaTime;
			if (((Component)this).transform.position.y >= 1500f && !orbited)
			{
				orbited = true;
				MonoSingleton<StyleHUD>.Instance.AddPoints(150, "hydraxous.ultrafunguns.orbited", (GameObject)null, enemy, -1, "", "");
				enemy.health = -1f;
				enemy.Explode(false);
			}
		}

		private void OnCollisionEnter(Collision collision)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			collisions++;
			if (collisions > 5)
			{
				Object.Destroy((Object)(object)((Component)this).GetComponent<SplatOnImpact>());
			}
			if (timeElapsed > invincibilityTimer)
			{
				Vector3 relativeVelocity = collision.relativeVelocity;
				if (((Vector3)(ref relativeVelocity)).magnitude >= velocityToSplatThreshold)
				{
					enemy.Splatter(true);
				}
				else
				{
					((Component)this).GetComponent<Rigidbody>().isKinematic = true;
					collisions = 10;
				}
			}
			if (timeElapsed > gravityTimer)
			{
				((Component)this).GetComponent<Rigidbody>().useGravity = true;
			}
		}
	}
	public class VisualCounterAnimator : MonoBehaviour
	{
		private List<Animator> displays = new List<Animator>();

		private bool descending = false;

		public bool initalized = false;

		private int displayCount = 0;

		public int DisplayCount
		{
			get
			{
				return displayCount;
			}
			set
			{
				displayCount = value;
				RefreshDisplays();
			}
		}

		public void Initialize(int numberOfDisplays, string relativePath, bool descending = false)
		{
			this.descending = descending;
			for (int i = 0; i < numberOfDisplays; i++)
			{
				displays.Add(((Component)((Component)this).transform.Find(string.Format(relativePath, i))).GetComponent<Animator>());
			}
			initalized = true;
			RefreshDisplays();
		}

		public void RefreshDisplays()
		{
			if (!initalized)
			{
				return;
			}
			if (!descending)
			{
				for (int i = 0; i < displays.Count; i++)
				{
					if (displayCount >= i)
					{
						displays[i].SetBool("Active", false);
					}
					else
					{
						displays[i].SetBool("Active", true);
					}
				}
				return;
			}
			for (int j = 0; j < displays.Count; j++)
			{
				if (displayCount - 1 >= j)
				{
					displays[j].SetBool("Active", true);
				}
				else
				{
					displays[j].SetBool("Active", false);
				}
			}
		}
	}
	[UFGWeapon("Tricksniper", "Tricksniper", 3, true, WeaponIconColor.Green, true, true)]
	[WeaponAbility("Fire", "Press <color=orange>Fire 1</color> to fire.", 0, RichTextColors.aqua)]
	[WeaponAbility("Optical Zoom", "Hold <color=orange>Fire 2</color> to engage zoom.", 1, RichTextColors.lime)]
	[WeaponAbility("Noscope!!", "Spinning before shooting directly increases damage and accuracy while not using <color=lime>Optical Zoom</color>.", 2, RichTextColors.yellow)]
	public class Tricksniper : UltraFunGunBase
	{
		[UFGAsset("ReflectedSniperShot")]
		private static GameObject reflectedSniperShot;

		public GameObject scopeUI;

		public GameObject viewModelWrapper;

		public float maxTargetAngle = 150f;

		public float spreadTightness = 3f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		[Range(0f, 100f)]
		private static float bulletPenetrationChance = 20f;

		public int revolutions = 0;

		public float rotationalAngleMultiplier = 4.5f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float maxRange = 2000f;

		[Configgable("Weapons/Tricksniper", null, 0, "Controls the max amount of ricochets possible.")]
		private static int maxRicochet = 200;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		[Range(0f, 1f)]
		private static float addedRicochetChance = 0f;

		public float turnCountThreshold = 6f;

		public int revolveCountThreshold = 18;

		public int turnsCompleted = 0;

		public float lastRecordedRotation = 0f;

		public bool scopedIn = false;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float scopeInTime = 0.25f;

		public float scopeTime = 0f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float scopedInBaseDamage = 1.6f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float noscopeBaseDamage = 0.4f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float noscopeMaxDistanceDamage = 15f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float noscopeDistanceDamageMultiplier = 0.15f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float noscopeDistanceDamageMaxDistance = 35f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float bankshotDamageMultiplier = 0.4f;

		private float timeScopedIn = 0f;

		public float spinCooldownMinThreshold = 5f;

		[Configgable("Weapons/Tricksniper", null, 0, null)]
		private static float primaryFireCooldown = 0.65f;

		private ActionCooldown fireCooldown = new ActionCooldown(primaryFireCooldown, affectedByNoCooldownCheat: true);

		private ActionCooldown turnExpiry = new ActionCooldown(0.35f);

		private TricksniperReactions reactions;

		private bool playReloadAnimWhenUnscoped;

		private Vector3 lastLook = Vector3.forward;

		private float currentSpin = 0f;

		[UFGAsset("TricksniperRicochet")]
		public static AudioClip TricksniperRicochetSound { get; private set; }

		[UFGAsset("TricksniperCoinRicochet")]
		public static AudioClip TricksniperCoinRicochetSound { get; private set; }

		[UFGAsset("TricksniperMuzzleFX")]
		public static GameObject muzzleFX { get; private set; }

		public override void OnAwakeFinished()
		{
			scopeUI = ((Component)((Component)this).transform.Find("ScopeUI")).gameObject;
			viewModelWrapper = ((Component)((Component)this).transform.Find("viewModelWrapper")).gameObject;
			scopeUI.SetActive(false);
			reactions = ((Component)this).GetComponent<TricksniperReactions>();
		}

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && fireCooldown.CanFire() && !om.paused)
			{
				fireCooldown.AddCooldown();
				Shooot();
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed && !om.paused)
			{
				scopeTime = Mathf.Clamp(scopeTime + Time.deltaTime, 0f, scopeInTime);
			}
			else if (!om.paused)
			{
				scopeTime = Mathf.Clamp(scopeTime - Time.deltaTime, 0f, scopeInTime);
			}
			scopedIn = scopeTime >= scopeInTime;
			if (scopedIn)
			{
				viewModelWrapper.SetActive(false);
				scopeUI.SetActive(true);
			}
			else
			{
				viewModelWrapper.SetActive(true);
				scopeUI.SetActive(false);
			}
			CheckSpin();
			timeScopedIn = (scopedIn ? (timeScopedIn + Time.deltaTime) : 0f);
			if (UFGInput.SecretButton.WasPeformed())
			{
				Animator obj = animator;
				if (obj != null)
				{
					obj.Play("Secret");
				}
			}
		}

		private void CheckSpin()
		{
			//IL_000c: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 forward = ((Component)mainCam).transform.forward;
			forward.y = 0f;
			((Vector3)(ref forward)).Normalize();
			float num = Vector3.SignedAngle(lastLook, forward, Vector3.up);
			lastLook = forward;
			if (Mathf.Abs(num) >= spinCooldownMinThreshold)
			{
				turnExpiry.AddCooldown();
			}
			currentSpin += num;
			if (turnExpiry.CanFire())
			{
				revolutions = 0;
				currentSpin = 0f;
			}
			if (Mathf.Abs(currentSpin) >= 360f)
			{
				currentSpin -= 360f * Mathf.Sign(currentSpin);
				revolutions++;
			}
		}

		private bool GetTarget(out Vector3 targetDirection)
		{
			//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_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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: 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_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			List<Transform> list2 = new List<Transform>();
			TargetQuery targetQuery = new TargetQuery
			{
				queryOrigin = mainCam.position,
				queryDirection = mainCam.forward,
				checkLineOfSight = true,
				maxRange = maxRange,
				lineOfSightCollider = (Collider)(object)player.playerCollider,
				lineOfSightErrorMargin = 1.2f
			};
			IUFGInteractionReceiver[] array = (from x in Object.FindObjectsOfType<MonoBehaviour>().OfType<IUFGInteractionReceiver>()
				where x != null
				select x into y
				where y.Targetable(targetQuery)
				select y into z
				orderby Vector3.Distance(z.GetPosition(), mainCam.position)
				select z).ToArray();
			if (array.Length != 0)
			{
				targetDirection = array[0].GetPosition() - mainCam.position;
				return true;
			}
			GameObject[] array2 = GameObject.FindGameObjectsWithTag("Enemy");
			GameObject[] array3 = array2;
			EnemyIdentifier val2 = default(EnemyIdentifier);
			foreach (GameObject val in array3)
			{
				if (val.TryGetComponent<EnemyIdentifier>(ref val2) && !val2.dead && !list.Contains(val2))
				{
					list.Add(val2);
					Transform val3;
					if ((Object)(object)val2.weakPoint != (Object)null && val2.weakPoint.activeInHierarchy)
					{
						val3 = val2.weakPoint.transform;
					}
					else
					{
						EnemyIdentifierIdentifier componentInChildren = ((Component)val2).GetComponentInChildren<EnemyIdentifierIdentifier>();
						val3 = ((!Object.op_Implicit((Object)(object)componentInChildren)) ? ((Component)val2).transform : ((Component)componentInChildren).transform);
					}
					Vector3 val4 = val3.position - mainCam.position;
					Vector3 normalized = ((Vector3)(ref val4)).normalized;
					val4 = mainCam.TransformDirection(Vector3.forward);
					Vector3 normalized2 = ((Vector3)(ref val4)).normalized;
					float num = (float)revolutions * (rotationalAngleMultiplier * ((float)revolutions + 1.25f));
					if (Vector3.Angle(normalized, normalized2) <= Mathf.Clamp(num, 0f, maxTargetAngle) || revolutions > 7)
					{
						list2.Add(val3);
					}
				}
			}
			int num2 = -1;
			float num3 = float.PositiveInfinity;
			for (int j = 0; j < list2.Count; j++)
			{
				Vector3 val5 = list2[j].position - mainCam.position;
				if (((Vector3)(ref val5)).sqrMagnitude < num3)
				{
					num2 = j;
					num3 = ((Vector3)(ref val5)).sqrMagnitude;
				}
			}
			if (num2 > -1)
			{
				targetDirection = list2[num2].position - mainCam.position;
				return true;
			}
			targetDirection = Vector3.zero;
			return false;
		}

		private void Shooot()
		{
			//IL_0012: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007f: 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_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_00b1: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			bool flag = scopedIn;
			bool flag2 = false;
			Ray hitRay = default(Ray);
			((Ray)(ref hitRay))..ctor(mainCam.position, mainCam.forward);
			if (revolutions > 0)
			{
				if (GetTarget(out var targetDirection))
				{
					flag2 = true;
					((Ray)(ref hitRay)).direction = targetDirection;
					Vector3 val = targetDirection;
					val.y = 0f;
					Vector3 direction = ((Ray)(ref hitRay)).direction;
					direction.y = 0f;
					if (Vector3.Dot(((Vector3)(ref val)).normalized, ((Vector3)(ref direction)).normalized) < 0f)
					{
						Quaternion playerRotation = Quaternion.LookRotation(new Vector3(val.x, ((Ray)(ref hitRay)).direction.y, val.z), Vector3.up);
						HydraUtils.SetPlayerRotation(playerRotation);
					}
				}
				flag = bulletPenetrationChance >= Random.Range(0f, 100f) || flag;
			}
			if (!scopedIn && !flag2)
			{
				float num = Random.Range(-1f, 1f);
				float num2 = Random.Range(-1f, 1f);
				((Ray)(ref hitRay)).direction = mainCam.TransformDirection(num, num2, spreadTightness);
				flag = true;
			}
			List<Vector3> list = new List<Vector3>();
			list.Add(firePoint.position);
			Vector3 lastNormal = -mainCam.forward;
			list = ExecuteHit(hitRay, flag, list, ref lastNormal);
			DrawBulletTrail(lastNormal, list.ToArray());
			Object.Instantiate<GameObject>(muzzleFX, scopedIn ? mainCam.position : firePoint.position, Quaternion.identity).transform.forward = (scopedIn ? mainCam.forward : firePoint.forward);
			if (!scopedIn)
			{
				animator.Play("Fire", 0, 0f);
			}
			else
			{
				playReloadAnimWhenUnscoped = true;
			}
			MonoSingleton<CameraController>.Instance.CameraShake(1.1f);
		}

		private List<Vector3> ExecuteHit(Ray hitRay, bool penetration, List<Vector3> pointsOfContact, ref Vector3 lastNormal)
		{
			//IL_0016: 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_00e1: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_0612: Unknown result type (might be due to invalid IL or missing references)
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			float num = (scopedIn ? scopedInBaseDamage : noscopeBaseDamage);
			RaycastHit[] array = Physics.RaycastAll(hitRay, maxRange, LayerMask.GetMask(new string[5] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default" }));
			if (array.Length == 0 || (array.Length == 1 && ((Object)((Component)((RaycastHit)(ref array[0])).collider).gameObject).name == "CameraCollisionChecker"))
			{
				pointsOfContact.Add(((Ray)(ref hitRay)).GetPoint(maxRange));
				return pointsOfContact;
			}
			array = array.OrderBy((RaycastHit x) => ((RaycastHit)(ref x)).distance).ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				pointsOfContact.Add(((RaycastHit)(ref array[i])).point);
				lastNormal = ((RaycastHit)(ref array[i])).normal;
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 8)
				{
					if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<Glass>(out var component))
					{
						component.Shatter();
					}
					else
					{
						if (!((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<Breakable>(out var component2))
						{
							float num2 = 1f + addedRicochetChance - Mathf.Abs(Vector3.Dot(((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).normal));
							if (Random.value < num2 && pointsOfContact.Count < maxRicochet)
							{
								TricksniperRicochetSound.PlayAudioClip(((RaycastHit)(ref array[i])).point, 0f, 1f, 0.8f);
								Object.Instantiate<GameObject>(Prefabs.BulletImpactFX, ((RaycastHit)(ref array[i])).point, Quaternion.identity).transform.up = ((RaycastHit)(ref array[i])).normal;
								Object.Instantiate<GameObject>(Prefabs.SparkBurst, ((RaycastHit)(ref array[i])).point, Quaternion.identity);
								return ExecuteHit(new Ray(((RaycastHit)(ref array[i])).point, Vector3.Reflect(((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).normal)), penetration, pointsOfContact, ref lastNormal);
							}
							break;
						}
						component2.Break();
					}
				}
				if (((RaycastHit)(ref array[i])).collider.IsColliderEnemy(out var enemy))
				{
					if (!scopedIn)
					{
						float lineDistance = pointsOfContact.GetLineDistance();
						float num3 = Mathf.Min(noscopeMaxDistanceDamage, noscopeDistanceDamageMultiplier * Mathf.Max(lineDistance, 1f));
						if (lineDistance > noscopeDistanceDamageMaxDistance)
						{
							reactions?.PlayReaction();
						}
						num += num3;
					}
					if (pointsOfContact.Count > 1)
					{
						num += num * bankshotDamageMultiplier * (float)pointsOfContact.Count - 1f;
						enemy.Override().AddStyleEntryOnDeath(new StyleEntry(100, "tricksniperbankshot", 1.4f, ((Component)this).gameObject));
					}
					enemy.DeliverDamage(((Component)enemy).gameObject, ((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).point, num, true, num, ((Component)this).gameObject, false, false);
					if (scopedIn)
					{
						if (timeScopedIn < 0.09f)
						{
							WeaponManager.AddStyle(50, "tricksniperquickscope", ((Component)this).gameObject, enemy);
						}
					}
					else
					{
						bool flag = revolutions > 0;
						if (flag)
						{
						}
						WeaponManager.AddStyle(flag ? 100 : 30, flag ? "tricksniper360" : "tricksnipernoscope", ((Component)this).gameObject, enemy);
					}
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<IUFGInteractionReceiver>(out var component3))
				{
					UFGInteractionEventData uFGInteractionEventData = default(UFGInteractionEventData);
					uFGInteractionEventData.tags = new string[4]
					{
						"shot",
						"pierce",
						"heavy",
						scopedIn ? "" : "god"
					};
					uFGInteractionEventData.data = "";
					uFGInteractionEventData.interactorPosition = mainCam.position;
					uFGInteractionEventData.direction = ((Ray)(ref hitRay)).direction;
					uFGInteractionEventData.invokeType = typeof(Tricksniper);
					uFGInteractionEventData.power = 60f;
					UFGInteractionEventData interaction = uFGInteractionEventData;
					component3.Interact(interaction);
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<Grenade>(out var component4))
				{
					MonoSingleton<TimeController>.Instance.ParryFlash();
					component4.Explode(false, false, false, 1f, false, (GameObject)null, false);
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<Coin>(out var component5))
				{
					Object.Instantiate<GameObject>(component5.coinBreak, ((Component)component5).transform.position, Quaternion.identity);
					Object.Destroy((Object)(object)((Component)component5).gameObject);
					penetration = true;
					Vector3 position = ((Component)component5).transform.position;
					Vector3 val = Random.insideUnitSphere;
					Object.Instantiate<GameObject>(Prefabs.SparkBurst, position, Quaternion.identity);
					TricksniperCoinRicochetSound?.PlayAudioClip();
					if (EnemyTools.TryGetHomingTarget(position, out var homingTarget, out var _))
					{
						val = ((Component)homingTarget).transform.position - position;
					}
					return ExecuteHit(new Ray(position, val), penetration, pointsOfContact, ref lastNormal);
				}
				if (!penetration)
				{
					break;
				}
			}
			return pointsOfContact;
		}

		private void Shoot()
		{
			//IL_0012: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_009c: 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_00af: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			bool flag = scopedIn;
			bool flag2 = false;
			Ray hitRay = default(Ray);
			((Ray)(ref hitRay))..ctor(mainCam.position, mainCam.forward);
			if (revolutions > 0)
			{
				if (GetTarget(out var targetDirection))
				{
					flag2 = true;
					((Ray)(ref hitRay)).direction = targetDirection;
					Vector3 val = targetDirection;
					val.y = 0f;
					Vector3 direction = ((Ray)(ref hitRay)).direction;
					direction.y = 0f;
					if (Vector3.Dot(((Vector3)(ref val)).normalized, ((Vector3)(ref direction)).normalized) < 0f)
					{
						Quaternion playerRotation = Quaternion.LookRotation(new Vector3(val.x, ((Ray)(ref hitRay)).direction.y, val.z), Vector3.up);
						HydraUtils.SetPlayerRotation(playerRotation);
					}
				}
				flag = bulletPenetrationChance >= Random.Range(0f, 100f) || flag;
			}
			if (!scopedIn && !flag2)
			{
				float num = Random.Range(-1f, 1f);
				float num2 = Random.Range(-1f, 1f);
				((Ray)(ref hitRay)).direction = mainCam.TransformDirection(num, num2, spreadTightness);
				flag = true;
			}
			DoHit(hitRay, flag);
			Object.Instantiate<GameObject>(muzzleFX, scopedIn ? mainCam.position : firePoint.position, Quaternion.identity).transform.forward = (scopedIn ? mainCam.forward : firePoint.forward);
			if (!scopedIn)
			{
				animator.Play("Fire", 0, 0f);
			}
			else
			{
				playReloadAnimWhenUnscoped = true;
			}
			MonoSingleton<CameraController>.Instance.CameraShake(1.1f);
		}

		private void DoHit(Ray hitRay, bool penetration)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: 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_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			float num = (scopedIn ? 1.5f : 3f);
			RaycastHit[] array = Physics.RaycastAll(hitRay, maxRange, LayerMask.GetMask(new string[5] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default" }));
			if (array.Length == 0 || (array.Length == 1 && ((Object)((Component)((RaycastHit)(ref array[0])).collider).gameObject).name == "CameraCollisionChecker"))
			{
				return;
			}
			int num2 = 0;
			array = HydraUtils.SortRaycastHitsByDistance(array);
			Breakable val = default(Breakable);
			for (int i = 0; i < array.Length; i++)
			{
				num2 = i;
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 8)
				{
					if (Mathf.Abs(Vector3.Dot(((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).normal)) < 0.25f)
					{
						DoHit(new Ray(((Ray)(ref hitRay)).origin, Vector3.Reflect(((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).normal)), penetration);
					}
					break;
				}
				if (((RaycastHit)(ref array[i])).collider.IsColliderEnemy(out var enemy))
				{
					enemy.DeliverDamage(((Component)enemy).gameObject, ((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).point, num, true, num, ((Component)this).gameObject, false, false);
					if (scopedIn)
					{
						if (timeScopedIn < 0.085f)
						{
							WeaponManager.AddStyle(50, "tricksniperquickscope", ((Component)this).gameObject, enemy);
						}
					}
					else
					{
						bool flag = revolutions > 0;
						if (flag && (Object)(object)reactions != (Object)null)
						{
							reactions.PlayReaction();
						}
						WeaponManager.AddStyle(flag ? 100 : 30, flag ? "tricksniper360" : "tricksnipernoscope", ((Component)this).gameObject, enemy);
					}
					if (!penetration)
					{
						break;
					}
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<Breakable>(ref val))
				{
					val.Break();
					if (!penetration)
					{
						break;
					}
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<IUFGInteractionReceiver>(out var component))
				{
					UFGInteractionEventData uFGInteractionEventData = default(UFGInteractionEventData);
					uFGInteractionEventData.tags = new string[4]
					{
						"shot",
						"pierce",
						"heavy",
						scopedIn ? "" : "god"
					};
					uFGInteractionEventData.data = "";
					uFGInteractionEventData.interactorPosition = mainCam.position;
					uFGInteractionEventData.direction = ((Ray)(ref hitRay)).direction;
					uFGInteractionEventData.invokeType = typeof(Tricksniper);
					uFGInteractionEventData.power = 60f;
					UFGInteractionEventData interaction = uFGInteractionEventData;
					if (component.Interact(interaction) && !penetration)
					{
						break;
					}
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<Grenade>(out var component2))
				{
					MonoSingleton<TimeController>.Instance.ParryFlash();
					component2.Explode(false, false, false, 1f, false, (GameObject)null, false);
					if (!penetration)
					{
						break;
					}
				}
				if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryFindComponent<Coin>(out var component3))
				{
					component3.DelayedReflectRevolver(((RaycastHit)(ref array[i])).point, reflectedSniperShot);
				}
			}
			CreateBulletTrail(scopedIn ? mainCam.position : firePoint.position, ((RaycastHit)(ref array[num2])).point, ((RaycastHit)(ref array[num2])).normal);
		}

		private void DrawBulletTrail(Vector3 normal, params Vector3[] positions)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Prefabs.BulletTrail == (Object)null) && positions.Length >= 2)
			{
				GameObject val = Object.Instantiate<GameObject>(Prefabs.BulletTrail, positions[^1], Quaternion.identity);
				val.transform.up = normal;
				LineRenderer component = val.GetComponent<LineRenderer>();
				component.positionCount = positions.Length;
				component.SetPositions(positions);
			}
		}

		private void CreateBulletTrail(Vector3 startPosition, Vector3 endPosition, Vector3 normal)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_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_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Prefabs.BulletTrail == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(Prefabs.BulletTrail, endPosition, Quaternion.identity);
				val.transform.up = normal;
				LineRenderer component = val.GetComponent<LineRenderer>();
				Vector3[] positions = (Vector3[])(object)new Vector3[2] { startPosition, endPosition };
				component.SetPositions(positions);
			}
		}

		protected override void DoAnimations()
		{
			animator.SetFloat("ScopeAmount", scopeTime / scopeInTime);
			if (!scopedIn && scopeTime <= 0f && playReloadAnimWhenUnscoped)
			{
				playReloadAnimWhenUnscoped = false;
				animator.Play("Tricksniper_Reload", 0, 0f);
			}
		}

		private void OnEnable()
		{
			animator.Play("Equip", 0, 0f);
		}

		public override string GetDebuggingText()
		{
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"SPIN: {currentSpin}\n";
			debuggingText += $"TURN_CD: {turnExpiry}\n";
			debuggingText += $"REVOLUTIONS: {revolutions}\n";
			return debuggingText + $"SCOPE: ({scopeTime / scopeInTime}) {scopedIn}\n";
		}
	}
	public class TricksniperReactions : MonoBehaviour
	{
		[SerializeField]
		private AudioClip[] reactions;

		public void PlayReaction()
		{
			if (reactions != null && Data.Config.Data.TricksniperReactionsEnabled)
			{
				AudioSource val = reactions[Random.Range(0, reactions.Length)]?.PlayAudioClip();
			}
		}
	}
	public abstract class UltraFunGunBase : MonoBehaviour, IUFGWeapon
	{
		public class ActionCooldown
		{
			public float TimeToFire;

			public float FireDelay;

			public bool NoCooldown;

			public bool AffectedByNoCooldownCheat;

			public ActionCooldown(float delay = 1f, bool affectedByNoCooldownCheat = false)
			{
				TimeToFire = 0f;
				NoCooldown = delay <= 0f;
				FireDelay = delay;
				AffectedByNoCooldownCheat = affectedByNoCooldownCheat;
			}

			public void AddCooldown()
			{
				TimeToFire = FireDelay + Time.time;
			}

			public void AddCooldown(float delayInSeconds)
			{
				TimeToFire = delayInSeconds + Time.time;
			}

			public bool CanFire()
			{
				if (TimeToFire < Time.time || NoCooldown || (NoWeaponCooldown.NoCooldown && AffectedByNoCooldownCheat))
				{
					return true;
				}
				return false;
			}

			public override string ToString()
			{
				return Mathf.Max(0f, TimeToFire - Time.time).ToString("0.000");
			}
		}

		public Dictionary<string, AudioSource> soundEffects = new Dictionary<string, AudioSource>();

		protected Transform mainCam;

		protected Transform firePoint;

		protected OptionsManager om;

		protected NewMovement player;

		protected WeaponIcon weaponIcon;

		protected WeaponIdentifier weaponIdentifier;

		protected Animator animator;

		protected WeaponTextureSwapper weaponTextureSwapper;

		protected UFGWeapon weaponInfo;

		public bool IsDuplicate
		{
			get
			{
				if ((Object)(object)weaponIdentifier == (Object)null)
				{
					return false;
				}
				return weaponIdentifier.duplicate;
			}
		}

		protected virtual void DoAnimations()
		{
		}

		private void Awake()
		{
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Expected O, but got Unknown
			weaponInfo = WeaponManager.GetWeaponInfo(((object)this).GetType());
			weaponTextureSwapper = ((Component)this).GetComponent<WeaponTextureSwapper>();
			if ((Object)(object)weaponTextureSwapper != (Object)null)
			{
				weaponTextureSwapper.WeaponName = weaponInfo.WeaponKey;
			}
			mainCam = ((Component)MonoSingleton<CameraController>.Instance).transform;
			om = MonoSingleton<OptionsManager>.Instance;
			player = MonoSingleton<NewMovement>.Instance;
			animator = ((Component)this).GetComponent<Animator>();
			weaponIcon = ((Component)this).gameObject.AddComponent<WeaponIcon>();
			weaponIdentifier = ((Component)this).gameObject.AddComponent<WeaponIdentifier>();
			Transform[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "firePoint")
				{
					firePoint = val;
					break;
				}
			}
			if ((Object)(object)firePoint == (Object)null)
			{
				firePoint = mainCam;
				UltraFunGuns.Log.LogWarning("FirePoint setup incorrectly for weapon: " + ((Object)((Component)this).gameObject).name);
			}
			if ((Object)(object)weaponIcon.weaponDescriptor == (Object)null)
			{
				weaponIcon.weaponDescriptor = ScriptableObject.CreateInstance<WeaponDescriptor>();
				HydraLoader.dataRegistry.TryGetValue(weaponInfo.WeaponKey + "_weaponIcon", out var value);
				weaponIcon.weaponDescriptor.icon = (Sprite)value;
				HydraLoader.dataRegistry.TryGetValue(weaponInfo.WeaponKey + "_glowIcon", out var value2);
				weaponIcon.weaponDescriptor.glowIcon = (Sprite)value2;
				weaponIcon.weaponDescriptor.variationColor = (WeaponVariant)weaponInfo.IconColor;
				if ((Object)(object)weaponIcon.weaponDescriptor.icon == (Object)null)
				{
					HydraLoader.dataRegistry.TryGetValue("debug_weaponIcon", out var value3);
					weaponIcon.weaponDescriptor.icon = (Sprite)value3;
				}
				if ((Object)(object)weaponIcon.weaponDescriptor.glowIcon == (Object)null)
				{
					HydraLoader.dataRegistry.TryGetValue("debug_glowIcon", out var value4);
					weaponIcon.weaponDescriptor.glowIcon = (Sprite)value4;
				}
			}
			OnAwakeFinished();
		}

		public virtual void OnAwakeFinished()
		{
		}

		private void Update()
		{
			GetInput();
			DoAnimations();
		}

		public virtual void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && !om.paused)
			{
				FirePrimary();
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && !om.paused)
			{
				FireSecondary();
			}
			if (UFGInput.SecretButton.WasPeformed())
			{
				DoSecret();
			}
			if (Input.GetKeyDown((KeyCode)61) && UltraFunGuns.DebugMode)
			{
				DebugAction();
			}
		}

		public virtual void FirePrimary()
		{
			UltraFunGuns.Log.Log(((Object)((Component)this).gameObject).name + " Fired Primary! (not implemented)");
		}

		public virtual void FireSecondary()
		{
			UltraFunGuns.Log.Log(((Object)((Component)this).gameObject).name + " Fired Secondary! (not implemented)");
		}

		public virtual void DoSecret()
		{
			UltraFunGuns.Log.Log(((Object)((Component)this).gameObject).name + " Used Secret! (not implemented)");
		}

		public virtual void DebugAction()
		{
			UltraFunGuns.Log.Log(((Object)((Component)this).gameObject).name + " Used Debug Action! (not implemented)");
		}

		public UFGWeapon GetWeaponInfo()
		{
			if (weaponInfo == null)
			{
				weaponInfo = WeaponManager.GetWeaponInfo(((object)this).GetType());
			}
			return weaponInfo;
		}

		public virtual string GetDebuggingText()
		{
			return "WEAPONKEY: " + weaponInfo.WeaponKey + "\nDISPLAYNAME: " + weaponInfo.DisplayName + "\n";
		}

		private void OnGUI()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (UltraFunGuns.DebugMode)
			{
				GUI.skin.box.fontSize = 35;
				GUI.skin.box.font = Prefabs.VCR_Font.Asset;
				GUI.skin.box.normal.textColor = Color.white;
				GUI.skin.box.alignment = (TextAnchor)0;
				GUILayout.Box(GetDebuggingText().TrimEnd('\n', '\r'), Array.Empty<GUILayoutOption>());
			}
		}

		private bool AddSFX(string clipName)
		{
			Transform val = ((Component)this).transform.Find("Audios/" + clipName);
			if ((Object)(object)val == (Object)null)
			{
				UltraFunGuns.Log.LogError($"{((Object)((Component)this).gameObject).name} is missing AudioSource Object: {clipName}");
				return false;
			}
			AudioSource value = default(AudioSource);
			if (!((Component)val).TryGetComponent<AudioSource>(ref value))
			{
				UltraFunGuns.Log.LogError($"{((Object)((Component)this).gameObject).name} is missing AudioSource Component: {clipName}");
				return false;
			}
			if (soundEffects.ContainsKey(((Object)this).name))
			{
				UltraFunGuns.Log.LogWarning($"{((Object)((Component)this).gameObject).name} attempted to add AudioSource: {clipName}, more than once.");
				return false;
			}
			soundEffects.Add(clipName, value);
			return true;
		}

		protected void AddSFX(params string[] names)
		{
			int num = 0;
			for (int i = 0; i < names.Length; i++)
			{
				if (AddSFX(names[i]))
				{
					num++;
				}
			}
			UltraFunGuns.Log.Log($"{((Object)((Component)this).gameObject).name}: {num}/{names.Length} SFX Added.");
		}

		protected void PlaySFX(string name, float minPitch = 1f, float maxPitch = 1f)
		{
			if (!soundEffects.ContainsKey(name))
			{
				UltraFunGuns.Log.LogError($"{((Object)((Component)this).gameObject).name}: sound effect: {name} not present in dictionary.");
				return;
			}
			if (minPitch != 1f || maxPitch != 1f)
			{
				soundEffects[name].pitch = Random.Range(minPitch, maxPitch);
			}
			soundEffects[name].Play();
		}
	}
	public class UltraBullet : MonoBehaviour, IUFGInteractionReceiver, ICleanable, IRevolverBeamShootable, ICoinTarget
	{
		[SerializeField]
		private UltraBulletReferenceFix _ubrf;

		private float maxPower;

		[Configgable("Weapons/UltraGun/UltraBullet", null, 0, null)]
		public static float PowerDecayRate = 30f;

		[Configgable("Weapons/UltraGun/UltraBullet", null, 0, null)]
		public static float Damage = 1.2f;

		private UltraGun originWeapon;

		private Rigidbody rb;

		private Vector3 lastVelocity;

		private Vector3 startDirection;

		private bool isMortar = false;

		private UltraFunGunBase.ActionCooldown collisionCD = new UltraFunGunBase.ActionCooldown(0.05f);

		private Transform thrustFX => ubrf.thrustFX;

		private Transform fallFX => ubrf.fallFX;

		private Transform parryThrustFX => ubrf.parryThrustFX;

		private MeshRenderer bulletMesh => ubrf.bulletMesh;

		private Material easterEggMaterial => ubrf.easterEggMaterial;

		private UltraBulletReferenceFix ubrf
		{
			get
			{
				if ((Object)(object)_ubrf == (Object)null)
				{
					_ubrf = ((Component)this).GetComponent<UltraBulletReferenceFix>();
				}
				return _ubrf;
			}
		}

		public float Power { get; private set; }

		public bool Falling { get; private set; }

		public bool Supercharged { get; private set; }

		public bool IsDivision { get; private set; }

		private float divisionScale => ((Component)this).transform.localScale.x + ((Component)this).transform.localScale.y + ((Component)this).transform.localScale.z / 3f;

		public Rigidbody Rigidbody
		{
			get
			{
				if ((Object)(object)rb == (Object)null)
				{
					rb = ((Component)this).GetComponent<Rigidbody>();
				}
				return rb;
			}
		}

		public bool Exploded { get; private set; }

		private void Start()
		{
			//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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)bulletMesh != (Object)null && Random.Range(0, 100) == 0)
			{
				((Renderer)bulletMesh).material = easterEggMaterial;
			}
			rb = ((Component)this).GetComponent<Rigidbody>();
			startDirection = ((Component)this).transform.forward;
			isMortar = Vector3.Dot(startDirection, Vector3.up) > 0.75f;
		}

		public void SetPower(float power)
		{
			Power = power;
			if (Power > maxPower)
			{
				maxPower = Power;
			}
		}

		public void SetOriginWeapon(UltraGun gun)
		{
			originWeapon = gun;
		}

		public void Divide(int divideInto = 3)
		{
			//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_0032: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b3: 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_00cb: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			if (divideInto >= 2 && !IsDivision)
			{
				Vector3 velocity = Rigidbody.velocity;
				Fall();
				Vector3 position = ((Component)this).transform.position;
				Ring ring = new Ring(divideInto, (float)divideInto * 2f);
				float circumferenceFromObjectRadius = ((Component)this).GetComponent<CapsuleCollider>().radius / (float)divideInto;
				ring.SetCircumferenceFromObjectRadius(circumferenceFromObjectRadius);
				Vector3[] positions = ring.GetPositions();
				for (int i = 0; i < positions.Length; i++)
				{
					positions[i] = ((Component)this).transform.rotation * positions[i];
				}
				float magnitude = ((Vector3)(ref velocity)).magnitude;
				Transform transform = ((Component)this).transform;
				transform.localScale /= (float)divideInto;
				((Component)this).transform.position = position + positions[0];
				Rigidbody.velocity = velocity;
				IsDivision = true;
				UltraFunGuns.Log.Log("Bullet divided from " + ((Object)((Component)this).gameObject).name);
				Vector3 val2;
				for (int j = 1; j < positions.Length; j++)
				{
					UltraBullet component = Object.Instantiate<GameObject>(((Component)this).gameObject, positions[j] + position, ((Component)this).transform.rotation).GetComponent<UltraBullet>();
					component.IsDivision = true;
					component.rb = ((Component)component).GetComponent<Rigidbody>();
					Rigidbody obj = component.rb;
					Vector3 val = velocity;
					val2 = ((Component)component).transform.position - position;
					obj.velocity = val + ((Vector3)(ref val2)).normalized * (magnitude * 0.25f);
				}
				Rigidbody rigidbody = Rigidbody;
				Vector3 velocity2 = rigidbody.velocity;
				val2 = ((Component)this).transform.position - position;
				rigidbody.velocity = velocity2 + ((Vector3)(ref val2)).normalized * (magnitude * 0.25f);
			}
		}

		public void Fall()
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if (!Falling)
			{
				if (Supercharged)
				{
					Supercharged = false;
				}
				Falling = true;
				if ((Object)(object)thrustFX != (Object)null)
				{
					((Component)thrustFX).gameObject.SetActive(false);
				}
				if ((Object)(object)parryThrustFX != (Object)null)
				{
					((Component)parryThrustFX).gameObject.SetActive(false);
				}
				if ((Object)(object)fallFX != (Object)null)
				{
					((Component)fallFX).gameObject.SetActive(true);
				}
				originWeapon = null;
				Object.Instantiate<GameObject>(Prefabs.BlackSmokeShockwave, ((Object)(object)thrustFX == (Object)null) ? ((Component)this).transform.position : thrustFX.position, Quaternion.Inverse(((Component)this).transform.rotation));
				((Component)this).gameObject.AddComponent<DestroyAfterTime>().TimeLeft = 25f;
			}
		}

		public void SetDirection(Vector3 direction)
		{
			//IL_0019: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Rigidbody == (Object)null))
			{
				((Component)this).transform.forward = direction;
				Rigidbody rigidbody = Rigidbody;
				Vector3 normalized = ((Vector3)(ref direction)).normalized;
				Vector3 velocity = Rigidbody.velocity;
				rigidbody.velocity = normalized * ((Vector3)(ref velocity)).magnitude;
			}
		}

		private void FixedUpdate()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Rigidbody == (Object)null))
			{
				Vector3 position = ((Component)this).transform.position;
				Vector3 velocity = Rigidbody.velocity;
				Visualizer.DrawRay(position + ((Vector3)(ref velocity)).normalized * 0.4f, Rigidbody.velocity * Time.fixedDeltaTime, 0.0166f);
				Vector3 position2 = ((Component)this).transform.position;
				velocity = Rigidbody.velocity;
				Vector3 val = position2 + ((Vector3)(ref velocity)).normalized * 0.4f;
				Vector3 val2 = Rigidbody.velocity * Time.fixedDeltaTime;
				velocity = Rigidbody.velocity;
				RaycastHit val3 = default(RaycastHit);
				if (Physics.Raycast(val, val2, ref val3, ((Vector3)(ref velocity)).magnitude * Time.fixedDeltaTime, LayerMask.GetMask(new string[2] { "Armor", "Water" })))
				{
					Visualizer.DrawSphere(((RaycastHit)(ref val3)).point, 0.5f, 5f);
					UltraFunGuns.Log.Log("Hit amror");
					Vector3 direction = Vector3.Reflect(Rigidbody.velocity, ((RaycastHit)(ref val3)).normal);
					SetDirection(direction);
				}
				if (Power > 0f && !Falling)
				{
					Rigidbody.velocity = ((Component)this).transform.forward * (((Object)(object)originWeapon != (Object)null) ? Power : maxPower);
				}
				((Component)this).transform.forward = Rigidbody.velocity;
				lastVelocity = Rigidbody.velocity;
				if ((Object)(object)originWeapon != (Object)null)
				{
					SetPower(originWeapon.GetPower(this));
					return;
				}
				Power -= Time.fixedDeltaTime * PowerDecayRate;
				Power = Mathf.Max(0f, Power);
			}
		}

		private void LateUpdate()
		{
			if (!Falling && Power <= 0f)
			{
				Fall();
			}
		}

		public void Explode()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			if (Exploded)
			{
				return;
			}
			Exploded = true;
			GameObject val = Prefabs.UK_Explosion.Asset;
			if (Supercharged)
			{
				val = Prefabs.UK_MindflayerExplosion.Asset;
				VirtualExplosion virtualExplosion = new VirtualExplosion(((Component)this).transform.position, 20f);
				EnemyIdentifier[] affectedEnemies = virtualExplosion.GetAffectedEnemies();
				for (int i = 0; i < affectedEnemies.Length; i++)
				{
					UltraFunGuns.Log.LogWarning($"Enemyinrange_{i}");
					affectedEnemies[i].Override().AddStyleEntryOnDeath(new StyleEntry(30, "ultragunsuperchargekill", 1f));
					Vector3 targetPoint = affectedEnemies[i].GetTargetPoint();
					affectedEnemies[i].DeliverDamage(((Component)affectedEnemies[i]).gameObject, targetPoint - ((Component)this).transform.position * 200f, targetPoint, 0.4f, true, 0.4f, Object.op_Implicit((Object)(object)originWeapon) ? ((Component)originWeapon).gameObject : null, false, false);
				}
			}
			if (IsDivision)
			{
				val = Prefabs.ShittyExplosionFX;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, ((Component)this).transform.position, Quaternion.identity);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		private void OnCollisionEnter(Collision col)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (collisionCD.CanFire() && !Exploded && (LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)3)) & (1 << col.gameObject.layer)) != 0)
			{
				if (col.IsCollisionEnemy(out var enemy))
				{
					HitEnemy(enemy, col);
				}
				Explode();
			}
		}

		public void Supercharge()
		{
			//IL_00a9: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (!Supercharged)
			{
				Supercharged = true;
				originWeapon = null;
				Falling = false;
				SetPower(150f);
				if ((Object)(object)thrustFX != (Object)null)
				{
					((Component)thrustFX).gameObject.SetActive(false);
				}
				if ((Object)(object)((Component)parryThrustFX).gameObject != (Object)null)
				{
					((Component)parryThrustFX).gameObject.SetActive(true);
				}
				if ((Object)(object)fallFX != (Object)null)
				{
					((Component)fallFX).gameObject.SetActive(false);
				}
				Object.Instantiate<GameObject>(Prefabs.BlackSmokeShockwave, thrustFX.position, Quaternion.LookRotation(-((Component)this).transform.forward, Vector3.up));
				Object.Destroy((Object)(object)((Component)this).GetComponent<DestroyAfterTime>());
			}
		}

		private void HitEnemy(EnemyIdentifier eid, Collision col)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0065: 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_007d: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			float num = (Supercharged ? 1.5f : 0f);
			float num2 = (IsDivision ? (Damage * divisionScale) : Damage);
			num2 = (Supercharged ? (num2 * 1.5f) : num2);
			if ((int)eid.enemyType == 34)
			{
				num2 *= 2f;
			}
			if (Falling && Vector3.Dot(Vector3.down, lastVelocity) > 0.75f && Vector3.Dot(startDirection, Vector3.down) > 0.75f)
			{
				eid.Override().AddStyleEntryOnDeath(new StyleEntry(40, "ultragunaerialkill", 1f));
			}
			else
			{
				eid.Override().AddStyleEntryOnDeath(new StyleEntry(25, "ultragunkill", 2f));
			}
			ContactPoint contact;
			if (Falling && Vector3.Dot(Vector3.down, lastVelocity) > 0.85f && isMortar)
			{
				contact = col.GetContact(0);
				if (Vector3.Dot(((ContactPoint)(ref contact)).normal, Vector3.up) > 0.25f)
				{
					WeaponManager.AddStyle(new StyleEntry(1000, "ultragunrainkill"));
					num2 *= 1000f;
					eid.Explode(false);
					return;
				}
			}
			GameObject gameObject = ((Component)eid).gameObject;
			contact = col.GetContact(0);
			Vector3 val = -((ContactPoint)(ref contact)).normal;
			Vector3 relativeVelocity = col.relativeVelocity;
			Vector3 val2 = val * ((Vector3)(ref relativeVelocity)).magnitude * 100f;
			contact = col.GetContact(0);
			eid.DeliverDamage(gameObject, val2, ((ContactPoint)(ref contact)).point, num2, true, num, ((Object)(object)originWeapon != (Object)null) ? ((Component)originWeapon).gameObject : null, false, false);
		}

		public bool Parry(Vector3 origin, Vector3 aimVector)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			SetDirection(aimVector);
			if (Falling)
			{
				Divide(4);
			}
			return true;
		}

		public bool Interact(UFGInteractionEventData interaction)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (interaction.ContainsAnyTag("electricity", "god", "sonic"))
			{
				SetDirection(interaction.direction);
				Supercharge();
				return true;
			}
			if (interaction.ContainsAnyTag("shot", "explode"))
			{
				MonoSingleton<TimeController>.Instance.ParryFlash();
				Explode();
				return true;
			}
			return false;
		}

		public Vector3 GetPosition()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)this).transform.position;
		}

		private void OnDestroy()
		{
			Explode();
		}

		public bool Targetable(TargetQuery query)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Exploded)
			{
				return false;
			}
			return query.CheckTargetable(((Component)this).transform.position);
		}

		public void Cleanup()
		{
			Explode();
		}

		public void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_0036: 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)
			if (Supercharged)
			{
				MonoSingleton<TimeController>.Instance.ParryFlash();
				Explode();
				return;
			}
			BeamType beamType = beam.beamType;
			BeamType val = beamType;
			if ((int)val == 1)
			{
				SetDirection(((Component)this).transform.position - ((Component)beam).transform.position);
				Supercharge();
			}
			else
			{
				MonoSingleton<TimeController>.Instance.ParryFlash();
				Explode();
			}
		}

		public bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit)
		{
			return !Exploded;
		}

		public Transform GetCoinTargetPoint(Coin coin)
		{
			return ((Component)this).transform;
		}

		public bool CanBeCoinTargeted(Coin coin)
		{
			return !Exploded;
		}

		public void OnCoinReflect(Coin coin, RevolverBeam beam)
		{
			//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_001f: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0032: 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_003d: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			UltraFunGuns.Log.Log("Coin reflect uB");
			BeamType beamType = beam.beamType;
			BeamType val = beamType;
			if ((int)val == 1)
			{
				Vector3 pos = ((Component)this).transform.position;
				Vector3 direction = pos - ((Component)beam).transform.position;
				List<EnemyIdentifier> currentEnemies = MonoSingleton<EnemyTracker>.Instance.GetCurrentEnemies();
				if (currentEnemies.Count > 0)
				{
					foreach (EnemyIdentifier item in currentEnemies.OrderBy((EnemyIdentifier x) => Vector3.Distance(x.GetCenter().position, pos)))
					{
						Vector3 val2 = item.GetCenter().position - pos;
						if (Physics.Raycast(pos, val2, ((Vector3)(ref val2)).magnitude, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
						{
							continue;
						}
						direction = val2;
						break;
					}
				}
				SetDirection(direction);
				Supercharge();
			}
			else
			{
				MonoSingleton<TimeController>.Instance.ParryFlash();
				Explode();
			}
		}

		public int GetCoinTargetPriority(Coin coin)
		{
			return 1;
		}
	}
	public class UltraBulletReferenceFix : MonoBehaviour
	{
		public Transform thrustFX;

		public Transform fallFX;

		public Transform parryThrustFX;

		public MeshRenderer bulletMesh;

		public Material easterEggMaterial;
	}
	[WeaponAbility("Heavy Shell", "SHOOT WITH <color=orange>Fire 1</color>", 0, RichTextColors.aqua)]
	[WeaponAbility("Barrage", "Hold <color=orange>Fire 2</color> and release for a barrage of shells.", 1, RichTextColors.lime)]
	[WeaponAbility("TX-Fuel", "The last shell fired will maintain it's initial speed.", 2, RichTextColors.yellow)]
	[UFGWeapon("UltraGun", "ULTRAGUN", 3, true, WeaponIconColor.Green, true, true)]
	public class UltraGun : UltraFunGunBase
	{
		[UFGAsset("BigGun_DeniedBoost")]
		private static AudioClip boostDenied_SFX;

		[UFGAsset("BigGun_Fire")]
		private static AudioClip fire_SFX;

		private ActionCooldown primaryFire = new ActionCooldown(0.5f, affectedByNoCooldownCheat: true);

		private ActionCooldown secondaryBoost = new ActionCooldown(0.5f, affectedByNoCooldownCheat: true);

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float primaryFireCooldown = 0.5f;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float secondaryFireCooldown = 0.5f;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float powerRestoreRate = 50f;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float minPower = 10f;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float maxPower = 80f;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float minPowerCost = 30f;

		private float power;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float barrageChargeMin = 0f;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float barrageChargeMax = 1.15f;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float barrageChargeMultiplier = 1f;

		private float barrageCharge;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static int barrageAmount = 3;

		[Configgable("Weapons/UltraGun/UltraGun", null, 0, null)]
		private static float barrageFireDelay = 0.15f;

		private AbilityMeter powerDisplay;

		private Vibrate vibrate;

		private AudioSource chargingAudioSrc;

		[UFGAsset("Charge_Loop_Alternate")]
		private static AudioClip chargingLoopClip;

		private List<UltraBullet> firedBullets = new List<UltraBullet>();

		private UltraBullet lastBullet;

		private bool barraging;

		private int divisions = 3;

		[UFGAsset("UltraBullet")]
		public static GameObject UltraBulletPrefab { get; private set; }

		private bool canBarrage => barrageCharge > barrageChargeMax / (float)barrageAmount && !barraging;

		public float Power
		{
			get
			{
				return power;
			}
			set
			{
				power = Mathf.Clamp(value, minPower, maxPower);
			}
		}

		private void Start()
		{
			primaryFire = new ActionCooldown(primaryFireCooldown, affectedByNoCooldownCheat: true);
			secondaryBoost = new ActionCooldown(secondaryFireCooldown, affectedByNoCooldownCheat: true);
			chargingAudioSrc = ((Component)this).gameObject.AddComponent<AudioSource>();
			chargingAudioSrc.clip = chargingLoopClip;
			chargingAudioSrc.playOnAwake = true;
			chargingAudioSrc.loop = true;
			chargingAudioSrc.Play();
			vibrate = ((Component)this).gameObject.GetComponentInChildren<Vibrate>();
			powerDisplay = ((Component)this).GetComponentInChildren<AbilityMeter>();
			Power = maxPower;
		}

		public override void GetInput()
		{
			//IL_00a2: 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_0095: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			if (om.paused || barraging)
			{
				return;
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.WasPerformedThisFrame && (primaryFire.CanFire() || canBarrage))
			{
				if (canBarrage)
				{
					Barrage();
					return;
				}
				primaryFire.AddCooldown();
				Ray val = (Ray)(base.IsDuplicate ? new Ray(firePoint.position, mainCam.forward) : HydraUtils.GetProjectileAimVector(mainCam, firePoint, 0.85f, 20000f));
				Fire(((Ray)(ref val)).direction);
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed)
			{
				barrageCharge = Mathf.Clamp(barrageCharge + Time.deltaTime * barrageChargeMultiplier, barrageChargeMin, barrageChargeMax);
			}
			else if (canBarrage)
			{
				Barrage();
			}
			else
			{
				barrageCharge = Mathf.Clamp(barrageCharge - Time.deltaTime * barrageChargeMultiplier, barrageChargeMin, barrageChargeMax);
			}
			if (UFGInput.SecretButton.WasPeformed() && !om.paused)
			{
				Animator obj = animator;
				if (obj != null)
				{
					obj.Play("Inspect", 0, 0f);
				}
			}
		}

		private void LateUpdate()
		{
			if (barrageAmount <= 0)
			{
				barrageAmount = 1;
			}
			float num = barrageCharge / barrageChargeMax;
			powerDisplay?.SetAmount(num);
			if ((Object)(object)vibrate != (Object)null)
			{
				vibrate.intensity = Mathf.Lerp(0f, 0.015f, num);
			}
			Animator obj = animator;
			if (obj != null)
			{
				obj.SetBool("Cooldown", !primaryFire.CanFire());
			}
			if ((Object)(object)chargingAudioSrc != (Object)null)
			{
				chargingAudioSrc.pitch = Mathf.Lerp(0f, 0.9f, num);
				chargingAudioSrc.volume = ((num > 0f) ? 1 : 0);
			}
		}

		private UltraBullet Fire(Vector3 aimDirection)
		{
			//IL_0095: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)UltraBulletPrefab == (Object)null)
			{
				return null;
			}
			float num = Power / 2f;
			AudioSource val = fire_SFX.PlayAudioClip(Random.Range(0.9f, 1.1f));
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.AddComponent<DestroyOnDisable>();
				((Component)val).transform.parent = firePoint;
			}
			if ((Object)(object)Prefabs.BlackSmokeShockwave != (Object)null)
			{
				Object.Instantiate<GameObject>(Prefabs.BlackSmokeShockwave, firePoint.position, firePoint.rotation);
			}
			Animator obj = animator;
			if (obj != null)
			{
				obj.Play("Fire", 0, 0f);
			}
			MonoSingleton<TimeController>.Instance.HitStop(0.015f);
			MonoSingleton<CameraController>.Instance.CameraShake(Mathf.Max(1.4f, num / 50f));
			float num2 = Vector3.Dot(mainCam.forward, Vector3.down);
			GameObject val2 = Object.Instantiate<GameObject>(UltraBulletPrefab, firePoint.position, Quaternion.identity);
			UltraBullet ultraBullet = default(UltraBullet);
			if (val2.TryGetComponent<UltraBullet>(ref ultraBullet))
			{
				ultraBullet.SetOriginWeapon(this);
				ultraBullet.SetDirection(aimDirection);
				firedBullets.Add(ultraBullet);
				lastBullet = ultraBullet;
				ultraBullet.SetPower(GetPower(ultraBullet));
			}
			if (!player.gc.onGround)
			{
				Rigidbody rb = player.rb;
				rb.velocity += -mainCam.forward * num * 0.25f * Mathf.Max(Mathf.Abs(num2), 0.45f);
			}
			else if (num2 >= 0.75f)
			{
				Rigidbody rb2 = player.rb;
				rb2.velocity += Vector3.Reflect(mainCam.forward, Vector3.up) * num * 0.45f;
			}
			return ultraBullet;
		}

		private void Barrage()
		{
			if (!barraging)
			{
				barraging = true;
				((MonoBehaviour)this).StartCoroutine(DoBarrage());
			}
		}

		private IEnumerator DoBarrage()
		{
			int barrageCount = Mathf.RoundToInt((float)barrageAmount * (barrageCharge / barrageChargeMax));
			List<Collider> bulletColliders = new List<Collider>();
			for (int i = 0; i < barrageCount; i++)
			{
				UltraBullet bullet = Fire(mainCam.forward + mainCam.rotation * Vector2.op_Implicit(Random.insideUnitCircle) * 0.085f);
				bullet.SetPower(125f);
				bullet.SetPower(3f);
				bullet.SetOriginWeapon(null);
				barrageCharge = Mathf.Clamp(barrageCharge - barrageChargeMax / (float)barrageAmount, barrageChargeMin, barrageChargeMax);
				Collider[] col = ((Component)bullet).GetComponentsInChildren<Collider>();
				for (int x = 0; x < col.Length; x++)
				{
					if ((Object)(object)col[x] == (Object)null)
					{
						continue;
					}
					foreach (Collider shotCollider in bulletColliders)
					{
						if (!((Object)(object)shotCollider == (Object)null))
						{
							Physics.IgnoreCollision(shotCollider, col[x], true);
						}
					}
				}
				bulletColliders.AddRange(col);
				yield return (object)new WaitForSeconds(barrageFireDelay);
			}
			primaryFire.AddCooldown(primaryFire.FireDelay * 2f);
			barraging = false;
			yield return (object)new WaitForSeconds(0.31666f);
			animator.Play("Cooldown", 0, 0f);
		}

		private void DropAllBullets()
		{
			firedBullets = (from x in firedBullets
				where (Object)(object)x != (Object)null
				select x into y
				where !y.Falling
				select y).ToList();
			for (int i = 0; i < firedBullets.Count; i++)
			{
				firedBullets[i].Fall();
			}
		}

		private void DivideBullets()
		{
			firedBullets = firedBullets.Where((UltraBullet x) => (Object)(object)x != (Object)null).ToList();
			for (int i = 0; i < firedBullets.Count; i++)
			{
				firedBullets[i].Divide(divisions);
			}
		}

		public float GetPower(UltraBullet bullet)
		{
			if ((Object)(object)bullet != (Object)(object)lastBullet)
			{
				return 0f;
			}
			return maxPower;
		}

		private void OnEnable()
		{
			animator.Play("Equip", 0, 0f);
		}

		private void OnDisable()
		{
			barrageCharge = barrageChargeMin;
			barraging = false;
		}

		public override string GetDebuggingText()
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			string debuggingText = base.GetDebuggingText();
			debuggingText += $"POWER: {Power}\n";
			debuggingText += $"BARRAGE: {barrageCharge}\n";
			if (firedBullets.Count > 0)
			{
				firedBullets = firedBullets.Where((UltraBullet x) => (Object)(object)x != (Object)null).ToList();
				for (int i = 0; i < firedBullets.Count; i++)
				{
					if (!((Object)(object)firedBullets[i] == (Object)null))
					{
						string text = debuggingText;
						object arg = i;
						string arg2 = firedBullets[i].Power.ToString("0.00");
						Vector3 velocity = firedBullets[i].Rigidbody.velocity;
						debuggingText = text + string.Format("BULLET_{0} PWR: {1} VEL: {2}\n", arg, arg2, ((Vector3)(ref velocity)).magnitude.ToString("0.00"));
					}
				}
			}
			return debuggingText;
		}
	}
	[Serializable]
	public class CustomVoxelData : VoxelData
	{
		public string BehaviourStateID { get; }

		public string MeshOverrideID { get; }

		public string AudioPath { get; }

		public string TexturePath { get; }

		public CustomVoxelData(string iD, string displayName, Material material, AudioClip sound, string stateID, string texturePath, string audioPath, string meshOverrideID)
			: base(iD, displayName, material, sound)
		{
			BehaviourStateID = stateID;
			TexturePath = texturePath;
			AudioPath = audioPath;
			MeshOverrideID = meshOverrideID;
		}
	}
	public interface IVoxelState
	{
		BinaryWriter WriteStateData(BinaryWriter bw);

		void ReadStateData(BinaryReader br);

		string GetID();

		void OnVoxel(Voxel voxel);

		void OnVoxelPlaced(Voxel voxel);

		void OnVoxelDestroyed(Voxel voxel);

		void OnVoxelUpdate(Voxel voxel);

		void OnVoxelInteract(Voxel voxel);

		void OnVoxelBreak(Voxel voxel);

		void PrintState(Voxel voxel);
	}
	[Serializable]
	public struct SerializedVoxel
	{
		public int x;

		public int y;

		public int z;

		public string id;

		public string stateTypeID;

		public byte[] stateData;

		public BinaryWriter WriteBytes(BinaryWriter bw)
		{
			bw.Write(x);
			bw.Write(y);
			bw.Write(z);
			bw.Write(id);
			bw.Write(stateTypeID);
			bw.Write(stateData.Length);
			bw.Write(stateData);
			return bw;
		}
	}
	public class VoxelData
	{
		public string ID { get; }

		public string DisplayName { get; }

		[JsonIgnore]
		public Material Material { get; }

		[JsonIgnore]
		public AudioClip Sound { get; }

		public VoxelData(string iD, string displayName, Material material, AudioClip sound)
		{
			ID = iD;
			DisplayName = displayName;
			Material = material;
			Sound = sound;
		}
	}
	public static class VoxelDatabase
	{
		[UFGAsset("vh_selection")]
		private static VoxelDataDef selection;

		[UFGAsset("VoxelBreakParticle")]
		private static GameObject voxelParticlePrefab;

		private static VoxelData[] builtInVoxelData;

		private static Dictionary<string, VoxelData> voxelRegistry;

		private static Dictionary<string, VoxelData> customBlocks = new Dictionary<string, VoxelData>();

		private static Dictionary<string, VoxelData> placeholderDatas = new Dictionary<string, VoxelData>();

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

		private static readonly string[] blacklistedVoxels = new string[1] { "vh_selection" };

		[UFGAsset("boulder_impact_on_stones_14 fast")]
		private static AudioClip defaultClip;

		private static Dictionary<string, Texture2D> loadedTextures = new Dictionary<string, Texture2D>();

		[Configgable("Voxel", null, 0, null)]
		private static ConfigToggle useCyberGrindTextures = new ConfigToggle(false);

		public static VoxelData Selection => selection.VoxelData;

		public static GameObject VoxelParticle => voxelParticlePrefab;

		private static string customVoxelsFolder => Paths.VoxelBlockTexturesFolder;

		public static bool IsImportingTextures { get; private set; }

		public static float TextureImportProgress { get; private set; }

		private static string cyberGrindTextureFolder => Paths.CybergrindTexturesFolder;

		public static event Action OnCustomBlocksUpdated;

		public static IEnumerable<VoxelData> GetPlaceableVoxels()
		{
			if (voxelRegistry == null)
			{
				InitializeVoxelDatabase();
			}
			IEnumerable<VoxelData> enumerable = voxelRegistry.Values;
			if (customBlocks != null)
			{
				enumerable = enumerable.Concat(customBlocks.Values);
			}
			return enumerable;
		}

		public static void OpenCustomVoxelFolder()
		{
			if (!Directory.Exists(customVoxelsFolder))
			{
				Directory.CreateDirectory(customVoxelsFolder);
			}
			Application.OpenURL("file://" + customVoxelsFolder);
		}

		public static void ImportCustomBlocksAsync()
		{
			if (!IsImportingTextures)
			{
				StaticCoroutine.RunCoroutine(ImportCustomTexturesAsync(delegate
				{
					VoxelDatabase.OnCustomBlocksUpdated?.Invoke();
				}));
			}
		}

		private static IEnumerator ImportCustomTexturesAsync(Action onComplete)
		{
			IsImportingTextures = true;
			List<string> pathes = new List<string>();
			if (!Directory.Exists(customVoxelsFolder))
			{
				Directory.CreateDirectory(customVoxelsFolder);
			}
			pathes.AddRange(Directory.GetFiles(customVoxelsFolder, "*.png", SearchOption.AllDirectories));
			pathes.AddRange(Directory.GetFiles(customVoxelsFolder, "*.jpg", SearchOption.AllDirectories));
			pathes.AddRange(Directory.GetFiles(customVoxelsFolder, "*.jpeg", SearchOption.AllDirectories));
			if (((ConfigValueElement<bool>)(object)useCyberGrindTextures).Value)
			{
				pathes.AddRange(Directory.GetFiles(cyberGrindTextureFolder, "*.png", SearchOption.AllDirectories));
				pathes.AddRange(Directory.GetFiles(cyberGrindTextureFolder, "*.jpg", SearchOption.AllDirectories));
				pathes.AddRange(Directory.GetFiles(cyberGrindTextureFolder, "*.jpeg", SearchOption.AllDirectories));
			}
			int totalCount = pathes.Count + 1;
			int indexProcessed = 1;
			foreach (string path in pathes)
			{
				TextureImportProgress = (float)indexProcessed / (float)totalCount;
				int num = indexProcessed + 1;
				indexProcessed = num;
				if (!loadedTextures.ContainsKey(path) && !checkedPathes.Contains(path))
				{
					checkedPathes.Add(path);
					yield return (object)new WaitForEndOfFrame();
					if (TextureLoader.TryLoadTexture(path, out var tex) && ((Texture)tex).width == ((Texture)tex).height)
					{
						((Object)tex).name = Path.GetFileNameWithoutExtension(path);
						loadedTextures.Add(path, tex);
						yield return (object)new WaitForEndOfFrame();
						tex = null;
					}
				}
			}
			Material defaultMaterial = VoxelMaterialManager.GetDefaultMaterial();
			foreach (Texture2D texture in loadedTextures.Values)
			{
				TextureImportProgress = (float)indexProcessed / (float)totalCount;
				int num = indexProcessed + 1;
				indexProcessed = num;
				if ((Object)(object)texture == (Object)null)
				{
					continue;
				}
				if (customBlocks.ContainsKey(((Object)texture).name))
				{
					if ((Object)(object)customBlocks[((Object)texture).name].Material != (Object)(object)defaultMaterial)
					{
						continue;
					}
					customBlocks.Remove(((Object)texture).name);
				}
				VoxelData customVoxelData = CreateCustomBlock(texture);
				customBlocks.Add(((Object)texture).name, customVoxelData);
			}
			TextureImportProgress = 1f;
			IsImportingTextures = false;
			onComplete?.Invoke();
		}

		private static void ImportPackagedVoxels()
		{
			if (builtInVoxelData == null && !((Object)(object)HydraLoader.AssetBundle == (Object)null))
			{
				builtInVoxelData = (from x in HydraLoader.AssetBundle.LoadAllAssets<VoxelDataDef>()
					where !blacklistedVoxels.Contains(((Object)x).name)
					select x.VoxelData).ToArray();
				voxelRegistry = builtInVoxelData.ToDictionary((VoxelData x) => x.ID, (VoxelData x) => x);
			}
		}

		private static VoxelData CreateCustomBlock(Texture2D texture)
		{
			((Texture)texture).filterMode = (FilterMode)0;
			return new VoxelData(((Object)texture).name, ((Object)texture).name, VoxelMaterialManager.GetMaterial(texture), defaultClip);
		}

		public static void RegisterCustomVoxelData(VoxelData voxelData)
		{
			if (voxelData == null)
			{
				throw new ArgumentNullException("voxelData");
			}
			if (customBlocks.ContainsKey(voxelData.ID))
			{
				throw new DuplicateNameException("voxelData");
			}
			customBlocks.Add(voxelData.ID, voxelData);
		}

		private static void InitializeVoxelDatabase()
		{
			ImportPackagedVoxels();
			ImportCustomBlocksAsync();
		}

		public static void Flush()
		{
			builtInVoxelData = null;
			voxelRegistry = null;
			customBlocks.Clear();
			loadedTextures.Clear();
			checkedPathes.Clear();
		}

		public static VoxelData GetVoxelData(string id)
		{
			if (voxelRegistry == null)
			{
				InitializeVoxelDatabase();
			}
			if (voxelRegistry.ContainsKey(id))
			{
				return voxelRegistry[id];
			}
			if (customBlocks.ContainsKey(id))
			{
				return customBlocks[id];
			}
			return null;
		}

		public static VoxelData GetPlaceholderVoxelData(string id)
		{
			if (!placeholderDatas.ContainsKey(id))
			{
				VoxelData value = new VoxelData(id, id, VoxelMaterialManager.GetDefaultMaterial(), defaultClip);
				placeholderDatas.Add(id, value);
			}
			return placeholderDatas[id];
		}

		public static bool VoxelIsPlaceholder(VoxelData voxelData)
		{
			return placeholderDatas.ContainsKey(voxelData.ID);
		}

		public static bool VoxelExists(string id)
		{
			if (voxelRegistry == null)
			{
				InitializeVoxelDatabase();
			}
			return voxelRegistry.ContainsKey(id) || customBlocks.ContainsKey(id);
		}
	}
	public class VoxelDataDef : ScriptableObject
	{
		public string DisplayName;

		public Texture2D Texture;

		public Material MaterialOverride;

		public AudioClip Sound;

		private VoxelData _voxelData;

		public VoxelData VoxelData
		{
			get
			{
				if (_voxelData == null)
				{
					_voxelData = ConvertData();
				}
				return _voxelData;
			}
		}

		private VoxelData ConvertData()
		{
			return new VoxelData(((Object)this).name, DisplayName, ((Object)(object)MaterialOverride == (Object)null) ? VoxelMaterialManager.GetMaterial(Texture) : MaterialOverride, Sound);
		}
	}
	public struct VoxelLocation
	{
		private Vector3Int _coordinate;

		private Vector3 _position;

		public Vector3Int Coordinate
		{
			get
			{
				//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_000a: Unknown result type (might be due to invalid IL or missing references)
				return _coordinate;
			}
			set
			{
				//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_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				_coordinate = value;
				_position = CoordinateToPosition(value);
			}
		}

		public Vector3 Position
		{
			get
			{
				//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_000a: Unknown result type (might be due to invalid IL or missing references)
				return _position;
			}
			set
			{
				//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_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				_position = value;
				_coordinate = PositionToCoordinate(value);
			}
		}

		public VoxelLocation(Vector3Int coordinate)
		{
			//IL_0007: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			_coordinate = default(Vector3Int);
			_position = default(Vector3);
			Coordinate = coordinate;
		}

		public VoxelLocation(Vector3 position)
		{
			//IL_0007: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			_coordinate = default(Vector3Int);
			_position = default(Vector3);
			Position = position;
		}

		public static VoxelLocation CoordinateToLocation(Vector3Int coordinate)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return new VoxelLocation(coordinate);
		}

		public static VoxelLocation PositionToLocation(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return new VoxelLocation(position);
		}

		public static Vector3 CoordinateToPosition(Vector3Int coordinate)
		{
			//IL_0019: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((float)((Vector3Int)(ref coordinate)).x, (float)((Vector3Int)(ref coordinate)).y, (float)((Vector3Int)(ref coordinate)).z) * VoxelWorld.WorldScale;
		}

		public static Vector3Int PositionToCoordinate(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0027: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = SnapToWorldGrid(position);
			Vector3Int result = default(Vector3Int);
			((Vector3Int)(ref result)).x = (int)(val.x / VoxelWorld.WorldScale);
			((Vector3Int)(ref result)).y = (int)(val.y / VoxelWorld.WorldScale);
			((Vector3Int)(ref result)).z = (int)(val.z / VoxelWorld.WorldScale);
			return result;
		}

		public static Vector3 SnapToWorldGrid(Vector3 samplePosition)
		{
			//IL_0003: 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_0031: 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_0047: 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)
			samplePosition.x = SnapAxis(samplePosition.x, VoxelWorld.WorldScale);
			samplePosition.y = SnapAxis(samplePosition.y, VoxelWorld.WorldScale);
			samplePosition.z = SnapAxis(samplePosition.z, VoxelWorld.WorldScale);
			return samplePosition;
		}

		public static float SnapAxis(float value, float interval)
		{
			float num = Mathf.Sign(value);
			value = Mathf.Abs(value);
			float num2 = value % interval;
			value = ((!(num2 > interval / 2f)) ? (value - num2) : (value - num2 + interval));
			return value * num;
		}
	}
	public static class VoxelSaveManager
	{
		public static IEnumerable<VoxelWorldFile> LoadWorldDatas()
		{
			if (!Directory.Exists(Paths.VoxelSavesFolder))
			{
				yield break;
			}
			string[] files = Directory.GetFiles(Paths.VoxelSavesFolder, "*.vwd", SearchOption.AllDirectories);
			foreach (string filePath in files)
			{
				if (File.Exists(filePath))
				{
					VoxelWorldFile worldData = null;
					using (FileStream file = new FileStream(filePath, FileMode.Open, FileAccess.Read))
					{
						BinaryFormatter binaryFormatter = new BinaryFormatter();
						worldData = (VoxelWorldFile)binaryFormatter.Deserialize(file);
					}
					yield return worldData;
				}
			}
		}

		public static IEnumerable<VoxelWorldFileHeader> LoadHeaders()
		{
			if (!Directory.Exists(Paths.VoxelSavesFolder))
			{
				yield break;
			}
			string[] files = Directory.GetFiles(Paths.VoxelSavesFolder, "*.vwd", SearchOption.AllDirectories);
			foreach (string filePath in files)
			{
				if (File.Exists(filePath))
				{
					yield return LoadHeaderAtFilePath(filePath);
				}
			}
		}

		public static VoxelWorldFileHeader LoadHeaderAtFilePath(string filePath)
		{
			if (!File.Exists(filePath))
			{
				return null;
			}
			VoxelWorldFileHeader voxelWorldFileHeader = null;
			using (FileStream input = new FileStream(filePath, FileMode.Open, FileAccess.Read))
			{
				using BinaryReader binaryReader = new BinaryReader(input);
				int version = binaryReader.ReadInt32();
				IVoxelFileReader reader = VoxelFileReaderFactory.GetReader(version);
				voxelWorldFileHeader = reader.ReadHeader(binaryReader);
				voxelWorldFileHeader.FilePath = filePath;
			}
			return voxelWorldFileHeader;
		}

		public static VoxelWorldFile LoadAtFilePath(string filePath)
		{
			if (!File.Exists(filePath))
			{
				return null;
			}
			VoxelWorldFile voxelWorldFile = null;
			using (FileStream input = new FileStream(filePath, FileMode.Open, FileAccess.Read))
			{
				using BinaryReader binaryReader = new BinaryReader(input);
				int version = binaryReader.ReadInt32();
				IVoxelFileReader reader = VoxelFileReaderFactory.GetReader(version);
				voxelWorldFile = reader.ReadWorldData(binaryReader);
				voxelWorldFile.Header.FilePath = filePath;
			}
			return voxelWorldFile;
		}

		public static VoxelWorldFile LoadFromBytes(byte[] bytes)
		{
			using MemoryStream input = new MemoryStream(bytes);
			using BinaryReader binaryReader = new BinaryReader(input);
			int version = binaryReader.ReadInt32();
			IVoxelFileReader reader = VoxelFileReaderFactory.GetReader(version);
			return reader.ReadWorldData(binaryReader);
		}

		public static byte[] ToBytes(VoxelWorldFile file)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (BinaryWriter binaryWriter = new BinaryWriter(memoryStream))
			{
				binaryWriter.Write(0);
				file.WriteBytes(binaryWriter);
			}
			return memoryStream.ToArray();
		}

		public static VoxelWorldFile LoadFromName(string name)
		{
			string filePath = Path.Combine(Paths.VoxelSavesFolder, name + ".vwd");
			return LoadAtFilePath(filePath);
		}

		public static bool Exists(string name)
		{
			string path = NameToFilePath(name);
			return File.Exists(path);
		}

		public static void SaveWorldData(string filePath, VoxelWorldFile data)
		{
			if (!Directory.Exists(Paths.VoxelSavesFolder))
			{
				Directory.CreateDirectory(Paths.VoxelSavesFolder);
			}
			using FileStream output = new FileStream(filePath, FileMode.Create, FileAccess.Write);
			using BinaryWriter binaryWriter = new BinaryWriter(output);
			binaryWriter.Write(0);
			data.WriteBytes(binaryWriter);
		}

		public static string NameToFilePath(string name)
		{
			return Path.Combine(Paths.VoxelSavesFolder, name + ".vwd");
		}

		public static void UpdateHeaderFile(VoxelWorldFileHeader header)
		{
			string filePath = header.FilePath;
			if (!File.Exists(filePath))
			{
				throw new Exception("Cannot update header in file " + filePath + ", file does not exist or filepath is invalid.");
			}
			VoxelWorldFile voxelWorldFile = LoadAtFilePath(filePath);
			voxelWorldFile.Header = header;
			SaveWorldData(filePath, voxelWorldFile);
			if (VoxelWorld.CurrentFile != null && VoxelWorld.CurrentFile.Header.FilePath == filePath)
			{
				VoxelWorld.CurrentFile.Header = header;
			}
		}

		public static void DeleteFile(VoxelWorldFileHeader header)
		{
			if (!File.Exists(header.FilePath))
			{
				throw new Exception("Cannot delete file " + header.FilePath + ", file does not exist or filepath is invalid.");
			}
			File.Delete(header.FilePath);
		}

		public static void RenameFile(VoxelWorldFileHeader header, string newPath)
		{
			if (!File.Exists(header.FilePath))
			{
				throw new Exception("Cannot rename file " + header.FilePath + ", file does not exist or filepath is invalid.");
			}
			string filePath = header.FilePath;
			byte[] bytes = File.ReadAllBytes(header.FilePath);
			File.WriteAllBytes(newPath, bytes);
			File.Delete(header.FilePath);
			header.FilePath = newPath;
			if (VoxelWorld.CurrentFile != null && VoxelWorld.CurrentFile.Header.FilePath == filePath)
			{
				VoxelWorld.CurrentFile.Header.FilePath = newPath;
			}
		}
	}
	public class VoxelWorldFile
	{
		public const int FILE_VERSION = 0;

		public VoxelWorldFileHeader Header;

		public SerializedVoxel[] VoxelData;

		public BinaryWriter WriteBytes(BinaryWriter bw)
		{
			Header.TotalVoxelCount = VoxelData.Length;
			Header.WriteBytes(bw);
			for (int i = 0; i < VoxelData.Length; i++)
			{
				VoxelData[i].WriteBytes(bw);
			}
			return bw;
		}
	}
	public class VoxelWorldFileHeader
	{
		public string FilePath;

		public int TotalVoxelCount;

		public float WorldScale;

		public string SceneName;

		public string DisplayName;

		public string Description;

		public string ModVersion;

		public string GameVersion;

		public BinaryWriter WriteBytes(BinaryWriter bw)
		{
			bw.Write(TotalVoxelCount);
			bw.Write(WorldScale);
			bw.Write(SceneName);
			bw.Write(DisplayName);
			bw.Write(Description);
			bw.Write(ModVersion);
			bw.Write(GameVersion);
			return bw;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is VoxelWorldFileHeader voxelWorldFileHeader))
			{
				return false;
			}
			return FilePath == voxelWorldFileHeader.FilePath;
		}

		public override int GetHashCode()
		{
			return FilePath.GetHashCode();
		}
	}
	public class VoxelFileInspector : MonoBehaviour
	{
		private InputField fileNameInputField;

		private InputField worldDisplayNameInputField;

		private InputField descriptionInputField;

		private Text voxelCountText;

		private GameObject fileNameWarningPanel;

		private Text fileNameWarningText;

		private VoxelSavesMenu menu;

		private VoxelWorldFileHeader target;

		private const int MAX_SAVE_NAME_CHARACTERS = 32;

		private const int MAX_WORLD_NAME_CHARACTERS = 48;

		private const int MAX_DESCRIPTION_CHARACTERS = 2048;

		private bool initialized = false;

		public void OpenWithFile(VoxelWorldFileHeader header)
		{
			InitializeReferences();
			SelectFile(header);
			Open();
			menu.DisableAllSideButtons();
			((Component)menu.returnButton).gameObject.SetActive(true);
			menu.returnButton.SetClickAction(delegate
			{
				Close();
				menu.Open();
			});
			((Component)menu.openInFolderButton).gameObject.SetActive(true);
			menu.openInFolderButton.SetClickAction(delegate
			{
				Application.OpenURL("file://" + Path.GetDirectoryName(header.FilePath));
			});
			((Component)menu.deleteButton).gameObject.SetActive(true);
			menu.deleteButton.SetClickAction(delegate
			{
				menu.Delete(header, delegate
				{
					Close();
					menu.Open();
				});
			});
			((Component)menu.loadButton).gameObject.SetActive(true);
			menu.loadButton.SetClickAction(delegate
			{
				menu.Load(header);
			});
		}

		public void CreationMode()
		{
			InitializeReferences();
			VoxelWorldFileHeader header = new VoxelWorldFileHeader();
			target = header;
			string text = "NewWorld";
			int i;
			for (i = 0; File.Exists(VoxelSaveManager.NameToFilePath(text + ((i > 0) ? $" ({i})" : ""))); i++)
			{
			}
			header.FilePath = VoxelSaveManager.NameToFilePath(text + ((i > 0) ? $" ({i})" : ""));
			header.DisplayName = "New World";
			header.Description = "A new world";
			header.SceneName = SceneHelper.CurrentScene;
			header.TotalVoxelCount = 0;
			header.WorldScale = VoxelWorld.WorldScale;
			header.ModVersion = "1.3.6";
			header.GameVersion = Application.version;
			if ((Object)(object)menu == (Object)null)
			{
				menu = ((Component)this).GetComponentInParent<VoxelSavesMenu>();
			}
			SelectFile(header);
			menu.DisableAllSideButtons();
			((Component)menu.confirmButton).gameObject.SetActive(true);
			menu.confirmButton.SetClickAction(delegate
			{
				VoxelWorldFile voxelWorldFile = null;
				if (VoxelWorld.CurrentFile != null)
				{
					voxelWorldFile = VoxelWorld.CurrentFile;
				}
				else
				{
					voxelWorldFile = new VoxelWorldFile();
					VoxelWorld.SetCurrentFile(voxelWorldFile);
				}
				voxelWorldFile.VoxelData = VoxelWorld.SerializeCurrentVoxels();
				voxelWorldFile.Header = target;
				VoxelSaveManager.SaveWorldData(voxelWorldFile.Header.FilePath, voxelWorldFile);
				Close();
				menu.Open();
			});
			((Component)menu.cancelButton).gameObject.SetActive(true);
			menu.cancelButton.SetClickAction(delegate
			{
				Close();
				menu.Open();
			});
			fileNameInputField.SetTextWithoutNotify(Path.GetFileNameWithoutExtension(header.FilePath));
			((UnityEventBase)fileNameInputField.onEndEdit).RemoveAllListeners();
			((UnityEventBase)fileNameInputField.onValueChanged).RemoveAllListeners();
			((UnityEvent<string>)(object)fileNameInputField.onValueChanged).AddListener((UnityAction<string>)delegate(string v)
			{
				bool flag2 = CheckName(v, Path.GetFileNameWithoutExtension(header.FilePath));
			});
			((UnityEvent<string>)(object)fileNameInputField.onEndEdit).AddListener((UnityAction<string>)delegate(string v)
			{
				bool flag = CheckName(v, Path.GetFileNameWithoutExtension(header.FilePath));
				if (flag)
				{
					header.FilePath = VoxelSaveManager.NameToFilePath(v);
				}
				((Selectable)menu.confirmButton).interactable = flag;
			});
			worldDisplayNameInputField.text = header.DisplayName;
			((UnityEventBase)worldDisplayNameInputField.onEndEdit).RemoveAllListeners();
			((UnityEvent<string>)(object)worldDisplayNameInputField.onEndEdit).AddListener((UnityAction<string>)delegate(string v)
			{
				header.DisplayName = v;
			});
			descriptionInputField.text = header.Description;
			((UnityEventBase)descriptionInputField.onEndEdit).RemoveAllListeners();
			((UnityEvent<string>)(object)descriptionInputField.onEndEdit).AddListener((UnityAction<string>)delegate(string v)
			{
				header.Description = v;
			});
		}

		private void SelectFile(VoxelWorldFileHeader header)
		{
			if (header == null)
			{
				return;
			}
			string newDisplayName = header.DisplayName;
			string newDescription = header.Description;
			string newFileName = Path.GetFileNameWithoutExtension(header.FilePath);
			Func<bool> checkDirty = () => File.Exists(header.FilePath) && (newDisplayName != header.DisplayName || newDescription != header.Description || newFileName != Path.GetFileNameWithoutExtension(header.FilePath));
			target = header;
			fileNameInputField.SetTextWithoutNotify(Path.GetFileNameWithoutExtension(header.FilePath));
			((UnityEventBase)fileNameInputField.onEndEdit).RemoveAllListeners();
			((UnityEventBase)fileNameInputField.onValueChanged).RemoveAllListeners();
			((UnityEvent<string>)(object)fileNameInputField.onValueChanged).AddListener((UnityAction<string>)delegate(string v)
			{
				CheckName(v, Path.GetFileNameWithoutExtension(header.FilePath));
			});
			((UnityEvent<string>)(object)fileNameInputField.onEndEdit).AddListener((UnityAction<string>)delegate(string v)
			{
				bool flag = CheckName(v, Path.GetFileNameWithoutExtension(header.FilePath));
				if (flag)
				{
					newFileName = v;
				}
				((Selectable)menu.saveButton).interactable = flag;
				fileNameInputField.SetTextWithoutNotify(v);
				((Component)menu.saveButton).gameObject.SetActive(checkDirty());
			});
			worldDisplayNameInputField.text = header.DisplayName;
			((UnityEventBase)worldDisplayNameInputField.onEndEdit).RemoveAllListeners();
			((UnityEvent<string>)(object)worldDisplayNameInputField.onEndEdit).AddListener((UnityAction<string>)delegate(string v)
			{
				newDisplayName = v;
				((Component)menu.saveButton).gameObject.SetActive(checkDirty());
			});
			descriptionInputField.text = header.Description;
			((UnityEventBase)descriptionInputField.onEndEdit).RemoveAllListeners();
			((UnityEvent<string>)(object)descriptionInputField.onEndEdit).AddListener((UnityAction<string>)delegate(string v)
			{
				newDescription = v;
				((Component)menu.saveButton).gameObject.SetActive(checkDirty());
			});
			menu.saveButton.SetClickAction(delegate
			{
				if (newDescription.Length > 2048)
				{
					newDescription = newDescription.Substring(0, 2048);
				}
				header.Description = newDescription;
				if (newDisplayName.Length > 48)
				{
					newDisplayName = newDisplayName.Substring(0, 32);
				}
				header.DisplayName = newDisplayName;
				VoxelSaveManager.UpdateHeaderFile(header);
				if (newFileName != Path.GetFileNameWithoutExtension(header.FilePath))
				{
					VoxelSaveManager.RenameFile(header, VoxelSaveManager.NameToFilePath(newFileName));
				}
				((Component)menu.saveButton).gameObject.SetActive(checkDirty());
			});
			voxelCountText.text = header.TotalVoxelCount.ToString("N0") + " VOXELS";
		}

		public void Open()
		{
			((Component)this).gameObject.SetActive(true);
			Pauser.Pause(((Component)this).gameObject);
		}

		public void Close()
		{
			((Component)this).gameObject.SetActive(false);
			target = null;
		}

		private void Awake()
		{
			InitializeReferences();
		}

		public void SetMenu(VoxelSavesMenu menu)
		{
			this.menu = menu;
		}

		private void InitializeReferences()
		{
			if (!initialized)
			{
				if ((Object)(object)menu == (Object)null)
				{
					menu = ((Component)this).GetComponentInParent<VoxelSavesMenu>();
				}
				fileNameInputField = LocateComponent<InputField>("InputField_FileName");
				descriptionInputField = LocateComponent<InputField>("InputField_WorldDescription");
				descriptionInputField.characterLimit = 2048;
				voxelCountText = LocateComponent<Text>("Text_VoxelCount");
				worldDisplayNameInputField = LocateComponent<InputField>("InputField_WorldName");
				worldDisplayNameInputField.characterLimit = 32;
				fileNameWarningPanel = ((Component)LocateComponent<RectTransform>("Panel_FileNameWarning")).gameObject;
				fileNameWarningText = LocateComponent<Text>("Text_FileNameWarning");
				fileNameWarningPanel.SetActive(false);
				if ((Object)(object)fileNameInputField != (Object)null)
				{
					fileNameInputField.characterLimit = 32;
					fileNameInputField.SetTextWithoutNotify("");
				}
				initialized = true;
			}
		}

		private T LocateComponent<T>(string name) where T : Component
		{
			return (from x in ((Component)((Component)this).transform).GetComponentsInChildren<T>()
				where ((Object)(object)x).name == name
				select x).FirstOrDefault();
		}

		private bool CheckName(string name, string oldName)
		{
			string errorMessage;
			bool flag = TryValidateSaveName(name, out errorMessage);
			if (name == oldName)
			{
				flag = true;
			}
			fileNameWarningPanel.SetActive(!flag);
			if (!flag)
			{
				fileNameWarningText.text = errorMessage;
			}
			return flag;
		}

		private bool TryValidateSaveName(string saveName, out string errorMessage)
		{
			errorMessage = "";
			if (string.IsNullOrEmpty(saveName) || string.IsNullOrWhiteSpace(saveName))
			{
				errorMessage = "Save name cannot be empty or whitespace";
				return false;
			}
			if (saveName == ":3")
			{
				errorMessage = "no :3";
				return false;
			}
			if (saveName.IndexOfAny(Path.GetInvalidFileNameChars()) != -1)
			{
				errorMessage = "Save name contains invalid characters";
				return false;
			}
			if (saveName.Length > 32)
			{
				errorMessage = $"Save name is too long. Max {32} chars. Literally, how did you even manage to do this?";
				return false;
			}
			if (VoxelSaveManager.Exists(saveName))
			{
				errorMessage = "A save with that name already exists.";
				return false;
			}
			return true;
		}
	}
	public class VoxelHandOverlay : MonoBehaviour
	{
		[Configgable("Voxel/Overlay", "Show Input Prompt", 0, null)]
		private static ConfigToggle displayInputPrompt = new ConfigToggle(true);

		private Text blockNameText;

		private Text inputPromptText;

		private GameObject container;

		private bool initialized;

		private void Awake()
		{
			Initialize();
		}

		private void Initialize()
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (!initialized)
			{
				container = ((Component)((Component)this).transform.LocateComponent<RectTransform>("Container")).gameObject;
				container.SetActive(false);
				inputPromptText = ((Component)this).transform.LocateComponent<Text>("Text_InputPrompt");
				blockNameText = ((Component)this).transform.LocateComponent<Text>("Text_BlockName");
				ConfigKeybind secretButton = UFGInput.SecretButton;
				((ConfigValueElement<KeyCode>)(object)secretButton).OnValueChanged = (Action<KeyCode>)Delegate.Combine(((ConfigValueElement<KeyCode>)(object)secretButton).OnValueChanged, new Action<KeyCode>(UpdateInputPrompt));
				ConfigToggle obj = displayInputPrompt;
				((ConfigValueElement<bool>)(object)obj).OnValueChanged = (Action<bool>)Delegate.Combine(((ConfigValueElement<bool>)(object)obj).OnValueChanged, new Action<bool>(SetInputPrompt));
				SetInputPrompt(((ConfigValueElement<bool>)(object)displayInputPrompt).Value);
				UpdateInputPrompt(((ConfigValueElement<KeyCode>)(object)UFGInput.SecretButton).Value);
				initialized = true;
			}
		}

		private void SetInputPrompt(bool value)
		{
			if (!((Object)(object)inputPromptText == (Object)null))
			{
				((Component)inputPromptText).gameObject.SetActive(value);
			}
		}

		public void SetOpen(bool value)
		{
			Initialize();
			container.SetActive(value);
		}

		public void UpdateBlockText(VoxelData selected)
		{
			Initialize();
			((MonoBehaviour)this).StopAllCoroutines();
			blockNameText.text = selected?.DisplayName ?? "";
			((MonoBehaviour)this).StartCoroutine(FadeOutText());
		}

		private IEnumerator FadeOutText()
		{
			((Graphic)blockNameText).color = Color.white;
			yield return (object)new WaitForSeconds(1f);
			float delay = 2f;
			float timer = delay;
			while (timer > 0f)
			{
				timer -= Time.deltaTime;
				float t = 1f - timer / delay;
				((Graphic)blockNameText).color = Color.Lerp(Color.white, Color.clear, t);
				yield return (object)new WaitForEndOfFrame();
			}
			((Graphic)blockNameText).color = Color.clear;
		}

		private void UpdateInputPrompt(KeyCode value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)inputPromptText == (Object)null))
			{
				inputPromptText.text = $"[<color=orange>{((ConfigValueElement<KeyCode>)(object)UFGInput.SecretButton).Value}</color>] Block Palette";
			}
		}

		private void OnDestroy()
		{
			ConfigKeybind secretButton = UFGInput.SecretButton;
			((ConfigValueElement<KeyCode>)(object)secretButton).OnValueChanged = (Action<KeyCode>)Delegate.Remove(((ConfigValueElement<KeyCode>)(object)secretButton).OnValueChanged, new Action<KeyCode>(UpdateInputPrompt));
			ConfigToggle obj = displayInputPrompt;
			((ConfigValueElement<bool>)(object)obj).OnValueChanged = (Action<bool>)Delegate.Remove(((ConfigValueElement<bool>)(object)obj).OnValueChanged, new Action<bool>(SetInputPrompt));
		}
	}
	public class VoxelMenuButton : MonoBehaviour
	{
		[SerializeField]
		private Image[] blockTexImages;

		[SerializeField]
		private Button button;

		[SerializeField]
		private GameObject selector;

		private VoxelData data;

		public void SetVoxelData(VoxelData data)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			this.data = data;
			Sprite sprite = VoxelMaterialManager.GetSprite((Texture2D)data.Material.mainTexture);
			for (int i = 0; i < blockTexImages.Length; i++)
			{
				blockTexImages[i].sprite = sprite;
			}
		}

		public void SetSelected(bool selected)
		{
			selector.SetActive(selected);
		}

		public void SetButtonAction(Action<VoxelMenuButton, VoxelData> onClick)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				onClick?.Invoke(this, data);
			});
		}
	}
	public class VoxelSavesMenu : MonoBehaviour
	{
		public class FileSelecitonButton : IDisposable
		{
			private Color defaultFrameColor;

			private static readonly Color orange = new Color(1f, 0.8f, 0f);

			public bool IsSelected;

			public Button Button { get; }

			public VoxelWorldFileHeader Header { get; }

			public Image Frame { get; }

			public Text WorldNameText { get; }

			public Text FileNameText { get; }

			public Text VoxelCountText { get; }

			public GameObject GameObject { get; }

			private bool IsLoaded()
			{
				return VoxelWorld.CurrentFile != null && VoxelWorld.CurrentFile.Header.FilePath == Header.FilePath;
			}

			public FileSelecitonButton(VoxelWorldFileHeader header, GameObject gameObject)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				Header = header;
				GameObject = gameObject;
				Button = gameObject.GetComponent<Button>();
				Frame = (from x in gameObject.GetComponentsInChildren<Image>(true)
					where ((Object)x).name == "Border"
					select x).FirstOrDefault();
				defaultFrameColor = ((Graphic)Frame).color;
				WorldNameText = (from x in gameObject.GetComponentsInChildren<Text>(true)
					where ((Object)x).name == "Text_WorldName"
					select x).FirstOrDefault();
				FileNameText = (from x in gameObject.GetComponentsInChildren<Text>(true)
					where ((Object)x).name == "Text_FileName"
					select x).FirstOrDefault();
				VoxelCountText = (from x in gameObject.GetComponentsInChildren<Text>(true)
					where ((Object)x).name == "Text_VoxelCount"
					select x).FirstOrDefault();
			}

			public void RefreshValues()
			{
				//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_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_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				WorldNameText.text = Header.DisplayName;
				FileNameText.text = Path.GetFileNameWithoutExtension(Header.FilePath);
				VoxelCountText.text = Header.TotalVoxelCount.ToString("N0") + " VOXELS";
				Color green = defaultFrameColor;
				if (IsLoaded())
				{
					green = Color.green;
				}
				if (IsSelected)
				{
					green = orange;
				}
				((Graphic)Frame).color = green;
			}

			public void Dispose()
			{
				Object.Destroy((Object)(object)GameObject);
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__23_1;

			public static Action <>9__24_1;

			public static Func<VoxelWorldFileHeader, string> <>9__29_0;

			public static Action <>9__32_3;

			public static Action <>9__38_0;

			internal void <InitializeReferences>b__23_1()
			{
				Application.OpenURL("https://discord.gg/kCHnwMDPt4");
			}

			internal void <SelectEntry>b__24_1()
			{
				VoxelWorld.SaveCurrentWorld();
			}

			internal string <PopulateList>b__29_0(VoxelWorldFileHeader x)
			{
				return x.DisplayName;
			}

			internal void <Load>b__32_3()
			{
			}

			internal void <NonSelectedButtons>b__38_0()
			{
				Application.OpenURL("file://" + Paths.VoxelSavesFolder);
			}
		}

		private GameObject listViewPanel;

		public Button newButton;

		public Button saveButton;

		public Button loadButton;

		public Button editButton;

		public Button openInFolderButton;

		public Button deleteButton;

		public Button discordButton;

		public Button confirmButton;

		public Button cancelButton;

		public Button returnButton;

		private Button[] SidePanelButtons;

		private RectTransform listViewContentBody;

		private VoxelFileInspector inspector;

		private VoxelSelectionMenu selectionMenu;

		[UFGAsset("VoxelSaveMenuFileButton")]
		private static GameObject buttonFilePrefab;

		private List<FileSelecitonButton> instancedButtons = new List<FileSelecitonButton>();

		private bool initialized;

		public VoxelWorldFileHeader SelectedFile { get; private set; }

		private void Awake()
		{
			InitializeReferences();
		}

		private void InitializeReferences()
		{
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			if (initialized)
			{
				return;
			}
			selectionMenu = ((Component)this).GetComponentInParent<VoxelSelectionMenu>();
			inspector = ((Component)this).GetComponentInChildren<VoxelFileInspector>(true);
			inspector.SetMenu(this);
			((Component)inspector).gameObject.SetActive(false);
			listViewPanel = ((Component)LocateComponent<RectTransform>("ListView")).gameObject;
			listViewContentBody = LocateComponent<RectTransform>("ListView_ContentBody");
			returnButton = LocateComponent<Button>("Button_Return");
			returnButton.SetClickAction(delegate
			{
				inspector.Close();
				((Component)this).gameObject.SetActive(false);
			});
			cancelButton = LocateComponent<Button>("Button_Cancel");
			confirmButton = LocateComponent<Button>("Button_Confirm");
			newButton = LocateComponent<Button>("Button_New");
			saveButton = LocateComponent<Button>("Button_Save");
			loadButton = LocateComponent<Button>("Button_Load");
			editButton = LocateComponent<Button>("Button_Edit");
			openInFolderButton = LocateComponent<Button>("Button_OpenInFolder");
			deleteButton = LocateComponent<Button>("Button_Delete");
			discordButton = LocateComponent<Button>("Button_Discord");
			((UnityEventBase)discordButton.onClick).RemoveAllListeners();
			ButtonClickedEvent onClick = discordButton.onClick;
			object obj = <>c.<>9__23_1;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					Application.OpenURL("https://discord.gg/kCHnwMDPt4");
				};
				<>c.<>9__23_1 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			SidePanelButtons = (Button[])(object)new Button[10] { returnButton, cancelButton, confirmButton, newButton, saveButton, loadButton, editButton, openInFolderButton, deleteButton, discordButton };
			initialized = true;
		}

		private void SelectEntry(VoxelWorldFileHeader header, FileSelecitonButton button)
		{
			foreach (FileSelecitonButton instancedButton in instancedButtons)
			{
				instancedButton.IsSelected = button == instancedButton;
				instancedButton.RefreshValues();
			}
			DisableAllSideButtons();
			NonSelectedButtons();
			((Component)editButton).gameObject.SetActive(true);
			editButton.SetClickAction(delegate
			{
				listViewPanel.SetActive(false);
				inspector.OpenWithFile(header);
			});
			bool active = VoxelWorld.CurrentFile != null && VoxelWorld.CurrentFile.Header.FilePath == header.FilePath;
			((Component)saveButton).gameObject.SetActive(active);
			saveButton.SetClickAction(delegate
			{
				VoxelWorld.SaveCurrentWorld();
			});
			((Component)loadButton).gameObject.SetActive(true);
			loadButton.SetClickAction(delegate
			{
				Load(header);
			});
			((Component)openInFolderButton).gameObject.SetActive(true);
			openInFolderButton.SetClickAction(delegate
			{
				Application.OpenURL("file://" + Path.GetDirectoryName(header.FilePath));
			});
			((Component)deleteButton).gameObject.SetActive(true);
			deleteButton.SetClickAction(delegate
			{
				Delete(header);
			});
		}

		public void DeselectAll()
		{
			foreach (FileSelecitonButton instancedButton in instancedButtons)
			{
				instancedButton.IsSelected = false;
				instancedButton.RefreshValues();
			}
			DisableAllSideButtons();
			NonSelectedButtons();
		}

		public void RebuildList()
		{
			ClearList();
			PopulateList(VoxelSaveManager.LoadHeaders());
		}

		private void ClearList()
		{
			foreach (FileSelecitonButton instancedButton in instancedButtons)
			{
				instancedButton.Dispose();
			}
			instancedButtons.Clear();
		}

		private void UpdateList()
		{
			foreach (FileSelecitonButton instancedButton in instancedButtons)
			{
				instancedButton.RefreshValues();
			}
		}

		private void PopulateList(IEnumerable<VoxelWorldFileHeader> headers)
		{
			foreach (VoxelWorldFileHeader header in headers.OrderBy((VoxelWorldFileHeader x) => x.DisplayName))
			{
				GameObject gameObject = Object.Instantiate<GameObject>(buttonFilePrefab, (Transform)(object)listViewContentBody);
				FileSelecitonButton fileButton = new FileSelecitonButton(header, gameObject);
				fileButton.RefreshValues();
				fileButton.Button.SetClickAction(delegate
				{
					SelectEntry(header, fileButton);
				});
				instancedButtons.Add(fileButton);
			}
		}

		public void DisableAllSideButtons()
		{
			for (int i = 0; i < SidePanelButtons.Length; i++)
			{
				((Component)SidePanelButtons[i]).gameObject.SetActive(false);
			}
		}

		private T LocateComponent<T>(string name) where T : Component
		{
			return (from x in ((Component)((Component)this).transform).GetComponentsInChildren<T>()
				where ((Object)(object)x).name == name
				select x).FirstOrDefault();
		}

		public void Load(VoxelWorldFileHeader header)
		{
			//IL_004a: 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_007b: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			bool flag = VoxelWorld.IsWorldDirty();
			Action loadConfirmation = delegate
			{
				ModalDialogue.ShowSimple("Load " + header.DisplayName + "?", "Loading " + header.DisplayName + " will clear all blocks in the current environment. Are you sure?", (Action<bool>)delegate(bool confirm)
				{
					if (confirm)
					{
						VoxelWorldFile data = VoxelSaveManager.LoadAtFilePath(header.FilePath);
						VoxelWorld.LoadWorld(data);
						UpdateList();
					}
				}, "Yes", "No");
			};
			if (flag)
			{
				ModalDialogue.ShowComplex("Unsaved Changes", "Your voxel world has unsaved changes. What would you like to do?", (DialogueBoxOption[])(object)new DialogueBoxOption[3]
				{
					new DialogueBoxOption
					{
						Color = Color.green,
						Name = "Save",
						OnClick = delegate
						{
							VoxelWorld.SaveCurrentWorld();
							loadConfirmation();
						}
					},
					new DialogueBoxOption
					{
						Color = Color.red,
						Name = "Discard Changes",
						OnClick = loadConfirmation
					},
					new DialogueBoxOption
					{
						Color = Color.white,
						Name = "Cancel",
						OnClick = delegate
						{
						}
					}
				});
			}
			else
			{
				loadConfirmation();
			}
		}

		public void Delete(VoxelWorldFileHeader header, Action<bool> callBack = null)
		{
			ModalDialogue.ShowSimple("Delete " + header.DisplayName + "?", "Are you sure you want to delete " + header.DisplayName + "?", (Action<bool>)delegate(bool confirm)
			{
				if (confirm)
				{
					VoxelSaveManager.DeleteFile(header);
					DeselectAll();
					RebuildList();
				}
				callBack?.Invoke(confirm);
			}, "Yes", "No");
		}

		public void Open()
		{
			((Component)this).gameObject.SetActive(true);
			Pauser.Pause(((Component)this).gameObject);
			InitializeReferences();
			DeselectAll();
			listViewPanel.SetActive(true);
			if (((Component)inspector).gameObject.activeInHierarchy)
			{
				inspector.Close();
			}
			RebuildList();
		}

		public void NewFile()
		{
			InitializeReferences();
			listViewPanel.SetActive(false);
			inspector.Open();
			inspector.CreationMode();
		}

		public void Close()
		{
			DeselectAll();
			listViewPanel.SetActive(true);
			if (((Component)inspector).gameObject.activeInHierarchy)
			{
				inspector.Close();
			}
			((Component)this).gameObject.SetActive(false);
			selectionMenu.OpenMenu();
		}

		public void EscapeAction()
		{
			if (((Component)inspector).gameObject.activeInHierarchy)
			{
				inspector.Close();
				Open();
			}
			else
			{
				Close();
			}
		}

		private void NonSelectedButtons()
		{
			DisableAllSideButtons();
			((Component)openInFolderButton).gameObject.SetActive(true);
			openInFolderButton.SetClickAction(delegate
			{
				Application.OpenURL("file://" + Paths.VoxelSavesFolder);
			});
			((Component)returnButton).gameObject.SetActive(true);
			returnButton.SetClickAction(delegate
			{
				listViewPanel.SetActive(true);
				((Component)this).gameObject.SetActive(false);
				selectionMenu.OpenMenu();
			});
			((Component)newButton).gameObject.SetActive(true);
			newButton.SetClickAction(delegate
			{
				NewFile();
			});
			((Component)discordButton).gameObject.SetActive(true);
		}

		public void OpenWithFile(VoxelWorldFileHeader header)
		{
			SelectedFile = header;
			inspector.OpenWithFile(SelectedFile);
		}
	}
	public class VoxelSelectionMenu : MonoBehaviour
	{
		[UFGAsset("VoxelSelectionMenu")]
		private static GameObject prefab;

		[UFGAsset("BlockSelectionIcon")]
		private static GameObject selectionButtonPrefab;

		private GameObject container;

		private RectTransform contentBody;

		private Button refreshButton;

		private Text refreshButtonText;

		private Text pageNumberLabel;

		private Button nextPageButton;

		private Button previousPageButton;

		private Button deselectButton;

		private Button openFolderButton;

		private Button saveButton;

		private Button clearButton;

		private Button worldsButton;

		private InputField searchField;

		private int currentPage = 0;

		private List<List<GameObject>> pages = new List<List<GameObject>>();

		private Dictionary<VoxelData, VoxelMenuButton> instancedButtons = new Dictionary<VoxelData, VoxelMenuButton>();

		private VoxelHand voxelHand;

		private VoxelSavesMenu savesMenu;

		private GameState voxelSelectGameState;

		private bool initialized;

		private bool rebuilding;

		[Configgable("Voxel/Palette", null, 0, null)]
		private static int maxIconsPerFrame = 10;

		[Configgable("Voxel/Palette", null, 0, null)]
		private static int maxIconsPerPage = 128;

		public static GameObject VoxelSelectionMenuPrefab => prefab;

		public bool IsOpen => container.activeInHierarchy || ((Object)(object)savesMenu != (Object)null && ((Component)savesMenu).gameObject.activeInHierarchy);

		public void SetVoxelHand(VoxelHand voxelHand)
		{
			this.voxelHand = voxelHand;
		}

		private void Awake()
		{
			InitializeReferences();
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(ButtonUpdate());
		}

		private void InitializeReferences()
		{
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			if (!initialized)
			{
				container = ((Component)((Component)this).transform.LocateComponent<RectTransform>("Panel_SelectionMenu")).gameObject;
				contentBody = ((Component)this).transform.LocateComponent<RectTransform>("ListView_VoxelContent");
				pageNumberLabel = ((Component)this).transform.LocateComponent<Text>("Text_PageNumber");
				savesMenu = ((Component)this).GetComponentInChildren<VoxelSavesMenu>(true);
				saveButton = container.transform.LocateComponent<Button>("Button_Save");
				refreshButton = ((Component)this).transform.LocateComponent<Button>("Button_RefreshVoxels");
				openFolderButton = ((Component)this).transform.LocateComponent<Button>("Button_OpenVoxelsFolder");
				clearButton = ((Component)this).transform.LocateComponent<Button>("Button_ClearAll");
				worldsButton = ((Component)this).transform.LocateComponent<Button>("Button_Worlds");
				previousPageButton = ((Component)this).transform.LocateComponent<Button>("Button_PreviousPage");
				nextPageButton = ((Component)this).transform.LocateComponent<Button>("Button_NextPage");
				deselectButton = ((Component)this).transform.LocateComponent<Button>("Button_Deselect");
				refreshButtonText = ((Component)refreshButton).transform.LocateComponent<Text>("Text");
				searchField = ((Component)this).transform.LocateComponent<InputField>("InputField_VoxelSearchBar");
				((Selectable)searchField).interactable = false;
				((Component)searchField.placeholder).GetComponent<Text>().text = "Search not implemented yet! Sorry!";
				worldsButton.SetClickAction(Button_Worlds);
				saveButton.SetClickAction(delegate
				{
					VoxelWorld.SaveCurrentWorld();
					((Component)saveButton).gameObject.SetActive(false);
				});
				clearButton.SetClickAction(Button_ClearAllVoxels);
				openFolderButton.SetClickAction(Button_OpenCustomVoxelFolder);
				refreshButton.SetClickAction(Button_RefreshVoxels);
				worldsButton.SetClickAction(Button_Worlds);
				deselectButton.SetClickAction(Button_DeselectHeldVoxel);
				previousPageButton.SetClickAction(delegate
				{
					NextPage(-1);
				});
				nextPageButton.SetClickAction(delegate
				{
					NextPage();
				});
				voxelSelectGameState = new GameState("VoxelSelect");
				voxelSelectGameState.cursorLock = (LockMode)2;
				voxelSelectGameState.cameraInputLock = (LockMode)2;
				voxelSelectGameState.playerInputLock = (LockMode)2;
				voxelSelectGameState.priority = 100;
				container.SetActive(false);
				initialized = true;
			}
		}

		private IEnumerator ButtonUpdate()
		{
			string buttonText = refreshButtonText.text;
			bool importingLastCheck = false;
			while (true)
			{
				bool importing = VoxelDatabase.IsImportingTextures;
				if (importing)
				{
					refreshButtonText.text = $"{Mathf.CeilToInt(VoxelDatabase.TextureImportProgress * 100f)}%";
					((Selectable)refreshButton).interactable = false;
				}
				else if (importingLastCheck)
				{
					refreshButtonText.text = buttonText;
					((Selectable)refreshButton).interactable = true;
				}
				importingLastCheck = importing;
				yield return (object)new WaitForSecondsRealtime(0.5f);
			}
		}

		private IEnumerator RebuildAsync()
		{
			rebuilding = true;
			int counter = 0;
			List<GameObject> currentPage = null;
			foreach (VoxelData voxel in from x in VoxelDatabase.GetPlaceableVoxels()
				orderby x.DisplayName
				select x)
			{
				if (!instancedButtons.ContainsKey(voxel))
				{
					List<GameObject> page = currentPage;
					if (counter % maxIconsPerPage == 0)
					{
						page = new List<GameObject>();
						pages.Add(page);
						currentPage = page;
					}
					VoxelMenuButton b = BuildButton(voxel);
					page.Add(((Component)b).gameObject);
					((Component)b).gameObject.SetActive(this.currentPage == pages.Count - 1);
					instancedButtons.Add(voxel, b);
					if (counter % maxIconsPerFrame == 0)
					{
						yield return (object)new WaitForEndOfFrame();
					}
					counter++;
				}
			}
			rebuilding = false;
		}

		private VoxelMenuButton BuildButton(VoxelData voxelData)
		{
			GameObject val = Object.Instantiate<GameObject>(selectionButtonPrefab, (Transform)(object)contentBody);
			VoxelMenuButton component = val.GetComponent<VoxelMenuButton>();
			component.SetVoxelData(voxelData);
			component.SetSelected(selected: false);
			if ((Object)(object)voxelHand != (Object)null && voxelHand.CurrentVoxelData == voxelData)
			{
				component.SetSelected(selected: true);
			}
			component.SetButtonAction(ButtonPressed);
			return component;
		}

		private void RebuildMenu()
		{
			if (rebuilding)
			{
				((MonoBehaviour)this).StopCoroutine(RebuildAsync());
			}
			((MonoBehaviour)this).StartCoroutine(RebuildAsync());
		}

		private void ButtonPressed(VoxelMenuButton button, VoxelData data)
		{
			foreach (VoxelMenuButton value in instancedButtons.Values)
			{
				value?.SetSelected((Object)(object)value == (Object)(object)button);
			}
			voxelHand?.SetHeldVoxel(data);
		}

		private void Button_Worlds()
		{
			container.SetActive(false);
			savesMenu.Open();
		}

		private void Update()
		{
			if (IsOpen)
			{
				if (Input.GetKeyDown((KeyCode)27))
				{
					CloseMenu();
				}
				if (Input.GetKeyDown((KeyCode)286))
				{
					RebuildMenu();
				}
			}
		}

		public void OpenMenu()
		{
			InitializeReferences();
			RebuildMenu();
			container.SetActive(true);
			((Component)saveButton).gameObject.SetActive(VoxelWorld.IsWorldDirty());
			SetPage(currentPage);
			Pauser.Pause(container);
		}

		public void SetPage(int index)
		{
			index = Mathf.Clamp(index, 0, pages.Count - 1);
			currentPage = index;
			for (int i = 0; i < pages.Count; i++)
			{
				for (int j = 0; j < pages[i].Count; j++)
				{
					pages[i][j].SetActive(i == currentPage);
				}
			}
			pageNumberLabel.text = $"{currentPage + 1}/{pages.Count}";
		}

		public void NextPage(int index = 1)
		{
			SetPage(currentPage + index);
		}

		public void CloseMenu()
		{
			InitializeReferences();
			if (((Component)savesMenu).gameObject.activeInHierarchy)
			{
				savesMenu.EscapeAction();
			}
			else
			{
				container.SetActive(false);
			}
		}

		private void ClearMenu()
		{
			foreach (KeyValuePair<VoxelData, VoxelMenuButton> instancedButton in instancedButtons)
			{
				if (!((Object)(object)instancedButton.Value == (Object)null))
				{
					VoxelMenuButton value = instancedButton.Value;
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			pages.Clear();
			instancedButtons.Clear();
		}

		public void Button_DeselectHeldVoxel()
		{
			voxelHand?.SetHeldVoxel(null);
		}

		public void Button_RefreshVoxels()
		{
			if (!VoxelDatabase.IsImportingTextures)
			{
				VoxelDatabase.ImportCustomBlocksAsync();
			}
		}

		public void Button_OpenCustomVoxelFolder()
		{
			VoxelDatabase.OpenCustomVoxelFolder();
		}

		public void NewWorld()
		{
			OpenMenu();
			Button_Worlds();
			savesMenu.NewFile();
		}

		public void Button_ClearAllVoxels()
		{
			ModalDialogue.ShowSimple("Are you sure?", "You are about to clear everything, this is irreversable! Are you sure you want to do this?", (Action<bool>)delegate(bool confirm)
			{
				if (confirm)
				{
					VoxelWorld.ClearBlocks();
				}
			}, "Yes", "No");
		}
	}
	public class VoxelSelectionMenuReferences : MonoBehaviour
	{
		[SerializeField]
		private GameObject container;

		[SerializeField]
		private RectTransform contentBody;

		[SerializeField]
		private GameObject selectionButtonPrefab;

		[SerializeField]
		private Button importButton;

		[SerializeField]
		private Button worldsButton;

		[SerializeField]
		private Button saveButton;

		[SerializeField]
		private Button openVoxelFolderButton;

		[SerializeField]
		private Button clearAllVoxelsButton;

		[SerializeField]
		private Button refreshVoxels;

		[SerializeField]
		private Text importButtonText;

		[SerializeField]
		private Text pageNumberLabel;

		public GameObject Container => container;

		public RectTransform ContentBody => contentBody;

		public GameObject SelectionButtonPrefab => selectionButtonPrefab;

		public Button ImportButton => importButton;

		public Button WorldsButton => worldsButton;

		public Button SaveButton => saveButton;

		public Button OpenVoxelFolderButton => openVoxelFolderButton;

		public Button ClearAllVoxelsButton => clearAllVoxelsButton;

		public Button RefreshVoxels => refreshVoxels;

		public Text ImportButtonText => importButtonText;

		public Text PageNumberLabel => pageNumberLabel;
	}
	public class Voxel : MonoBehaviour
	{
		public VoxelData VoxelData { get; private set; }

		public IVoxelState VoxelState { get; private set; }

		private void Start()
		{
			VoxelState?.OnVoxelPlaced(this);
		}

		public void SetVoxelData(VoxelData voxelData)
		{
			VoxelData = voxelData;
			((Component)this).GetComponent<Renderer>().sharedMaterial = voxelData.Material;
		}

		public void SetVoxelState(IVoxelState voxelState)
		{
			VoxelState = voxelState;
			VoxelState?.OnVoxel(this);
		}

		public void Break()
		{
			BreakVFX();
			VoxelState?.OnVoxelBreak(this);
			VoxelWorld.DeleteVoxel(GetLocation());
		}

		public void Interact()
		{
			VoxelState?.OnVoxelInteract(this);
		}

		public void VoxelUpdate()
		{
			VoxelState?.OnVoxelUpdate(this);
		}

		public void PrintState()
		{
			VoxelState?.PrintState(this);
		}

		private void BreakVFX()
		{
			//IL_0027: 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_0059: 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)
			if ((Object)(object)VoxelData.Sound != (Object)null)
			{
				AudioSource.PlayClipAtPoint(VoxelData.Sound, ((Component)this).transform.position);
			}
			if (!((Object)(object)VoxelData.Material == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(VoxelDatabase.VoxelParticle, ((Component)this).transform.position, Quaternion.identity);
				val.transform.localScale = Vector3.one * VoxelWorld.WorldScale;
				val.layer = 24;
				val.AddComponent<DeleteAfterTime>().TimeLeft = 3f;
				ParticleSystemRenderer component = val.GetComponent<ParticleSystemRenderer>();
				((Renderer)component).material = VoxelData.Material;
			}
		}

		public static Voxel Create(VoxelLocation position, VoxelData data, IVoxelState state = null)
		{
			//IL_0010: 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_0053: 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)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)val).name = $"VH_{position.Coordinate}";
			val.tag = "Floor";
			val.layer = 24;
			val.transform.position = position.Position;
			val.transform.localScale = Vector3.one * VoxelWorld.WorldScale;
			Voxel voxel = val.AddComponent<Voxel>();
			if (state == null)
			{
				Type stateType = VoxelStateDatabase.GetStateType(data.ID);
				if (stateType != null && typeof(IVoxelState).IsAssignableFrom(stateType))
				{
					state = (IVoxelState)Activator.CreateInstance(stateType);
				}
			}
			voxel.SetVoxelData(data);
			voxel.SetVoxelState(state);
			return voxel;
		}

		public static Voxel Build(VoxelLocation position, VoxelData data, IVoxelState state = null)
		{
			Voxel voxel = Create(position, data, state);
			VoxelWorld.ReplaceVoxel(position, voxel);
			return voxel;
		}

		public VoxelLocation GetLocation()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return new VoxelLocation(((Component)this).transform.position);
		}

		private void OnDestroy()
		{
			VoxelState?.OnVoxelDestroyed(this);
		}
	}
	[UFGWeapon("VoxelHand", "Architect's Hand", 0, true, WeaponIconColor.Green, true, true)]
	[WeaponAbility("Manifest", "Press <color=orange>Fire 1</color> to manifest voxels.", 0, RichTextColors.aqua)]
	[WeaponAbility("Obliterate", "Press <color=orange>Fire 2</color> to obliterate voxels.", 1, RichTextColors.lime)]
	[WeaponAbility("Summon World", "Press <color=orange>Secret</color> to summon world.", 3, RichTextColors.yellow)]
	public class VoxelHand : UltraFunGunBase
	{
		[Configgable("Weapons/Architects Hand", null, 0, null)]
		private static float interactRange = 9.5f;

		[Configgable("Weapons/Architects Hand", null, 0, null)]
		private static float placeBlockFaceOffset = 0.5f;

		[Configgable("Weapons/Architects Hand", null, 0, null)]
		private static float inputHoldDelay = 0.3f;

		[Configgable("Weapons/Architects Hand", null, 0, null)]
		private static float autoInteractInterval = 0.175f;

		private VoxelData lastVoxelData;

		private VoxelData currentVoxelData;

		private float secondaryHoldTime;

		private float primaryHoldTime;

		private float timeUntilAutoBreak;

		private float timeUntilAutoSecondary;

		private GameObject selectionVisual;

		private VoxelHandReferences parts;

		private VoxelHandOverlay overlay;

		private int anim_Equip = Animator.StringToHash("Equip");

		private int anim_Place = Animator.StringToHash("Place");

		private int anim_Punch = Animator.StringToHash("Punch");

		private VoxelSelectionMenu palette;

		private bool primaryPressed => MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && !om.paused;

		private bool secondaryPressed => MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed && !om.paused;

		private bool middleClickPerformed => Input.GetKeyDown((KeyCode)325);

		public VoxelData CurrentVoxelData => currentVoxelData;

		public override void OnAwakeFinished()
		{
			parts = ((Component)this).GetComponent<VoxelHandReferences>();
			overlay = Object.FindObjectOfType<VoxelHandOverlay>();
			overlay.SetOpen(((Component)this).gameObject.activeInHierarchy);
		}

		private void Start()
		{
			SetHeldVoxel(null);
			VoxelWorld.QueryInstance();
		}

		private void Update()
		{
			CheckForInteraction();
			HandleInput();
		}

		private void CheckForInteraction()
		{
			//IL_0007: 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_001f: 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_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_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)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(mainCam.position, mainCam.forward, ref val, interactRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
			{
				GetSelectionVisual().SetActive(false);
				return;
			}
			Vector3 samplePosition = ((RaycastHit)(ref val)).point + -((RaycastHit)(ref val)).normal * placeBlockFaceOffset;
			Vector3 position = VoxelLocation.SnapToWorldGrid(samplePosition);
			if (currentVoxelData != null)
			{
				GetSelectionVisual().SetActive(true);
			}
			else
			{
				Voxel voxel = default(Voxel);
				GetSelectionVisual().SetActive(((Component)((RaycastHit)(ref val)).collider).TryGetComponent<Voxel>(ref voxel));
			}
			GetSelectionVisual().transform.position = position;
		}

		private void HandleInput()
		{
			HandleBlockBreak();
			HandleBlockPlace();
			HandleSwitchVoxel();
			HandlePickBlock();
			HandleDebugSerialization();
		}

		private void HandleBlockBreak()
		{
			if (primaryPressed)
			{
				if (primaryHoldTime == 0f)
				{
					BreakBlockAction();
				}
				if (primaryHoldTime > inputHoldDelay)
				{
					if (timeUntilAutoBreak <= 0f)
					{
						BreakBlockAction();
						timeUntilAutoBreak = autoInteractInterval;
					}
					else
					{
						timeUntilAutoBreak -= Time.deltaTime;
					}
				}
				primaryHoldTime += Time.deltaTime;
			}
			else
			{
				primaryHoldTime = 0f;
			}
		}

		private void HandleBlockPlace()
		{
			if (secondaryPressed)
			{
				if (secondaryHoldTime == 0f)
				{
					SecondaryAction();
				}
				if (secondaryHoldTime > inputHoldDelay)
				{
					if (timeUntilAutoSecondary <= 0f)
					{
						SecondaryAction();
						timeUntilAutoSecondary = autoInteractInterval;
					}
					else
					{
						timeUntilAutoSecondary -= Time.deltaTime;
					}
				}
				secondaryHoldTime += Time.deltaTime;
			}
			else
			{
				secondaryHoldTime = 0f;
			}
		}

		private void SecondaryAction()
		{
			if (currentVoxelData == null)
			{
				InteractAction();
			}
			else
			{
				PlaceBlockAction();
			}
		}

		private void PlaceNormalLayer()
		{
			//IL_001b: 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_0052: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_0095: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (currentVoxelData == null || !Physics.Raycast(mainCam.position, mainCam.forward, ref val, interactRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
			{
				return;
			}
			Vector3 samplePosition = ((RaycastHit)(ref val)).point + ((RaycastHit)(ref val)).normal * placeBlockFaceOffset;
			Vector3 val2 = VoxelLocation.SnapToWorldGrid(samplePosition);
			VoxelLocation location = new VoxelLocation(val2);
			Vector3 samplePosition2 = ((RaycastHit)(ref val)).point - ((RaycastHit)(ref val)).normal * placeBlockFaceOffset;
			Vector3 position = VoxelLocation.SnapToWorldGrid(samplePosition2);
			VoxelLocation voxelLocation = new VoxelLocation(position);
			Vector3Int normal = location.Coordinate - voxelLocation.Coordinate;
			if (!VoxelWorld.CheckVoxelCollision(val2))
			{
				PlaceNormalLayer(location, currentVoxelData, normal);
				if ((Object)(object)currentVoxelData.Sound != (Object)null)
				{
					AudioSource.PlayClipAtPoint(currentVoxelData.Sound, val2);
				}
				Animator obj = animator;
				if (obj != null)
				{
					obj.Play(anim_Place, 0, 0f);
				}
			}
		}

		private void PlaceNormalLayer(VoxelLocation location, VoxelData data, Vector3Int normal)
		{
			int num = 0;
		}

		private void InteractAction()
		{
			//IL_0025: 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_003d: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			Animator obj = animator;
			if (obj != null)
			{
				obj.Play(anim_Place, 0, 0f);
			}
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(mainCam.position, mainCam.forward, ref val, interactRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)3))))
			{
				return;
			}
			Voxel voxel = default(Voxel);
			if (((RaycastHit)(ref val)).collider.IsColliderEnemy(out var enemy))
			{
				Vector3 eulerAngles = ((Component)enemy).transform.eulerAngles;
				((Component)enemy).transform.rotation = Quaternion.Euler(eulerAngles.x, eulerAngles.y + 180f, eulerAngles.z);
			}
			else if (((Component)((RaycastHit)(ref val)).collider).TryGetComponent<Voxel>(ref voxel))
			{
				if (voxel.VoxelData != null && (Object)(object)voxel.VoxelData.Sound != (Object)null)
				{
					AudioSource.PlayClipAtPoint(voxel.VoxelData.Sound, ((Component)voxel).transform.position);
				}
				voxel.Interact();
			}
		}

		private void HandleDebugSerialization()
		{
		}

		private void BuildStructure()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetLookLocation(out var location))
			{
				MySphere mySphere = new MySphere();
				mySphere.Build(location.Coordinate, Random.Range(0, 9999));
			}
		}

		private bool TryGetLookLocation(out VoxelLocation location, bool invertNormal = false)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0066: Unknown result type (might be due to invalid IL or missing references)
			location = default(VoxelLocation);
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(mainCam.position, mainCam.forward, ref val, interactRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)3))))
			{
				return false;
			}
			location.Position = ((RaycastHit)(ref val)).point + ((RaycastHit)(ref val)).normal * placeBlockFaceOffset * (float)(invertNormal ? 1 : (-1));
			return true;
		}

		private void HandlePickBlock()
		{
			//IL_0016: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			Voxel voxel = default(Voxel);
			if (middleClickPerformed && Physics.Raycast(mainCam.position, mainCam.forward, ref val, interactRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))) && ((Component)((RaycastHit)(ref val)).collider).TryGetComponent<Voxel>(ref voxel) && voxel.VoxelData != null)
			{
				SetHeldVoxel(voxel.VoxelData);
			}
		}

		private void HandleSwitchVoxel()
		{
			if (Input.GetKeyDown((KeyCode)120))
			{
				ToggleHand();
			}
			if (!UFGInput.SecretButton.WasPeformed())
			{
				return;
			}
			if ((Object)(object)palette == (Object)null)
			{
				palette = Object.FindObjectOfType<VoxelSelectionMenu>();
				if ((Object)(object)palette == (Object)null)
				{
					palette = Object.Instantiate<GameObject>(VoxelSelectionMenu.VoxelSelectionMenuPrefab, (Transform)(object)InstanceUIComponents.Rect).GetComponent<VoxelSelectionMenu>();
				}
				palette.SetVoxelHand(this);
			}
			if (!((Object)(object)palette == (Object)null) && !palette.IsOpen)
			{
				palette.OpenMenu();
			}
		}

		private void ToggleHand()
		{
			if (currentVoxelData != null)
			{
				SetHeldVoxel(null);
			}
			else if (lastVoxelData != null)
			{
				SetHeldVoxel(lastVoxelData);
			}
		}

		public void SetHeldVoxel(VoxelData voxel)
		{
			lastVoxelData = currentVoxelData;
			currentVoxelData = voxel;
			bool flag = currentVoxelData == null;
			parts.HandObject.SetActive(flag);
			parts.DisplayedCube.SetActive(!flag);
			if (!flag)
			{
				parts.DisplayCubeRenderer.sharedMaterial = voxel.Material;
			}
			if (lastVoxelData != voxel)
			{
				Animator obj = animator;
				if (obj != null)
				{
					obj.Play(anim_Equip, 0, 0f);
				}
			}
			if ((Object)(object)overlay != (Object)null)
			{
				overlay.UpdateBlockText(voxel);
			}
		}

		private void PlaceBlockAction()
		{
			//IL_001b: 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_0052: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (currentVoxelData == null || !Physics.Raycast(mainCam.position, mainCam.forward, ref val, interactRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1))))
			{
				return;
			}
			Vector3 samplePosition = ((RaycastHit)(ref val)).point + ((RaycastHit)(ref val)).normal * placeBlockFaceOffset;
			Vector3 val2 = VoxelLocation.SnapToWorldGrid(samplePosition);
			VoxelLocation position = new VoxelLocation(val2);
			if (!VoxelWorld.CheckVoxelCollision(val2))
			{
				Voxel.Build(position, currentVoxelData);
				if ((Object)(object)currentVoxelData.Sound != (Object)null)
				{
					AudioSource.PlayClipAtPoint(currentVoxelData.Sound, val2);
				}
				Animator obj = animator;
				if (obj != null)
				{
					obj.Play(anim_Place, 0, 0f);
				}
			}
		}

		private GameObject GetSelectionVisual()
		{
			//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)
			if ((Object)(object)selectionVisual != (Object)null)
			{
				return selectionVisual;
			}
			float num = VoxelWorld.WorldScale + 0.01f;
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)val).name = "VH_SELECTION";
			val.layer = 24;
			val.transform.localScale = Vector3.one * num;
			Voxel voxel = val.AddComponent<Voxel>();
			voxel.SetVoxelData(VoxelDatabase.Selection);
			val.GetComponent<Collider>().enabled = false;
			val.SetActive(false);
			selectionVisual = val;
			return selectionVisual;
		}

		private void BreakBlockAction()
		{
			//IL_0025: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0095: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			Animator obj = animator;
			if (obj != null)
			{
				obj.Play(anim_Punch, 0, 0f);
			}
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(mainCam.position, mainCam.forward, ref val, interactRange, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)3))))
			{
				IParriable parriable = default(IParriable);
				Voxel voxel = default(Voxel);
				if (((RaycastHit)(ref val)).collider.IsColliderEnemy(out var enemy))
				{
					enemy.DeliverDamage(((Component)((RaycastHit)(ref val)).collider).gameObject, -((RaycastHit)(ref val)).normal * interactRange, ((RaycastHit)(ref val)).point, 0.2f, false, 1.2f, ((Component)this).gameObject, false, false);
				}
				else if ((!((Component)((RaycastHit)(ref val)).collider).TryGetComponent<IParriable>(ref parriable) || !parriable.Parry(((RaycastHit)(ref val)).point, mainCam.forward * interactRange)) && ((Component)((RaycastHit)(ref val)).collider).TryGetComponent<Voxel>(ref voxel))
				{
					voxel.Break();
				}
			}
		}

		public override string GetDebuggingText()
		{
			string text = "";
			if (currentVoxelData != null)
			{
				text = text + "Current: " + currentVoxelData.DisplayName;
			}
			return text;
		}

		private void OnEnable()
		{
			Animator obj = animator;
			if (obj != null)
			{
				obj.Play(anim_Equip, 0, 0f);
			}
			if ((Object)(object)overlay != (Object)null)
			{
				overlay.SetOpen(value: true);
			}
		}

		private void OnDisable()
		{
			GetSelectionVisual().SetActive(false);
			if ((Object)(object)overlay != (Object)null)
			{
				overlay.SetOpen(value: false);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)selectionVisual != (Object)null)
			{
				Object.Destroy((Object)(object)selectionVisual);
			}
			if ((Object)(object)overlay != (Object)null)
			{
				overlay.SetOpen(value: false);
			}
		}
	}
	public class VoxelHandReferences : MonoBehaviour
	{
		[SerializeField]
		private GameObject handObject;

		[SerializeField]
		private GameObject displayedCube;

		[SerializeField]
		private Renderer displayCubeRenderer;

		public GameObject HandObject => handObject;

		public GameObject DisplayedCube => displayedCube;

		public Renderer DisplayCubeRenderer => displayCubeRenderer;
	}
	public static class VoxelMaterialManager
	{
		private static Dictionary<Texture2D, Material> materials = new Dictionary<Texture2D, Material>();

		private static Dictionary<Texture2D, Sprite> sprites = new Dictionary<Texture2D, Sprite>();

		[UFGAsset("voxelHandMaterial")]
		private static Material voxelMaterial;

		[UFGAsset("cobbledstone")]
		private static Texture2D defaultTexture;

		private static Shader voxelShader => voxelMaterial.shader;

		public static Material GetMaterial(Texture2D texture)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (materials.ContainsKey(texture))
			{
				return materials[texture];
			}
			Material val = new Material(voxelShader);
			val.mainTexture = (Texture)(object)texture;
			materials.Add(texture, val);
			return val;
		}

		public static Material GetDefaultMaterial()
		{
			return GetMaterial(defaultTexture);
		}

		public static Sprite GetSprite(Texture2D texture)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!sprites.ContainsKey(texture))
			{
				Sprite value = Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0.5f, 0.5f));
				sprites.Add(texture, value);
			}
			return sprites[texture];
		}
	}
	public static class VoxelStateDatabase
	{
		private static Dictionary<string, Type> stateRegistry;

		public static Type GetStateType(string id)
		{
			if (stateRegistry == null)
			{
				InitializeStates();
			}
			if (!stateRegistry.ContainsKey(id))
			{
				return null;
			}
			return stateRegistry[id];
		}

		private static void InitializeStates()
		{
			stateRegistry = new Dictionary<string, Type>();
			stateRegistry.Add("glass", typeof(VoxelGlass));
			stateRegistry.Add("silica_glass", typeof(VoxelGlass));
			stateRegistry.Add("silica_glass_dirty", typeof(VoxelGlass));
			stateRegistry.Add("tnt", typeof(ExplosiveVoxel));
		}
	}
	public class ExplosiveVoxel : IVoxelState
	{
		[Configgable("Voxel/TNT", null, 0, null)]
		private static float activateForce = 3f;

		[Configgable("Voxel/TNT", null, 0, null)]
		private static float explosionSizeMultiplier = 1f;

		private Rigidbody rb;

		private Voxel voxel;

		private Explodable explodable;

		private bool primed;

		public void OnVoxel(Voxel voxel)
		{
			this.voxel = voxel;
		}

		public void OnVoxelBreak(Voxel voxel)
		{
		}

		public void OnVoxelDestroyed(Voxel voxel)
		{
		}

		public void OnVoxelInteract(Voxel voxel)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0047: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			if (!primed)
			{
				Prime(4f);
				Vector2 insideUnitCircle = Random.insideUnitCircle;
				Vector3 val = new Vector3(insideUnitCircle.x, 4f, insideUnitCircle.y);
				Vector3 val2 = ((Vector3)(ref val)).normalized * activateForce;
				Rigidbody obj = rb;
				obj.velocity += val2;
			}
		}

		private void Prime(float time)
		{
			primed = true;
			VoxelWorld.SetVoxel(voxel.GetLocation(), null);
			rb = ((Component)voxel).gameObject.AddComponent<Rigidbody>();
			((MonoBehaviour)voxel).StartCoroutine(Timer(delegate
			{
				explodable.Explode(null);
			}, time));
		}

		private IEnumerator Timer(Action onTimerFinish, float timer)
		{
			while (timer > 0f)
			{
				timer -= Time.deltaTime;
				yield return (object)new WaitForEndOfFrame();
			}
			onTimerFinish?.Invoke();
		}

		public void OnVoxelPlaced(Voxel voxel)
		{
			explodable = ((Component)voxel).gameObject.AddComponent<Explodable>();
			Explodable obj = explodable;
			obj.OnExplode = (Action<Explosion>)Delegate.Combine(obj.OnExplode, (Action<Explosion>)delegate(Explosion e)
			{
				//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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: 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_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_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)e != (Object)null)
				{
					if (!e.harmless)
					{
						Prime(0.1f);
						Vector3 val = ((Component)voxel).transform.position - ((Component)e).transform.position;
						Vector3 val2 = ((Vector3)(ref val)).normalized * 25f;
						Rigidbody obj2 = rb;
						obj2.velocity += val2;
					}
				}
				else
				{
					GameObject val3 = Object.Instantiate<GameObject>(Prefabs.UK_Explosion.Asset, ((Component)voxel).transform.position, Quaternion.identity);
					Explosion componentInChildren = val3.GetComponentInChildren<Explosion>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						componentInChildren.maxSize *= VoxelWorld.WorldScale / 2f * explosionSizeMultiplier;
					}
					Object.Destroy((Object)(object)((Component)voxel).gameObject);
				}
			});
		}

		public void OnVoxelUpdate(Voxel voxel)
		{
		}

		public void PrintState(Voxel voxel)
		{
		}

		public void SetStateData(object stateData)
		{
		}

		public BinaryWriter WriteStateData(BinaryWriter bw)
		{
			return bw;
		}

		public void ReadStateData(BinaryReader br)
		{
		}

		public string GetID()
		{
			return "explosive";
		}
	}
	public class RunawayBlock : IVoxelState
	{
		public const string blockID = "Waystone.png";

		private int travels = 0;

		public void OnVoxel(Voxel voxel)
		{
		}

		public void OnVoxelBreak(Voxel voxel)
		{
		}

		public void OnVoxelDestroyed(Voxel voxel)
		{
		}

		public void OnVoxelInteract(Voxel voxel)
		{
			VoxelLocation location = voxel.GetLocation();
			PrintState(voxel);
		}

		public void OnVoxelPlaced(Voxel voxel)
		{
		}

		public void OnVoxelUpdate(Voxel voxel)
		{
		}

		public void PrintState(Voxel voxel)
		{
			UltraFunGuns.Log.LogWarning($"Current travels: {travels}");
		}

		public void ReadStateData(BinaryReader br)
		{
			travels = br.ReadInt32();
		}

		public BinaryWriter WriteStateData(BinaryWriter bw)
		{
			bw.Write(travels);
			return bw;
		}

		public string GetID()
		{
			return "runawayblock";
		}

		public void SetStateData(object stateData)
		{
			RunawayBlock runawayBlock = (RunawayBlock)stateData;
			travels = runawayBlock.travels;
		}
	}
	[Serializable]
	public class VoxelGlass : IVoxelState
	{
		public void OnVoxel(Voxel voxel)
		{
		}

		public void OnVoxelDestroyed(Voxel voxel)
		{
		}

		public void OnVoxelInteract(Voxel voxel)
		{
			PrintState(voxel);
		}

		public void OnVoxelPlaced(Voxel voxel)
		{
			Explodable explodable = ((Component)voxel).gameObject.AddComponent<Explodable>();
			explodable.OnExplode = (Action<Explosion>)Delegate.Combine(explodable.OnExplode, (Action<Explosion>)delegate(Explosion e)
			{
				if (!((Object)(object)e == (Object)null) || !e.harmless)
				{
					voxel.Break();
				}
			});
			SimpleBreakable simpleBreakable = ((Component)voxel).gameObject.AddComponent<SimpleBreakable>();
			simpleBreakable.OnBreak = (Action)Delegate.Combine(simpleBreakable.OnBreak, new Action(voxel.Break));
		}

		public void OnVoxelUpdate(Voxel voxel)
		{
		}

		public void PrintState(Voxel voxel)
		{
		}

		public void SetStateData(object stateData)
		{
		}

		public void OnVoxelBreak(Voxel voxel)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)voxel).transform.position;
			UltraFunGuns.Log.LogWarning("Glass broken!");
		}

		public BinaryWriter WriteStateData(BinaryWriter bw)
		{
			return bw;
		}

		public void ReadStateData(BinaryReader br)
		{
		}

		public string GetID()
		{
			return "glass";
		}
	}
	public interface IVoxelStructure
	{
		void Build(Vector3Int origin, int seed);
	}
	public class MySphere : IVoxelStructure
	{
		private const string fillID = "cobblestone";

		private VoxelData fillVoxel;

		public void Build(Vector3Int origin, int seed)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			fillVoxel = VoxelDatabase.GetVoxelData("cobblestone");
			int rad = new Random(seed).Next(2, 10);
			BuildSphere(origin, rad);
		}

		private void BuildSphere(Vector3Int origin, int rad)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			Vector3Int val = origin - new Vector3Int(rad, rad, rad);
			Vector3Int val2 = origin + new Vector3Int(rad, rad, rad);
			Vector3Int val3 = default(Vector3Int);
			for (int i = ((Vector3Int)(ref val)).x; i <= ((Vector3Int)(ref val2)).x; i++)
			{
				for (int j = ((Vector3Int)(ref val)).y; j <= ((Vector3Int)(ref val2)).y; j++)
				{
					for (int k = ((Vector3Int)(ref val)).z; k <= ((Vector3Int)(ref val2)).z; k++)
					{
						((Vector3Int)(ref val3))..ctor(i, j, k);
						if (Vector3Int.Distance(val3, origin) <= (float)rad)
						{
							Voxel.Build(VoxelLocation.CoordinateToLocation(new Vector3Int(i, j, k)), fillVoxel);
						}
					}
				}
			}
		}
	}
	public class MyVoxelHouse : IVoxelStructure
	{
		private Vector3Int origin;

		private int seed;

		private const string floorID = "cobblestone";

		private const string wallID = "wooden_planks";

		private const string pillarID = "log";

		private const string glassID = "glass";

		private const string floorBorderID = "smooth_stone";

		private int height;

		private int width;

		private int length;

		private VoxelData floorVoxel;

		private VoxelData wallVoxel;

		private VoxelData glassVoxel;

		private VoxelData pillarVoxel;

		private VoxelData floorBorderVoxel;

		private const int maxHeight = 9;

		private const int kneeHeight = 1;

		private const int heightSize = 4;

		private const int widthSize = 4;

		private const int lengthSize = 4;

		public void Build(Vector3Int origin, int seed)
		{
			//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)
			this.origin = origin;
			this.seed = seed;
			floorVoxel = VoxelDatabase.GetVoxelData("cobblestone");
			wallVoxel = VoxelDatabase.GetVoxelData("wooden_planks");
			pillarVoxel = VoxelDatabase.GetVoxelData("log");
			glassVoxel = VoxelDatabase.GetVoxelData("glass");
			floorBorderVoxel = VoxelDatabase.GetVoxelData("smooth_stone");
			Random random = new Random(seed);
			height = random.Next(9);
			width = random.Next(9);
			length = random.Next(9);
			BuildBuilding(length, width, height);
		}

		private void BuildBuilding(int length, int width, int height)
		{
			int num = height * 4 + 1;
			int num2 = width * 4 + 1;
			int num3 = length * 4 + 1;
			for (int i = 0; i < num; i++)
			{
				if (i % 4 == 0)
				{
					BuildFloorLayer(i, num3, num2);
					continue;
				}
				VoxelData wallMaterial = (((i - 1) % 4 == 0) ? wallVoxel : glassVoxel);
				BuildWalls(i, num3, num2, wallMaterial, pillarVoxel);
			}
		}

		private void BuildFloorLayer(int y, int length, int width)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			VoxelLocation position = default(VoxelLocation);
			for (int i = 0; i < length; i++)
			{
				for (int j = 0; j < width; j++)
				{
					bool flag = i == 0 || i == length - 1 || j == 0 || j == width - 1;
					position.Coordinate = origin + new Vector3Int(i, y, j);
					VoxelData data = (flag ? floorBorderVoxel : floorVoxel);
					Voxel.Build(position, data);
				}
			}
		}

		private void BuildWalls(int y, int length, int width, VoxelData wallMaterial, VoxelData pillarMaterial)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			VoxelLocation position = default(VoxelLocation);
			for (int i = 0; i < length; i++)
			{
				for (int j = 0; j < width; j++)
				{
					bool flag = j % 4 == 0 && i % 4 == 0;
					bool flag2 = i == 0 || i == length - 1 || j == 0 || j == width - 1;
					if (flag || flag2)
					{
						VoxelData data = (flag ? pillarMaterial : wallMaterial);
						position.Coordinate = origin + new Vector3Int(i, y, j);
						Voxel.Build(position, data);
					}
				}
			}
		}

		private void BuildLayer(int y, int length, int width, Action<int, int> onSpot)
		{
			for (int i = 0; i < length; i++)
			{
				for (int j = 0; j < width; j++)
				{
					onSpot?.Invoke(i, j);
				}
			}
		}
	}
	public class VoxelWorld : MonoBehaviour
	{
		private static VoxelWorld _instance;

		[Configgable("Voxel/World", null, 0, null)]
		private static ConfigInputField<float> worldScale = new ConfigInputField<float>(2f, (Func<float, bool>)ValidateWorldScaleInput, (Func<string, ValueTuple<bool, float>>)null);

		[Configgable("Voxel/World", null, 0, null)]
		private static int maxBlocks = 10000;

		[Configgable("Voxel/Advanced", "Clear Texture Cache On Scene Changed", 0, "When the scene changes, textures get flushed to restore the memory used by them. Disabling this will keep the textures loaded at the cost of high memory usage.")]
		private static ConfigToggle flushTextureCacheOnSceneChanged = new ConfigToggle(true);

		private const string FLUSH_TEXTURE_ON_SCENE_CHANGE_DESCRIPTION = "When the scene changes, textures get flushed to restore the memory used by them. Disabling this will keep the textures loaded at the cost of high memory usage.";

		private Dictionary<Vector3Int, Voxel> voxelData = new Dictionary<Vector3Int, Voxel>();

		private bool worldDirty;

		public static float WorldScale => ((ConfigValueElement<float>)(object)worldScale).Value;

		public static int MaxBlocks => maxBlocks;

		public static VoxelWorldFile CurrentFile { get; private set; }

		private static VoxelWorld instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = new GameObject("VoxelWorld").AddComponent<VoxelWorld>();
				}
				return _instance;
			}
		}

		internal static void SetCurrentFile(VoxelWorldFile file)
		{
			CurrentFile = file;
		}

		public static bool IsWorldDirty()
		{
			return instance.worldDirty;
		}

		private static bool ValidateWorldScaleInput(float value)
		{
			return value > 0f;
		}

		private void Start()
		{
			if ((Object)(object)_instance != (Object)null && (Object)(object)_instance != (Object)(object)this)
			{
				UltraFunGuns.Log.LogError("VoxelWorld already exists! Destroying new instance.");
				Object.DestroyImmediate((Object)(object)this);
				return;
			}
			if (CurrentFile != null)
			{
				UltraFunGuns.Log.Log("Populating existing voxel world.");
				PopulateWorld(CurrentFile);
			}
			ConfigInputField<float> obj = worldScale;
			((ConfigValueElement<float>)(object)obj).OnValueChanged = (Action<float>)Delegate.Combine(((ConfigValueElement<float>)(object)obj).OnValueChanged, new Action<float>(OnWorldScaleChanged));
			VoxelDatabase.OnCustomBlocksUpdated += FixPlaceholders;
		}

		public static bool QueryInstance()
		{
			return (Object)(object)instance != (Object)null;
		}

		private void OnWorldScaleChanged(float newValue)
		{
			//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_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)
			foreach (KeyValuePair<Vector3Int, Voxel> voxelDatum in voxelData)
			{
				if (!((Object)(object)voxelDatum.Value == (Object)null))
				{
					Voxel value = voxelDatum.Value;
					((Component)value).transform.position = VoxelLocation.CoordinateToPosition(voxelDatum.Key);
					((Component)value).transform.localScale = Vector3.one * WorldScale;
				}
			}
		}

		private void ClearAllBlocks()
		{
			if (voxelData == null)
			{
				voxelData = new Dictionary<Vector3Int, Voxel>();
				return;
			}
			foreach (KeyValuePair<Vector3Int, Voxel> voxelDatum in voxelData)
			{
				if (!((Object)(object)voxelDatum.Value == (Object)null))
				{
					Voxel value = voxelDatum.Value;
					if ((Object)(object)value != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)value).gameObject);
					}
				}
			}
			voxelData.Clear();
			worldDirty = true;
		}

		public static void ClearBlocks()
		{
			instance.ClearAllBlocks();
		}

		public static bool TryGetVoxelAtLocation(VoxelLocation location, out Voxel voxel)
		{
			//IL_0010: 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)
			voxel = null;
			if (!instance.voxelData.ContainsKey(location.Coordinate))
			{
				return false;
			}
			voxel = instance.voxelData[location.Coordinate];
			return (Object)(object)voxel != (Object)null;
		}

		public static void SetVoxel(VoxelLocation position, Voxel voxel)
		{
			SetVoxelInternal(position, voxel);
			instance.worldDirty = true;
		}

		private static void SetVoxelInternal(VoxelLocation position, Voxel voxel)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)voxel == (Object)null)
			{
				if (instance.voxelData.ContainsKey(position.Coordinate))
				{
					instance.voxelData.Remove(position.Coordinate);
				}
			}
			else
			{
				instance.voxelData[position.Coordinate] = voxel;
			}
		}

		public static void ReplaceVoxel(VoxelLocation position, Voxel voxel)
		{
			DeleteVoxel(position);
			if (!((Object)(object)voxel == (Object)null))
			{
				SetVoxel(position, voxel);
			}
		}

		public static void DeleteVoxel(VoxelLocation location)
		{
			//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_0013: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			Vector3Int coordinate = location.Coordinate;
			if (instance.voxelData.ContainsKey(coordinate))
			{
				Voxel voxel = instance.voxelData[coordinate];
				if ((Object)(object)voxel != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)voxel).gameObject);
				}
				instance.voxelData.Remove(coordinate);
				instance.worldDirty = true;
			}
		}

		public static Voxel GetVoxelAtCoordinate(Vector3Int coordinate)
		{
			//IL_000b: 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)
			if (!instance.voxelData.ContainsKey(coordinate))
			{
				return null;
			}
			return instance.voxelData[coordinate];
		}

		public static Voxel GetVoxelAtPosition(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			Vector3Int coordinate = VoxelLocation.PositionToCoordinate(position);
			return GetVoxelAtCoordinate(coordinate);
		}

		public static Voxel GetVoxelAtLocation(VoxelLocation location)
		{
			//IL_000d: 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)
			if (!instance.voxelData.ContainsKey(location.Coordinate))
			{
				return null;
			}
			return instance.voxelData[location.Coordinate];
		}

		public static bool CheckVoxelCollision(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_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_004e: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			Vector3Int key = VoxelLocation.PositionToCoordinate(position);
			if (instance.voxelData.ContainsKey(key))
			{
				return (Object)(object)instance.voxelData[key] != (Object)null;
			}
			float num = WorldScale * 0.5f;
			Collider[] array = Physics.OverlapBox(position, Vector3.one * num, Quaternion.identity, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)4)), (QueryTriggerInteraction)1);
			return array.Length != 0;
		}

		public static void LoadWorld(VoxelWorldFile data)
		{
			if (data == null)
			{
				UltraFunGuns.Log.LogError("VoxelWorld: parameter data is null! load aborted.");
				return;
			}
			ClearBlocks();
			instance.worldDirty = false;
			CurrentFile = data;
			PopulateWorld(data);
		}

		private void FixPlaceholders()
		{
			foreach (KeyValuePair<Vector3Int, Voxel> voxelDatum in this.voxelData)
			{
				if ((Object)(object)voxelDatum.Value == (Object)null)
				{
					continue;
				}
				Voxel value = voxelDatum.Value;
				if (value.VoxelData != null)
				{
					VoxelData voxelData = value.VoxelData;
					if (VoxelDatabase.VoxelIsPlaceholder(voxelData) && VoxelDatabase.VoxelExists(voxelData.ID))
					{
						VoxelData voxelData2 = VoxelDatabase.GetVoxelData(voxelData.ID);
						value.SetVoxelData(voxelData2);
					}
				}
			}
		}

		private static void PopulateWorld(VoxelWorldFile worldData)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (worldData == null)
			{
				UltraFunGuns.Log.LogError("No world data ahh boy!");
			}
			int num = 0;
			SerializedVoxel[] array = worldData.VoxelData;
			for (int i = 0; i < array.Length; i++)
			{
				SerializedVoxel serializedVoxel = array[i];
				VoxelLocation position = new VoxelLocation(new Vector3Int(serializedVoxel.x, serializedVoxel.y, serializedVoxel.z));
				VoxelData placeholderVoxelData = VoxelDatabase.GetVoxelData(serializedVoxel.id);
				if (placeholderVoxelData == null)
				{
					placeholderVoxelData = VoxelDatabase.GetPlaceholderVoxelData(serializedVoxel.id);
				}
				IVoxelState voxelState = null;
				if (string.IsNullOrEmpty(serializedVoxel.stateTypeID) && serializedVoxel.stateData != null && serializedVoxel.stateData.Length != 0)
				{
					voxelState = (IVoxelState)Activator.CreateInstance(VoxelStateDatabase.GetStateType(serializedVoxel.stateTypeID));
					voxelState.ReadStateData(new BinaryReader(new MemoryStream(serializedVoxel.stateData)));
				}
				Voxel voxel = Voxel.Create(position, placeholderVoxelData, voxelState);
				SetVoxelInternal(position, voxel);
				num++;
			}
		}

		public static void SaveCurrentWorld()
		{
			if (CurrentFile == null)
			{
				if (!instance.worldDirty)
				{
					return;
				}
				ModalDialogue.ShowSimple("No save selected.", "Would you like to save the current world as a new file?", (Action<bool>)delegate(bool r)
				{
					if (r)
					{
						VoxelSelectionMenu voxelSelectionMenu = Object.FindObjectOfType<VoxelSelectionMenu>();
						if ((Object)(object)voxelSelectionMenu == (Object)null)
						{
							UltraFunGuns.Log.LogError("No voxel selection menu?!?!");
						}
						else
						{
							voxelSelectionMenu.NewWorld();
						}
					}
				}, "Yes", "No");
			}
			else
			{
				CurrentFile.VoxelData = SerializeCurrentVoxels();
				VoxelSaveManager.SaveWorldData(CurrentFile.Header.FilePath, CurrentFile);
				instance.worldDirty = false;
			}
		}

		public static VoxelWorldFile BuildNewWorldFile(string displayName)
		{
			VoxelWorldFile voxelWorldFile = new VoxelWorldFile();
			voxelWorldFile.VoxelData = SerializeCurrentVoxels();
			voxelWorldFile.Header = new VoxelWorldFileHeader();
			voxelWorldFile.Header.DisplayName = displayName;
			voxelWorldFile.Header.WorldScale = WorldScale;
			voxelWorldFile.Header.Description = "My Voxel World!";
			voxelWorldFile.Header.SceneName = SceneHelper.CurrentScene;
			voxelWorldFile.Header.TotalVoxelCount = voxelWorldFile.VoxelData.Length;
			voxelWorldFile.Header.ModVersion = "1.3.6";
			voxelWorldFile.Header.GameVersion = Application.version;
			return voxelWorldFile;
		}

		public static SerializedVoxel[] SerializeCurrentVoxels()
		{
			//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)
			CleanWorldData();
			SerializedVoxel[] array = new SerializedVoxel[instance.voxelData.Count];
			int num = 0;
			foreach (KeyValuePair<Vector3Int, Voxel> voxelDatum in instance.voxelData)
			{
				Voxel value = voxelDatum.Value;
				Vector3Int key = voxelDatum.Key;
				SerializedVoxel serializedVoxel = default(SerializedVoxel);
				serializedVoxel.id = value.VoxelData.ID;
				serializedVoxel.x = ((Vector3Int)(ref key)).x;
				serializedVoxel.y = ((Vector3Int)(ref key)).y;
				serializedVoxel.z = ((Vector3Int)(ref key)).z;
				serializedVoxel.stateTypeID = ((value.VoxelState == null) ? "" : value.VoxelState.GetID());
				if (value.VoxelState == null)
				{
					serializedVoxel.stateData = Array.Empty<byte>();
				}
				else
				{
					using MemoryStream memoryStream = new MemoryStream();
					using BinaryWriter bw = new BinaryWriter(memoryStream);
					value.VoxelState.WriteStateData(bw);
					serializedVoxel.stateData = memoryStream.ToArray();
				}
				array[num] = serializedVoxel;
				num++;
			}
			return array;
		}

		private static void CleanWorldData()
		{
			if (instance.voxelData == null)
			{
				instance.voxelData = new Dictionary<Vector3Int, Voxel>();
				return;
			}
			instance.voxelData = instance.voxelData.Where((KeyValuePair<Vector3Int, Voxel> x) => (Object)(object)x.Value != (Object)null).ToDictionary((KeyValuePair<Vector3Int, Voxel> x) => x.Key, (KeyValuePair<Vector3Int, Voxel> x) => x.Value);
		}

		private void OnDestroy()
		{
			_instance = null;
			ConfigInputField<float> obj = worldScale;
			((ConfigValueElement<float>)(object)obj).OnValueChanged = (Action<float>)Delegate.Remove(((ConfigValueElement<float>)(object)obj).OnValueChanged, new Action<float>(OnWorldScaleChanged));
			VoxelDatabase.OnCustomBlocksUpdated -= FixPlaceholders;
			if (((ConfigValueElement<bool>)(object)flushTextureCacheOnSceneChanged).Value && SceneHelper.PendingScene != SceneHelper.CurrentScene)
			{
				VoxelDatabase.Flush();
			}
		}
	}
	public static class ConstInfo
	{
		public const string NAME = "UltraFunGuns";

		public const string GUID = "Hydraxous.ULTRAKILL.UltraFunGuns";

		public const string VERSION = "1.3.6";

		public const string RELEASE_VERSION = "Release-1.3.6";

		public const string GITHUB_VERSION_URL = "https://api.github.com/repos/Hydraxous/UltraFunGuns/tags";

		public const string GITHUB_URL = "https://github.com/Hydraxous/UltraFunGuns";

		public const string KOFI_URL = "https://ko-fi.com/Hydraxous/";

		public const string TWITTER_URL = "https://twitter.com/Hydraxous";

		public const string YOUTUBE_URL = "https://youtube.com/@Hydraxouz";

		public const string DISCORD_URL = "https://discord.gg/kCHnwMDPt4";

		public const string THUNDERSTORE_URL = "https://thunderstore.io/c/ultrakill/p/Hydraxous/";

		public const string GITHUB_BUG_REPORT_URL = "https://github.com/Hydraxous/UltraFunGuns/issues/new/choose";

		public const string PROFILE_PICTURE_URL = "https://avatars.githubusercontent.com/hydraxous";

		public const string CHANGELOG = "-- 1.3.6 --\nUpdated for fraud release";

		public const string FUN_HEADER = "\r\n   __  ______             ______            ______                \r\n  / / / / / /__________ _/ ____/_  ______  / ____/_  ______  _____\r\n / / / / / __/ ___/ __ `/ /_  / / / / __ \\/ / __/ / / / __ \\/ ___/\r\n/ /_/ / / /_/ /  / /_/ / __/ / /_/ / / / / /_/ / /_/ / / / (__  ) \r\n\\____/_/\\__/_/   \\__,_/_/    \\__,_/_/ /_/\\____/\\__,_/_/ /_/____/";
	}
	public static class AssetManifest
	{
		private static bool assetsRegistered;

		public static void RegisterAssets()
		{
			if (!assetsRegistered)
			{
				new HydraLoader.CustomAssetData("debug_weaponIcon", typeof(Sprite));
				new HydraLoader.CustomAssetData("debug_glowIcon", typeof(Sprite));
				UFGWeapon[] weapons = WeaponManager.GetWeapons();
				for (int i = 0; i < weapons.Length; i++)
				{
					new HydraLoader.CustomAssetPrefab(weapons[i].WeaponKey);
					new HydraLoader.CustomAssetData(weapons[i].WeaponKey + "_glowIcon", typeof(Sprite));
					new HydraLoader.CustomAssetData(weapons[i].WeaponKey + "_weaponIcon", typeof(Sprite));
				}
				for (int j = 0; j < 10; j++)
				{
					new HydraLoader.CustomAssetData($"CanLauncher_CanProjectile_Material_{j}", typeof(Material));
				}
				assetsRegistered = true;
			}
		}
	}
	public static class HydraLoader
	{
		public class CustomAssetPrefab
		{
			public Component[] modules;

			public string name;

			public CustomAssetPrefab(string assetName, Component[] componentsToAdd = null)
			{
				name = assetName;
				if (componentsToAdd == null)
				{
					modules = (Component[])(object)new Component[0];
				}
				else
				{
					modules = componentsToAdd;
				}
				assetsToRegister.Add(this);
				UltraFunGuns.Log.Log($"prefab: {assetName}, registered successfully.");
			}
		}

		public class CustomAssetData
		{
			public string name;

			public DataFile dataFile;

			public bool hasData = false;

			public Type dataType;

			public CustomAssetData(string dataName, DataFile dataFile)
			{
				hasData = true;
				name = dataName;
				this.dataFile = dataFile;
				dataToRegister.Add(this);
				UltraFunGuns.Log.Log($"{dataName} of type: {((object)dataFile).GetType().ToString()} registered successfully.");
			}

			public CustomAssetData(string dataName, Type type)
			{
				name = dataName;
				dataType = type;
				dataToRegister.Add(this);
				UltraFunGuns.Log.Log($"{dataName} of type: {type.ToString()} registered successfully.");
			}
		}

		private static List<CustomAssetPrefab> assetsToRegister = new List<CustomAssetPrefab>();

		private static List<CustomAssetData> dataToRegister = new List<CustomAssetData>();

		public static Dictionary<string, Object> dataRegistry = new Dictionary<string, Object>();

		public static Dictionary<string, GameObject> prefabRegistry = new Dictionary<string, GameObject>();

		private static AssetBundleCreateRequest bundleRequest;

		public static bool dataRegistered = false;

		public static bool assetsRegistered = false;

		public static bool BundleLoaded { get; private set; }

		public static AssetBundle AssetBundle { get; private set; }

		public static void LoadAssets(Action<bool> onLoaderComplete)
		{
			UltraFunGuns.Log.Log("Loader: Loading Assetbundle.");
			bundleRequest = AssetBundle.LoadFromMemoryAsync(Resources.UltraFunGuns);
			((AsyncOperation)bundleRequest).completed += delegate
			{
				AssetManifest.RegisterAssets();
				AssetBundle = bundleRequest.assetBundle;
				UltraFunGuns.Log.Log("Loader: Assetbundle Loaded.");
				bool obj = (BundleLoaded = RegisterAll());
				onLoaderComplete?.Invoke(obj);
			};
		}

		public static void UnloadAssets()
		{
			if (BundleLoaded)
			{
				dataToRegister.Clear();
				assetsToRegister.Clear();
				prefabRegistry.Clear();
				dataRegistry.Clear();
				assetsRegistered = false;
				dataRegistered = false;
				if ((Object)(object)AssetBundle != (Object)null)
				{
					AssetBundle.Unload(true);
					AssetBundle = null;
				}
			}
		}

		public static T LoadAssetOfType<T>(string name) where T : Object
		{
			if (!BundleLoaded)
			{
				return default(T);
			}
			return AssetBundle.LoadAsset<T>(name);
		}

		public static bool RegisterAll()
		{
			try
			{
				UltraFunGuns.Log.Log("Loader: Registering all assets.");
				RegisterDataFiles();
				RegisterCustomAssets();
				UltraFunGuns.Log.Log("Loader: Asset registration complete.");
				return true;
			}
			catch (Exception ex)
			{
				UltraFunGuns.Log.LogError("Loader: Asset loading failed!");
				UltraFunGuns.Log.LogError("Loader: " + ex.Message);
				return false;
			}
		}

		public static bool RegisterAll(byte[] assetBundleObject)
		{
			try
			{
				UltraFunGuns.Log.Log("HydraLoader: loading mod assets");
				RegisterDataFiles();
				RegisterCustomAssets();
				UltraFunGuns.Log.Log("HydraLoader: loading complete");
				return true;
			}
			catch (Exception ex)
			{
				UltraFunGuns.Log.LogError("HydraLoader: asset loading failed\n" + ex.Message);
				return false;
			}
		}

		public static void RegisterDataFiles()
		{
			if (dataRegistered)
			{
				return;
			}
			foreach (CustomAssetData item in dataToRegister)
			{
				if (item.hasData)
				{
					dataRegistry.Add(item.name, (Object)(object)item.dataFile);
				}
				else
				{
					dataRegistry.Add(item.name, AssetBundle.LoadAsset(item.name, item.dataType));
				}
			}
			UltraFunGuns.Log.Log($"HydraLoader: {dataRegistry.Count} asset datas registered successfully");
			dataRegistered = true;
		}

		public static void RegisterCustomAssets()
		{
			if (assetsRegistered)
			{
				return;
			}
			foreach (CustomAssetPrefab item in assetsToRegister)
			{
				GameObject val = AssetBundle.LoadAsset<GameObject>(item.name);
				if ((Object)(object)val == (Object)null)
				{
					UltraFunGuns.Log.LogError("HydraLoader: (Load Error): " + item.name + " could not be found in assetbundle");
					val = AssetBundle.LoadAsset<GameObject>("BrokenAsset");
					((Object)val).name = item.name;
				}
				for (int i = 0; i < item.modules.Length; i++)
				{
					val.AddComponent(((object)item.modules[i]).GetType());
				}
				if (!prefabRegistry.ContainsKey(item.name))
				{
					prefabRegistry.Add(item.name, val);
				}
			}
			UltraFunGuns.Log.Log($"HydraLoader: {prefabRegistry.Count} prefabs registered successfully");
			assetsRegistered = true;
		}
	}
	public class DataFile : Object
	{
	}
	public static class Prefabs
	{
		[UFGAsset("ThrownBrick")]
		public static GameObject ThrownBrick { get; private set; }

		[UFGAsset("BulletTrail")]
		public static GameObject BulletTrail { get; private set; }

		[UFGAsset("BulletImpactFX")]
		public static GameObject BulletImpactFX { get; private set; }

		[UFGAsset("CanLauncher_MuzzleFX")]
		public static GameObject CanLauncher_MuzzleFX { get; private set; }

		[UFGAsset("HydraDevPlushie")]
		public static GameObject HydraPlushie { get; private set; }

		[UFGAsset("ForceDeployPickup")]
		public static GameObject ForceDeployPickup { get; private set; }

		public static UKAsset<GameObject> UK_Explosion { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion.prefab");


		public static UKAsset<GameObject> UK_ExplosionMalicious { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Malicious Railcannon.prefab");


		public static UKAsset<GameObject> UK_ExplosionSuper { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Super.prefab");


		public static UKAsset<GameObject> UK_ExplosionBig { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Big.prefab");


		public static UKAsset<GameObject> UK_ExplosionPrime { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Minos Prime.prefab");


		public static UKAsset<GameObject> UK_ExplosionLightning { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Lightning.prefab");


		public static UKAsset<GameObject> UK_ExplosionFerryman { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Ferryman.prefab");


		public static UKAsset<GameObject> UK_ExplosionSand { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Sand.prefab");


		public static UKAsset<GameObject> UK_MindflayerExplosion { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Explosions/Explosion Mindflayer.prefab");


		public static UKAsset<Font> VCR_Font { get; private set; } = new UKAsset<Font>("Assets/Fonts/VCR_OSD_MONO_1.001.ttf");


		public static UKAsset<GameObject> HakitaPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Hakita).prefab");


		public static UKAsset<GameObject> PITRPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (PITR).prefab");


		public static UKAsset<GameObject> HeckPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Heckteck).prefab");


		public static UKAsset<GameObject> MegaNekoPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Meganeko).prefab");


		public static UKAsset<GameObject> JerichoPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Jericho).prefab");


		public static UKAsset<GameObject> KGCPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (KGC).prefab");


		public static UKAsset<GameObject> JoyPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Joy).prefab");


		public static UKAsset<GameObject> DaliaPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Dalia).prefab");


		public static UKAsset<GameObject> SaladPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Salad).prefab");


		public static UKAsset<GameObject> LucasPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Lucas).prefab");


		public static UKAsset<GameObject> DawgPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Dawg).prefab");


		public static UKAsset<GameObject> CameronPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Cameron).prefab");


		public static UKAsset<GameObject> MakoPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Mako).prefab");


		public static UKAsset<GameObject> MandyPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Mandy).prefab");


		public static UKAsset<GameObject> VvizardPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Vvizard).prefab");


		public static UKAsset<GameObject> FrancisPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Francis).prefab");


		public static UKAsset<GameObject> GianniPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Gianni).prefab");


		public static UKAsset<GameObject> BigRockPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (BigRock).prefab");


		public static UKAsset<GameObject> ScottPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Scott).prefab");


		public static UKAsset<GameObject> JacobPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Jacob).prefab");


		public static UKAsset<GameObject> HealthJakePlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (HEALTH - Jake).prefab");


		public static UKAsset<GameObject> HealthJohnPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (HEALTH - John).prefab");


		public static UKAsset<GameObject> HealthBJPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (HEALTH - BJ).prefab");


		public static UKAsset<GameObject> WeytePlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Weyte).prefab");


		public static UKAsset<GameObject> LenvalPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Lenval).prefab");


		public static UKAsset<GameObject> CabalCrowPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (CabalCrow) Variant.prefab");


		public static UKAsset<GameObject> QuetzalPlush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie (Quetzal).prefab");


		public static UKAsset<GameObject> V1Plush { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Items/DevPlushies/DevPlushie.prefab");


		public static UKAsset<GameObject> FishingRod { get; private set; } = new UKAsset<GameObject>("Assets/Prefabs/Fishing/Fishing Rod Weapon.prefab");


		[UFGAsset("ShittyExplosion")]
		public static GameObject ShittyExplosionFX { get; private set; }

		[UFGAsset("ThatExplosionSound")]
		public static AudioClip ShittyExplosionSound { get; private set; }

		public static UKAsset<AudioClip> BonusBreakSound { get; private set; } = new UKAsset<AudioClip>("Assets/Sounds/Environment/bonusbreak.wav");


		[UFGAsset("SmackFX")]
		public static GameObject SmackFX { get; private set; }

		[UFGAsset("SparkBurst")]
		public static GameObject SparkBurst { get; private set; }

		[UFGAsset("BlackSmokeShockwave")]
		public static GameObject BlackSmokeShockwave { get; private set; }
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	public class UFGAsset : Attribute
	{
		public string Key { get; }

		public UFGAsset(string Key = "")
		{
			this.Key = Key;
		}
	}
	public static class UKPrefabs
	{
		private static AssetBundle gameAssets;

		private static GameObject assetLoaderObject;

		private static bool attemptingLoad;

		public static AssetBundle GameAssets
		{
			get
			{
				if ((Object)(object)gameAssets == (Object)null && !attemptingLoad)
				{
					LoadAll();
				}
				return gameAssets;
			}
		}

		public static bool AssetsLoaded
		{
			get
			{
				if ((Object)(object)gameAssets == (Object)null && !attemptingLoad)
				{
					LoadAll();
				}
				return (Object)(object)gameAssets != (Object)null;
			}
		}

		public static void LoadAll()
		{
		}

		private static IEnumerator LoadAssets()
		{
			attemptingLoad = true;
			AssetBundleCreateRequest request = AssetBundle.LoadFromFileAsync(Environment.CurrentDirectory + "\\ULTRAKILL_Data\\StreamingAssets\\common");
			yield return request;
			int attempts = 0;
			while ((Object)(object)request.assetBundle == (Object)null)
			{
				yield return (object)new WaitForSeconds(0.2f);
				if (attempts >= 5)
				{
					UltraFunGuns.Log.LogError("Couldn't load the game bundle.");
					yield break;
				}
				request = AssetBundle.LoadFromFileAsync(Environment.CurrentDirectory + "\\ULTRAKILL_Data\\StreamingAssets\\common");
				yield return request;
				attempts++;
			}
			gameAssets = request.assetBundle;
			attemptingLoad = false;
			if ((Object)(object)assetLoaderObject != (Object)null)
			{
				Object.Destroy((Object)(object)assetLoaderObject);
			}
		}

		public static T AssetFind<T>(string name) where T : Object
		{
			T val = default(T);
			T[] array = Resources.FindObjectsOfTypeAll<T>();
			T[] array2 = array;
			foreach (T val2 in array2)
			{
				if (((Object)val2).name == name)
				{
					val = val2;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				UltraFunGuns.Log.Log($"Failed to find asset: {name} of type {typeof(T)}");
			}
			return val;
		}

		public static bool TryFindAsset(Type type, string name, out Object outasset)
		{
			outasset = null;
			Object[] array = Resources.FindObjectsOfTypeAll(type);
			Object[] array2 = array;
			foreach (Object val in array2)
			{
				if (val.name == name)
				{
					outasset = val;
					return true;
				}
			}
			UltraFunGuns.Log.LogError("Could not find asset : " + name);
			return false;
		}
	}
	public static class UltraLoader
	{
		public static bool AssetsLoaded { get; private set; }

		public static bool LoadAll()
		{
			if (AssetsLoaded)
			{
				return false;
			}
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			UltraFunGuns.Log.Log("AssetLoader: Finding asset tags.");
			Type[] types = executingAssembly.GetTypes();
			foreach (Type type in types)
			{
				CheckType(type);
			}
			AssetsLoaded = true;
			UltraFunGuns.Log.Log("UltraLoader: Asset loading complete.");
			return true;
		}

		private static void CheckType(Type type)
		{
			FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo[] array = fields;
			foreach (FieldInfo field in array)
			{
				ProcessMember(field);
			}
			PropertyInfo[] properties = type.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			PropertyInfo[] array2 = properties;
			foreach (PropertyInfo property in array2)
			{
				ProcessMember(property);
			}
		}

		private static void ProcessMember(FieldInfo field)
		{
			if ((field.FieldType.IsSubclassOf(typeof(Object)) || (field.FieldType.IsArray && field.FieldType.GetElementType().IsSubclassOf(typeof(Object)))) && field.IsStatic)
			{
				UFGAsset customAttribute = field.GetCustomAttribute<UFGAsset>();
				if (customAttribute != null)
				{
					PopulateField(customAttribute, field);
				}
			}
		}

		private static void ProcessMember(PropertyInfo property)
		{
			if (!property.PropertyType.IsSubclassOf(typeof(Object)) && (!property.PropertyType.IsArray || !property.PropertyType.GetElementType().IsSubclassOf(typeof(Object))))
			{
				return;
			}
			MethodInfo[] accessors = property.GetAccessors();
			MethodInfo[] array = accessors;
			foreach (MethodInfo methodInfo in array)
			{
				if (!methodInfo.IsStatic)
				{
					return;
				}
			}
			UFGAsset customAttribute = property.GetCustomAttribute<UFGAsset>();
			if (customAttribute != null)
			{
				PopulateProperty(customAttribute, property);
			}
		}

		private static void PopulateField(UFGAsset assetTag, FieldInfo field)
		{
			string text = ((assetTag.Key != "") ? assetTag.Key : field.Name);
			UltraFunGuns.Log.Log("AssetLoader: Found asset " + (field.FieldType.IsArray ? "array " : "") + "tag " + text);
			if (field.FieldType.IsArray && !text.Contains("{0}"))
			{
				UltraFunGuns.Log.LogError("AssetLoader: Error if an asset tag is placed on an array the key must contain a placeholder bracket with 0 to be iteratable. Skipping.");
				return;
			}
			if (field.FieldType.IsArray)
			{
				Type elementType = field.FieldType.GetElementType();
				List<Object> list = new List<Object>();
				Object obj;
				for (int i = 0; TryLoadAsset(string.Format(text, i), HydraLoader.AssetBundle, elementType, out obj); i++)
				{
					if (obj != (Object)null)
					{
						list.Add(obj);
					}
				}
				if (list.Count > 0)
				{
					field.SetValue(null, list.ToArray());
					UltraFunGuns.Log.Log($"AssetLoader: {text} ({field.FieldType}), successfully cached to {field.DeclaringType}.{field.Name} with {list.Count} indicies.");
				}
				return;
			}
			Type fieldType = field.FieldType;
			if (TryLoadAsset(text, HydraLoader.AssetBundle, fieldType, out var obj2))
			{
				UltraFunGuns.Log.Log("AssetLoader: " + text + " (" + fieldType.Name + "), successfully cached to " + field.DeclaringType.Name + "." + field.Name);
				field.SetValue(null, obj2);
			}
			else
			{
				UltraFunGuns.Log.LogError(field.DeclaringType.Name + ":" + field.Name + ":CacheOnLoad: (" + text + ") Load error, see above.");
			}
		}

		private static void PopulateProperty(UFGAsset assetTag, PropertyInfo property)
		{
			string text = ((assetTag.Key != "") ? assetTag.Key : property.Name);
			if (!property.CanWrite)
			{
				UltraFunGuns.Log.LogError("AssetLoader: " + property.DeclaringType.Name + ": " + property.Name + ": No setter found, unable to assign asset.");
			}
			else if (property.PropertyType.IsArray && !text.Contains("{0}"))
			{
				UltraFunGuns.Log.LogError("AssetLoader: Error if an asset tag is placed on an array the key must contain a placeholder bracket with 0 to be iteratable. Skipping.");
			}
			else if (property.PropertyType.IsArray)
			{
				Type elementType = property.PropertyType.GetElementType();
				List<Object> list = new List<Object>();
				Object obj;
				for (int i = 0; TryLoadAsset(string.Format(text, i), HydraLoader.AssetBundle, elementType, out obj); i++)
				{
					if (obj != (Object)null)
					{
						list.Add(obj);
					}
				}
				if (list.Count > 0)
				{
					property.SetValue(null, list.ToArray());
				}
			}
			else
			{
				Type propertyType = property.PropertyType;
				if (TryLoadAsset(text, HydraLoader.AssetBundle, propertyType, out var obj2))
				{
					property.SetValue(null, obj2);
					return;
				}
				UltraFunGuns.Log.LogError(property.DeclaringType.Name + ":" + property.Name + ":CacheOnLoad: (" + text + ") Load error, see above.");
			}
		}

		private static bool TryLoadAsset(string key, AssetBundle bundle, Type type, out Object obj)
		{
			obj = bundle.LoadAsset(key, type);
			if (obj == (Object)null)
			{
				UltraFunGuns.Log.LogError("AssetLoader: Attempted to load asset " + key + " of type " + type.Name + ", but it was not found in the assetbundle.");
				return false;
			}
			return true;
		}
	}
	public static class Data
	{
		public static DataFile<Loadout> Loadout { get; private set; } = new DataFile<Loadout>(new Loadout(), "loadout.ufg", (Formatting)0);


		public static DataFile<SaveInfo> SaveInfo { get; private set; } = new DataFile<SaveInfo>(new SaveInfo(), "save.ufg", (Formatting)0);


		public static DataFile<Config> Config { get; private set; } = new DataFile<Config>(new Config(), "config.txt", (Formatting)1);


		public static void SaveAll()
		{
			UltraFunGuns.Log.Log("Saving all.");
			Loadout.Save();
			SaveInfo.Save();
			Config.Save();
		}

		[Commands.UFGDebugMethod("Reload Config", "Reloads the config file.")]
		public static void ReloadConfig()
		{
			Config.Load();
		}

		[Commands.UFGDebugMethod("Reset Loadout", "Resets UFG loadout to default.")]
		public static void ResetLoadout()
		{
			Loadout.New();
			if (InGameCheck.InLevel())
			{
				WeaponManager.DeployWeapons();
			}
		}

		[Commands.UFGDebugMethod("Reset Save Data", "Resets UFG save data to default.")]
		public static void ResetSaveData()
		{
			SaveInfo.New();
		}

		[Commands.UFGDebugMethod("Reset Config", "Resets UFG config to default.")]
		public static void ResetConfig()
		{
			Config.New();
		}

		[Commands.UFGDebugMethod("Reset All Data", "Resets UFG Mod data.")]
		public static void FirstTimeSetup()
		{
			UltraFunGuns.Log.Log("Creating new persistent data.");
			Loadout.New();
			Config.New();
			SaveInfo.New();
		}

		public static void CheckSetup()
		{
			InGameCheck.OnLevelChanged = (InGameCheck.OnLevelChangedHandler)Delegate.Combine(InGameCheck.OnLevelChanged, (InGameCheck.OnLevelChangedHandler)delegate
			{
				SaveAll();
			});
			DirectoryInfo directoryInfo = new DirectoryInfo(Paths.DataFolder);
			if (directoryInfo.GetFiles().Length == 0)
			{
				FirstTimeSetup();
				UltraFunGuns.Log.Log("Thanks for installing UltraFunGuns! I hope you enjoy my silly weapons. :) -Hydra");
			}
			Paths.CheckFolders();
			string path = Path.Combine(Paths.VoxelBlockTexturesFolder, "customvoxels_readme.txt");
			if (!Directory.Exists(Path.GetDirectoryName(path)))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(path));
			}
			if (!File.Exists(path))
			{
				File.WriteAllText(path, Resources.customvoxels_readme);
			}
		}

		public static string GetDataPath(params string[] subpath)
		{
			string location = Assembly.GetExecutingAssembly().Location;
			string text = Path.GetDirectoryName(location);
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			if (subpath.Length != 0)
			{
				string path = Path.Combine(subpath);
				text = Path.Combine(text, path);
			}
			return text;
		}
	}
	public static class DataManager
	{
		internal static void SaveData<T>(DataFile<T> data) where T : Validatable
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (!data.Data.Validate())
			{
				UltraFunGuns.Log.LogError("Invalid data!! " + data.FileName);
				return;
			}
			if (!Directory.Exists(Paths.DataFolder))
			{
				Directory.CreateDirectory(Paths.DataFolder);
			}
			string contents = JsonConvert.SerializeObject((object)data.Data, data.Formatting);
			string path = Path.Combine(Paths.DataFolder, data.FileName);
			File.WriteAllText(path, contents);
		}

		internal static T LoadData<T>(DataFile<T> data) where T : Validatable
		{
			T val = null;
			if (data == null)
			{
				UltraFunGuns.Log.LogError("UFG: Data file was incorrectly setup. This is a result of an initialization error.");
				return null;
			}
			string path = Path.Combine(Paths.DataFolder, data.FileName);
			if (File.Exists(path))
			{
				string text;
				using (StreamReader streamReader = new StreamReader(path))
				{
					text = streamReader.ReadToEnd();
				}
				try
				{
					val = JsonConvert.DeserializeObject<T>(text);
					if (val.Validate())
					{
						return val;
					}
				}
				catch (Exception)
				{
					UltraFunGuns.Log.LogError("UFG: Data file " + data.FileName + " could not be validated or deserialized.");
				}
			}
			data.New();
			return data.Data;
		}
	}
	[Serializable]
	public class Config : Validatable
	{
		public bool DebugMode;

		public bool DisableVersionMessages;

		public bool EnableVisualizer;

		public bool EnableAutosave;

		public bool EnableBasketballHoop;

		public bool EnableWeaponsInAllScenes;

		public bool BasketBallMode;

		public bool TricksniperReactionsEnabled;

		public float MouseOverNodeTime;

		public float InventoryInfoCardScale;

		public override bool AllowExternalRead => false;

		public Config()
		{
			DisableVersionMessages = false;
			BasketBallMode = false;
			MouseOverNodeTime = 0.8f;
			DebugMode = false;
			EnableVisualizer = false;
			InventoryInfoCardScale = 1f;
			EnableAutosave = true;
			EnableBasketballHoop = true;
			TricksniperReactionsEnabled = true;
		}

		public override bool Validate()
		{
			return true;
		}
	}
	[Serializable]
	public class DataFile<T> where T : Validatable
	{
		private bool autoSave = true;

		private T fallbackData;

		private T data;

		public string FileName { get; }

		public Formatting Formatting { get; }

		public T Data
		{
			get
			{
				if (data == null)
				{
					Load();
				}
				return data;
			}
			set
			{
				data = value;
				if (autoSave)
				{
					Save();
				}
			}
		}

		public DataFile(T fallback, string filename, Formatting jsonFormatting = 0)
		{
			//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)
			FileName = filename;
			Formatting = jsonFormatting;
			fallbackData = fallback;
			Load();
		}

		public void SetAutoSave(bool enabled)
		{
			autoSave = enabled;
			if (autoSave)
			{
				Save();
			}
		}

		public void Save()
		{
			DataManager.SaveData(this);
		}

		public void Load()
		{
			if (FileName == null)
			{
				New();
				return;
			}
			data = DataManager.LoadData(this);
			if (data == null)
			{
				New();
			}
		}

		public void New()
		{
			if (fallbackData == null)
			{
				data = null;
				return;
			}
			data = fallbackData;
			Save();
		}

		public bool Validate()
		{
			return Data.Validate();
		}
	}
	public abstract class Validatable
	{
		public abstract bool AllowExternalRead { get; }

		public abstract bool Validate();
	}
	[Serializable]
	public class Loadout : Validatable
	{
		public InventorySlotData[] slots;

		public override bool AllowExternalRead => true;

		public Loadout(InventorySlotData[] slots)
		{
			this.slots = slots;
		}

		public Loadout()
		{
			slots = WeaponManager.GetDefaultLoadout();
		}

		public bool CheckUnlocked(string weaponKey)
		{
			InventorySlotData[] array = slots;
			foreach (InventorySlotData inventorySlotData in array)
			{
				InventoryNodeData[] slotNodes = inventorySlotData.slotNodes;
				foreach (InventoryNodeData inventoryNodeData in slotNodes)
				{
					if (!(inventoryNodeData.weaponKey != weaponKey))
					{
						return inventoryNodeData.weaponUnlocked;
					}
				}
			}
			return false;
		}

		public void SetUnlocked(string weaponKey, bool unlocked)
		{
			InventorySlotData[] array = slots;
			foreach (InventorySlotData inventorySlotData in array)
			{
				InventoryNodeData[] slotNodes = inventorySlotData.slotNodes;
				foreach (InventoryNodeData inventoryNodeData in slotNodes)
				{
					if (!(inventoryNodeData.weaponKey != weaponKey))
					{
						inventoryNodeData.weaponUnlocked = unlocked;
						return;
					}
				}
			}
		}

		public override bool Validate()
		{
			if (slots.Length == 0)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < slots.Length; i++)
			{
				if (slots[i] == null)
				{
					return false;
				}
				if (slots[i].slotNodes.Length != 0)
				{
					num += slots[i].slotNodes.Length;
				}
				if (num <= 0)
				{
					return false;
				}
			}
			if (num != WeaponManager.WeaponCount)
			{
				return false;
			}
			return true;
		}
	}
	[Serializable]
	public class SaveInfo : Validatable
	{
		public bool firstTimeUsingInventory;

		public bool firstTimeModLoaded;

		public string modVersion;

		public int basketballHighScore;

		public bool usedVoxelhandBefore;

		public override bool AllowExternalRead => true;

		public SaveInfo()
		{
			modVersion = "Release-1.3.6";
			firstTimeModLoaded = true;
			firstTimeUsingInventory = true;
			basketballHighScore = 0;
			usedVoxelhandBefore = false;
		}

		public override bool Validate()
		{
			if (modVersion == null)
			{
				return false;
			}
			if (modVersion == "")
			{
				return false;
			}
			if (modVersion != "Release-1.3.6")
			{
				return false;
			}
			return true;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class UFGWeapon : Attribute
	{
		private Sprite weaponIcon;

		private Sprite glowIcon;

		private static string[] randomPlaceholders = new string[11]
		{
			"REDACTED", "DATA EXPUNGED", "INFORMATION DELETED", "DATA DELETED", "DATA MISSING", "UNKNOWN ORIGIN", "404-ERROR", "MISSING", "CLASSIFIED", "UNKNOWN",
			"??????"
		};

		public Type Type { get; private set; }

		public string WeaponKey { get; }

		public string DisplayName { get; }

		public bool Equipped { get; }

		public int Slot { get; }

		public bool Finished { get; }

		public WeaponIconColor IconColor { get; }

		public WeaponAbility[] Abilities { get; private set; }

		public bool StartUnlocked { get; }

		public GameObject Prefab { get; private set; }

		public Sprite WeaponIcon
		{
			get
			{
				if ((Object)(object)weaponIcon == (Object)null)
				{
					return weaponIcon;
				}
				return weaponIcon;
			}
		}

		public Sprite GlowIcon
		{
			get
			{
				if ((Object)(object)glowIcon == (Object)null)
				{
					return glowIcon;
				}
				return glowIcon;
			}
		}

		public UFGWeapon(string WeaponKey, string DisplayName, int Slot, bool Equipped, WeaponIconColor IconColor, bool StartUnlocked = true, bool finished = true)
		{
			this.WeaponKey = WeaponKey;
			this.DisplayName = DisplayName;
			this.Equipped = Equipped;
			this.Slot = Slot;
			this.IconColor = IconColor;
			this.StartUnlocked = StartUnlocked;
			Finished = finished;
		}

		public void SetAbilities(WeaponAbility[] abilities)
		{
			Abilities = abilities;
			Array.Sort(Abilities);
		}

		public void SetType(Type type)
		{
			if (Type == null)
			{
				Type = type;
			}
		}

		public void SetPrefab(GameObject prefab)
		{
			if ((Object)(object)Prefab == (Object)null)
			{
				Prefab = prefab;
			}
		}

		public string GetCodexText()
		{
			if (UltraFunGuns.DebugMode)
			{
			}
			if (Abilities.Length == 0 || Abilities == null)
			{
				return "<size=4>[<color=grey>" + randomPlaceholders[Random.Range(0, randomPlaceholders.Length)] + "</color>]</size>";
			}
			string text = "";
			for (int i = 0; i < Abilities.Length; i++)
			{
				text = text + ((i > 0) ? "\n" : "") + Abilities[i].GetLine();
			}
			return text;
		}

		public bool TryGetGameobject(out GameObject prefab)
		{
			prefab = null;
			return HydraLoader.prefabRegistry.TryGetValue(WeaponKey, out prefab);
		}

		public override string ToString()
		{
			string text = "";
			MemberInfo[] members = Type.GetMembers();
			for (int i = 0; i < members.Length; i++)
			{
				text += $"{members[i].Name}: {members[i]}\n";
			}
			return text;
		}
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
	public class WeaponAbility : Attribute, IComparable
	{
		public RichTextColors NameColor;

		public string Name;

		public string Description;

		public int Priority;

		public WeaponAbility(string Name, string Description, int Priority = 0, RichTextColors NameColor = RichTextColors.white)
		{
			this.Name = Name;
			this.Description = Description;
			this.NameColor = NameColor;
			this.Priority = Priority;
		}

		public string GetLine()
		{
			return string.Format("<size=4><color={2}>{0}</color></size>\n<size=3>{1}</size>", Name, Description, NameColor.ToString());
		}

		public int CompareTo(object obj)
		{
			if (obj == null)
			{
				return 1;
			}
			if (obj is WeaponAbility weaponAbility)
			{
				return Priority.CompareTo(weaponAbility.Priority);
			}
			throw new ArgumentException("Compared object is not a weaponability.");
		}
	}
	public enum RichTextColors
	{
		aqua,
		black,
		blue,
		brown,
		darkblue,
		fuchsia,
		green,
		grey,
		lightblue,
		lime,
		magenta,
		maroon,
		navy,
		olive,
		orange,
		purple,
		red,
		silver,
		teal,
		white,
		yellow
	}
	public enum WeaponIconColor
	{
		Blue,
		Green,
		Red,
		Yellow
	}
	public static class WeaponIconColorExtensions
	{
		public static Color ToColor(this WeaponIconColor color)
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MonoSingleton<ColorBlindSettings>.Instance != (Object)null)
			{
				return MonoSingleton<ColorBlindSettings>.Instance.variationColors[(int)color];
			}
			return (Color)(color switch
			{
				WeaponIconColor.Blue => Color.blue, 
				WeaponIconColor.Green => Color.green, 
				WeaponIconColor.Red => Color.red, 
				WeaponIconColor.Yellow => Color.yellow, 
				_ => Color.white, 
			});
		}
	}
	public interface IVoxelFileReader
	{
		VoxelWorldFile ReadWorldData(BinaryReader br);

		VoxelWorldFileHeader ReadHeader(BinaryReader br);

		SerializedVoxel ReadVoxel(BinaryReader br);
	}
	public class VoxelFileReaderV0 : IVoxelFileReader
	{
		public VoxelWorldFileHeader ReadHeader(BinaryReader br)
		{
			VoxelWorldFileHeader voxelWorldFileHeader = new VoxelWorldFileHeader();
			voxelWorldFileHeader.TotalVoxelCount = br.ReadInt32();
			voxelWorldFileHeader.WorldScale = br.ReadSingle();
			voxelWorldFileHeader.SceneName = br.ReadString();
			voxelWorldFileHeader.DisplayName = br.ReadString();
			voxelWorldFileHeader.Description = br.ReadString();
			voxelWorldFileHeader.ModVersion = br.ReadString();
			voxelWorldFileHeader.GameVersion = br.ReadString();
			return voxelWorldFileHeader;
		}

		public VoxelWorldFile ReadWorldData(BinaryReader br)
		{
			VoxelWorldFile voxelWorldFile = new VoxelWorldFile();
			voxelWorldFile.Header = ReadHeader(br);
			voxelWorldFile.VoxelData = new SerializedVoxel[voxelWorldFile.Header.TotalVoxelCount];
			for (int i = 0; i < voxelWorldFile.Header.TotalVoxelCount; i++)
			{
				voxelWorldFile.VoxelData[i] = ReadVoxel(br);
			}
			return voxelWorldFile;
		}

		public SerializedVoxel ReadVoxel(BinaryReader br)
		{
			SerializedVoxel result = default(SerializedVoxel);
			result.x = br.ReadInt32();
			result.y = br.ReadInt32();
			result.z = br.ReadInt32();
			result.id = br.ReadString();
			result.stateTypeID = br.ReadString();
			int count = br.ReadInt32();
			result.stateData = br.ReadBytes(count);
			return result;
		}
	}
	public static class VoxelFileReaderFactory
	{
		private static readonly VoxelFileReaderV0 readerV0 = new VoxelFileReaderV0();

		public static IVoxelFileReader GetReader(int version)
		{
			if (version == 0)
			{
				return readerV0;
			}
			throw new Exception(string.Format("No voxel file reader found for version {0}, Is UltraFunGuns out of date? Current: ({1})", version, "1.3.6"));
		}
	}
	public static class UKEvents
	{
		public static class Enemy
		{
			public struct EnemyHitEvent
			{
				public GameObject target;

				public Vector3 force;

				public Vector3 hitPoint;

				public float multiplier;

				public bool tryForExplode;

				public float critMultiplier;

				public GameObject sourceWeapon;

				public bool IsValid()
				{
					return (Object)(object)target != (Object)null || (Object)(object)sourceWeapon != (Object)null;
				}
			}

			public struct EnemyDeathEvent
			{
				public EnemyIdentifier EnemyIdentifier;

				public EnemyHitEvent LastHit;
			}

			private static List<EnemyIdentifier> deathEventQueue = new List<EnemyIdentifier>();

			private static Dictionary<EnemyIdentifier, List<EnemyHitEvent>> trackedHits = new Dictionary<EnemyIdentifier, List<EnemyHitEvent>>();

			public static event Action<EnemyDeathEvent> OnEnemyDeath;
		}

		public static class Player
		{
		}

		public static class World
		{
		}
	}
	public interface ICoinTarget
	{
		Transform GetCoinTargetPoint(Coin coin);

		bool CanBeCoinTargeted(Coin coin);

		void OnCoinReflect(Coin coin, RevolverBeam beam);

		int GetCoinTargetPriority(Coin coin);
	}
	public interface IExplodable
	{
		void Explode(Explosion explosion);
	}
	public interface IParriable
	{
		bool Parry(Vector3 position, Vector3 direction);
	}
	public interface IRevolverBeamShootable
	{
		void OnRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit);

		bool CanRevolverBeamHit(RevolverBeam beam, ref RaycastHit hit);
	}
	public interface ISharpshooterTarget
	{
		bool CanBeSharpshot(RevolverBeam beam, RaycastHit hit);

		Vector3 GetSharpshooterTargetPoint();

		void OnSharpshooterTargeted(RevolverBeam beam, RaycastHit hit);

		int GetSharpshooterTargetPriority();
	}
	public interface IUFGShootable
	{
		bool CanBeShot(GameObject sourceWeapon);

		void OnShot(GameObject sourceWeapon);
	}
	public interface IUFGWeapon
	{
		UFGWeapon GetWeaponInfo();
	}
	[HarmonyPatch]
	public static class CoinPatch
	{
		private static List<Coin> coins = new List<Coin>();

		private static MethodInfo coinMethod = typeof(CoinPatch).GetMethod("SupplyCoinList", BindingFlags.Static | BindingFlags.NonPublic);

		private static MethodInfo transformGetPositon = typeof(Transform).GetMethod("get_position", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static MethodInfo evalMethod = typeof(CoinPatch).GetMethod("EvalCustomCoinTarget", BindingFlags.Static | BindingFlags.NonPublic);

		private static MethodInfo lineRenderer_setPosition = typeof(LineRenderer).GetMethod("SetPosition", BindingFlags.Instance | BindingFlags.Public);

		public static void OnDelayReflectRevolver(Coin __instance)
		{
			coins.Remove(__instance);
		}

		public static Coin GetLastAdded()
		{
			if (coins == null)
			{
				return null;
			}
			return coins[coins.Count - 1];
		}

		[HarmonyPatch(typeof(Coin), "ReflectRevolver")]
		public static void PreReflectRevolver(Coin __instance)
		{
			coins.Add(__instance);
		}

		[HarmonyPatch(typeof(Coin), "ReflectRevolver")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> InjectICoinTargetDiscovery(IEnumerable<CodeInstruction> instructions)
		{
			UltraFunGuns.Log.LogWarning("Beginning compilation of InjectICoinTargetDiscovery");
			CodeInstruction[] codeInstructions = instructions.ToArray();
			ILTools.ILOrderMatch(codeInstructions, out var index, 0, OpCodes.Callvirt, OpCodes.Stloc_2, OpCodes.Ldloc_S, OpCodes.Callvirt, OpCodes.Stloc_S);
			for (int i = 0; i < codeInstructions.Length; i++)
			{
				if (i == index)
				{
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Ldloc_S, (object)16);
					yield return new CodeInstruction(OpCodes.Call, (object)coinMethod);
					UltraFunGuns.Log.LogWarning("Complilation Sucess!");
				}
				yield return codeInstructions[i];
			}
		}

		[HarmonyPatch(typeof(Coin), "ReflectRevolver")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> InjectICoinTargetEvaluation(IEnumerable<CodeInstruction> instructions)
		{
			UltraFunGuns.Log.LogWarning("Beginning compilation of InjectICoinTargetEvaluation");
			CodeInstruction[] codeInstructions = instructions.ToArray();
			for (int i = 0; i < codeInstructions.Length; i++)
			{
				if (codeInstructions[i].opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(codeInstructions[i], (MemberInfo)lineRenderer_setPosition) && ILTools.ILOrderMatch(codeInstructions, out var index, i, OpCodes.Callvirt, OpCodes.Ldloc_S, OpCodes.Ldc_I4_1, OpCodes.Ldloc_0, OpCodes.Callvirt, OpCodes.Callvirt, OpCodes.Callvirt, OpCodes.Ldloc_S, OpCodes.Ldloca_S, OpCodes.Callvirt) && index == i)
				{
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Ldloc_S, (object)27);
					yield return new CodeInstruction(OpCodes.Ldloc_S, (object)17);
					yield return new CodeInstruction(OpCodes.Call, (object)evalMethod);
					UltraFunGuns.Log.LogWarning("Complilation Sucess!");
				}
				yield return codeInstructions[i];
			}
		}

		private static void SupplyCoinList(Coin coin, List<Transform> list)
		{
			IEnumerable<ICoinTarget> source = from x in Object.FindObjectsOfType<MonoBehaviour>()
				where typeof(ICoinTarget).IsAssignableFrom(((object)x).GetType())
				select (ICoinTarget)x;
			source = source.Where((ICoinTarget x) => x.CanBeCoinTargeted(coin));
			source = source.OrderBy((ICoinTarget x) => x.GetCoinTargetPriority(coin));
			list.AddRange(source.Select((ICoinTarget x) => x.GetCoinTargetPoint(coin)));
		}

		private static void EvalCustomCoinTarget(Coin coin, LineRenderer beamLine, Transform transform)
		{
			RevolverBeam component = ((Component)beamLine).GetComponent<RevolverBeam>();
			ICoinTarget coinTarget = default(ICoinTarget);
			if (((Component)transform).TryGetComponent<ICoinTarget>(ref coinTarget))
			{
				coinTarget.OnCoinReflect(coin, component);
			}
		}
	}
	[HarmonyPatch(typeof(GunControl))]
	public static class GunControlPatch
	{
		[HarmonyPatch("UpdateWeaponList")]
		[HarmonyPrefix]
		public static void OnUpdateWeaponList(GunControl __instance, bool firstTime)
		{
			UltraFunGuns.Log.Log($"GunControl: Set weapons {firstTime}");
			if (__instance.slots != null && __instance.slots.Count >= 6)
			{
				WeaponManager.DeployWeapons(firstTime);
			}
		}

		[HarmonyPatch("UpdateWeaponList")]
		[HarmonyPostfix]
		public static void OnUpdateWeaponList2(bool firstTime)
		{
			GunControl instance = MonoSingleton<GunControl>.Instance;
			StringBuilder stringBuilder = new StringBuilder();
			UltraFunGuns.Log.Log($"FIRST :{firstTime}");
			for (int i = 0; i < instance.slots.Count; i++)
			{
				stringBuilder.AppendLine("--------------------");
				stringBuilder.AppendLine($"Slot {i}: {instance.slots[i].Count}");
				for (int j = 0; j < instance.slots[i].Count; j++)
				{
					stringBuilder.AppendLine($"Weapon {j}: {((Object)instance.slots[i][j]).name}");
				}
				UltraFunGuns.Log.Log(stringBuilder.ToString());
				stringBuilder.Clear();
			}
			foreach (KeyValuePair<GameObject, int> item in instance.slotDict)
			{
				stringBuilder.Clear();
				stringBuilder.AppendLine("--------------------");
				stringBuilder.AppendLine($"SD: K:{((Object)item.Key).name} V:{item.Value}");
			}
		}
	}
	[HarmonyPatch]
	public static class ParryPatch
	{
		[HarmonyPatch(typeof(Punch), "TryParryProjectile")]
		[HarmonyPrefix]
		public static bool Prefix(Punch __instance, Transform target, bool __result, bool canProjectileBoost)
		{
			//IL_001f: 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)
			if (!target.TryFindComponent<IParriable>(out var component))
			{
				return true;
			}
			if (!component.Parry(((Component)MonoSingleton<CameraController>.Instance).transform.position, ((Component)MonoSingleton<CameraController>.Instance).transform.forward))
			{
				return true;
			}
			__instance.anim.Play("Hook", 0, 0.065f);
			MonoSingleton<TimeController>.Instance.ParryFlash();
			__result = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(NewMovement), "Respawn")]
	public static class PlayerRespawnPatch
	{
		public static void PostFix()
		{
			Events.OnPlayerRespawn?.Invoke();
			PlayerDeathPatch.PlayerDead = false;
		}
	}
	[HarmonyPatch(typeof(NewMovement), "GetHurt")]
	public static class PlayerDeathPatch
	{
		public static bool PlayerDead;

		public static void PostFix(NewMovement __instance, int damage)
		{
			Events.PlayerHurt(__instance, damage);
			if (!PlayerDead && (__instance.dead || __instance.hp <= 0))
			{
				PlayerDead = true;
				Events.OnPlayerDeath?.Invoke();
				UltraFunGuns.Log.LogWarning("Player died!");
			}
		}
	}
	[HarmonyPatch(typeof(StatsManager))]
	public static class StasManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Restart")]
		public static void Postfix()
		{
			Cleaner.Clean();
		}
	}
	[HarmonyPatch(typeof(NewMovement))]
	public static class InputDisruptor
	{
	}
	[HarmonyPatch]
	public static class RevolverBeamPatches
	{
		[HarmonyPatch(typeof(RevolverBeam), "ExecuteHits")]
		[HarmonyPrefix]
		public static bool OnExecuteHits(RevolverBeam __instance, ref RaycastHit currentHit)
		{
			if ((Object)(object)((RaycastHit)(ref currentHit)).transform == (Object)null)
			{
				return true;
			}
			if (!((RaycastHit)(ref currentHit)).transform.TryFindComponent<IRevolverBeamShootable>(out var component))
			{
				return true;
			}
			if (!component.CanRevolverBeamHit(__instance, ref currentHit))
			{
				return true;
			}
			component.OnRevolverBeamHit(__instance, ref currentHit);
			return false;
		}

		public static void SetShotHitPoint(this RevolverBeam instance, Vector3 point)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			FieldInfo field = typeof(RevolverBeam).GetField("shotHitPoint", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				throw new Exception("Could not find shotHitPoint field in RevolverBeam. Possible outdated UFG or Game Version.");
			}
			field.SetValue(instance, point);
		}

		[HarmonyPatch(typeof(RevolverBeam), "RicochetAimAssist")]
		[HarmonyPrefix]
		public static bool OnRicochetAimAssist(RevolverBeam __instance, GameObject beam)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			RaycastHit[] array = Physics.SphereCastAll(beam.transform.position, 5f, beam.transform.forward, float.PositiveInfinity, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)0)));
			if (array == null || array.Length == 0)
			{
				return true;
			}
			Vector3 val = beam.transform.forward * 1000f;
			float num = float.PositiveInfinity;
			GameObject val2 = null;
			bool flag2 = false;
			RaycastHit hit = default(RaycastHit);
			Coin val3 = default(Coin);
			EnemyIdentifierIdentifier val4 = default(EnemyIdentifierIdentifier);
			for (int i = 0; i < array.Length; i++)
			{
				bool flag3 = MonoSingleton<CoinTracker>.Instance.revolverCoinsList.Count > 0 && ((Component)((RaycastHit)(ref array[i])).transform).TryGetComponent<Coin>(ref val3) && (!val3.shot || val3.shotByEnemy);
				bool flag4 = !flag2 || flag3;
				bool flag5 = Physics.Raycast(beam.transform.position, ((RaycastHit)(ref array[i])).point - beam.transform.position, ((RaycastHit)(ref array[i])).distance, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1)));
				bool flag6 = ((Component)((RaycastHit)(ref array[i])).transform).TryGetComponent<EnemyIdentifierIdentifier>(ref val4) && Object.op_Implicit((Object)(object)val4.eid) && !val4.eid.dead;
				ISharpshooterTarget component;
				bool flag7 = ((RaycastHit)(ref array[i])).transform.TryFindComponent<ISharpshooterTarget>(out component) && component.CanBeSharpshot(__instance, array[i]);
				if (flag4 && (((RaycastHit)(ref array[i])).distance <= num || flag4) && (((RaycastHit)(ref array[i])).distance >= 0.1f || flag3) && !flag5 && (flag3 || flag6 || flag7))
				{
					if (flag3)
					{
						flag2 = true;
					}
					val = (flag3 ? ((RaycastHit)(ref array[i])).transform.position : ((!flag7) ? ((RaycastHit)(ref array[i])).point : component.GetSharpshooterTargetPoint()));
					num = ((RaycastHit)(ref array[i])).distance;
					val2 = ((Component)((RaycastHit)(ref array[i])).transform).gameObject;
					hit = array[i];
				}
			}
			if (Object.op_Implicit((Object)(object)val2))
			{
				if (!val2.TryFindComponent<ISharpshooterTarget>(out var component2))
				{
					return true;
				}
				flag = true;
				beam.transform.LookAt(val);
				component2.OnSharpshooterTargeted(__instance, hit);
			}
			return !flag;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Hydraxous.ULTRAKILL.UltraFunGuns", "UltraFunGuns", "1.3.6")]
	[BepInProcess("ULTRAKILL.exe")]
	public class UltraFunGuns : BaseUnityPlugin
	{
		private Harmony harmony = new Harmony("Hydraxous.ULTRAKILL.UltraFunGuns");

		private ConfigBuilder config = new ConfigBuilder("Hydraxous.ULTRAKILL.UltraFunGuns", "UltraFunGuns");

		public static bool UsingLatestVersion = true;

		public static string LatestVersion = "UNKNOWN";

		private UltraFunGunBase.ActionCooldown autosave = new UltraFunGunBase.ActionCooldown(120f);

		private Action<bool, string> onVersionCheckFinished = delegate(bool usingLatest, string latestVersion)
		{
			UsingLatestVersion = usingLatest;
			LatestVersion = latestVersion;
		};

		internal static Ilogger Log { get; private set; }

		public static UltraFunGuns UFG { get; private set; }

		public static bool DebugMode
		{
			get
			{
				if (Data.Config != null)
				{
					return Data.Config.Data.DebugMode;
				}
				return false;
			}
		}

		private void Awake()
		{
			UFG = this;
			Log = new BepInExLogger(((BaseUnityPlugin)this).Logger);
			Data.CheckSetup();
			((MonoBehaviour)this).StartCoroutine(Startup());
		}

		private IEnumerator Startup()
		{
			WeaponManager.Init();
			HydraLoader.LoadAssets(delegate(bool loaded)
			{
				if (loaded)
				{
					Log.LogWarning("\r\n   __  ______             ______            ______                \r\n  / / / / / /__________ _/ ____/_  ______  / ____/_  ______  _____\r\n / / / / / __/ ___/ __ `/ /_  / / / / __ \\/ / __/ / / / __ \\/ ___/\r\n/ /_/ / / /_/ /  / /_/ / __/ / /_/ / / / / /_/ / /_/ / / / (__  ) \r\n\\____/_/\\__/_/   \\__,_/_/    \\__,_/_/ /_/\\____/\\__,_/_/ /_/____/");
					Log.Log("UltraFunGuns is loading... Version: Release-1.3.6");
					UltraLoader.LoadAll();
					config.BuildAll();
					VersionCheck.CheckVersion("https://api.github.com/repos/Hydraxous/UltraFunGuns/tags", "Release-1.3.6", onVersionCheckFinished);
					DoPatching();
					InGameCheck.Init();
					CustomPlacedObjectManager.Init();
					NoHighScorePatch.Init();
					Commands.Register();
					TextureLoader.Init();
					Log.Log("Successfully Loaded!");
					((Component)this).gameObject.AddComponent<DebuggingDummy>();
				}
				else
				{
					Log.LogError("Loading failed.");
					((Behaviour)this).enabled = false;
				}
			});
			yield return null;
		}

		private void Update()
		{
			if (autosave.CanFire() && Data.Config.Data.EnableAutosave)
			{
				autosave.AddCooldown();
				Data.SaveAll();
			}
		}

		private void DoPatching()
		{
			harmony.PatchAll();
		}

		[Commands.UFGDebugMethod("Toggle Debug", "Toggles the debug mode for UFG.")]
		[Configgable("Commands", "Toggle Debug Mode", 0, null)]
		public static void ToggleDebugMode()
		{
			bool flag = !DebugMode;
			Data.Config.Data.DebugMode = flag;
			Data.Config.Save();
			Log.Log("Debug mode: " + (flag ? "Enabled" : "Disabled"));
		}

		private void OnApplicationQuit()
		{
			Data.SaveAll();
		}
	}
	public static class CustomStyleDefinitions
	{
		public const string VAPORIZED = "<color=#0bd6fcff>VAPORIZED</color>";

		public const string VIBE_CHECK = "VIBE-CHECKED";

		public const string V2_KILL = "<color=#ff33001>OXIDIZED</color>";

		public const string GABRIEL_KILL = "<color=#ff0051>L-DISTRIBUTED</color>";

		public const string WICKED_KILL = "<color=#919191>NOT WICKED ENOUGH</color>";

		public const string MINOS_KILL = "<color=#03ffa7>JUDGED</color>";

		public const string ORBITED = "ORBITAL LAUNCH";

		public const string EGGED = "EGGED";

		public const string EGG_STRIKE = "TACTICAL EGG STRIKE";

		public const string EGG_SPLOSION = "<color=yellow>EGGSPLOSION</color>";

		public const string LASER_REFRACTION_HIT = "BUG ZAPPER";

		public const string LASER_DISCO_HIT = "DISCO INFERNO";

		public const string DODGEBALL_HIT = "OUTPLAYED";

		public const string DODGEBALL_PARRY = "BOOST BALL";

		public const string DODGEBALL_PARRY_HIT = "<color=orange>SLAM DUNK</color>";

		public const string DODGEBALL_REVERSE_HIT = "REBOUND";

		public const string FINGER_GUN_HIT = "BANG'D";

		public const string FINGER_GUN_PENETRATE = "<color=#0bd6fcff>KABOOMA!</color>";

		public const string FINGER_GUN_PROJECTILE_HIT = "DENIAL";

		public const string ADMIN_GUN_KILL = "<color=red>GAMING CHAIR</color>";

		public const string BRICK_MIND_KILL = "<color=orange>SOUL ASSIMILATION</color>";

		public const string BRICK_PARRY_KILL = "BRICKED";

		public const string TRICKSNIPER_QUICKSCOPE = "QUICKSCOPE";

		public const string TRICKSNIPER_360 = "<color=#0bd6fcff>TRICKSHOT</color>";

		public const string TRICKSNIPER_NOSCOPE = "<color=orange>NOSCOPE</color>";

		public const string TRICKSNIPER_BANKSHOT = "<color=orange>BANKSHOT</color>";

		public const string ULTRAGUN_SUPERCHARGE_KILL = "<color=#0bd6fcff>EXPRESS BILLING</color>";

		public const string ULTRAGUN_KILL = "BILLED";

		public const string ULTRAGUN_RAIN_KILL = "<color=red>WHAT GOES UP</color>";

		public const string ULTRAGUN_AERIAL_KILL = "DEATH FROM ABOVE";
	}
	public static class AudioTools
	{
		public static AudioSource PlayAudioClip(this AudioClip clip, float pitch = 1f, float volume = 1f, float spatialBlend = 0f)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return clip.PlayAudioClip(Vector3.zero, pitch, volume, spatialBlend);
		}

		public static AudioSource PlayAudioClip(this AudioClip clip, Vector3 position, float pitch = 1f, float volume = 1f, float spatialBlend = 0f)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)clip == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject("AudioSource(" + ((Object)clip).name + ")");
			val.transform.position = position;
			AudioSource val2 = val.AddComponent<AudioSource>();
			DestroyAfterTime destroyAfterTime = val.AddComponent<DestroyAfterTime>();
			val2.playOnAwake = false;
			val2.spatialBlend = spatialBlend;
			val2.volume = volume;
			val2.pitch = pitch;
			val2.clip = clip;
			val2.Play();
			return val2;
		}
	}
	public static class ButtonExtensions
	{
		public static void SetClickAction(this Button b, Action action)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			((UnityEventBase)b.onClick).RemoveAllListeners();
			((UnityEvent)b.onClick).AddListener((UnityAction)delegate
			{
				action();
			});
		}
	}
	public static class Commands
	{
		public class UFGCommand : ICommand
		{
			public string Name => "Ultra Fun Guns Command";

			public string Description => "Perform actions in the UltraFunGuns mod.";

			public string Command => "ufg";

			public void Execute(Console con, string[] args)
			{
				if (args.Length != 0)
				{
					if (ufgCommands.ContainsKey(args[0].ToLower()))
					{
						if (args.Length <= 1)
						{
							foreach (KeyValuePair<string, UFGDebugMethod> item in ufgCommands[args[0].ToLower()])
							{
								UltraFunGuns.Log.Log(CommandAlias + " " + args[0].ToLower() + " " + item.Value.MethodName + " - " + item.Value.Name + ": " + item.Value.Description);
							}
							return;
						}
						if (ufgCommands[args[0].ToLower()].ContainsKey(args[1].ToLower()))
						{
							ufgCommands[args[0].ToLower()][args[1].ToLower()].Action?.Invoke();
						}
						else
						{
							UltraFunGuns.Log.Log("UFG " + args[0].ToLower() + " method does not exist.");
						}
					}
					else
					{
						UltraFunGuns.Log.Log("UFG Subcommand does not exist.");
					}
				}
				else
				{
					PrintHelp(con);
				}
			}

			private void PrintHelp(Console con)
			{
				foreach (KeyValuePair<string, Dictionary<string, UFGDebugMethod>> ufgCommand in ufgCommands)
				{
					UltraFunGuns.Log.Log(CommandAlias + " " + ufgCommand.Key);
				}
			}
		}

		[AttributeUsage(AttributeTargets.Method)]
		public class UFGDebugMethod : Attribute
		{
			public string Name { get; }

			public string Description { get; }

			public string MethodName { get; private set; }

			public Action Action { get; private set; }

			public UFGDebugMethod(string Name, string Description)
			{
				this.Name = Name;
				this.Description = Description;
			}

			public void Setup(Action method, string methodName)
			{
				Action = method;
				MethodName = methodName;
			}

			public void Execute()
			{
				Action?.Invoke();
			}
		}

		private static Dictionary<string, Dictionary<string, UFGDebugMethod>> ufgCommands = new Dictionary<string, Dictionary<string, UFGDebugMethod>>();

		public static string CommandAlias => "ufg";

		public static void Register()
		{
			RegisterCommands();
			if (!MonoSingleton<Console>.Instance.recognizedCommands.ContainsKey(new UFGCommand().Name.ToLower()))
			{
				MonoSingleton<Console>.Instance.RegisterCommand((ICommand)(object)new UFGCommand());
			}
		}

		private static void RegisterCommands()
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Type[] types = executingAssembly.GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods = type.GetMethods();
				if (methods.Length == 0)
				{
					continue;
				}
				MethodInfo[] array = methods;
				foreach (MethodInfo method in array)
				{
					if (!method.IsStatic)
					{
						continue;
					}
					UFGDebugMethod customAttribute = method.GetCustomAttribute<UFGDebugMethod>();
					if (customAttribute == null)
					{
						continue;
					}
					string key = type.Name.ToLower();
					string text = method.Name.ToLower();
					if (!ufgCommands.ContainsKey(key))
					{
						ufgCommands.Add(key, new Dictionary<string, UFGDebugMethod>());
					}
					if (ufgCommands[key].ContainsKey(text))
					{
						continue;
					}
					bool flag = true;
					ParameterInfo[] parameters = method.GetParameters();
					for (int k = 0; k < parameters.Length; k++)
					{
						if (!parameters[k].HasDefaultValue)
						{
							flag = false;
						}
					}
					if (flag)
					{
						object[] defaultParams = parameters.Select((ParameterInfo x) => x.DefaultValue).ToArray();
						customAttribute.Setup(delegate
						{
							method.Invoke(null, defaultParams);
						}, text);
						ufgCommands[key].Add(text, customAttribute);
					}
				}
			}
		}
	}
	public static class ComponentTools
	{
		public static bool TryFindComponent<T>(this GameObject gameObject, out T component)
		{
			if (gameObject.TryGetComponent<T>(ref component))
			{
				return true;
			}
			component = gameObject.GetComponentInChildren<T>();
			if (component != null)
			{
				return true;
			}
			component = gameObject.GetComponentInParent<T>();
			if (component != null)
			{
				return true;
			}
			return false;
		}

		public static bool TryFindComponent<T>(this Transform transform, out T component)
		{
			return ((Component)transform).gameObject.TryFindComponent<T>(out component);
		}

		public static bool TryFindComponent<T>(this Collider col, out T component)
		{
			return ((Component)col).gameObject.TryFindComponent<T>(out component);
		}

		public static T EnsureComponent<T>(this GameObject gameObject)
		{
			T result = default(T);
			if (gameObject.TryGetComponent<T>(ref result))
			{
				return result;
			}
			return (T)(object)gameObject.AddComponent(typeof(T));
		}

		public static T EnsureComponent<T>(this Transform transform)
		{
			T result = default(T);
			if (((Component)transform).TryGetComponent<T>(ref result))
			{
				return result;
			}
			return (T)(object)((Component)transform).gameObject.AddComponent(typeof(T));
		}

		public static T LocateComponent<T>(this Transform tf, string name) where T : Component
		{
			return (from x in ((Component)tf).GetComponentsInChildren<T>(true)
				where ((Object)(object)x).name == name
				select x).FirstOrDefault();
		}
	}
	public static class EnemyTools
	{
		public static bool CanBeDamaged(this EnemyIdentifier eid)
		{
			if ((Object)(object)eid == (Object)null)
			{
				return false;
			}
			if (eid.dead)
			{
				return false;
			}
			if (eid.health <= 0f)
			{
				return false;
			}
			if (!((Behaviour)eid).enabled)
			{
				return false;
			}
			return true;
		}

		public static Vector3 GetTargetPoint(this EnemyIdentifier eid)
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0047: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)eid == (Object)null)
			{
				return Vector3.zero;
			}
			if ((Object)(object)eid.weakPoint != (Object)null)
			{
				return eid.weakPoint.transform.position;
			}
			return ((Component)eid).transform.position;
		}

		public static bool IsColliderEnemy(this Collider collider, out EnemyIdentifier enemy, bool filterDead = true)
		{
			enemy = null;
			EnemyIdentifierIdentifier val = default(EnemyIdentifierIdentifier);
			EnemyIdentifier val2 = default(EnemyIdentifier);
			if (((Component)collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val))
			{
				if ((Object)(object)val.eid != (Object)null)
				{
					enemy = val.eid;
					if (!enemy.dead || !filterDead)
					{
						return true;
					}
				}
			}
			else if (((Component)collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val2))
			{
				enemy = val2;
				if (!enemy.dead || !filterDead)
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsCollisionEnemy(this Collision collider, out EnemyIdentifier enemy, bool filterDead = true)
		{
			enemy = null;
			EnemyIdentifierIdentifier val = default(EnemyIdentifierIdentifier);
			EnemyIdentifier val2 = default(EnemyIdentifier);
			if (collider.gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val))
			{
				if ((Object)(object)val.eid != (Object)null)
				{
					enemy = val.eid;
					if (!enemy.dead || !filterDead)
					{
						return true;
					}
				}
			}
			else if (collider.gameObject.TryGetComponent<EnemyIdentifier>(ref val2))
			{
				enemy = val2;
				if (!enemy.dead || !filterDead)
				{
					return true;
				}
			}
			return false;
		}

		public static bool TryGetHomingTarget(Vector3 sampleLocation, out Transform homingTarget, out EnemyIdentifier enemyComponent)
		{
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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)
			homingTarget = null;
			enemyComponent = null;
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			List<Transform> list2 = new List<Transform>();
			GameObject[] array = GameObject.FindGameObjectsWithTag("Enemy");
			GameObject[] array2 = array;
			EnemyIdentifier val2 = default(EnemyIdentifier);
			RaycastHit val5 = default(RaycastHit);
			EnemyIdentifier val6 = default(EnemyIdentifier);
			EnemyIdentifierIdentifier val7 = default(EnemyIdentifierIdentifier);
			foreach (GameObject val in array2)
			{
				if (val.TryGetComponent<EnemyIdentifier>(ref val2) && !val2.dead && !list.Contains(val2))
				{
					list.Add(val2);
					Transform val3;
					if ((Object)(object)val2.weakPoint != (Object)null && val2.weakPoint.activeInHierarchy)
					{
						val3 = val2.weakPoint.transform;
					}
					else
					{
						EnemyIdentifierIdentifier componentInChildren = ((Component)val2).GetComponentInChildren<EnemyIdentifierIdentifier>();
						val3 = ((!Object.op_Implicit((Object)(object)componentInChildren)) ? ((Component)val2).transform : ((Component)componentInChildren).transform);
					}
					Vector3 val4 = val3.position - sampleLocation;
					if (Physics.Raycast(sampleLocation, val4, ref val5, ((Vector3)(ref val4)).magnitude, LayerMask.GetMask(new string[5] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default" })) && (((Component)((RaycastHit)(ref val5)).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val6) || ((Component)((RaycastHit)(ref val5)).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val7)))
					{
						list2.Add(val3);
					}
				}
			}
			int num = -1;
			float num2 = float.PositiveInfinity;
			for (int j = 0; j < list2.Count; j++)
			{
				Vector3 val8 = list2[j].position - sampleLocation;
				if (((Vector3)(ref val8)).sqrMagnitude < num2)
				{
					num = j;
					num2 = ((Vector3)(ref val8)).sqrMagnitude;
				}
			}
			if (num > -1)
			{
				homingTarget = list2[num];
				enemyComponent = ((Component)homingTarget).GetComponent<EnemyIdentifier>();
				return true;
			}
			return false;
		}

		public static bool TryGetTarget(out Vector3 targetDirection)
		{
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: 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_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			List<Transform> list2 = new List<Transform>();
			GameObject[] array = (from x in MonoSingleton<EnemyTracker>.Instance.GetCurrentEnemies()
				where !x.blessed && !x.dead
				select x into e
				select ((Component)e).gameObject).ToArray();
			Transform transform = ((Component)MonoSingleton<CameraController>.Instance).transform;
			GameObject[] array2 = array;
			EnemyIdentifier val2 = default(EnemyIdentifier);
			foreach (GameObject val in array2)
			{
				if (!val.TryGetComponent<EnemyIdentifier>(ref val2) || val2.dead || list.Contains(val2))
				{
					continue;
				}
				list.Add(val2);
				Transform val3;
				if ((Object)(object)val2.weakPoint != (Object)null && val2.weakPoint.activeInHierarchy)
				{
					val3 = val2.weakPoint.transform;
				}
				else
				{
					EnemyIdentifierIdentifier componentInChildren = ((Component)val2).GetComponentInChildren<EnemyIdentifierIdentifier>();
					val3 = ((!Object.op_Implicit((Object)(object)componentInChildren)) ? ((Component)val2).transform : ((Component)componentInChildren).transform);
				}
				Vector3 val4 = val3.position - transform.position;
				Vector3 normalized = ((Vector3)(ref val4)).normalized;
				Vector3 forward = transform.forward;
				if (HydraUtils.SphereCastMacro(transform.position, 0.05f, normalized, float.PositiveInfinity, out var hit))
				{
					int layer = ((Component)((RaycastHit)(ref hit)).collider).gameObject.layer;
					int num = layer;
					if ((uint)(num - 10) <= 1u)
					{
						list2.Add(val3);
					}
				}
			}
			int num2 = -1;
			float num3 = float.PositiveInfinity;
			for (int j = 0; j < list2.Count; j++)
			{
				Vector3 val5 = list2[j].position - transform.position;
				if (((Vector3)(ref val5)).sqrMagnitude < num3)
				{
					num2 = j;
					num3 = ((Vector3)(ref val5)).sqrMagnitude;
				}
			}
			if (num2 > -1)
			{
				targetDirection = list2[num2].position - transform.position;
				return true;
			}
			targetDirection = Vector3.zero;
			return false;
		}
	}
	public static class Events
	{
		public delegate void EventHandler();

		public static EventHandler OnPlayerDeath;

		public static EventHandler OnPlayerRespawn;

		public static event Action<NewMovement, int> OnPlayerHurt;

		public static void PlayerHurt(NewMovement player, int damage)
		{
			Events.OnPlayerHurt?.Invoke(player, damage);
		}
	}
	public static class HydraUtils
	{
		public static Ray GetProjectileAimVector(Transform view, Transform projectileOrigin, float thickness = 0.01f, float maxRange = 1000f)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_003e: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_006e: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			Ray result = default(Ray);
			((Ray)(ref result)).origin = view.position;
			((Ray)(ref result)).direction = view.forward;
			Vector3 point = ((Ray)(ref result)).GetPoint(maxRange);
			((Ray)(ref result)).origin = projectileOrigin.position;
			((Ray)(ref result)).direction = point - projectileOrigin.position;
			if (SphereCastMacro(view.position, thickness, view.forward, maxRange, out var hit))
			{
				((Ray)(ref result)).origin = projectileOrigin.position;
				((Ray)(ref result)).direction = ((RaycastHit)(ref hit)).point - projectileOrigin.position;
				UltraFunGuns.Log.Log("Raycast hit [" + ((Object)((Component)((RaycastHit)(ref hit)).collider).gameObject).name + "]");
			}
			return result;
		}

		public static bool SphereCastMacro(Vector3 position, float thickness, Vector3 direction, float maxRange, out RaycastHit hit, bool hitTriggers = false)
		{
			//IL_0003: 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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			hit = default(RaycastHit);
			if (SphereCastAllMacro(position, thickness, direction, maxRange, out var hits, hitTriggers))
			{
				hit = hits[0];
				return true;
			}
			return false;
		}

		public static bool SphereCastAllMacro(Vector3 position, float thickness, Vector3 direction, float maxRange, out RaycastHit[] hits, bool hitTriggers = false)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_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)
			hits = Physics.SphereCastAll(position, thickness, direction, maxRange, LayerMask.GetMask(new string[7] { "Projectile", "Limb", "BigCorpse", "Environment", "Outdoors", "Armor", "Default" }));
			if (hits.Length == 0)
			{
				return false;
			}
			List<RaycastHit> list = new List<RaycastHit>(SortRaycastHitsByDistance(hits));
			int num = 0;
			while (num < list.Count)
			{
				RaycastHit val = list[num];
				if (!(((Object)((Component)((RaycastHit)(ref val)).collider).gameObject).name == "CameraCollisionChecker"))
				{
					val = list[num];
					if (!((RaycastHit)(ref val)).collider.isTrigger || hitTriggers)
					{
						num++;
						continue;
					}
				}
				list.RemoveAt(num);
			}
			hits = list.ToArray();
			return list.Count > 0;
		}

		public static string CollisionInfo(Collision col)
		{
			string format = "Name: {0}\nLayer: {1}\nTag: {2}\nContactCount: {3}";
			return string.Format(format, ((Object)col.collider).name, col.gameObject.layer, ((Component)col.collider).tag, col.contactCount);
		}

		public static RaycastHit[] SortRaycastHitsByDistance(RaycastHit[] hits)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			List<RaycastHit> list = new List<RaycastHit>(hits.Length);
			for (int i = 0; i < hits.Length; i++)
			{
				RaycastHit item = hits[i];
				int num;
				for (num = i; num > 0; num--)
				{
					RaycastHit val = list[num - 1];
					if (!(((RaycastHit)(ref val)).distance > ((RaycastHit)(ref item)).distance))
					{
						break;
					}
				}
				list.Insert(num, item);
			}
			return list.ToArray();
		}

		public static bool LineOfSightCheck(Vector3 source, Vector3 target)
		{
			//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_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)
			Vector3 val = target - source;
			RaycastHit[] hits = Physics.RaycastAll(source, val, ((Vector3)(ref val)).magnitude);
			hits = SortRaycastHitsByDistance(hits);
			RaycastHit[] array = hits;
			for (int i = 0; i < array.Length; i++)
			{
				RaycastHit val2 = array[i];
				if ((((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 8 || ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 0) && ((Object)((Component)((RaycastHit)(ref val2)).collider).gameObject).name != "CameraCollisionChecker")
				{
					return false;
				}
			}
			return true;
		}

		public static bool IsColliderEnvironment(this Collider col)
		{
			int layer = ((Component)col).gameObject.layer;
			int num = layer;
			if (num == 8 || (uint)(num - 24) <= 1u)
			{
				return true;
			}
			return false;
		}

		public static Vector3[] DoRayHit(Ray hitRay, float range, bool penetration = false, float enemyDamage = 1f, bool explodeEnemyLimb = false, float critDamageMultiplier = 0f, GameObject sourceObject = null, bool explodeGrenade = false, bool explodeEgg = false, bool breakGlass = false, bool breakBreakable = false, bool exciteDodgeball = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit[] array = Physics.RaycastAll(hitRay, range, LayerMask.GetMask(new string[5] { "Limb", "BigCorpse", "Outdoors", "Environment", "Default" }));
			if (array.Length != 0 && (array.Length != 1 || !(((Object)((Component)((RaycastHit)(ref array[0])).collider).gameObject).name == "CameraCollisionChecker")))
			{
				int num = 0;
				array = SortRaycastHitsByDistance(array);
				EnemyIdentifierIdentifier val = default(EnemyIdentifierIdentifier);
				EnemyIdentifier val2 = default(EnemyIdentifier);
				Breakable val3 = default(Breakable);
				ThrownEgg thrownEgg = default(ThrownEgg);
				ThrownDodgeball thrownDodgeball = default(ThrownDodgeball);
				Grenade val4 = default(Grenade);
				for (int i = 0; i < array.Length; i++)
				{
					num = i;
					if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 24 || ((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 25 || ((Component)((RaycastHit)(ref array[i])).collider).gameObject.layer == 8)
					{
						break;
					}
					if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<EnemyIdentifierIdentifier>(ref val))
					{
						val.eid.DeliverDamage(((Component)((RaycastHit)(ref array[i])).collider).gameObject, ((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).point, enemyDamage, explodeEnemyLimb, critDamageMultiplier, sourceObject, false, false);
						if (!penetration)
						{
							break;
						}
					}
					else if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<EnemyIdentifier>(ref val2))
					{
						val2.DeliverDamage(((Component)((RaycastHit)(ref array[i])).collider).gameObject, ((Ray)(ref hitRay)).direction, ((RaycastHit)(ref array[i])).point, enemyDamage, explodeEnemyLimb, critDamageMultiplier, sourceObject, false, false);
						if (!penetration)
						{
							break;
						}
					}
					if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<Breakable>(ref val3) && breakBreakable)
					{
						val3.Break();
						if (!penetration)
						{
							break;
						}
					}
					if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<ThrownEgg>(ref thrownEgg) && explodeEgg)
					{
						thrownEgg.Explode();
						if (!penetration)
						{
							break;
						}
					}
					if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<ThrownDodgeball>(ref thrownDodgeball) && exciteDodgeball)
					{
						thrownDodgeball.ExciteBall(6);
						if (!penetration)
						{
							break;
						}
					}
					if (((Component)((RaycastHit)(ref array[i])).collider).gameObject.TryGetComponent<Grenade>(ref val4) && explodeGrenade)
					{
						MonoSingleton<TimeController>.Instance.ParryFlash();
						val4.Explode(false, false, false, 1f, false, (GameObject)null, false);
						if (!penetration)
						{
							break;
						}
					}
				}
				return (Vector3[])(object)new Vector3[2]
				{
					((RaycastHit)(ref array[num])).point,
					((RaycastHit)(ref array[num])).normal
				};
			}
			return (Vector3[])(object)new Vector3[1] { Vector3.zero };
		}

		public static T[] GetAllAttributesOfType<T>() where T : Attribute
		{
			List<T> list = new List<T>();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Type[] types = executingAssembly.GetTypes();
			foreach (Type element in types)
			{
				IEnumerable<T> customAttributes = element.GetCustomAttributes<T>();
				if (customAttributes == null)
				{
					continue;
				}
				foreach (T item in customAttributes)
				{
					if (item != null && !list.Contains(item))
					{
						list.Add(item);
					}
				}
			}
			return list.ToArray();
		}

		public static Transform[] GetChildren(this Transform tf)
		{
			List<Transform> list = new List<Transform>();
			for (int i = 0; i < tf.childCount; i++)
			{
				list.Add(tf.GetChild(i));
			}
			return list.ToArray();
		}

		public static Ray ToRay(this Transform transform)
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Ray(transform.position, transform.forward);
		}

		public static void SetPlayerRotation(Quaternion newRotation)
		{
			//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_002c: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation;
			((Component)MonoSingleton<CameraController>.Instance).transform.rotation = newRotation;
			float x = ((Component)MonoSingleton<CameraController>.Instance).transform.localEulerAngles.x;
			float rotationX = x;
			if (x <= 90f && x >= 0f)
			{
				rotationX = 0f - x;
			}
			else if (x >= 270f && x <= 360f)
			{
				rotationX = Mathf.Lerp(0f, 90f, Mathf.InverseLerp(360f, 270f, x));
			}
			Quaternion rotation2 = ((Component)MonoSingleton<CameraController>.Instance).transform.rotation;
			float y = ((Quaternion)(ref rotation2)).eulerAngles.y;
			MonoSingleton<CameraController>.Instance.rotationX = rotationX;
			MonoSingleton<CameraController>.Instance.rotationY = y;
		}

		public static void CreateBulletTrail(Vector3 startPosition, Vector3 endPosition, Vector3 normal)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_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_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Prefabs.BulletTrail == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(Prefabs.BulletTrail, endPosition, Quaternion.identity);
				val.transform.up = normal;
				LineRenderer component = val.GetComponent<LineRenderer>();
				Vector3[] positions = (Vector3[])(object)new Vector3[2] { startPosition, endPosition };
				component.SetPositions(positions);
			}
		}
	}
	public class Trajectory
	{
		public Vector3 Origin;

		public Vector3 End;

		public float AirTime;

		public Vector3 Gravity;

		public Trajectory(Vector3 origin, Vector3 end, float airTime, Vector3 gravity)
		{
			//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_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_001e: 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)
			Origin = origin;
			End = end;
			AirTime = airTime;
			Gravity = gravity;
		}

		public Trajectory(Vector3 origin, Vector3 end, float airTime)
		{
			//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_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_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)
			Origin = origin;
			End = end;
			AirTime = airTime;
			Gravity = Physics.gravity;
		}

		public Vector3 GetRequiredVelocity()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			float num = ((AirTime == 0f) ? (AirTime + 0.0001f) : AirTime);
			Vector3 val = Vector3.LerpUnclamped(Origin, End, 0.5f / num);
			val -= Gravity * num;
			return val - Origin;
		}

		public Vector3[] GetPoints(int quality = 100, float drag = 0f)
		{
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			if (quality == 0)
			{
				return (Vector3[])(object)new Vector3[2] { Origin, End };
			}
			Vector3 val = GetRequiredVelocity();
			float num = AirTime / (float)(quality / 2);
			Vector3 val2 = Origin;
			List<Vector3> list = new List<Vector3>();
			for (int i = 0; i < quality; i++)
			{
				val *= 1f - num * drag;
				val += Gravity * num;
				list.Add(val2);
				val2 += val * num;
			}
			return list.ToArray();
		}

		public Vector3 GetPoint(float time, int quality = 100, float drag = 0f)
		{
			//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_0028: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] points = GetPoints(quality, drag);
			time = Mathf.Clamp01(time);
			return points[Mathf.FloorToInt((float)(points.Length - 1) * time)];
		}
	}
	public class Ring
	{
		private int objectCount;

		private float radius;

		private float circumference;

		public float Radius
		{
			get
			{
				return CalcRadius();
			}
			set
			{
				radius = value;
				circumference = CalcCircumference();
			}
		}

		public float Circumference
		{
			get
			{
				return CalcCircumference();
			}
			set
			{
				circumference = value;
				radius = CalcRadius();
			}
		}

		public float Diameter
		{
			get
			{
				return radius * 2f;
			}
			set
			{
				radius = value / 2f;
			}
		}

		public float CalcRadius()
		{
			return circumference / (MathF.PI * 2f);
		}

		public float CalcCircumference()
		{
			return MathF.PI * 2f * radius;
		}

		public Ring(int objectCount, float radius)
		{
			this.objectCount = objectCount;
			this.radius = radius;
			Circumference = CalcCircumference();
		}

		public void SetCircumferenceFromObjectRadius(float objectRadius)
		{
			Circumference = objectRadius * (float)objectCount;
		}

		public void SetCircumference(float circumference)
		{
			radius = circumference / (MathF.PI * 2f);
		}

		public float GetSliceSize()
		{
			return MathF.PI * 2f / (float)objectCount;
		}

		public Vector3[] GetPositions()
		{
			//IL_0017: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			if (objectCount == 1)
			{
				return (Vector3[])(object)new Vector3[1] { Vector3.zero };
			}
			List<Vector3> list = new List<Vector3>();
			float sliceSize = GetSliceSize();
			for (int i = 0; i < objectCount; i++)
			{
				float num = sliceSize * (float)i;
				float num2 = Radius * Mathf.Cos(num);
				float num3 = Radius * Mathf.Sin(num);
				list.Add(new Vector3(num2, num3, 0f));
			}
			return list.ToArray();
		}
	}
	public static class ILTools
	{
		public static bool ILOrderMatch(CodeInstruction[] instructions, out int index, int startIndex = 0, params OpCode[] orderMatch)
		{
			index = -1;
			int num = instructions.Length;
			int num2 = orderMatch.Length;
			for (int i = startIndex; i < instructions.Length; i++)
			{
				for (int j = 0; j < orderMatch.Length && !(instructions[i + j].opcode != orderMatch[j]); j++)
				{
					if (j == num2 - 1)
					{
						index = i;
						return true;
					}
				}
			}
			return false;
		}
	}
	public static class InGameCheck
	{
		public enum UKLevelType
		{
			Intro,
			MainMenu,
			Level,
			Endless,
			Sandbox,
			Credits,
			Custom,
			Intermission,
			Secret,
			Tutorial,
			PrimeSanctum,
			Unknown
		}

		public delegate void OnLevelChangedHandler(UKLevelType uKLevelType);

		private static bool initialized;

		public static UKLevelType CurrentLevelType = UKLevelType.Intro;

		public static string CurrentSceneName = "";

		public static OnLevelChangedHandler OnLevelTypeChanged;

		public static OnLevelChangedHandler OnLevelChanged;

		public static void Init()
		{
			if (!initialized)
			{
				initialized = true;
				SceneManager.sceneLoaded += OnSceneLoad;
			}
		}

		private static void PrintLoadedScenes()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			int sceneCountInBuildSettings = SceneManager.sceneCountInBuildSettings;
			for (int i = 0; i < sceneCountInBuildSettings; i++)
			{
				PrintSceneDetails(SceneManager.GetSceneByBuildIndex(i));
			}
		}

		private static void PrintSceneDetails(Scene scene, bool force = false)
		{
			if (((Scene)(ref scene)).buildIndex == -1 && !force)
			{
				UltraFunGuns.Log.Log("SCENEHELPER: Scene is null!");
				return;
			}
			UltraFunGuns.Log.Log("=============================\nSCENE FOUND: " + ((Scene)(ref scene)).name + "\n" + $"VALID: {((Scene)(ref scene)).IsValid()}\n" + $"INDEX: {((Scene)(ref scene)).buildIndex}\n" + "PATH: " + ((Scene)(ref scene)).path + "\n" + $"OBJS: {((Scene)(ref scene)).rootCount}\n" + "=============================");
		}

		private static void OnSceneLoad(Scene scene, LoadSceneMode loadSceneMode)
		{
			//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)
			if (!(scene != SceneManager.GetActiveScene()))
			{
				UKLevelType uKLevelType = GetUKLevelType(SceneHelper.CurrentScene);
				if (uKLevelType != CurrentLevelType)
				{
					CurrentLevelType = uKLevelType;
					CurrentSceneName = SceneHelper.CurrentScene;
					OnLevelTypeChanged?.Invoke(uKLevelType);
				}
				OnLevelChanged?.Invoke(CurrentLevelType);
			}
		}

		public static UKLevelType GetUKLevelType(string sceneName)
		{
			UltraFunGuns.Log.Log("Scene Loaded: [" + sceneName + "]");
			sceneName = (sceneName.Contains("P-") ? "Sanctum" : sceneName);
			sceneName = (sceneName.Contains("-S") ? "Secret" : sceneName);
			sceneName = (sceneName.Contains("Level") ? "Level" : sceneName);
			sceneName = (sceneName.Contains("Intermission") ? "Intermission" : sceneName);
			return sceneName switch
			{
				"Main Menu" => UKLevelType.MainMenu, 
				"Custom Content" => UKLevelType.Custom, 
				"Intro" => UKLevelType.Intro, 
				"Endless" => UKLevelType.Endless, 
				"uk_construct" => UKLevelType.Sandbox, 
				"Intermission" => UKLevelType.Intermission, 
				"Level" => UKLevelType.Level, 
				"Secret" => UKLevelType.Secret, 
				"Sanctum" => UKLevelType.PrimeSanctum, 
				"CreditsMuseum2" => UKLevelType.Credits, 
				"Tutorial" => UKLevelType.Tutorial, 
				_ => UKLevelType.Unknown, 
			};
		}

		public static bool InLevel()
		{
			bool flag = CurrentLevelType == UKLevelType.MainMenu || CurrentLevelType == UKLevelType.Tutorial || CurrentLevelType == UKLevelType.Intro || CurrentLevelType == UKLevelType.Intermission || CurrentLevelType == UKLevelType.Secret || CurrentLevelType == UKLevelType.Unknown;
			return !flag;
		}
	}
	public static class MathTools
	{
		public static Vector3 Abs(this Vector3 vector)
		{
			//IL_0003: 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_0027: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			vector.x = Mathf.Abs(vector.x);
			vector.y = Mathf.Abs(vector.y);
			vector.z = Mathf.Abs(vector.z);
			return vector;
		}

		public static Vector3 CalculateProjectileArcPosition(Vector3 start, Vector3 end, float airTime, float normalizedTime)
		{
			//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_0004: 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_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)
			Vector3 velocityTrajectory = GetVelocityTrajectory(start, end, airTime);
			Vector3[] trajectoryPoints = GetTrajectoryPoints(start, Physics.gravity, velocityTrajectory, 0f, airTime);
			int num = Mathf.FloorToInt((float)trajectoryPoints.Length - 1f * normalizedTime);
			return trajectoryPoints[num];
		}

		public static bool ConeCheck(Vector3 direction1, Vector3 direction2, float maximumAngle = 90f)
		{
			//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)
			return Vector3.Angle(direction1, direction2) <= maximumAngle;
		}

		public static Vector3 GetVelocityTrajectory(Vector3 start, Vector3 end, float airTime)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002a: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			Vector3 gravity = Physics.gravity;
			airTime = ((airTime == 0f) ? (airTime + 0.0001f) : airTime);
			Vector3 val = Vector3.LerpUnclamped(start, end, 0.5f / airTime);
			val -= gravity * airTime;
			return val - start;
		}

		public static Quaternion WorldToLocalRotation(this Transform transform, Quaternion worldRotation)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.Inverse(transform.rotation) * worldRotation;
		}

		private static Vector3[] GetTrajectoryPoints(Vector3 start, Vector3 gravity, Vector3 direction, float drag, float flightTime)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_002a: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_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_004d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = direction;
			float num = flightTime / 100f;
			Vector3 val2 = start;
			List<Vector3> list = new List<Vector3>();
			for (int i = 0; i < 200; i++)
			{
				val *= 1f - num * drag;
				val += gravity * num;
				list.Add(val2);
				val2 += val * num;
			}
			return list.ToArray();
		}

		public static void Cycle(this ref int i, int amount, int max)
		{
			if (max <= 1)
			{
				i = 0;
				return;
			}
			i += amount;
			while (i >= max)
			{
				i -= max;
			}
			while (i < 0)
			{
				i = max - i;
			}
		}

		public static bool RandomChance(float percentage)
		{
			float num = percentage / 100f;
			return Random.value < num;
		}

		public static float GetLineDistance(this List<Vector3> vector3List)
		{
			//IL_003a: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			if (vector3List == null)
			{
				return 0f;
			}
			if (vector3List.Count <= 1)
			{
				return 0f;
			}
			for (int i = 0; i < vector3List.Count - 1; i++)
			{
				Vector3 val = vector3List[i + 1] - vector3List[i];
				float magnitude = ((Vector3)(ref val)).magnitude;
				num += magnitude;
			}
			return num;
		}

		public static Vector3 GetProjectileSpreadVector(float spread)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0032: Unknown result type (might be due to invalid IL or missing references)
			Vector2 insideUnitCircle = Random.insideUnitCircle;
			insideUnitCircle *= spread;
			Vector3 val = new Vector3(insideUnitCircle.x, insideUnitCircle.y, 1f - spread);
			return ((Vector3)(ref val)).normalized;
		}
	}
	public static class ParryTool
	{
		public static void ParryProjectile(Projectile proj, Vector3 parryDirection)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0111: 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)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			proj.hittingPlayer = false;
			proj.friendly = true;
			proj.speed *= 2f;
			proj.homingType = (HomingType)0;
			proj.explosionEffect = Prefabs.UK_Explosion.Asset;
			proj.precheckForCollisions = true;
			Rigidbody component = ((Component)proj).GetComponent<Rigidbody>();
			if (proj.playerBullet)
			{
				proj.boosted = true;
				SphereCollider component2 = ((Component)proj).GetComponent<SphereCollider>();
				component2.radius *= 4f;
				proj.damage = 0f;
				if (Object.op_Implicit((Object)(object)component))
				{
					component.collisionDetectionMode = (CollisionDetectionMode)2;
				}
				Color val = default(Color);
				((Color)(ref val))..ctor(1f, 0.35f, 0f);
				MeshRenderer val2 = default(MeshRenderer);
				if (((Component)proj).TryGetComponent<MeshRenderer>(ref val2) && Object.op_Implicit((Object)(object)((Renderer)val2).material) && ((Renderer)val2).material.HasProperty("_Color"))
				{
					((Renderer)val2).material.SetColor("_Color", val);
				}
				TrailRenderer val3 = default(TrailRenderer);
				if (((Component)proj).TryGetComponent<TrailRenderer>(ref val3))
				{
					Gradient val4 = new Gradient();
					val4.SetKeys((GradientColorKey[])(object)new GradientColorKey[2]
					{
						new GradientColorKey(val, 0f),
						new GradientColorKey(val, 1f)
					}, (GradientAlphaKey[])(object)new GradientAlphaKey[2]
					{
						new GradientAlphaKey(1f, 0f),
						new GradientAlphaKey(0f, 1f)
					});
					val3.colorGradient = val4;
				}
				Light val5 = default(Light);
				if (((Component)proj).TryGetComponent<Light>(ref val5))
				{
					val5.color = val;
				}
			}
			if (Object.op_Implicit((Object)(object)component))
			{
				component.constraints = (RigidbodyConstraints)112;
			}
			else
			{
				MonoSingleton<TimeController>.Instance.ParryFlash();
			}
			if (proj.explosive)
			{
				proj.explosive = false;
			}
			Rigidbody component3 = ((Component)proj).GetComponent<Rigidbody>();
			if (Object.op_Implicit((Object)(object)component3) && component3.useGravity)
			{
				component3.useGravity = false;
			}
			((Component)proj).transform.forward = parryDirection;
			if (proj.speed == 0f)
			{
				component3.velocity = parryDirection * 250f;
			}
			else if (proj.speed < 100f)
			{
				proj.speed = 100f;
			}
			if (proj.spreaded)
			{
				ProjectileSpread componentInParent = ((Component)proj).GetComponentInParent<ProjectileSpread>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					componentInParent.ParriedProjectile();
				}
			}
			((Component)proj).transform.SetParent((Transform)null, true);
		}

		public static void ParryCannonball(Cannonball cannonball, Vector3 direction)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			((Component)cannonball).transform.forward = direction;
			cannonball.Launch();
		}

		public static bool TryParryCannonball(Collider collider, Vector3 direction, out Cannonball cannonball)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			cannonball = null;
			Transform val = (((Object)(object)collider.attachedRigidbody != (Object)null) ? ((Component)collider.attachedRigidbody).transform : ((Component)collider).transform);
			ParryHelper val2 = default(ParryHelper);
			if (((Component)val).TryGetComponent<ParryHelper>(ref val2))
			{
				val = val2.target;
			}
			if (((Component)val).TryGetComponent<Cannonball>(ref cannonball) && cannonball.launchable)
			{
				ParryCannonball(cannonball, direction);
				return true;
			}
			return false;
		}

		public static bool TryParryProjectile(Collider collider, Vector3 direction, out Projectile foundProjectile)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			foundProjectile = null;
			Transform val = (((Object)(object)collider.attachedRigidbody != (Object)null) ? ((Component)collider.attachedRigidbody).transform : ((Component)collider).transform);
			ParryHelper val2 = default(ParryHelper);
			if (((Component)val).TryGetComponent<ParryHelper>(ref val2))
			{
				val = val2.target;
			}
			Projectile val3 = default(Projectile);
			if (((Component)val).TryGetComponent<Projectile>(ref val3))
			{
				foundProjectile = val3;
				ParryProjectile(val3, direction);
				return true;
			}
			return false;
		}
	}
	internal static class Paths
	{
		public const string SAVE_FILE_EXTENSION = ".ufg";

		public const string VOXEL_SAVE_FILE_EXTENSION = ".vwd";

		public static string GameFolder => Directory.GetParent(Application.dataPath).FullName;

		public static string ModFolder => Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		public static string DataFolder => Path.Combine(BepInExConfigFolder, "UltraFunGuns");

		public static string LegacyDataFolder => Path.Combine(ModFolder, "Data");

		public static string BepInExFolder => Path.Combine(GameFolder, "BepInEx");

		public static string BepInExConfigFolder => Path.Combine(BepInExFolder, "config");

		public static string SaveFilePath => Path.Combine(UFGSlotDataFolder, "save.ufg");

		public static string VoxelDataFolder => Path.Combine(DataFolder, "Voxel");

		public static string VoxelTexturesFolder => Path.Combine(VoxelDataFolder, "Textures");

		public static string VoxelBlockTexturesFolder => Path.Combine(VoxelTexturesFolder, "Block");

		public static string VoxelPlayerTexturesFolder => Path.Combine(VoxelTexturesFolder, "PlayerSkin");

		public static string VoxelSavesFolder => Path.Combine(UFGGlobalDataFolder, "VoxelSaves");

		public static string GameSavesFolder => GameProgressSaver.BaseSavePath;

		public static string UFGGlobalDataFolder => Path.Combine(GameSavesFolder, "UltraFunGuns");

		public static string UFGSlotDataFolder => Path.Combine(CurrentSaveSlotFolder, "UltraFunGuns");

		public static string CybergrindFolder => Path.Combine(GameFolder, "Cybergrind");

		public static string CybergrindTexturesFolder => Path.Combine(CybergrindFolder, "Textures");

		public static string CurrentSaveSlotFolder => GameProgressSaver.SavePath;

		public static void CheckFolders()
		{
			if (!Directory.Exists(DataFolder))
			{
				Directory.CreateDirectory(DataFolder);
			}
			if (Directory.Exists(LegacyDataFolder))
			{
				UltraFunGuns.Log.LogWarning("Found legacy UFG data. Moving to new location.");
				CopyFilesRecursively(LegacyDataFolder, DataFolder);
				UltraFunGuns.Log.LogWarning("Legacy data moved.");
				Directory.Delete(LegacyDataFolder, recursive: true);
			}
		}

		private static void CopyFilesRecursively(string sourcePath, string targetPath)
		{
			string[] directories = Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories);
			foreach (string text in directories)
			{
				Directory.CreateDirectory(text.Replace(sourcePath, targetPath));
			}
			string[] files = Directory.GetFiles(sourcePath, "*.*", SearchOption.AllDirectories);
			foreach (string text2 in files)
			{
				File.Copy(text2, text2.Replace(sourcePath, targetPath), overwrite: true);
			}
		}
	}
	public static class RandomExtensions
	{
		public static T RandomEntry<T>(this IEnumerable<T> elements)
		{
			return elements.ElementAt(Random.Range(0, elements.Count()));
		}
	}
	public static class UFGInput
	{
		[Configgable("Binds", "Slot 7 Key", 1, null)]
		public static ConfigKeybind Slot7Key = new ConfigKeybind((KeyCode)55);

		[Configgable("Binds", "Slot 8 Key", 1, null)]
		public static ConfigKeybind Slot8Key = new ConfigKeybind((KeyCode)56);

		[Configgable("Binds", "Slot 9 Key", 1, null)]
		public static ConfigKeybind Slot9Key = new ConfigKeybind((KeyCode)57);

		[Configgable("Binds", "Slot 10 Key", 1, null)]
		public static ConfigKeybind Slot10Key = new ConfigKeybind((KeyCode)48);

		[Configgable("Binds", "Secret Use", 0, null)]
		public static ConfigKeybind SecretButton = new ConfigKeybind((KeyCode)107);

		[Configgable("Binds", "Open UFG Inventory", 0, null)]
		public static ConfigKeybind OpenInventory = new ConfigKeybind((KeyCode)105);
	}
	public static class Visualizer
	{
		[UFGAsset("DebugSphere")]
		private static GameObject debugSphere;

		[UFGAsset("DebugCube")]
		private static GameObject debugCube;

		[UFGAsset("DebugLine")]
		private static GameObject debugLine;

		[UFGAsset("DebugTextPopup")]
		private static GameObject debugTextPopup;

		private static List<Vector3> currentPositions = new List<Vector3>();

		private static Dictionary<DebugTextPopup, Vector3> cachedTexts = new Dictionary<DebugTextPopup, Vector3>();

		private static bool visualizerEnabled => UltraFunGuns.DebugMode && Data.Config.Data.EnableVisualizer;

		[Commands.UFGDebugMethod("ToggleVisualizer", "Toggles Visual Debugging")]
		public static void ToggleVisualizer()
		{
			bool flag = !Data.Config.Data.EnableVisualizer;
			Data.Config.Data.EnableVisualizer = flag;
			Data.Config.Save();
			UltraFunGuns.Log.Log($"Visual Debugging: {flag}");
		}

		public static void DrawSphere(Vector3 position, float radius, float time = 1f)
		{
			//IL_0027: 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_003a: 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)
			if (visualizerEnabled && !((Object)(object)debugSphere == (Object)null))
			{
				Transform transform = Object.Instantiate<GameObject>(debugSphere, position, Quaternion.identity).transform;
				transform.localScale *= radius;
				((Component)transform).gameObject.AddComponent<DestroyAfterTime>().TimeLeft = time;
			}
		}

		public static void DrawLine(float time, params Vector3[] points)
		{
			//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)
			if (visualizerEnabled && !((Object)(object)debugLine == (Object)null))
			{
				if (points.Length < 2)
				{
					UltraFunGuns.Log.LogError("Not enough points provided for Visualizer.DrawLine");
					return;
				}
				DebugLine component = Object.Instantiate<GameObject>(debugLine, points[0], Quaternion.identity).GetComponent<DebugLine>();
				component.SetLine(points);
				DestroyAfterTime destroyAfterTime = ((Component)component).gameObject.AddComponent<DestroyAfterTime>();
				destroyAfterTime.TimeLeft = time;
			}
		}

		public static void DrawSphereCast(Vector3 origin, float radius, Vector3 direction, float maxRange, float time)
		{
			//IL_0072: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_004e: 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_0059: 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)
			if (!UltraFunGuns.DebugMode || !Data.Config.Data.EnableVisualizer)
			{
				return;
			}
			if (radius > 0f)
			{
				int num = Mathf.CeilToInt(maxRange / radius);
				Vector3 val = origin;
				for (int i = 0; i < num; i++)
				{
					DrawSphere(val, radius, time);
					val += ((Vector3)(ref direction)).normalized * radius;
				}
			}
			DrawRay(origin, ((Vector3)(ref direction)).normalized * maxRange, time);
		}

		public static void DrawRay(Vector3 position, Vector3 direction, float time = 0.4f)
		{
			//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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (UltraFunGuns.DebugMode && Data.Config.Data.EnableVisualizer)
			{
				DrawLine(time, position, position + direction);
			}
		}

		public static void DisplayTextAtPosition(string text, Vector3 position, Color color, float killTime = 3f)
		{
			//IL_0040: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (visualizerEnabled && (Object)(object)debugTextPopup != (Object)null)
			{
				while (currentPositions.Contains(position))
				{
					position += Random.onUnitSphere * 2f;
				}
				currentPositions.Add(position);
				GameObject val = Object.Instantiate<GameObject>(debugTextPopup, position, Quaternion.identity);
				DebugTextPopup component = val.GetComponent<DebugTextPopup>();
				cachedTexts.Add(component, position);
				component.SetText(text, color);
				component.SetKillTime(killTime);
			}
		}

		public static void ClearDebugText(DebugTextPopup textPopup)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (cachedTexts.ContainsKey(textPopup))
			{
				currentPositions.Remove(cachedTexts[textPopup]);
				cachedTexts.Remove(textPopup);
			}
		}
	}
}
namespace UltraFunGuns.Util
{
	public static class Cleaner
	{
		public static void Clean()
		{
			ICleanable[] array = Object.FindObjectsOfType<MonoBehaviour>().OfType<ICleanable>().ToArray();
			ICleanable[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i]?.Cleanup();
			}
		}
	}
	public static class TextureLoader
	{
		public struct TextureDownloadResult
		{
			public bool Success;

			public Texture2D Texture;
		}

		private static Texture2D[] cachedTextures = (Texture2D[])(object)new Texture2D[0];

		private static bool initialized = false;

		private static List<Texture2D> additionalTextures = new List<Texture2D>();

		public static string GetTextureFolder()
		{
			return Path.Combine(Paths.DataFolder, "Textures");
		}

		public static void Init()
		{
			if (!initialized)
			{
				InGameCheck.OnLevelChanged = (InGameCheck.OnLevelChangedHandler)Delegate.Combine(InGameCheck.OnLevelChanged, new InGameCheck.OnLevelChangedHandler(OnLevelChanged));
				initialized = true;
			}
		}

		private static void OnLevelChanged(InGameCheck.UKLevelType ltype)
		{
			if (InGameCheck.InLevel())
			{
				RefreshTextures();
			}
		}

		public static void RefreshTextures()
		{
			CleanCachedTextures();
			cachedTextures = FindTextures();
		}

		public static void SaveTexture(string path, Texture2D texture)
		{
			if (!((Object)(object)texture == (Object)null))
			{
				byte[] bytes = ImageConversion.EncodeToPNG(texture);
				if (!Directory.Exists(Path.GetDirectoryName(path)))
				{
					Directory.CreateDirectory(Path.GetDirectoryName(path));
				}
				File.WriteAllBytes(path, bytes);
			}
		}

		public static void DownloadTexture(string url, Action<TextureDownloadResult> onComplete)
		{
			StaticCoroutine.RunCoroutine(DownloadImageCoroutine(url, onComplete));
		}

		private static IEnumerator DownloadImageCoroutine(string url, Action<TextureDownloadResult> onComplete)
		{
			UnityWebRequest www = UnityWebRequestTexture.GetTexture(url);
			try
			{
				yield return www.SendWebRequest();
				if (www.isNetworkError)
				{
					onComplete(new TextureDownloadResult
					{
						Success = false
					});
					yield break;
				}
				Texture2D tex = DownloadHandlerTexture.GetContent(www);
				onComplete(new TextureDownloadResult
				{
					Success = true,
					Texture = tex
				});
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		public static bool TryLoadTexture(string path, out Texture2D tex, bool checkerIfNull = false)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			tex = null;
			if (!File.Exists(path))
			{
				UltraFunGuns.Log.Log("Invalid location: " + path);
				return false;
			}
			byte[] array = null;
			try
			{
				array = File.ReadAllBytes(path);
			}
			catch (Exception)
			{
				UltraFunGuns.Log.Log("Invalid path: " + path);
			}
			tex = new Texture2D(16, 16);
			if (!ImageConversion.LoadImage(tex, array))
			{
				UltraFunGuns.Log.Log("texture loading failed!");
				if (checkerIfNull)
				{
					Checker(ref tex);
				}
				return false;
			}
			return true;
		}

		public static Texture2D PullRandomTexture()
		{
			if (cachedTextures.Length != 0)
			{
				int num = Random.Range(0, cachedTextures.Length);
				return cachedTextures[num];
			}
			return null;
		}

		public static void AddTextureToCache(Texture2D texture)
		{
			List<Texture2D> list = new List<Texture2D>(cachedTextures);
			list.Add(texture);
			additionalTextures.Add(texture);
			cachedTextures = list.ToArray();
		}

		private static void CleanCachedTextures()
		{
			if (cachedTextures == null)
			{
				return;
			}
			int num = cachedTextures.Length;
			for (int i = 0; i < num; i++)
			{
				if ((Object)(object)cachedTextures[i] != (Object)null && !additionalTextures.Contains(cachedTextures[i]))
				{
					Object.Destroy((Object)(object)cachedTextures[i]);
				}
			}
			cachedTextures = null;
		}

		private static Texture2D[] FindTextures()
		{
			List<Texture2D> list = new List<Texture2D>();
			string path = GetTextureFolder();
			if (!Directory.Exists(path))
			{
				return Array.Empty<Texture2D>();
			}
			string[] files = Directory.GetFiles(path, "*.png", SearchOption.AllDirectories);
			string[] files2 = Directory.GetFiles(path, "*.jpg", SearchOption.AllDirectories);
			for (int i = 0; i < files.Length; i++)
			{
				if (TryLoadTexture(ImagePath(files[i]), out var tex))
				{
					list.Add(tex);
				}
			}
			for (int j = 0; j < files2.Length; j++)
			{
				if (TryLoadTexture(ImagePath(files2[j]), out var tex2))
				{
					list.Add(tex2);
				}
			}
			for (int k = 0; k < additionalTextures.Count; k++)
			{
				list.Add(additionalTextures[k]);
			}
			UltraFunGuns.Log.Log($"Found {list.Count} textures");
			return list.ToArray();
			string ImagePath(string filename)
			{
				string textureFolder = GetTextureFolder();
				return Path.Combine(path, filename);
			}
		}

		private static void Checker(ref Texture2D tex)
		{
			//IL_0037: 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_003c: 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)
			for (int i = 0; i < ((Texture)tex).height; i++)
			{
				for (int j = 0; j < ((Texture)tex).width; j++)
				{
					bool flag = j % 2 == 0;
					bool flag2 = i % 2 == 0;
					if (flag2 != flag)
					{
						flag = !flag;
					}
					Color val = (flag ? Color.white : Color.black);
					tex.SetPixel(j, i, val);
				}
			}
			tex.Apply();
		}
	}
	public static class VirtualWeapons
	{
	}
	public class VirtualExplosion
	{
		public Vector3 Position { get; private set; }

		public float Radius { get; private set; }

		public float Power { get; private set; }

		public VirtualExplosion(Vector3 position, float radius)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			Radius = radius;
		}

		public EnemyIdentifier[] GetAffectedEnemies()
		{
			//IL_0002: 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)
			Collider[] array = Physics.OverlapSphere(Position, Radius, LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)0)));
			UltraFunGuns.Log.LogWarning($"Hit Obejcts {array.Length}");
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			Collider[] array2 = array;
			foreach (Collider collider in array2)
			{
				if (collider.IsColliderEnemy(out var enemy) && !list.Contains(enemy))
				{
					list.Add(enemy);
				}
			}
			return list.ToArray();
		}
	}
}
namespace UltraFunGuns.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	public class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("UltraFunGuns.Properties.Resources", typeof(Resources).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		public static string customvoxels_readme => ResourceManager.GetString("customvoxels_readme", resourceCulture);

		public static byte[] UltraFunGuns
		{
			get
			{
				object @object = ResourceManager.GetObject("UltraFunGuns", resourceCulture);
				return (byte[])@object;
			}
		}

		public static string UnhardendedBundlesJson => ResourceManager.GetString("UnhardendedBundlesJson", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace UltraFunGuns.Patches
{
	public static class BreakablePatch
	{
		[HarmonyPatch(typeof(Breakable), "Start")]
		[HarmonyPostfix]
		public static void FixBreakable(Breakable __instance)
		{
			SimpleBreakable simpleBreakable = ((Component)__instance).gameObject.AddComponent<SimpleBreakable>();
			simpleBreakable.OnBreak = (Action)Delegate.Combine(simpleBreakable.OnBreak, new Action(__instance.Break));
		}

		[HarmonyPatch(typeof(Glass))]
		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static void FixGlass(Glass __instance)
		{
			SimpleBreakable simpleBreakable = ((Component)__instance).gameObject.AddComponent<SimpleBreakable>();
			simpleBreakable.OnBreak = (Action)Delegate.Combine(simpleBreakable.OnBreak, new Action(__instance.Shatter));
		}
	}
	public static class DebuggingPatches
	{
		[HarmonyPatch(typeof(GameStateManager))]
		public static class GameStateManagerPatch
		{
			[HarmonyPrefix]
			[HarmonyPatch("RegisterState")]
			private static bool Prefix1(GameStateManager __instance, GameState newState)
			{
				UltraFunGuns.Log.Log("--Registered State--");
				UltraFunGuns.Log.Log(FormatGameState(newState));
				return true;
			}

			[HarmonyPrefix]
			[HarmonyPatch("EvaluateState")]
			private static bool Prefix2(GameStateManager __instance, Dictionary<string, GameState> ___activeStates)
			{
				UltraFunGuns.Log.Log("--Evaluate State--");
				foreach (KeyValuePair<string, GameState> ___activeState in ___activeStates)
				{
					if (___activeState.Value != null)
					{
						UltraFunGuns.Log.Log(FormatGameState(___activeState.Value));
					}
				}
				return true;
			}

			private static string FormatGameState(GameState state)
			{
				//IL_003a: 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_0056: Unknown result type (might be due to invalid IL or missing references)
				if (state == null)
				{
					return "NULL-STATE.";
				}
				string text = $"GameState: {state.key} ({state.priority}) \n[{state.cursorLock}|{state.playerInputLock}|{state.cameraInputLock}]\n";
				if (state.trackedObjects != null)
				{
					for (int i = 0; i < state.trackedObjects.Length; i++)
					{
						if ((Object)(object)state.trackedObjects[i] != (Object)null)
						{
							text += $"Tracked {i + 1}: {((Object)state.trackedObjects[i]).name}\n";
						}
					}
					return text;
				}
				if ((Object)(object)state.trackedObject != (Object)null)
				{
					return text + "Tracked " + ((Object)state.trackedObject).name + "\n";
				}
				return text;
			}
		}
	}
	[HarmonyPatch(typeof(Explosion))]
	public static class ExplosionPatch
	{
		[HarmonyPatch("Collide")]
		[HarmonyPostfix]
		public static void PostCollide(Explosion __instance, Collider other, HashSet<int> ___hitColliders)
		{
			IExplodable explodable = default(IExplodable);
			if (!__instance.harmless && !((Object)(object)other == (Object)null) && !___hitColliders.Contains(((Object)other).GetInstanceID()) && ((Component)other).TryGetComponent<IExplodable>(ref explodable))
			{
				explodable.Explode(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(CanvasController))]
	public static class InstanceUIComponents
	{
		[UFGAsset("VoxelHandOverlay")]
		private static GameObject voxelHandOverlay;

		public static RectTransform Rect { get; private set; }

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void SpawnUI(CanvasController __instance)
		{
			Rect = ((Component)__instance).GetComponent<RectTransform>();
			RectTransform component = ((Component)__instance).GetComponent<RectTransform>();
			GameObject val = Object.Instantiate<GameObject>(voxelHandOverlay, (Transform)(object)component);
		}
	}
	public static class NoHighScorePatch
	{
		private static bool weaponsUsed;

		[HarmonyPatch(typeof(LeaderboardController), "SubmitCyberGrindScore")]
		[HarmonyPrefix]
		public static bool OnSubmitCyberGrindScore()
		{
			UltraFunGuns.Log.LogWarning("Trying To Submit Cybergrind Highscore.");
			if (weaponsUsed)
			{
				UltraFunGuns.Log.LogWarning($"Modded weapons used. Disqualifying Cybergrind submission. WeaponsUsed:{weaponsUsed}");
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(LeaderboardController), "SubmitLevelScore")]
		[HarmonyPrefix]
		public static bool OnSubmitLevelScore()
		{
			UltraFunGuns.Log.LogWarning($"Trying To Submit Level Highscore. WeaponsUsed:{weaponsUsed}");
			if (weaponsUsed)
			{
				UltraFunGuns.Log.LogWarning("Modded weapons used. Disqualifying Level submission.");
				return false;
			}
			return true;
		}

		public static void Init()
		{
			WeaponManager.OnWeaponsDeployed = (WeaponManager.OnWeaponsDeployedHandler)Delegate.Combine(WeaponManager.OnWeaponsDeployed, new WeaponManager.OnWeaponsDeployedHandler(CheckWeaponUsage));
			SceneManager.sceneLoaded += delegate
			{
				weaponsUsed = false;
			};
		}

		public static void CheckWeaponUsage(UFGWeapon[] weaponsDeployed)
		{
			bool flag = weaponsDeployed.Length != 0;
			if (InGameCheck.CurrentLevelType == InGameCheck.UKLevelType.Endless)
			{
				if (weaponsUsed)
				{
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("You must restart the level after disabling UFG weapons for your score to count.", "", "", 0, false, false, true);
				}
				else if (flag)
				{
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("Warning: having any UFG weapons enabled will prevent your CyberGrind score from being submitted.", "", "", 0, false, false, true);
				}
			}
			if (flag)
			{
				weaponsUsed = true;
			}
		}
	}
	[HarmonyPatch(typeof(WeaponIcon), "OnEnable")]
	public static class WeaponIconFix
	{
		public static bool Prefix(ref Renderer[] ___variationColoredRenderers, ref Image[] ___variationColoredImages, WeaponIcon __instance)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			if ((Object)(object)__instance.weaponDescriptor != (Object)null)
			{
				return true;
			}
			IUFGWeapon iUFGWeapon = default(IUFGWeapon);
			if (((Component)__instance).TryGetComponent<IUFGWeapon>(ref iUFGWeapon))
			{
				UFGWeapon weaponInfo = iUFGWeapon.GetWeaponInfo();
				__instance.weaponDescriptor = ScriptableObject.CreateInstance<WeaponDescriptor>();
				HydraLoader.dataRegistry.TryGetValue(weaponInfo.WeaponKey + "_weaponIcon", out var value);
				__instance.weaponDescriptor.icon = (Sprite)value;
				HydraLoader.dataRegistry.TryGetValue(weaponInfo.WeaponKey + "_glowIcon", out var value2);
				__instance.weaponDescriptor.glowIcon = (Sprite)value2;
				__instance.weaponDescriptor.variationColor = (WeaponVariant)weaponInfo.IconColor;
				if ((Object)(object)__instance.weaponDescriptor.icon == (Object)null)
				{
					HydraLoader.dataRegistry.TryGetValue("debug_weaponIcon", out var value3);
					__instance.weaponDescriptor.icon = (Sprite)value3;
				}
				if ((Object)(object)__instance.weaponDescriptor.glowIcon == (Object)null)
				{
					HydraLoader.dataRegistry.TryGetValue("debug_glowIcon", out var value4);
					__instance.weaponDescriptor.glowIcon = (Sprite)value4;
				}
			}
			___variationColoredRenderers = (Renderer[])((___variationColoredRenderers == null) ? ((Array)new Renderer[0]) : ((Array)___variationColoredRenderers));
			___variationColoredImages = (Image[])((___variationColoredImages == null) ? ((Array)new Image[0]) : ((Array)___variationColoredImages));
			return true;
		}
	}
}
namespace UltraFunGuns.Logging
{
	internal class BepInExLogger : Ilogger
	{
		private ManualLogSource _logger;

		public BepInExLogger(ManualLogSource logger)
		{
			_logger = logger;
		}

		public void Log(object obj)
		{
			_logger.LogInfo(obj);
		}

		public void LogError(object obj)
		{
			_logger.LogError(obj);
		}

		public void LogException(Exception ex)
		{
			_logger.LogError((object)("EXCEPTION: " + ex.Message));
			Debug.LogException(ex);
		}

		public void LogWarning(object obj)
		{
			_logger.LogWarning(obj);
		}
	}
	internal interface Ilogger
	{
		void Log(object obj);

		void LogWarning(object obj);

		void LogError(object obj);

		void LogException(Exception ex);
	}
}
namespace UltraFunGuns.Datas
{
	public class UKAsset<T> where T : Object
	{
		private T asset;

		private string path;

		public T Asset
		{
			get
			{
				if ((Object)(object)asset == (Object)null)
				{
					asset = LoadAsset<T>();
				}
				return asset;
			}
		}

		public string AssetName => Path.GetFileName(path);

		private T LoadAsset<T>() where T : Object
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Object val = (Object)(object)Addressables.LoadAssetAsync<T>((object)path).WaitForCompletion();
			return (T)(object)val;
		}

		public UKAsset(string key)
		{
			path = key;
		}
	}
}
namespace UltraFunGuns.CustomPlacedObjects
{
	public static class CustomPlacedObjectManager
	{
		private static Dictionary<string, List<ICustomPlacedObject>> objectsForScenes = new Dictionary<string, List<ICustomPlacedObject>>();

		public static void Init()
		{
			RegisterAllCustomPlacementObjects();
			InGameCheck.OnLevelChanged = (InGameCheck.OnLevelChangedHandler)Delegate.Combine(InGameCheck.OnLevelChanged, (InGameCheck.OnLevelChangedHandler)delegate
			{
				OnLevelChanged();
			});
		}

		private static void RegisterAllCustomPlacementObjects()
		{
			Type intf = typeof(ICustomPlacedObject);
			List<Type> list = (from p in Assembly.GetExecutingAssembly().GetTypes()
				where intf.IsAssignableFrom(p) && !p.IsInterface
				select p).ToList();
			foreach (Type item in list)
			{
				object obj = Activator.CreateInstance(item);
				ICustomPlacedObject customPlacedObject = obj as ICustomPlacedObject;
				RegisterPlacable(customPlacedObject);
			}
		}

		private static void OnLevelChanged()
		{
			string currentSceneName = InGameCheck.CurrentSceneName;
			if (!objectsForScenes.ContainsKey(currentSceneName))
			{
				return;
			}
			foreach (ICustomPlacedObject item in objectsForScenes[currentSceneName])
			{
				if (item.Place(currentSceneName))
				{
					UltraFunGuns.Log.Log(item.GetType().Name + ": Placed");
				}
				else
				{
					UltraFunGuns.Log.LogError(item.GetType().Name + ": Failed to place");
				}
			}
		}

		public static void RegisterPlacable(ICustomPlacedObject customPlacedObject)
		{
			string[] scenePlacementNames = customPlacedObject.GetScenePlacementNames();
			string[] array = scenePlacementNames;
			foreach (string key in array)
			{
				if (!objectsForScenes.ContainsKey(key))
				{
					objectsForScenes.Add(key, new List<ICustomPlacedObject>());
				}
				if (!objectsForScenes[key].Contains(customPlacedObject))
				{
					objectsForScenes[key].Add(customPlacedObject);
				}
			}
		}
	}
	public interface ICustomPlacedObject
	{
		string[] GetScenePlacementNames();

		bool Place(string sceneName);
	}
}
namespace UltraFunGuns.CustomPlacedObjects.Objects
{
	public class ArmorCubePlacer : ICustomPlacedObject
	{
		public string[] GetScenePlacementNames()
		{
			return new string[1] { "uk_construct" };
		}

		public bool Place(string sceneName)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!UltraFunGuns.DebugMode)
			{
				return false;
			}
			Place(new Vector3(0f, 15.5f, -20f), Vector3.zero);
			return true;
		}

		private void Place(Vector3 position, Vector3 rotation)
		{
			//IL_0027: 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_0041: 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_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_007d: 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_0098: 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_00c3: 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_00c5: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
			GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
			val.layer = 26;
			val2.layer = 25;
			val.transform.position = position;
			val2.transform.position = position;
			val.transform.rotation = Quaternion.Euler(rotation);
			val2.transform.rotation = Quaternion.Euler(rotation);
			BoxCollider val3 = default(BoxCollider);
			if (val2.TryGetComponent<BoxCollider>(ref val3))
			{
				((Collider)val3).enabled = false;
			}
			val2.transform.localScale = Vector3.one * 19.99f;
			val.transform.localScale = Vector3.one * 20f;
			GameObject val4 = GameObject.CreatePrimitive((PrimitiveType)0);
			val4.layer = 26;
			val4.transform.position = position + position;
			val4.transform.localScale = Vector3.one * 20f;
			GameObject val5 = GameObject.CreatePrimitive((PrimitiveType)0);
			val5.layer = 25;
			SphereCollider val6 = default(SphereCollider);
			if (val5.TryGetComponent<SphereCollider>(ref val6))
			{
				((Collider)val6).enabled = false;
			}
			val5.transform.position = position + position;
			val5.transform.localScale = Vector3.one * 19.99f;
		}
	}
	public class BasketballHoopPlacer : ICustomPlacedObject
	{
		[UFGAsset("BasketballHoop")]
		private static GameObject basketBallHoop;

		public string[] GetScenePlacementNames()
		{
			return new string[1] { "uk_construct" };
		}

		public bool Place(string sceneName)
		{
			//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)
			if (sceneName != "uk_construct" || (Object)(object)basketBallHoop == (Object)null)
			{
				return false;
			}
			Object.Instantiate<GameObject>(basketBallHoop, new Vector3(-136f, -1.5f, 362.2f), Quaternion.identity);
			return true;
		}
	}
	public class DeployWeaponsPickupPlacer : ICustomPlacedObject
	{
		public string[] GetScenePlacementNames()
		{
			return new string[1] { "Level 5-S" };
		}

		public bool Place(string sceneName)
		{
			//IL_0024: 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)
			if (sceneName == "Level 5-S")
			{
				Place(new Vector3(43.9f, -39.7f, 34.2f), new Vector3(7.14f, 0f, 0f));
				return true;
			}
			return false;
		}

		private void Place(Vector3 position, Vector3 rotation)
		{
			//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_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Prefabs.ForceDeployPickup == (Object)null))
			{
				Object.Instantiate<GameObject>(Prefabs.ForceDeployPickup, position, Quaternion.Euler(rotation));
			}
		}
	}
	public class HydraPlushPlacer : ICustomPlacedObject
	{
		public string[] GetScenePlacementNames()
		{
			return new string[2] { "uk_construct", "CreditsMuseum2" };
		}

		public bool Place(string sceneName)
		{
			//IL_0024: 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)
			if (sceneName != "CreditsMuseum2")
			{
				return false;
			}
			Place(new Vector3(231.2761f, 75.04001f, 710.4579f), new Vector3(0f, 90f, 0f));
			return true;
		}

		private void Place(Vector3 position, Vector3 rotation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Prefabs.HydraPlushie == (Object)null))
			{
				StaticCoroutine.DelayedExecute(delegate
				{
					//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_0012: Unknown result type (might be due to invalid IL or missing references)
					Object.Instantiate<GameObject>(Prefabs.HydraPlushie, position, Quaternion.Euler(rotation));
				}, 10f);
			}
		}
	}
}
namespace UltraFunGuns.Components
{
	public class Cleanable : MonoBehaviour, ICleanable
	{
		public void Cleanup()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public class CoinTarget : MonoBehaviour, ICoinTarget
	{
		private void Awake()
		{
			UltraFunGuns.Log.Log("CT: I'm in danger!");
		}

		public bool CanBeCoinTargeted(Coin coin)
		{
			return true;
		}

		public int GetCoinTargetPriority(Coin coin)
		{
			return 0;
		}

		public void OnCoinReflect(Coin coin, RevolverBeam beam)
		{
			UltraFunGuns.Log.Log("REFLECT COIN!");
			UltraFunGuns.Log.Log("Coin: " + ((Object)coin).name + " Beam: " + ((Object)beam).name);
		}

		public Transform GetCoinTargetPoint(Coin coin)
		{
			return ((Component)this).transform;
		}
	}
	public interface IBreakable
	{
		void Break();
	}
	public class WeaponTextureSwapper : MonoBehaviour
	{
		[SerializeField]
		private Renderer[] texturedRenderers;

		public string WeaponName = "UNKNOWN_WEAPON";

		private string texturePath => Path.Combine(TextureLoader.GetTextureFolder(), "WeaponTextures");

		private void Start()
		{
		}

		private void ProcessRenderer(Renderer renderer)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			if ((Object)(object)renderer == (Object)null || (Object)(object)renderer.material == (Object)null)
			{
				return;
			}
			Shader shader = renderer.material.shader;
			for (int i = 0; i < shader.GetPropertyCount(); i++)
			{
				string propertyName = shader.GetPropertyName(i);
				ShaderPropertyType propertyType = shader.GetPropertyType(i);
				if ((int)propertyType != 4)
				{
					continue;
				}
				Texture2D val = (Texture2D)renderer.material.GetTexture(propertyName);
				if ((Object)(object)val != (Object)null && ((Texture)val).isReadable)
				{
					if (!TryLoadTexture(WeaponName, ((Object)val).name, out var loadedTexture))
					{
						DumpTexture(val);
						continue;
					}
					((Texture)loadedTexture).filterMode = (FilterMode)0;
					renderer.material.SetTexture(propertyName, (Texture)(object)loadedTexture);
				}
			}
		}

		private void DumpTexture(Texture2D tex)
		{
			TextureLoader.SaveTexture(Path.Combine(texturePath, WeaponName, ((Object)tex).name + ".png"), tex);
		}

		private bool TryLoadTexture(string weaponName, string textureName, out Texture2D loadedTexture)
		{
			return TextureLoader.TryLoadTexture(Path.Combine(texturePath, weaponName, textureName + ".png"), out loadedTexture);
		}
	}
}
namespace UltraFunGuns.Components.Weapons.TireGun
{
	public class TireGun : UltraFunGunBase
	{
	}
	public class TireProjectile : MonoBehaviour
	{
		private Rigidbody rb;

		private bool grounded;

		private RaycastHit groundHit;

		private void Awake()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
		}

		private void OnCollisionEnter(Collision collision)
		{
			//IL_0007: 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)
			rb.velocity = Vector3.zero;
			rb.angularVelocity = Vector3.zero;
			rb.isKinematic = true;
			rb.useGravity = false;
			rb.detectCollisions = false;
			Object.Destroy((Object)(object)((Component)this).gameObject, 5f);
		}

		private void FixedUpdate()
		{
			bool flag = grounded;
			grounded = CheckGrounding();
		}

		private bool CheckGrounding()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			bool flag = Physics.BoxCast(((Component)this).transform.position, Vector3.one * 0.5f, Vector3.down, ref val, Quaternion.identity, 0.5f);
			if (flag)
			{
				groundHit = val;
			}
			return flag;
		}
	}
}
namespace UltraFunGuns.Components.Weapons.Melee
{
	[WeaponAbility("Assault", "Use the Aggromorph to it's fullest ability.", 0, RichTextColors.aqua)]
	[WeaponAbility("Morph", "Morph the weapon.", 1, RichTextColors.lime)]
	[UFGWeapon("Aggromorphic", "Aggromorph", 2, true, WeaponIconColor.Red, true, true)]
	public class Aggromorphic : UltraFunGunBase
	{
		public float damage = 1f;

		public float maxRange = 3.75f;

		private ActionCooldown fireCooldown = new ActionCooldown(0.3f, affectedByNoCooldownCheat: true);

		private ActionCooldown audioCooldown = new ActionCooldown(0.075f);

		private List<AggromorphicWeapon> subWeapons = new List<AggromorphicWeapon>();

		private int selectedWeapon;

		[UFGAsset("AggromorphicSwitch")]
		private static AudioClip switchSubWeaponSound;

		private bool hitEnvironmentAudio = false;

		private List<EnemyIdentifier> hitEnemies = new List<EnemyIdentifier>();

		private AggromorphicWeapon currentWeapon => subWeapons[selectedWeapon];

		public override void OnAwakeFinished()
		{
			subWeapons = new List<AggromorphicWeapon>(((Component)this).GetComponentsInChildren<AggromorphicWeapon>(true));
			foreach (AggromorphicWeapon subWeapon in subWeapons)
			{
				((Component)subWeapon).gameObject.SetActive(false);
			}
		}

		public override void GetInput()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && !om.paused && fireCooldown.CanFire())
			{
				fireCooldown.AddCooldown(currentWeapon.hitCooldown);
				Fire();
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.WasPerformedThisFrame && !om.paused)
			{
				EquipNext();
			}
			if (UFGInput.SecretButton.WasPeformed() && !om.paused)
			{
				currentWeapon?.SecretAnimation();
			}
		}

		private void EquipNext()
		{
			switchSubWeaponSound.PlayAudioClip(Random.Range(0.93f, 1.06f));
			AggromorphicWeapon aggromorphicWeapon = currentWeapon;
			if (aggromorphicWeapon != null)
			{
				((Component)aggromorphicWeapon).gameObject.SetActive(false);
			}
			int num = selectedWeapon;
			while (subWeapons.Count > 1 && selectedWeapon != num)
			{
				selectedWeapon = Random.Range(0, subWeapons.Count);
			}
			selectedWeapon = ((selectedWeapon + 1 < subWeapons.Count) ? (selectedWeapon + 1) : 0);
			AggromorphicWeapon aggromorphicWeapon2 = currentWeapon;
			if (aggromorphicWeapon2 != null)
			{
				((Component)aggromorphicWeapon2).gameObject.SetActive(true);
			}
		}

		private void Fire()
		{
			//IL_002c: 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_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_0066: Unknown result type (might be due to invalid IL or missing references)
			hitEnemies.Clear();
			hitEnvironmentAudio = false;
			currentWeapon?.Hit();
			if (HydraUtils.SphereCastAllMacro(mainCam.position, 0.75f, mainCam.forward, maxRange, out var hits))
			{
				RaycastHit[] array = hits;
				foreach (RaycastHit hit in array)
				{
					ProcessHit(hit);
				}
			}
		}

		private void ProcessHit(RaycastHit hit)
		{
			//IL_00a2: 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_00b3: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			Breakable val = default(Breakable);
			if (((Component)((RaycastHit)(ref hit)).collider).TryGetComponent<Breakable>(ref val))
			{
				val.Break();
			}
			Glass val2 = default(Glass);
			if (((Component)((RaycastHit)(ref hit)).collider).TryGetComponent<Glass>(ref val2))
			{
				val2.Shatter();
			}
			EnemyIdentifier enemy;
			if (((RaycastHit)(ref hit)).collider.IsColliderEnvironment() && !hitEnvironmentAudio)
			{
				if (audioCooldown.CanFire())
				{
					audioCooldown.AddCooldown();
					currentWeapon?.PlayHitAudio(((RaycastHit)(ref hit)).point, 0.6f);
				}
				GameObject val3 = Object.Instantiate<GameObject>(Prefabs.BulletImpactFX, ((RaycastHit)(ref hit)).point + ((RaycastHit)(ref hit)).normal * 0.01f, Quaternion.identity);
				val3.transform.up = ((RaycastHit)(ref hit)).normal;
				hitEnvironmentAudio = true;
			}
			else if (((RaycastHit)(ref hit)).collider.IsColliderEnemy(out enemy, filterDead: false) && !hitEnemies.Contains(enemy))
			{
				if (audioCooldown.CanFire())
				{
					audioCooldown.AddCooldown();
					currentWeapon?.PlayHitAudio(((RaycastHit)(ref hit)).point, 0.2f, flesh: true);
				}
				enemy.DeliverDamage(((Component)enemy).gameObject, mainCam.forward * 5000f, ((RaycastHit)(ref hit)).point, currentWeapon.damage, true, 1f, ((Component)this).gameObject, false, false);
				hitEnemies.Add(enemy);
			}
		}

		private void OnEnable()
		{
			AggromorphicWeapon aggromorphicWeapon = currentWeapon;
			if (aggromorphicWeapon != null)
			{
				((Component)aggromorphicWeapon).gameObject.SetActive(true);
			}
		}

		public override string GetDebuggingText()
		{
			string text = base.GetDebuggingText();
			if ((Object)(object)currentWeapon != (Object)null)
			{
				text = text + "SUBWEAPON: " + ((Object)((Component)currentWeapon).gameObject).name + "\n";
				text += $"SW_DAMAGE: {currentWeapon.damage}\n";
				text += $"SW_COOLDOWN: {currentWeapon.hitCooldown}\n";
			}
			text += $"CD: {fireCooldown}\n";
			return text + $"SUBWEAPON_COUNT: {subWeapons.Count}";
		}
	}
	public class AggromorphicWeapon : MonoBehaviour
	{
		[SerializeField]
		private AudioClip[] hitSounds;

		[SerializeField]
		private AudioClip[] hitEnemySounds;

		[SerializeField]
		private int hitAnimationVariations = 1;

		public float hitCooldown = 0.3f;

		public float damage = 1f;

		private Animator animator;

		private int currentHitAnimation = 0;

		private void Awake()
		{
			animator = ((Component)this).GetComponent<Animator>();
		}

		public void Hit()
		{
			animator.Play("Hit", 0, 0f);
			currentHitAnimation = ((Random.value >= 0.75f) ? Random.Range(0, hitAnimationVariations - 1) : ((currentHitAnimation + 1 <= hitAnimationVariations - 1) ? (currentHitAnimation + 1) : 0));
			animator.SetInteger("HitAnim", currentHitAnimation);
		}

		public void PlayHitAudio(Vector3 position, float spatial, bool flesh = false)
		{
			//IL_0051: 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)
			if (flesh)
			{
				hitEnemySounds[Random.Range(0, hitEnemySounds.Length)].PlayAudioClip(position, Random.Range(0.85f, 1.1f), 1f, spatial);
			}
			else
			{
				hitSounds[Random.Range(0, hitSounds.Length)].PlayAudioClip(position, Random.Range(0.85f, 1.1f), 1f, spatial);
			}
		}

		public void SecretAnimation()
		{
			animator.Play("Secret", 0, 0f);
		}

		private void OnEnable()
		{
			animator.Play("Equip", 0, 0f);
		}
	}
}
namespace UltraFunGuns.Components.Entity
{
	public class BasketballHoop : MonoBehaviour
	{
		[UFGAsset("MegaDunk")]
		private static AudioClip megaDunkAudio;

		[UFGAsset("BasketballScoreFX")]
		private static GameObject basketballScoreFX;

		[UFGAsset("CardboardTubeHit1")]
		private static AudioClip ballSpawnSound;

		[Configgable("Ballin", "Basketball Hoop In Sandbox", 0, null)]
		public static ConfigToggle EnableBasketballHoop = new ConfigToggle(true);

		[SerializeField]
		private Transform hoop;

		[SerializeField]
		private Rigidbody[] netRbs;

		[SerializeField]
		private Text scoreText;

		[SerializeField]
		private Text highScoreText;

		private bool ballInHoop;

		private List<Rigidbody> rbsInHoop = new List<Rigidbody>();

		private List<GameObject> spawnedBasketballs = new List<GameObject>();

		private int maxBalls = 69;

		private int currentScore;

		private float lastThrowDistance = 0f;

		private Vector3 lastBallVelo;

		[UFGAsset("ThrowableBasketball")]
		public static GameObject basketballPrefab { get; private set; }

		private int highScore => Data.SaveInfo.Data.basketballHighScore;

		public int CurrentScore
		{
			get
			{
				return currentScore;
			}
			private set
			{
				currentScore = value;
				UpdateScore();
			}
		}

		private void UpdateScore()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (currentScore > highScore)
			{
				if (highScore <= 99 && currentScore >= 100)
				{
					MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage($"You have unlocked <color=orange>BasketBall Skin</color> for the weapon <color=orange>ULTRABALLER</color> use <color=orange>{((ConfigValueElement<KeyCode>)(object)UFGInput.SecretButton).Value}</color> while using it to toggle it.", "", "", 0, false, false, true);
				}
				Data.SaveInfo.Data.basketballHighScore = currentScore;
			}
			highScoreText.text = ((highScore > 99999999) ? "ERROR" : highScore.ToString("000"));
			scoreText.text = ((currentScore > 99999999) ? "ERROR" : currentScore.ToString("000"));
		}

		private void Start()
		{
			ConfigToggle enableBasketballHoop = EnableBasketballHoop;
			((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged = (Action<bool>)Delegate.Combine(((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged, new Action<bool>(((Component)((Component)this).transform.root).gameObject.SetActive));
			UpdateScore();
			((Component)((Component)this).transform.root).gameObject.SetActive(((ConfigValueElement<bool>)(object)EnableBasketballHoop).Value);
		}

		public Vector3 GetHoopPos()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return hoop.position;
		}

		public void OnTriggerEnter(Collider col)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			UltraFunGuns.Log.Log("TRIGGERED " + ((Object)((Component)col).gameObject).name + " ENTER");
			if ((Object)(object)col.attachedRigidbody == (Object)null)
			{
				return;
			}
			Vector3 velocity = col.attachedRigidbody.velocity;
			MoveNet(((Vector3)(ref velocity)).magnitude * 18f);
			if (!((Object)(object)col.attachedRigidbody != (Object)null) || !rbsInHoop.Contains(col.attachedRigidbody))
			{
				Vector3 val = ((Component)col).gameObject.transform.position - GetHoopPos();
				float num = Vector3.Dot(((Vector3)(ref val)).normalized, Vector3.up);
				bool flag = IsBall(col, num > 0f);
				bool flag2 = rbsInHoop.Contains(col.attachedRigidbody);
				UltraFunGuns.Log.Log($"isball: {flag} inhoop: {ballInHoop} dot: {num > 0f}");
				if (flag && !flag2 && num > 0f)
				{
					rbsInHoop.Add(col.attachedRigidbody);
					UltraFunGuns.Log.Log("In da hoop " + ((Object)((Component)col).gameObject).name);
				}
				else
				{
					UltraFunGuns.Log.Log("Failed check " + ((Object)((Component)col).gameObject).name);
				}
			}
		}

		public void OnTriggerExit(Collider col)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_0095: 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_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)
			UltraFunGuns.Log.Log("TRIGGERED " + ((Object)((Component)col).gameObject).name + " EXIT");
			if ((Object)(object)col.attachedRigidbody == (Object)null)
			{
				return;
			}
			Vector3 velocity = col.attachedRigidbody.velocity;
			MoveNet(((Vector3)(ref velocity)).magnitude * 18f);
			bool flag = rbsInHoop.Contains(col.attachedRigidbody);
			if (flag)
			{
				Vector3 val = ((Component)col).gameObject.transform.position - GetHoopPos();
				float num = Vector3.Dot(((Vector3)(ref val)).normalized, Vector3.down);
				bool flag2 = IsBall(col, num < 0f);
				UltraFunGuns.Log.Log($"isball: {flag2} inhoop: {flag} dot: {num > 0f}");
				if (flag2 && num > 0f)
				{
					rbsInHoop.Remove(col.attachedRigidbody);
					UltraFunGuns.Log.Log("Out da " + ((Object)((Component)col).gameObject).name);
					Score();
				}
				else
				{
					UltraFunGuns.Log.Log("Failed check " + ((Object)((Component)col).gameObject).name);
				}
			}
		}

		private bool IsBall(Collider col, bool aboveHoop)
		{
			//IL_0026: 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_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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)col).gameObject.TryFindComponent<RealisticBasketball>(out var component))
			{
				lastThrowDistance = component.LastThrowDist;
				lastBallVelo = component.Rigidbody.velocity;
				if (Random.value > 0.5f && aboveHoop)
				{
					component.Rigidbody.velocity = GetHoopPos() - (component.Rigidbody.centerOfMass + ((Component)component).transform.position);
				}
				return true;
			}
			if (((Component)col).gameObject.TryFindComponent<ThrownDodgeball>(out var component2))
			{
				lastBallVelo = component2.rb.velocity;
				return true;
			}
			return false;
		}

		public void AnnihilateBalls()
		{
			for (int i = 0; i < spawnedBasketballs.Count; i++)
			{
				if (!((Object)(object)spawnedBasketballs[i] == (Object)null) && !((Object)(object)spawnedBasketballs[i].transform.parent != (Object)null))
				{
					Object.Destroy((Object)(object)spawnedBasketballs[i]);
				}
			}
			spawnedBasketballs = spawnedBasketballs.Where((GameObject x) => (Object)(object)x != (Object)null).ToList();
		}

		public void SpawnBall()
		{
			//IL_0007: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_005c: 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)
			Vector3 val = hoop.position + ((Component)hoop).transform.forward * 10f;
			ballSpawnSound.PlayAudioClip();
			Object.Instantiate<GameObject>(Prefabs.SmackFX, val, Quaternion.identity);
			GameObject item = Object.Instantiate<GameObject>(basketballPrefab, val, Quaternion.identity);
			spawnedBasketballs.Add(item);
			spawnedBasketballs = spawnedBasketballs.Where((GameObject x) => (Object)(object)x != (Object)null).ToList();
			if (spawnedBasketballs.Count > maxBalls)
			{
				if ((Object)(object)spawnedBasketballs[0].transform.parent != (Object)null)
				{
					GameObject item2 = spawnedBasketballs[0];
					spawnedBasketballs.Remove(item2);
					spawnedBasketballs.Add(item2);
				}
				Object.Destroy((Object)(object)spawnedBasketballs[0]);
			}
		}

		public void SlamDunk()
		{
			//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)
			lastBallVelo = Vector3.zero;
			lastThrowDistance = 75f;
			megaDunkAudio.PlayAudioClip();
			Score();
		}

		private void Score()
		{
			//IL_0017: 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_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)
			UltraFunGuns.Log.Log("SCORED");
			Object.Instantiate<GameObject>(basketballScoreFX, GetHoopPos(), Quaternion.identity);
			if (((Vector3)(ref lastBallVelo)).magnitude > 100f)
			{
				Object.Instantiate<GameObject>(Prefabs.UK_Explosion.Asset, GetHoopPos(), Quaternion.identity);
				megaDunkAudio.PlayAudioClip();
				MoveNet(500f);
				CurrentScore += 10;
			}
			else
			{
				CurrentScore += CalcScore(lastThrowDistance);
			}
		}

		private int CalcScore(float distance)
		{
			int num = 1;
			float num2 = distance % 25f;
			float num3 = distance - num2;
			int num4 = Mathf.FloorToInt(num3 / 25f);
			return num + ((num4 <= 0) ? 1 : (2 * num4));
		}

		private void MoveNet(float intensity)
		{
			//IL_0021: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody[] array = netRbs;
			foreach (Rigidbody val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 val2 = Random.onUnitSphere * intensity;
					val2.y = 0f;
					val.AddTorque(val2, (ForceMode)1);
				}
			}
		}

		private void OnDestroy()
		{
			ConfigToggle enableBasketballHoop = EnableBasketballHoop;
			((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged = (Action<bool>)Delegate.Remove(((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged, new Action<bool>(((Component)((Component)this).transform.root).gameObject.SetActive));
		}
	}
	public class ForceDeployPickup : MonoBehaviour
	{
		private bool pickedUp;

		private void OnTriggerEnter(Collider col)
		{
			if (((Component)col).gameObject.tag == "Player" || ((Object)((Component)col).gameObject).name.Contains("Player"))
			{
				Pickup();
			}
		}

		private void Pickup()
		{
			if (!pickedUp)
			{
				pickedUp = true;
				WeaponManager.ForceDeploy();
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
	public class RealisticBasketball : MonoBehaviour, ICleanable
	{
		private BasketballHoop hoop;

		private float rollSpeed = 4f;

		private bool goingBack = false;

		private UltraFunGunBase.ActionCooldown awayCheckCD = new UltraFunGunBase.ActionCooldown(20f);

		public Rigidbody Rigidbody { get; private set; }

		public Vector3 LastVelocity { get; private set; }

		public float LastThrowDist { get; private set; }

		private void Start()
		{
			Rigidbody = ((Component)this).GetComponent<Rigidbody>();
			hoop = Object.FindObjectOfType<BasketballHoop>();
			ConfigToggle enableBasketballHoop = BasketballHoop.EnableBasketballHoop;
			((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged = (Action<bool>)Delegate.Combine(((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged, new Action<bool>(((Component)this).gameObject.SetActive));
			((Component)this).gameObject.SetActive(((ConfigValueElement<bool>)(object)BasketballHoop.EnableBasketballHoop).Value);
		}

		private void Update()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//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 (goingBack && (Object)(object)Rigidbody != (Object)null && (Object)(object)hoop != (Object)null)
			{
				Vector3 val = hoop.GetHoopPos() - ((Component)this).transform.position;
				float magnitude = ((Vector3)(ref val)).magnitude;
				if (magnitude > 30f)
				{
					Rigidbody rigidbody = Rigidbody;
					Vector3 velocity = rigidbody.velocity;
					Vector3 val2 = ((Vector3)(ref val)).normalized * rollSpeed;
					Vector3 velocity2 = Rigidbody.velocity;
					rigidbody.velocity = velocity + val2 * (float)((((Vector3)(ref velocity2)).magnitude < 5f) ? 1 : 0);
				}
				else
				{
					goingBack = false;
				}
			}
		}

		private void LateUpdate()
		{
			//IL_0032: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Rigidbody != (Object)null)
			{
				LastVelocity = Rigidbody.velocity;
				CheckAway();
			}
			Vector3 position = ((Component)this).transform.position;
			if (((Vector3)(ref position)).sqrMagnitude > 25000000f)
			{
				Cleanup();
			}
		}

		private void CheckAway()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (awayCheckCD.CanFire() && !((Object)(object)hoop == (Object)null) && !((Object)(object)((Component)this).transform.parent != (Object)null))
			{
				awayCheckCD.AddCooldown();
				Vector3 val = hoop.GetHoopPos() - ((Component)this).transform.position;
				float magnitude = ((Vector3)(ref val)).magnitude;
				if (magnitude > 40f)
				{
					goingBack = true;
				}
			}
		}

		public void Thrown()
		{
			//IL_0019: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hoop != (Object)null)
			{
				Vector3 val = hoop.GetHoopPos() - ((Component)this).transform.position;
				LastThrowDist = ((Vector3)(ref val)).magnitude;
				CheckSlamDunk();
			}
		}

		private void CheckSlamDunk()
		{
			//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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0041: 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_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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			UltraFunGuns.Log.Log("Dunk: Trying!");
			CameraController instance = MonoSingleton<CameraController>.Instance;
			Vector3 hoopPos = hoop.GetHoopPos();
			Vector3 position = ((Component)instance).transform.position;
			Vector3 val = hoopPos - ((Component)instance).transform.position;
			Vector2 val2 = new Vector2(val.x, val.z);
			float num = Mathf.Abs(((Vector2)(ref val2)).magnitude);
			float num2 = Mathf.Abs(val.z);
			UltraFunGuns.Log.Log($"Dunk: Range {num}:{num2}!");
			if (num2 > 3.9f || num > 2.5f)
			{
				return;
			}
			UltraFunGuns.Log.Log("Dunk: In range!");
			NewMovement instance2 = MonoSingleton<NewMovement>.Instance;
			if (instance2.gc.onGround || !instance2.gc.heavyFall)
			{
				return;
			}
			UltraFunGuns.Log.Log("Dunk: Slamming!");
			Vector3 val3 = position - hoopPos;
			if (Vector3.Dot(((Vector3)(ref val3)).normalized, Vector3.up) >= -0.1f)
			{
				UltraFunGuns.Log.Log("Dunk: Above rim!");
				if (Vector3.Dot(((Vector3)(ref val)).normalized, ((Component)instance).transform.forward) > 0.83f)
				{
					hoop.SlamDunk();
					((Component)this).transform.position = hoopPos + Vector3.down * 0.25f;
					Rigidbody.velocity = Vector3.down * 100f;
				}
			}
		}

		public void Cleanup()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		private void OnDestroy()
		{
			ConfigToggle enableBasketballHoop = BasketballHoop.EnableBasketballHoop;
			((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged = (Action<bool>)Delegate.Remove(((ConfigValueElement<bool>)(object)enableBasketballHoop).OnValueChanged, new Action<bool>(((Component)this).gameObject.SetActive));
		}
	}
}
namespace UltraFunGuns.Components.Audio
{
	public class PhysicAudio : MonoBehaviour
	{
		private Rigidbody rb;

		[SerializeField]
		private AudioClip[] impactAudio;

		private float timeSinceLastImpact;

		private void Start()
		{
			rb = ((Component)this).GetComponent<Rigidbody>();
			if ((Object)(object)rb == (Object)null)
			{
				Object.Destroy((Object)(object)this);
			}
			impactAudio = impactAudio.Where((AudioClip x) => (Object)(object)x != (Object)null).ToArray();
		}

		private void Update()
		{
			timeSinceLastImpact += Time.deltaTime;
		}

		public void ImpactAt(Vector3 point, float magnitude)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!(magnitude < 3.5f))
			{
				AudioSource val = new GameObject("physAudio (" + ((Object)((Component)this).gameObject).name + ")").AddComponent<AudioSource>();
				((Component)val).transform.position = point;
				val.clip = impactAudio[Random.Range(0, impactAudio.Length)];
				val.volume = Mathf.Lerp(0.2f, 1f, magnitude / 60f);
				val.pitch = Mathf.Lerp(0.65f, 2.2f, (60f - magnitude) / 60f);
				val.spatialBlend = 1f;
				((Component)val).gameObject.SetActive(true);
				val.Play();
				((Component)val).gameObject.AddComponent<DestroyAfterTime>();
			}
		}

		private void OnCollisionEnter(Collision other)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			if (!rb.isKinematic)
			{
				Vector3 impulse = other.impulse;
				if (!(((Vector3)(ref impulse)).magnitude < 3f) && !(timeSinceLastImpact < 0.1f))
				{
					timeSinceLastImpact = 0f;
					ContactPoint contact = other.GetContact(0);
					Vector3 point = ((ContactPoint)(ref contact)).point;
					impulse = other.impulse;
					ImpactAt(point, ((Vector3)(ref impulse)).magnitude);
				}
			}
		}
	}
}