using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NLayer;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("JujutsuCube")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("JujutsuCube")]
[assembly: AssemblyTitle("JujutsuCube")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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;
		}
	}
}
namespace JujutsuCube
{
	[BepInPlugin("com.hellotest006.jujutsucube", "JujutsuCube", "1.0.0")]
	public class JujutsuCubePlugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(GunControl), "Start")]
		public static class GunControlStartPatch
		{
			private static void Postfix(GunControl __instance)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				//IL_0033: 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_006e: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("JujutsuCubeWeapon");
				val.transform.SetParent(((Component)__instance).transform);
				val.transform.localPosition = new Vector3(0.5f, -0.25f, 0.6f);
				val.transform.localRotation = Quaternion.identity;
				GameObject val2 = GameObject.CreatePrimitive((PrimitiveType)3);
				val2.transform.SetParent(val.transform);
				val2.transform.localPosition = Vector3.zero;
				Object.Destroy((Object)(object)val2.GetComponent<Collider>());
				Renderer component = val2.GetComponent<Renderer>();
				Material material = component.material;
				material.color = Color.white;
				Light val3 = val2.AddComponent<Light>();
				val3.color = Color.white;
				val3.intensity = 3f;
				val3.range = 8f;
				((Behaviour)val3).enabled = true;
				JujutsuCubeWeapon jujutsuCubeWeapon = val.AddComponent<JujutsuCubeWeapon>();
				jujutsuCubeWeapon.weaponModel = val2.transform;
				jujutsuCubeWeapon.weaponRenderer = component;
				jujutsuCubeWeapon.weaponLight = val3;
				jujutsuCubeWeapon.isPrimaryHeavy = primaryVariant.Value == 1;
				jujutsuCubeWeapon.UpdateWeaponVisuals();
				int num = weaponSlot.Value - 1;
				if (num < 0 || num >= __instance.slots.Count)
				{
					num = 4;
				}
				__instance.slots[num].Add(val);
				jujutsuCubeInstance = val;
				val.SetActive(false);
			}
		}

		public static ConfigEntry<int> weaponSlot;

		public static ConfigEntry<bool> showAoEVisual;

		public static ConfigEntry<bool> useOldCube;

		public static ConfigEntry<KeyCode> positiveModeKey;

		public static ConfigEntry<KeyCode> primaryVariantToggleKey;

		public static ConfigEntry<float> blackFlashChance;

		public static ConfigEntry<float> blackFlashChainModifierChance;

		public static ConfigEntry<float> positiveDamageMult;

		public static ConfigEntry<int> positiveHealPrimary;

		public static ConfigEntry<int> positiveHealSecondary;

		public static ConfigEntry<float> rctRadius;

		public static ConfigEntry<float> rctDuration;

		public static ConfigEntry<float> rctTickRate;

		public static ConfigEntry<float> domainMinHoldTime;

		public static ConfigEntry<float> domainDurationMultiplier;

		public static ConfigEntry<float> domainRadius;

		public static ConfigEntry<float> domainBlackFlashChance;

		public static ConfigEntry<int> primaryVariant;

		public static ConfigEntry<float> primaryDamageMin;

		public static ConfigEntry<float> primaryDamageMax;

		public static ConfigEntry<float> primaryRapidCooldown;

		public static ConfigEntry<float> primaryHeavyCooldown;

		public static ConfigEntry<float> primaryHeavyDamageMult;

		public static ConfigEntry<float> primaryAltChance;

		public static ConfigEntry<float> primaryLongHeight;

		public static ConfigEntry<float> primaryLongWidth;

		public static ConfigEntry<float> primaryWideHeight;

		public static ConfigEntry<float> primaryWideWidth;

		public static ConfigEntry<float> secondaryDamage;

		public static ConfigEntry<int> secondaryHits;

		public static ConfigEntry<float> secondaryChargeTime;

		public static ConfigEntry<float> secondaryWidth;

		public static ConfigEntry<float> secondaryAltChance;

		public static ConfigEntry<float> secondaryLongHeight;

		public static ConfigEntry<float> secondaryLongWidth;

		public static ConfigEntry<float> secondaryWideHeight;

		public static ConfigEntry<float> secondaryWideWidth;

		public static ConfigEntry<float> voiceLineVolumeBoost;

		public static GameObject jujutsuCubeInstance;

		public static Dictionary<string, List<AudioClip>> VoiceLines = new Dictionary<string, List<AudioClip>>();

		private readonly Harmony harmony = new Harmony("com.hellotest006.jujutsucube");

		private void Awake()
		{
			weaponSlot = ((BaseUnityPlugin)this).Config.Bind<int>("General", "WeaponSlot", 5, "Which slot (1-5)");
			showAoEVisual = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowAoEVisual", false, "Show secondary AoE sphere");
			useOldCube = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "UseOldCube", true, "If true, uses the old uniform cube that changes color instead of shape based on mode.");
			positiveModeKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "PositiveModeKey", (KeyCode)121, "Key to toggle Positive mode");
			primaryVariantToggleKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "PrimaryVariantToggleKey", (KeyCode)117, "Key to toggle Primary variant (Rapid/Heavy)");
			blackFlashChance = ((BaseUnityPlugin)this).Config.Bind<float>("BlackFlash", "BaseChance", 5f, "Base chance (%) to trigger a Black Flash");
			blackFlashChainModifierChance = ((BaseUnityPlugin)this).Config.Bind<float>("BlackFlash", "ChainModifierChance", 10f, "Chance (%) after a Black Flash chain ends to modify the base chance");
			positiveDamageMult = ((BaseUnityPlugin)this).Config.Bind<float>("PositiveMode", "DamageMultiplier", 16f, "Damage multiplier in Positive mode (16 = 1600%)");
			positiveHealPrimary = ((BaseUnityPlugin)this).Config.Bind<int>("PositiveMode", "PrimaryHeal", 5, "HP healed per primary hit in Positive mode");
			positiveHealSecondary = ((BaseUnityPlugin)this).Config.Bind<int>("PositiveMode", "SecondaryHeal", 20, "HP healed per secondary hit in Positive mode");
			rctRadius = ((BaseUnityPlugin)this).Config.Bind<float>("PositiveMode", "RCTRadius", 100f, "Radius of RCT health halve effect");
			rctDuration = ((BaseUnityPlugin)this).Config.Bind<float>("PositiveMode", "RCTDuration", 10f, "How many seconds RCT lasts");
			rctTickRate = ((BaseUnityPlugin)this).Config.Bind<float>("PositiveMode", "RCTTickRate", 0.5f, "Seconds between RCT health halving ticks");
			domainMinHoldTime = ((BaseUnityPlugin)this).Config.Bind<float>("DomainExpansion", "MinHoldTime", 10f, "Seconds required to hold middle mouse to cast domain");
			domainDurationMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("DomainExpansion", "DurationMultiplier", 1.5f, "Domain duration = HoldTime * Multiplier");
			domainRadius = ((BaseUnityPlugin)this).Config.Bind<float>("DomainExpansion", "Radius", 30f, "Radius of the domain sphere");
			domainBlackFlashChance = ((BaseUnityPlugin)this).Config.Bind<float>("DomainExpansion", "BlackFlashChance", 7.5f, "Chance (%) for domain ticks to trigger a Black Flash");
			primaryVariant = ((BaseUnityPlugin)this).Config.Bind<int>("Primary", "Variant", 1, "Default Primary variant: 0 = Rapid, 1 = Heavy");
			primaryDamageMin = ((BaseUnityPlugin)this).Config.Bind<float>("Primary", "MinDamage", 4f, (ConfigDescription)null);
			primaryDamageMax = ((BaseUnityPlugin)this).Config.Bind<float>("Primary", "MaxDamage", 6f, (ConfigDescription)null);
			primaryRapidCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Primary", "RapidCooldown", 0.08f, "Cooldown for Rapid variant");
			primaryHeavyCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Primary", "HeavyCooldown", 0.75f, "Cooldown for Heavy variant (0.5 to 1.0 recommended)");
			primaryHeavyDamageMult = ((BaseUnityPlugin)this).Config.Bind<float>("Primary", "HeavyDamageMultiplier", 10f, "Damage multiplier for Heavy variant (10 = 40-60 damage)");
			primaryAltChance = ((BaseUnityPlugin)this).Config.Bind<float>("Primary", "AltStyleChance", 0.5f, "Chance for 'minced'");
			primaryLongHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Primary.LongMode", "Height", 8f, "Vertical reach");
			primaryLongWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Primary.LongMode", "Width", 0.5f, "Horizontal thickness");
			primaryWideHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Primary.WideMode", "Height", 0.5f, "Vertical thickness");
			primaryWideWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Primary.WideMode", "Width", 12f, "Horizontal reach");
			secondaryDamage = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary", "Damage", 170f, (ConfigDescription)null);
			secondaryHits = ((BaseUnityPlugin)this).Config.Bind<int>("Secondary", "HitCount", 7, (ConfigDescription)null);
			secondaryChargeTime = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary", "ChargeTime", 1.5f, (ConfigDescription)null);
			secondaryWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary", "AoERadius", 10f, (ConfigDescription)null);
			secondaryAltChance = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary", "AltStyleChance", 0.2f, "Chance for 'kitkat'd'");
			secondaryLongHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary.LongMode", "Height", 25f, "Vertical reach");
			secondaryLongWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary.LongMode", "Width", 2f, "Horizontal thickness");
			secondaryWideHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary.WideMode", "Height", 2f, "Vertical thickness");
			secondaryWideWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Secondary.WideMode", "Width", 35f, "Horizontal reach");
			voiceLineVolumeBoost = ((BaseUnityPlugin)this).Config.Bind<float>("VoiceLines", "VolumeBoost", 2f, "Volume multiplier for voice lines. 1 = Normal, 2 = Twice as loud, 3 = Three times as loud. May cause audio distortion if too high.");
			LoadEmbeddedVoiceLines();
			harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Jujutsu Cube Loaded!");
		}

		private void LoadEmbeddedVoiceLines()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			string[] array = manifestResourceNames;
			foreach (string text in array)
			{
				if (!text.StartsWith("JujutsuCube.voices."))
				{
					continue;
				}
				try
				{
					using Stream stream = executingAssembly.GetManifestResourceStream(text);
					string path = text.Substring("JujutsuCube.voices.".Length);
					path = Path.GetFileNameWithoutExtension(path);
					string text2 = Regex.Replace(path, "\\d+$", "");
					MpegFile val = new MpegFile(stream);
					try
					{
						List<float> list = new List<float>();
						float[] array2 = new float[1024];
						int num;
						while ((num = val.ReadSamples(array2, 0, array2.Length)) > 0)
						{
							for (int j = 0; j < num; j++)
							{
								list.Add(array2[j]);
							}
						}
						while ((num = val.ReadSamples(array2, 0, array2.Length)) > 0)
						{
							for (int k = 0; k < num; k++)
							{
								list.Add(array2[k]);
							}
						}
						float value = voiceLineVolumeBoost.Value;
						if (value > 1f)
						{
							for (int l = 0; l < list.Count; l++)
							{
								list[l] = (float)Math.Tanh(list[l] * value);
							}
						}
						if (list.Count != 0)
						{
							int channels = val.Channels;
							int sampleRate = val.SampleRate;
							int num2 = list.Count / channels;
							AudioClip val2 = AudioClip.Create(path, num2, channels, sampleRate, false);
							val2.SetData(list.ToArray(), 0);
							if (!VoiceLines.ContainsKey(text2))
							{
								VoiceLines[text2] = new List<AudioClip>();
							}
							VoiceLines[text2].Add(val2);
							((BaseUnityPlugin)this).Logger.LogInfo((object)("Loaded voice line: " + path + " -> Key: " + text2));
						}
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("Failed to load voice line " + text + ": " + ex.Message));
				}
			}
		}

		private void Update()
		{
			if (!Input.GetKeyDown((KeyCode)55))
			{
				return;
			}
			GunControl instance = MonoSingleton<GunControl>.Instance;
			if (!((Object)(object)instance != (Object)null) || !instance.activated || !((Object)(object)jujutsuCubeInstance != (Object)null))
			{
				return;
			}
			for (int i = 0; i < instance.slots.Count; i++)
			{
				if (instance.slots[i].Contains(jujutsuCubeInstance))
				{
					instance.SwitchWeapon(i, (int?)instance.slots[i].IndexOf(jujutsuCubeInstance), false, false, false);
					break;
				}
			}
		}
	}
	public class VoiceLineRequest
	{
		public AudioClip Clip;

		public string Key;
	}
	public class JujutsuCubeWeapon : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <FireSecondary>d__46 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public JujutsuCubeWeapon <>4__this;

			private float <damageMult>5__1;

			private string <bfStyleName>5__2;

			private int <bfStylePoints>5__3;

			private bool <triggerEffects>5__4;

			private Transform <cam>5__5;

			private Vector3 <lockedCamPos>5__6;

			private Vector3 <lockedCamForward>5__7;

			private Quaternion <lockedCamRot>5__8;

			private Vector3 <lockedSphereOrigin>5__9;

			private RaycastHit <firstHit>5__10;

			private string <secStyleName>5__11;

			private int <secStylePoints>5__12;

			private float <range>5__13;

			private float <width>5__14;

			private float <height>5__15;

			private Vector3 <halfExtents>5__16;

			private float <finalSecDamage>5__17;

			private GameObject <aoeVis>5__18;

			private Material <aoeMat>5__19;

			private int <i>5__20;

			private Vector3 <center>5__21;

			private Collider[] <slashHits>5__22;

			private List<EnemyIdentifier> <slashHitEnemies>5__23;

			private Collider[] <colliders>5__24;

			private List<EnemyIdentifier> <sphereHitEnemies>5__25;

			private List<EnemyIdentifier> <allHitEnemies>5__26;

			private Collider[] <>s__27;

			private int <>s__28;

			private Collider <col>5__29;

			private EnemyIdentifier <eid>5__30;

			private Collider[] <>s__31;

			private int <>s__32;

			private Collider <col>5__33;

			private EnemyIdentifier <eid>5__34;

			private Vector3 <direction>5__35;

			private List<EnemyIdentifier>.Enumerator <>s__36;

			private EnemyIdentifier <eid>5__37;

			private int <healAmt>5__38;

			private List<EnemyIdentifier>.Enumerator <>s__39;

			private EnemyIdentifier <eid>5__40;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<bfStyleName>5__2 = null;
				<cam>5__5 = null;
				<secStyleName>5__11 = null;
				<aoeVis>5__18 = null;
				<aoeMat>5__19 = null;
				<slashHits>5__22 = null;
				<slashHitEnemies>5__23 = null;
				<colliders>5__24 = null;
				<sphereHitEnemies>5__25 = null;
				<allHitEnemies>5__26 = null;
				<>s__27 = null;
				<col>5__29 = null;
				<eid>5__30 = null;
				<>s__31 = null;
				<col>5__33 = null;
				<eid>5__34 = null;
				<>s__36 = default(List<EnemyIdentifier>.Enumerator);
				<eid>5__37 = null;
				<>s__39 = default(List<EnemyIdentifier>.Enumerator);
				<eid>5__40 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0104: 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_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_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_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_0324: 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_033b: 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_0345: Unknown result type (might be due to invalid IL or missing references)
				//IL_034c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0352: Unknown result type (might be due to invalid IL or missing references)
				//IL_0358: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: 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_01bb: 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_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0495: Unknown result type (might be due to invalid IL or missing references)
				//IL_0415: Unknown result type (might be due to invalid IL or missing references)
				//IL_041f: Unknown result type (might be due to invalid IL or missing references)
				//IL_042f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0549: 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_0554: Unknown result type (might be due to invalid IL or missing references)
				//IL_0559: Unknown result type (might be due to invalid IL or missing references)
				//IL_055d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0562: Unknown result type (might be due to invalid IL or missing references)
				//IL_0568: Unknown result type (might be due to invalid IL or missing references)
				//IL_056d: Unknown result type (might be due to invalid IL or missing references)
				//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_05b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_05bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_057f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0584: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0808: Unknown result type (might be due to invalid IL or missing references)
				//IL_0812: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.ProcessBlackFlash(out <damageMult>5__1, out <bfStyleName>5__2, out <bfStylePoints>5__3, out <triggerEffects>5__4);
					if (<triggerEffects>5__4)
					{
						<>4__this.TriggerBlackFlashEffects();
					}
					<>4__this.isFiringSecondary = true;
					<>4__this.PlayVoiceLine(<>4__this.isWideMode ? "SecondaryWide" : "SecondaryLong", "Secondary");
					<cam>5__5 = ((Component)MonoSingleton<CameraController>.Instance).transform;
					<lockedCamPos>5__6 = <cam>5__5.position;
					<lockedCamForward>5__7 = <cam>5__5.forward;
					<lockedCamRot>5__8 = <cam>5__5.rotation;
					<lockedSphereOrigin>5__9 = <lockedCamPos>5__6 + <lockedCamForward>5__7 * 100f;
					if (Physics.Raycast(<lockedCamPos>5__6, <lockedCamForward>5__7, ref <firstHit>5__10, 100000f, <>4__this.hitMask))
					{
						<lockedSphereOrigin>5__9 = ((RaycastHit)(ref <firstHit>5__10)).point + ((RaycastHit)(ref <firstHit>5__10)).normal * 0.5f;
					}
					if (JujutsuCubePlugin.showAoEVisual.Value)
					{
						<aoeVis>5__18 = GameObject.CreatePrimitive((PrimitiveType)0);
						Object.Destroy((Object)(object)<aoeVis>5__18.GetComponent<Collider>());
						<aoeVis>5__18.transform.position = <lockedSphereOrigin>5__9;
						<aoeVis>5__18.transform.localScale = Vector3.one * JujutsuCubePlugin.secondaryWidth.Value * 2f;
						<aoeMat>5__19 = <aoeVis>5__18.GetComponent<Renderer>().material;
						<aoeMat>5__19.color = new Color(1f, 1f, 1f, 0.5f);
						Object.Destroy((Object)(object)<aoeVis>5__18, 0.4f);
						<aoeVis>5__18 = null;
						<aoeMat>5__19 = null;
					}
					<secStyleName>5__11 = ((Random.value <= JujutsuCubePlugin.secondaryAltChance.Value) ? "kitkat'd" : "World Cutting Slash");
					<secStylePoints>5__12 = ((<secStyleName>5__11 == "kitkat'd") ? 750 : 550);
					<range>5__13 = 300f;
					<width>5__14 = (<>4__this.isWideMode ? JujutsuCubePlugin.secondaryWideWidth.Value : JujutsuCubePlugin.secondaryLongWidth.Value);
					<height>5__15 = (<>4__this.isWideMode ? JujutsuCubePlugin.secondaryWideHeight.Value : JujutsuCubePlugin.secondaryLongHeight.Value);
					<halfExtents>5__16 = new Vector3(<width>5__14 / 2f, <height>5__15 / 2f, <range>5__13 / 2f);
					<finalSecDamage>5__17 = JujutsuCubePlugin.secondaryDamage.Value * <damageMult>5__1;
					<i>5__20 = 0;
					break;
				case 1:
					<>1__state = -1;
					<slashHits>5__22 = null;
					<slashHitEnemies>5__23 = null;
					<colliders>5__24 = null;
					<sphereHitEnemies>5__25 = null;
					<allHitEnemies>5__26 = null;
					<i>5__20++;
					break;
				}
				if (<i>5__20 < JujutsuCubePlugin.secondaryHits.Value)
				{
					<center>5__21 = <lockedCamPos>5__6 + <lockedCamForward>5__7 * (<range>5__13 / 2f);
					<slashHits>5__22 = Physics.OverlapBox(<center>5__21, <halfExtents>5__16, <lockedCamRot>5__8, <>4__this.hitMask, (QueryTriggerInteraction)2);
					<slashHitEnemies>5__23 = new List<EnemyIdentifier>();
					<>s__27 = <slashHits>5__22;
					for (<>s__28 = 0; <>s__28 < <>s__27.Length; <>s__28++)
					{
						<col>5__29 = <>s__27[<>s__28];
						<eid>5__30 = <>4__this.GetEnemy(((Component)<col>5__29).gameObject);
						if ((Object)(object)<eid>5__30 != (Object)null && !<slashHitEnemies>5__23.Contains(<eid>5__30))
						{
							<eid>5__30.hitter = "railgun";
							<eid>5__30.DeliverDamage(((Component)<col>5__29).gameObject, <lockedCamForward>5__7 * 50f, ((Component)<eid>5__30).transform.position, <finalSecDamage>5__17, true, 0f, (GameObject)null, false, false);
							<slashHitEnemies>5__23.Add(<eid>5__30);
						}
						<eid>5__30 = null;
						<col>5__29 = null;
					}
					<>s__27 = null;
					<colliders>5__24 = Physics.OverlapSphere(<lockedSphereOrigin>5__9, JujutsuCubePlugin.secondaryWidth.Value, <>4__this.hitMask, (QueryTriggerInteraction)2);
					<sphereHitEnemies>5__25 = new List<EnemyIdentifier>();
					<>s__31 = <colliders>5__24;
					for (<>s__32 = 0; <>s__32 < <>s__31.Length; <>s__32++)
					{
						<col>5__33 = <>s__31[<>s__32];
						<eid>5__34 = <>4__this.GetEnemy(((Component)<col>5__33).gameObject);
						if ((Object)(object)<eid>5__34 != (Object)null && !<sphereHitEnemies>5__25.Contains(<eid>5__34))
						{
							Vector3 val = ((Component)<eid>5__34).transform.position - <lockedSphereOrigin>5__9;
							<direction>5__35 = ((Vector3)(ref val)).normalized;
							if (<direction>5__35 == Vector3.zero)
							{
								<direction>5__35 = <lockedCamForward>5__7;
							}
							<eid>5__34.hitter = "railgun";
							<eid>5__34.DeliverDamage(((Component)<col>5__33).gameObject, <direction>5__35 * 50f, <lockedSphereOrigin>5__9, <finalSecDamage>5__17, true, 0f, (GameObject)null, false, false);
							<sphereHitEnemies>5__25.Add(<eid>5__34);
						}
						<eid>5__34 = null;
						<col>5__33 = null;
					}
					<>s__31 = null;
					<allHitEnemies>5__26 = new List<EnemyIdentifier>(<slashHitEnemies>5__23);
					<>s__36 = <sphereHitEnemies>5__25.GetEnumerator();
					try
					{
						while (<>s__36.MoveNext())
						{
							<eid>5__37 = <>s__36.Current;
							if (!<allHitEnemies>5__26.Contains(<eid>5__37))
							{
								<allHitEnemies>5__26.Add(<eid>5__37);
							}
							<eid>5__37 = null;
						}
					}
					finally
					{
						((IDisposable)<>s__36).Dispose();
					}
					<>s__36 = default(List<EnemyIdentifier>.Enumerator);
					if (<allHitEnemies>5__26.Count > 0)
					{
						if (<>4__this.isPositiveMode)
						{
							<healAmt>5__38 = JujutsuCubePlugin.positiveHealSecondary.Value * <allHitEnemies>5__26.Count;
							MonoSingleton<NewMovement>.Instance.GetHealth(<healAmt>5__38, false, false, true);
						}
						<>s__39 = <allHitEnemies>5__26.GetEnumerator();
						try
						{
							while (<>s__39.MoveNext())
							{
								<eid>5__40 = <>s__39.Current;
								MonoSingleton<StyleHUD>.Instance.AddPoints(<secStylePoints>5__12, <secStyleName>5__11, ((Component)<>4__this).gameObject, <eid>5__40, -1, "", "");
								if (!<>4__this.isPositiveMode && !string.IsNullOrEmpty(<bfStyleName>5__2))
								{
									MonoSingleton<StyleHUD>.Instance.AddPoints(<bfStylePoints>5__3, <bfStyleName>5__2, ((Component)<>4__this).gameObject, <eid>5__40, -1, "", "");
								}
								<eid>5__40 = null;
							}
						}
						finally
						{
							((IDisposable)<>s__39).Dispose();
						}
						<>s__39 = default(List<EnemyIdentifier>.Enumerator);
					}
					<>2__current = (object)new WaitForSeconds(0.05f);
					<>1__state = 1;
					return true;
				}
				<>4__this.isFiringSecondary = false;
				return false;
			}

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

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

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

			private object <>2__current;

			public JujutsuCubeWeapon <>4__this;

			private VoiceLineRequest <request>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0186;
				case 1:
					<>1__state = -1;
					goto IL_0066;
				case 2:
					{
						<>1__state = -1;
						goto IL_016a;
					}
					IL_0186:
					if (<>4__this.voiceQueue.Count > 0)
					{
						<request>5__1 = <>4__this.voiceQueue[0];
						goto IL_0066;
					}
					<>4__this.voiceQueueCoroutine = null;
					return false;
					IL_016a:
					if (<>4__this.audioSource.isPlaying)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<request>5__1 = null;
					goto IL_0186;
					IL_0066:
					if (<>4__this.audioSource.isPlaying)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					if (<>4__this.voiceCooldowns.ContainsKey(<request>5__1.Key) && Time.unscaledTime < <>4__this.voiceCooldowns[<request>5__1.Key])
					{
						<>4__this.voiceQueue.RemoveAt(0);
						goto IL_0186;
					}
					<>4__this.audioSource.clip = <request>5__1.Clip;
					<>4__this.audioSource.Play();
					<>4__this.voiceCooldowns[<request>5__1.Key] = Time.unscaledTime + <request>5__1.Clip.length + 2f;
					<>4__this.voiceQueue.RemoveAt(0);
					goto IL_016a;
				}
			}

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

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

		public Transform weaponModel;

		public Renderer weaponRenderer;

		public Light weaponLight;

		private AudioSource audioSource;

		private List<VoiceLineRequest> voiceQueue = new List<VoiceLineRequest>();

		private Dictionary<string, float> voiceCooldowns = new Dictionary<string, float>();

		private Coroutine voiceQueueCoroutine;

		private float primaryTimer = 0f;

		private float chargeTimer = 0f;

		private float kickTimer = 0f;

		private float hitstopTimer = 0f;

		private bool isHitstopped = false;

		private bool isBlackFlashing = false;

		private bool isFiringSecondary = false;

		private bool isWideMode = false;

		private bool isPositiveMode = false;

		public bool isPrimaryHeavy = false;

		private float currentBlackFlashChance;

		private int blackFlashChainsLeft = 0;

		private float domainHoldTimer = 0f;

		private bool isDomainCharging = false;

		private bool isDomainActive = false;

		private float domainActiveTimer = 0f;

		private float domainTickTimer = 0f;

		private GameObject chargeSphereObj;

		private GameObject activeDomainObj;

		private bool isRCTActive = false;

		private float rctActiveTimer = 0f;

		private float rctTickTimer = 0f;

		private GameObject activeRCTObj;

		private int hitMask = LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)0)) | LayerMask.op_Implicit(LayerMaskDefaults.Get((LMD)1));

		private void Start()
		{
			currentBlackFlashChance = JujutsuCubePlugin.blackFlashChance.Value;
			audioSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			audioSource.spatialBlend = 0f;
			audioSource.volume = 1f;
			audioSource.playOnAwake = false;
			audioSource.ignoreListenerVolume = true;
			audioSource.bypassEffects = true;
			audioSource.bypassListenerEffects = true;
			audioSource.bypassReverbZones = true;
		}

		public void PlayVoiceLine(params string[] keys)
		{
			foreach (string key in keys)
			{
				if (JujutsuCubePlugin.VoiceLines == null || !JujutsuCubePlugin.VoiceLines.ContainsKey(key))
				{
					continue;
				}
				List<AudioClip> list = JujutsuCubePlugin.VoiceLines[key];
				if (list.Count <= 0 || (voiceCooldowns.ContainsKey(key) && Time.unscaledTime < voiceCooldowns[key]))
				{
					continue;
				}
				AudioClip val = list[Random.Range(0, list.Count)];
				if ((Object)(object)val != (Object)null)
				{
					voiceQueue.Add(new VoiceLineRequest
					{
						Clip = val,
						Key = key
					});
					if (voiceQueueCoroutine == null)
					{
						voiceQueueCoroutine = ((MonoBehaviour)this).StartCoroutine(ProcessVoiceLineQueue());
					}
					break;
				}
			}
		}

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

		public void UpdateWeaponVisuals()
		{
			//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_007b: 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_003f: 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_0074: 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_005a: 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_011b: 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_00cd: 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_0181: 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)
			if ((Object)(object)weaponModel == (Object)null)
			{
				return;
			}
			weaponModel.localRotation = Quaternion.identity;
			Color white = Color.white;
			white = (Color)((!isPositiveMode) ? (isPrimaryHeavy ? Color.red : (isWideMode ? Color.white : Color.black)) : (isPrimaryHeavy ? new Color(1f, 0.6f, 0f) : Color.yellow));
			if (JujutsuCubePlugin.useOldCube.Value)
			{
				weaponModel.localScale = new Vector3(0.4f, 0.4f, 0.4f);
				if ((Object)(object)weaponRenderer != (Object)null)
				{
					weaponRenderer.material.color = white;
				}
			}
			else
			{
				if (isWideMode)
				{
					weaponModel.localScale = new Vector3(0.6f, 0.1f, 0.4f);
				}
				else
				{
					weaponModel.localScale = new Vector3(0.1f, 0.6f, 0.4f);
				}
				if ((Object)(object)weaponRenderer != (Object)null)
				{
					weaponRenderer.material.color = white;
				}
			}
			if ((Object)(object)weaponLight != (Object)null && !isBlackFlashing)
			{
				weaponLight.color = (isPositiveMode ? Color.yellow : Color.white);
				weaponLight.intensity = (isPositiveMode ? 5f : 3f);
				weaponLight.range = 8f;
			}
		}

		private void OnDisable()
		{
			//IL_0122: 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)
			chargeTimer = 0f;
			kickTimer = 0f;
			hitstopTimer = 0f;
			isBlackFlashing = false;
			isFiringSecondary = false;
			isDomainCharging = false;
			if (isHitstopped)
			{
				Time.timeScale = 1f;
				isHitstopped = false;
			}
			if ((Object)(object)chargeSphereObj != (Object)null)
			{
				Object.Destroy((Object)(object)chargeSphereObj);
			}
			if ((Object)(object)activeDomainObj != (Object)null)
			{
				Object.Destroy((Object)(object)activeDomainObj);
			}
			isDomainActive = false;
			if ((Object)(object)activeRCTObj != (Object)null)
			{
				Object.Destroy((Object)(object)activeRCTObj);
			}
			isRCTActive = false;
			((MonoBehaviour)this).StopAllCoroutines();
			voiceQueueCoroutine = null;
			voiceQueue.Clear();
			UpdateWeaponVisuals();
			if ((Object)(object)weaponLight != (Object)null)
			{
				weaponLight.intensity = 3f;
				weaponLight.range = 8f;
				weaponLight.color = (isPositiveMode ? Color.yellow : Color.white);
			}
			if ((Object)(object)audioSource != (Object)null)
			{
				audioSource.Stop();
			}
		}

		private void Update()
		{
			//IL_0025: 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_00c4: 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_018b: 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_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: 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)
			if (!MonoSingleton<GunControl>.Instance.activated || isFiringSecondary)
			{
				return;
			}
			((Component)this).transform.localScale = Vector3.one;
			((Component)weaponModel).gameObject.SetActive(true);
			Vector3 localPosition = default(Vector3);
			((Vector3)(ref localPosition))..ctor(0.5f, -0.25f, 0.6f);
			if (hitstopTimer > 0f)
			{
				hitstopTimer -= Time.unscaledDeltaTime;
				Time.timeScale = 0.01f;
				isHitstopped = true;
				((Component)this).transform.localPosition = localPosition;
			}
			else
			{
				if (isHitstopped)
				{
					Time.timeScale = 1f;
					isHitstopped = false;
					((Component)this).transform.localPosition = localPosition;
				}
				if (isBlackFlashing)
				{
					isBlackFlashing = false;
					UpdateWeaponVisuals();
				}
			}
			if (Input.GetKeyDown(JujutsuCubePlugin.positiveModeKey.Value))
			{
				isPositiveMode = !isPositiveMode;
				CancelDomainCharge();
				if (isDomainActive)
				{
					if ((Object)(object)activeDomainObj != (Object)null)
					{
						Object.Destroy((Object)(object)activeDomainObj);
					}
					isDomainActive = false;
				}
				if (isRCTActive)
				{
					if ((Object)(object)activeRCTObj != (Object)null)
					{
						Object.Destroy((Object)(object)activeRCTObj);
					}
					isRCTActive = false;
				}
				UpdateWeaponVisuals();
			}
			if (Input.GetKeyDown(JujutsuCubePlugin.primaryVariantToggleKey.Value))
			{
				isPrimaryHeavy = !isPrimaryHeavy;
				UpdateWeaponVisuals();
			}
			float y = Input.mouseScrollDelta.y;
			if (y != 0f)
			{
				if (isPositiveMode)
				{
					FirePrimary();
					primaryTimer = 0.01f;
				}
				else
				{
					isWideMode = !isWideMode;
					UpdateWeaponVisuals();
				}
			}
			if (isPositiveMode)
			{
				if (Input.GetMouseButtonDown(2) && !isRCTActive)
				{
					ActivateRCT();
				}
			}
			else if (Input.GetMouseButton(2))
			{
				domainHoldTimer += Time.deltaTime;
				isDomainCharging = true;
				if ((Object)(object)chargeSphereObj == (Object)null)
				{
					chargeSphereObj = GameObject.CreatePrimitive((PrimitiveType)0);
					Object.Destroy((Object)(object)chargeSphereObj.GetComponent<Collider>());
					chargeSphereObj.transform.SetParent(weaponModel);
					chargeSphereObj.transform.localPosition = new Vector3(0f, 0f, 1.5f);
					Material material = chargeSphereObj.GetComponent<Renderer>().material;
					material.color = new Color(0f, 0f, 0f, 0.8f);
				}
				float num = Mathf.Clamp01(domainHoldTimer / JujutsuCubePlugin.domainMinHoldTime.Value);
				chargeSphereObj.transform.localScale = Vector3.one * num * 1.5f;
			}
			else if (isDomainCharging)
			{
				if (domainHoldTimer >= JujutsuCubePlugin.domainMinHoldTime.Value)
				{
					ActivateDomain();
				}
				else
				{
					CancelDomainCharge();
				}
			}
			if (isDomainActive)
			{
				domainActiveTimer -= Time.deltaTime;
				domainTickTimer -= Time.deltaTime;
				if (domainActiveTimer <= 0f)
				{
					if ((Object)(object)activeDomainObj != (Object)null)
					{
						Object.Destroy((Object)(object)activeDomainObj);
					}
					isDomainActive = false;
				}
				else if (domainTickTimer <= 0f)
				{
					domainTickTimer = 0.2f;
					DomainDamageTick();
				}
			}
			if (isRCTActive)
			{
				rctActiveTimer -= Time.deltaTime;
				rctTickTimer -= Time.deltaTime;
				if (rctActiveTimer <= 0f)
				{
					if ((Object)(object)activeRCTObj != (Object)null)
					{
						Object.Destroy((Object)(object)activeRCTObj);
					}
					isRCTActive = false;
				}
				else if (rctTickTimer <= 0f)
				{
					rctTickTimer = JujutsuCubePlugin.rctTickRate.Value;
					RCTTick();
				}
			}
			primaryTimer -= Time.deltaTime;
			kickTimer -= Time.deltaTime;
			if ((Object)(object)weaponModel != (Object)null)
			{
				if (kickTimer > 0f)
				{
					weaponModel.localPosition = new Vector3(0f, 0f, -0.15f);
				}
				else
				{
					weaponModel.localPosition = Vector3.zero;
				}
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire1.IsPressed && primaryTimer <= 0f)
			{
				FirePrimary();
				primaryTimer = (isPrimaryHeavy ? JujutsuCubePlugin.primaryHeavyCooldown.Value : JujutsuCubePlugin.primaryRapidCooldown.Value);
				kickTimer = (isPrimaryHeavy ? 0.15f : 0.05f);
			}
			if (MonoSingleton<InputManager>.Instance.InputSource.Fire2.IsPressed)
			{
				chargeTimer += Time.deltaTime;
				if ((Object)(object)weaponModel != (Object)null)
				{
					float num2 = 600f + chargeTimer * 400f;
					if (isWideMode)
					{
						weaponModel.Rotate(0f, num2 * Time.deltaTime, 0f, (Space)1);
					}
					else
					{
						weaponModel.Rotate(0f, 0f, num2 * Time.deltaTime, (Space)1);
					}
				}
				if ((Object)(object)weaponLight != (Object)null)
				{
					float num3 = Mathf.Clamp01(chargeTimer / JujutsuCubePlugin.secondaryChargeTime.Value);
					weaponLight.intensity = (isPositiveMode ? 5f : 3f) + num3 * 15f;
					weaponLight.range = 8f + num3 * 15f;
				}
			}
			else
			{
				if (chargeTimer >= JujutsuCubePlugin.secondaryChargeTime.Value)
				{
					((MonoBehaviour)this).StartCoroutine(FireSecondary());
				}
				chargeTimer = 0f;
				UpdateWeaponVisuals();
			}
		}

		private void ActivateRCT()
		{
			//IL_00c6: 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_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_01b6: Unknown result type (might be due to invalid IL or missing references)
			isRCTActive = true;
			rctActiveTimer = JujutsuCubePlugin.rctDuration.Value;
			rctTickTimer = 0f;
			PlayVoiceLine("RCT");
			NewMovement instance = MonoSingleton<NewMovement>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				float num = 200f - (float)instance.hp;
				if (num > 0f)
				{
					instance.GetHealth((int)num, false, false, true);
				}
			}
			if ((Object)(object)activeRCTObj == (Object)null)
			{
				activeRCTObj = GameObject.CreatePrimitive((PrimitiveType)0);
				Object.Destroy((Object)(object)activeRCTObj.GetComponent<Collider>());
				activeRCTObj.transform.SetParent(((Component)instance).transform);
				activeRCTObj.transform.localPosition = Vector3.zero;
				activeRCTObj.transform.localScale = Vector3.one * JujutsuCubePlugin.rctRadius.Value * 2f;
				Material material = activeRCTObj.GetComponent<Renderer>().material;
				material.SetInt("_Surface", 1);
				material.SetInt("_Blend", 0);
				material.SetInt("_Cull", 0);
				material.SetInt("_ZWrite", 0);
				material.SetInt("_SrcBlend", 5);
				material.SetInt("_DstBlend", 10);
				material.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
				material.DisableKeyword("_ALPHATEST_ON");
				material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				material.renderQueue = 3000;
				material.SetColor("_BaseColor", new Color(1f, 1f, 0f, 0.15f));
			}
		}

		private void RCTTick()
		{
			//IL_0021: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)activeRCTObj == (Object)null)
			{
				return;
			}
			Collider[] array = Physics.OverlapSphere(activeRCTObj.transform.position, JujutsuCubePlugin.rctRadius.Value, hitMask, (QueryTriggerInteraction)2);
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				EnemyIdentifier enemy = GetEnemy(((Component)val).gameObject);
				if ((Object)(object)enemy != (Object)null && !list.Contains(enemy))
				{
					float num = enemy.health / 2f;
					if (num > 0f)
					{
						enemy.hitter = "railgun";
						enemy.DeliverDamage(((Component)enemy).gameObject, Vector3.zero, ((Component)enemy).transform.position, num, true, 0f, (GameObject)null, false, false);
					}
					MonoSingleton<StyleHUD>.Instance.AddPoints(50, "RCT", ((Component)this).gameObject, enemy, -1, "", "");
					list.Add(enemy);
				}
			}
			if (list.Count > 0)
			{
				MonoSingleton<NewMovement>.Instance.GetHealth(1, false, false, true);
			}
		}

		private void ActivateDomain()
		{
			//IL_00a5: 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_00ca: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			isDomainActive = true;
			isDomainCharging = false;
			domainActiveTimer = domainHoldTimer * JujutsuCubePlugin.domainDurationMultiplier.Value;
			domainTickTimer = 0f;
			PlayVoiceLine("Domain");
			if ((Object)(object)chargeSphereObj != (Object)null)
			{
				Object.Destroy((Object)(object)chargeSphereObj);
			}
			activeDomainObj = GameObject.CreatePrimitive((PrimitiveType)0);
			Object.Destroy((Object)(object)activeDomainObj.GetComponent<Collider>());
			activeDomainObj.transform.SetParent(((Component)MonoSingleton<NewMovement>.Instance).transform);
			activeDomainObj.transform.localPosition = Vector3.zero;
			activeDomainObj.transform.localScale = Vector3.one * JujutsuCubePlugin.domainRadius.Value * 2f;
			Material material = activeDomainObj.GetComponent<Renderer>().material;
			material.SetInt("_Surface", 1);
			material.SetInt("_Blend", 0);
			material.SetInt("_Cull", 0);
			material.SetInt("_ZWrite", 0);
			material.SetInt("_SrcBlend", 5);
			material.SetInt("_DstBlend", 10);
			material.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
			material.DisableKeyword("_ALPHATEST_ON");
			material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
			material.renderQueue = 3000;
			material.SetColor("_BaseColor", new Color(0f, 0f, 0f, 0.4f));
		}

		private void CancelDomainCharge()
		{
			isDomainCharging = false;
			domainHoldTimer = 0f;
			if ((Object)(object)chargeSphereObj != (Object)null)
			{
				Object.Destroy((Object)(object)chargeSphereObj);
			}
		}

		private void DomainDamageTick()
		{
			//IL_0023: 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_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)activeDomainObj == (Object)null)
			{
				return;
			}
			Collider[] array = Physics.OverlapSphere(activeDomainObj.transform.position, JujutsuCubePlugin.domainRadius.Value, hitMask, (QueryTriggerInteraction)2);
			bool flag = !isPositiveMode && Random.value * 100f < JujutsuCubePlugin.domainBlackFlashChance.Value;
			float num = (flag ? 2.5f : (isPositiveMode ? JujutsuCubePlugin.positiveDamageMult.Value : 1f));
			if (flag)
			{
				isBlackFlashing = true;
				if ((Object)(object)weaponLight != (Object)null)
				{
					weaponLight.color = Color.magenta;
					weaponLight.intensity = 100f;
					weaponLight.range = 50f;
				}
				PlayVoiceLine("BlackFlash");
			}
			float num2 = Random.Range(JujutsuCubePlugin.primaryDamageMin.Value, JujutsuCubePlugin.primaryDamageMax.Value) * num;
			if (!isPositiveMode && isPrimaryHeavy)
			{
				num2 *= JujutsuCubePlugin.primaryHeavyDamageMult.Value;
			}
			float num3 = JujutsuCubePlugin.secondaryDamage.Value * num;
			float num4 = num2 + num3;
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				EnemyIdentifier enemy = GetEnemy(((Component)val).gameObject);
				if ((Object)(object)enemy != (Object)null && !list.Contains(enemy))
				{
					enemy.hitter = "shotgun";
					enemy.DeliverDamage(((Component)val).gameObject, Vector3.up * 50f, ((Component)enemy).transform.position, num4, true, 0f, (GameObject)null, false, false);
					list.Add(enemy);
				}
			}
			if (list.Count <= 0)
			{
				return;
			}
			if (isPositiveMode)
			{
				int num5 = (JujutsuCubePlugin.positiveHealPrimary.Value + JujutsuCubePlugin.positiveHealSecondary.Value) * list.Count;
				MonoSingleton<NewMovement>.Instance.GetHealth(num5, false, false, true);
				MonoSingleton<StyleHUD>.Instance.AddPoints(15 * list.Count, "dismantled", ((Component)this).gameObject, (EnemyIdentifier)null, -1, "", "");
				return;
			}
			string text = (flag ? "black flash" : "dismantled");
			int num6 = (flag ? 750 : 15);
			string text2 = (flag ? "black flash again" : "World Cutting Slash");
			int num7 = (flag ? 350 : 550);
			foreach (EnemyIdentifier item in list)
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(num6, text, ((Component)this).gameObject, item, -1, "", "");
				MonoSingleton<StyleHUD>.Instance.AddPoints(num7, text2, ((Component)this).gameObject, item, -1, "", "");
			}
		}

		private void ProcessBlackFlash(out float damageMult, out string bfStyleName, out int bfStylePoints, out bool triggerEffects)
		{
			damageMult = 1f;
			bfStyleName = "";
			bfStylePoints = 0;
			triggerEffects = false;
			if (isPositiveMode)
			{
				damageMult = JujutsuCubePlugin.positiveDamageMult.Value;
			}
			else if (blackFlashChainsLeft > 0)
			{
				damageMult = 2.5f;
				bfStyleName = "black flash again";
				bfStylePoints = 350;
				triggerEffects = false;
				blackFlashChainsLeft--;
				if (blackFlashChainsLeft == 0 && Random.value * 100f < JujutsuCubePlugin.blackFlashChainModifierChance.Value)
				{
					if (Random.value < 0.5f)
					{
						currentBlackFlashChance += 0.35f;
					}
					else
					{
						currentBlackFlashChance -= 0.75f;
					}
					currentBlackFlashChance = Mathf.Clamp(currentBlackFlashChance, 0.1f, 100f);
				}
			}
			else if (Random.value * 100f < currentBlackFlashChance)
			{
				damageMult = 2.5f;
				bfStyleName = "black flash";
				bfStylePoints = 750;
				triggerEffects = true;
				blackFlashChainsLeft = Random.Range(1, 37);
			}
		}

		private void TriggerBlackFlashEffects()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			hitstopTimer = 0.25f;
			isBlackFlashing = true;
			if ((Object)(object)weaponLight != (Object)null)
			{
				weaponLight.color = Color.magenta;
				weaponLight.intensity = 100f;
				weaponLight.range = 50f;
			}
			PlayVoiceLine("BlackFlash");
		}

		private EnemyIdentifier GetEnemy(GameObject obj)
		{
			EnemyIdentifierIdentifier val = default(EnemyIdentifierIdentifier);
			if (obj.TryGetComponent<EnemyIdentifierIdentifier>(ref val))
			{
				return val.eid;
			}
			EnemyIdentifier componentInChildren = obj.GetComponentInChildren<EnemyIdentifier>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren;
			}
			componentInChildren = obj.GetComponentInParent<EnemyIdentifier>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren;
			}
			return null;
		}

		private void FirePrimary()
		{
			//IL_009f: 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_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_00de: 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_00e4: 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_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			ProcessBlackFlash(out var damageMult, out var bfStyleName, out var bfStylePoints, out var triggerEffects);
			if (triggerEffects)
			{
				TriggerBlackFlashEffects();
			}
			PlayVoiceLine(isPrimaryHeavy ? "PrimaryHeavy" : "PrimaryRapid", "Primary");
			Transform transform = ((Component)MonoSingleton<CameraController>.Instance).transform;
			float num = 200f;
			float num2 = (isWideMode ? JujutsuCubePlugin.primaryWideWidth.Value : JujutsuCubePlugin.primaryLongWidth.Value);
			float num3 = (isWideMode ? JujutsuCubePlugin.primaryWideHeight.Value : JujutsuCubePlugin.primaryLongHeight.Value);
			Vector3 val = transform.position + transform.forward * (num / 2f);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(num2 / 2f, num3 / 2f, num / 2f);
			Collider[] array = Physics.OverlapBox(val, val2, transform.rotation, hitMask, (QueryTriggerInteraction)2);
			List<EnemyIdentifier> list = new List<EnemyIdentifier>();
			Collider[] array2 = array;
			foreach (Collider val3 in array2)
			{
				EnemyIdentifier enemy = GetEnemy(((Component)val3).gameObject);
				if ((Object)(object)enemy != (Object)null && !list.Contains(enemy))
				{
					float num4 = Random.Range(JujutsuCubePlugin.primaryDamageMin.Value, JujutsuCubePlugin.primaryDamageMax.Value);
					if (isPrimaryHeavy && !isPositiveMode)
					{
						num4 *= JujutsuCubePlugin.primaryHeavyDamageMult.Value;
					}
					num4 *= damageMult;
					enemy.hitter = "shotgun";
					enemy.DeliverDamage(((Component)val3).gameObject, transform.forward * 5f, ((Component)enemy).transform.position, num4, true, 0f, (GameObject)null, false, false);
					list.Add(enemy);
				}
			}
			if (list.Count <= 0)
			{
				return;
			}
			if (isPositiveMode)
			{
				int num5 = JujutsuCubePlugin.positiveHealPrimary.Value * list.Count;
				MonoSingleton<NewMovement>.Instance.GetHealth(num5, false, false, true);
			}
			string text = ((Random.value <= JujutsuCubePlugin.primaryAltChance.Value) ? "minced" : "dismantled");
			int num6 = ((text == "minced") ? 20 : 15);
			foreach (EnemyIdentifier item in list)
			{
				MonoSingleton<StyleHUD>.Instance.AddPoints(num6, text, ((Component)this).gameObject, item, -1, "", "");
				if (!isPositiveMode && !string.IsNullOrEmpty(bfStyleName))
				{
					MonoSingleton<StyleHUD>.Instance.AddPoints(bfStylePoints, bfStyleName, ((Component)this).gameObject, item, -1, "", "");
				}
			}
		}

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