using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using EntityStates;
using GojoSatoruMod.Components;
using GojoSatoruMod.Content;
using GojoSatoruMod.States;
using GojoSatoruMod.Sukuna.Visuals;
using GojoSatoruMod.Visuals;
using On.RoR2;
using R2API;
using R2API.Utils;
using RoR2;
using RoR2.Skills;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RyomenSukuna")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.1.0")]
[assembly: AssemblyInformationalVersion("1.3.1+4bfea71e3ca88fd38135ba73f70b6801fa7b0366")]
[assembly: AssemblyProduct("RyomenSukuna")]
[assembly: AssemblyTitle("RyomenSukuna")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace GojoSatoruMod.Visuals
{
	internal sealed class RuntimeFugaPillar : MonoBehaviour
	{
		private const int TongueCount = 18;

		private const int CoreCount = 6;

		private const int HazeCount = 8;

		private const int Segments = 14;

		private const float ClimbSeconds = 0.62f;

		private const float EmberInterval = 0.5f;

		private const float SmokeInterval = 1.1f;

		private readonly List<Material> materials = new List<Material>();

		private LineRenderer[] tongues;

		private LineRenderer[] core;

		private LineRenderer[] haze;

		private Material tongueMaterial;

		private Material coreMaterial;

		private Material hazeMaterial;

		private Color tongueBase;

		private Color coreBase;

		private Color hazeBase;

		private Vector3 root;

		private float radius;

		private float height;

		private float ignition;

		private float fade = 1f;

		private float age;

		private float emberStopwatch;

		private float smokeStopwatch;

		internal void Initialize(Vector3 basePosition, float effectRadius)
		{
			//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_001f: 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_0050: 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_008b: 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_00c6: 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_0129: 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_013f: 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)
			root = basePosition;
			radius = Mathf.Max(1f, effectRadius);
			((Component)this).transform.position = root;
			tongueBase = new Color(1f, 0.42f, 0.03f, 0.95f);
			tongueMaterial = Dress("matSukunaFugaPillarTongues", tongueBase, 1.6f);
			coreBase = new Color(1f, 0.93f, 0.72f, 0.95f);
			coreMaterial = Dress("matSukunaFugaPillarCore", coreBase, 4.4f);
			hazeBase = new Color(0.62f, 0.16f, 0.02f, 0.5f);
			hazeMaterial = Dress("matSukunaFugaPillarHaze", hazeBase, 0.55f);
			tongues = Build("FugaPillarTongue_", 18, tongueMaterial);
			core = Build("FugaPillarCore_", 6, coreMaterial);
			haze = Build("FugaPillarHaze_", 8, hazeMaterial);
			SukunaVisuals.Flare(root + Vector3.up * (radius * 0.2f), new Color(1f, 0.72f, 0.2f, 1f), radius * 0.9f, 0.4f, 45f);
		}

		internal void SetState(float takeHold, float remaining)
		{
			ignition = Mathf.Clamp01(takeHold);
			fade = Mathf.Clamp01(remaining);
		}

		private Material Dress(string name, Color tint, float glow)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Material val = JujutsuFxMaterials.CreateLineMaterial(name, tint, glow, JujutsuFxTextures.Streak);
			materials.Add(val);
			return val;
		}

		private LineRenderer[] Build(string prefix, int count, Material material)
		{
			//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)
			LineRenderer[] array = (LineRenderer[])(object)new LineRenderer[count];
			for (int i = 0; i < count; i++)
			{
				GameObject val = new GameObject(prefix + i);
				val.transform.SetParent(((Component)this).transform, true);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				JujutsuFxMaterials.PrepareRenderer((Renderer)(object)val2);
				val2.useWorldSpace = true;
				val2.positionCount = 14;
				val2.numCornerVertices = 3;
				val2.numCapVertices = 3;
				((Renderer)val2).material = material;
				val2.widthCurve = JujutsuEase.Curve((Func<float, float>)((float t) => Mathf.Lerp(1f, 0.06f, JujutsuEase.InQuad(t))), 8);
				val2.textureMode = (LineTextureMode)0;
				array[i] = val2;
			}
			return array;
		}

		private void Update()
		{
			//IL_00a5: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			age += Time.deltaTime;
			height = Mathf.Lerp(3f, radius * 1.7f, JujutsuEase.OutBack(ignition, 0.22f));
			Shape(haze, 0.44f, 0.78f, 2.6f, 0.7f);
			Shape(tongues, 0.3f, 1f, 0.62f, 1f);
			Shape(core, 0.085f, 0.78f, 1f, 1.35f);
			JujutsuFxMaterials.SetEnvelope(hazeMaterial, hazeBase, fade, 0.55f);
			JujutsuFxMaterials.SetEnvelope(tongueMaterial, tongueBase, fade, 1.6f);
			JujutsuFxMaterials.SetEnvelope(coreMaterial, coreBase, fade * JujutsuEase.FlickerScaled(age, 0.72f, 9f), 4.4f);
			Aftermath();
		}

		private void Aftermath()
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008e: Unknown result type (might be due to invalid IL or missing references)
			float deltaTime = Time.deltaTime;
			emberStopwatch += deltaTime;
			smokeStopwatch += deltaTime;
			if (ignition > 0.35f && fade > 0.15f && emberStopwatch >= 0.5f)
			{
				emberStopwatch = 0f;
				JujutsuMotes.Burst(root + Vector3.up * (height * 0.3f), Vector3.up, new Color(1f, 0.62f, 0.16f, 1f), radius * 0.22f, (JujutsuMoteKind)0, 0);
			}
			if (ignition > 0.5f && smokeStopwatch >= 1.1f)
			{
				smokeStopwatch = 0f;
				JujutsuMotes.Burst(root + Vector3.up * (height * 0.62f), Vector3.up, new Color(0.4f, 0.36f, 0.34f, 1f), radius * 0.3f, (JujutsuMoteKind)3, 0);
			}
		}

		private void Shape(LineRenderer[] set, float spread, float reach, float weight, float hurry)
		{
			//IL_013c: 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_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_0168: 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_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_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: 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_018c: 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_01ee: Unknown result type (might be due to invalid IL or missing references)
			if (set == null)
			{
				return;
			}
			Vector3 val2 = default(Vector3);
			Vector3 val3 = default(Vector3);
			for (int i = 0; i < set.Length; i++)
			{
				LineRenderer val = set[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					float num = (float)i * 2.39996f;
					float num2 = JujutsuEase.OutQuint(Mathf.Repeat(age * hurry / 0.62f + (float)i / (float)set.Length, 1f));
					float num3 = height * reach * Mathf.Lerp(0.55f, 1f, num2);
					float num4 = radius * spread * (0.35f + (float)(i % 5) * 0.19f);
					float num5 = ((i % 2 == 0) ? 1f : (-1f)) * (0.9f + (float)(i % 3) * 0.35f);
					for (int j = 0; j < 14; j++)
					{
						float num6 = (float)j / 13f;
						float num7 = Mathf.Lerp(1f, 0.28f, num6) + num6 * num6 * 0.85f;
						float num8 = num + num6 * 2.1f + age * num5;
						float num9 = Mathf.Sin(num6 * 6.5f - age * 7.5f + num) * radius * 0.055f * (0.25f + num6);
						((Vector3)(ref val2))..ctor(Mathf.Cos(num8), 0f, Mathf.Sin(num8));
						((Vector3)(ref val3))..ctor(0f - val2.z, 0f, val2.x);
						val.SetPosition(j, root + Vector3.up * (num3 * num6) + val2 * (num4 * num7) + val3 * num9);
					}
					float num10 = (1f - num2) * fade * ignition;
					float num11 = ((i % 4 == 0) ? 1f : 0.8f);
					val.startColor = new Color(num11, num11, num11, num10);
					val.endColor = new Color(num11, num11, num11, 0f);
					val.widthMultiplier = radius * weight * (0.055f + (float)(i % 4) * 0.014f) * (0.45f + (1f - num2) * 0.85f) * fade;
				}
			}
		}

		private void OnDestroy()
		{
			for (int i = 0; i < materials.Count; i++)
			{
				if (Object.op_Implicit((Object)(object)materials[i]))
				{
					Object.Destroy((Object)(object)materials[i]);
				}
			}
			materials.Clear();
		}
	}
	internal static class SukunaFugaVisuals
	{
		internal static RuntimeFugaExplosionVisual CreateFugaExplosion(Vector3 impactPosition, Vector3 groundPosition, float radius, float duration = 8.5f, FugaExplosionDetail detail = FugaExplosionDetail.Blast)
		{
			//IL_0005: 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)
			RuntimeFugaExplosionVisual runtimeFugaExplosionVisual = new GameObject("SukunaFugaExplosion").AddComponent<RuntimeFugaExplosionVisual>();
			runtimeFugaExplosionVisual.Initialize(impactPosition, groundPosition, radius, duration, detail);
			return runtimeFugaExplosionVisual;
		}

		internal static RuntimeFugaProjectileVisual AddFugaProjectileFlames(GameObject projectileObject, Vector3 direction)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)projectileObject))
			{
				return null;
			}
			RuntimeFugaProjectileVisual runtimeFugaProjectileVisual = projectileObject.AddComponent<RuntimeFugaProjectileVisual>();
			runtimeFugaProjectileVisual.Initialize(direction);
			return runtimeFugaProjectileVisual;
		}
	}
	internal enum FugaExplosionDetail
	{
		Blast,
		Flare
	}
	internal sealed class RuntimeFugaProjectileVisual : MonoBehaviour
	{
		private const int BodyFlameCount = 7;

		private const int CoreFlameCount = 3;

		private const int FlameSegments = 7;

		private const float EmberInterval = 0.35f;

		private readonly List<Material> materials = new List<Material>();

		private LineRenderer[] flames;

		private LineRenderer[] cores;

		private TrailRenderer[] trails;

		private Transform head;

		private Material headMaterial;

		private Color headColour;

		private Material flameMaterial;

		private Color flameColour;

		private Material coreMaterial;

		private Color coreColour;

		private Material trailMaterial;

		private Color trailColour;

		private Vector3 direction;

		private Vector3 lastPosition;

		private float age;

		private float emberStopwatch;

		private bool stopped;

		internal void Initialize(Vector3 initialDirection)
		{
			//IL_0018: 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_001d: 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)
			direction = ((((Vector3)(ref initialDirection)).sqrMagnitude > 0.001f) ? ((Vector3)(ref initialDirection)).normalized : Vector3.forward);
			lastPosition = ((Component)this).transform.position;
			BuildFlames();
			BuildTrails();
			BuildHead();
		}

		internal void SetDirection(Vector3 newDirection)
		{
			//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)
			if (((Vector3)(ref newDirection)).sqrMagnitude > 0.001f)
			{
				direction = ((Vector3)(ref newDirection)).normalized;
			}
		}

		internal void Stop()
		{
			stopped = true;
			Quench(flames);
			Quench(cores);
			if (trails != null)
			{
				for (int i = 0; i < trails.Length; i++)
				{
					if (Object.op_Implicit((Object)(object)trails[i]))
					{
						trails[i].emitting = false;
					}
				}
			}
			if (Object.op_Implicit((Object)(object)head))
			{
				((Component)head).gameObject.SetActive(false);
			}
			((Behaviour)this).enabled = false;
		}

		private static void Quench(LineRenderer[] set)
		{
			if (set == null)
			{
				return;
			}
			for (int i = 0; i < set.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)set[i]))
				{
					((Renderer)set[i]).enabled = false;
				}
			}
		}

		private Material Dress(string name, Color tint, float glow)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Material val = JujutsuFxMaterials.CreateLineMaterial(name, tint, glow, JujutsuFxTextures.Streak);
			materials.Add(val);
			return val;
		}

		private void BuildFlames()
		{
			//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_0027: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			flameColour = new Color(1f, 0.28f, 0.02f, 0.92f);
			flameMaterial = Dress("matFugaProjectileFlames", flameColour, 1.6f);
			coreColour = new Color(1f, 0.92f, 0.66f, 0.95f);
			coreMaterial = Dress("matFugaProjectileCore", coreColour, 4.4f);
			flames = BuildSet("FugaProjectileFlame_", 7, flameMaterial);
			cores = BuildSet("FugaProjectileCore_", 3, coreMaterial);
		}

		private LineRenderer[] BuildSet(string prefix, int count, Material material)
		{
			//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)
			LineRenderer[] array = (LineRenderer[])(object)new LineRenderer[count];
			for (int i = 0; i < count; i++)
			{
				GameObject val = new GameObject(prefix + i);
				val.transform.SetParent(((Component)this).transform, false);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				JujutsuFxMaterials.PrepareRenderer((Renderer)(object)val2);
				val2.useWorldSpace = true;
				val2.positionCount = 7;
				val2.numCornerVertices = 4;
				val2.numCapVertices = 4;
				((Renderer)val2).material = material;
				val2.widthCurve = JujutsuEase.Curve((Func<float, float>)((float t) => Mathf.Lerp(1f, 0.04f, JujutsuEase.InQuad(t))), 8);
				val2.textureMode = (LineTextureMode)0;
				array[i] = val2;
			}
			return array;
		}

		private void BuildTrails()
		{
			//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_0033: 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_008b: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			trails = (TrailRenderer[])(object)new TrailRenderer[3];
			trailColour = new Color(0.66f, 0.12f, 0.01f, 0.55f);
			trailMaterial = Dress("matFugaInfernoTrails", trailColour, 0.55f);
			for (int i = 0; i < trails.Length; i++)
			{
				GameObject val = new GameObject("FugaInfernoTrail_" + i);
				val.transform.SetParent(((Component)this).transform, false);
				float num = (float)i / 3f * MathF.PI * 2f;
				val.transform.localPosition = new Vector3(Mathf.Cos(num) * 0.28f, Mathf.Sin(num) * 0.28f, 0f);
				TrailRenderer val2 = val.AddComponent<TrailRenderer>();
				JujutsuFxMaterials.PrepareRenderer((Renderer)(object)val2);
				val2.time = 0.38f + (float)i * 0.09f;
				val2.minVertexDistance = 0.08f;
				val2.numCornerVertices = 4;
				val2.numCapVertices = 3;
				((Renderer)val2).material = trailMaterial;
				val2.widthCurve = JujutsuEase.Curve((Func<float, float>)((float t) => 1f - JujutsuEase.InQuad(t)), 8);
				val2.widthMultiplier = 0.72f - (float)i * 0.12f;
				val2.textureMode = (LineTextureMode)0;
				val2.alignment = (LineAlignment)0;
				val2.startColor = Color.white;
				val2.endColor = new Color(1f, 1f, 1f, 0f);
				trails[i] = val2;
			}
		}

		private void BuildHead()
		{
			//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_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_0066: Unknown result type (might be due to invalid IL or missing references)
			headColour = new Color(1f, 0.78f, 0.32f, 1f);
			GameObject val = JujutsuPrimitives.Flare("FugaArrowHead", ((Component)this).transform.position, headColour, 0.9f, 160f);
			if (Object.op_Implicit((Object)(object)val))
			{
				val.transform.SetParent(((Component)this).transform, false);
				val.transform.localPosition = Vector3.zero;
				head = val.transform;
				MeshRenderer component = val.GetComponent<MeshRenderer>();
				headMaterial = (Object.op_Implicit((Object)(object)component) ? ((Renderer)component).sharedMaterial : null);
			}
		}

		private void Update()
		{
			//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_0031: 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_0079: 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_0042: 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_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_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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c6: 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_00de: 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_00f7: 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)
			if (!stopped)
			{
				age += Time.deltaTime;
				Vector3 val = ((Component)this).transform.position - lastPosition;
				if (((Vector3)(ref val)).sqrMagnitude > 0.0025f)
				{
					direction = Vector3.Slerp(direction, ((Vector3)(ref val)).normalized, Mathf.Clamp01(Time.deltaTime * 18f));
				}
				lastPosition = ((Component)this).transform.position;
				Vector3 val2 = Vector3.Cross(Vector3.up, direction);
				if (((Vector3)(ref val2)).sqrMagnitude < 0.001f)
				{
					val2 = Vector3.right;
				}
				((Vector3)(ref val2)).Normalize();
				Vector3 val3 = Vector3.Cross(direction, val2);
				Vector3 normalized = ((Vector3)(ref val3)).normalized;
				float rootScale = Mathf.Max(0.45f, ((Component)this).transform.localScale.x);
				Stream(flames, val2, normalized, rootScale, 1f, 1f);
				Stream(cores, val2, normalized, rootScale, 0.42f, 0.5f);
				Head();
				Embers(rootScale);
			}
		}

		private void Stream(LineRenderer[] set, Vector3 right, Vector3 up, float rootScale, float reach, float thickness)
		{
			//IL_00b3: 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_00c8: 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_00dd: 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_00e9: 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_0110: 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_011a: 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_0122: 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_018e: Unknown result type (might be due to invalid IL or missing references)
			if (set == null)
			{
				return;
			}
			for (int i = 0; i < set.Length; i++)
			{
				LineRenderer val = set[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					float num = (float)i / (float)set.Length * MathF.PI * 2f;
					float num2 = rootScale * reach * (2.4f + (float)(i % 4) * 0.42f);
					for (int j = 0; j < 7; j++)
					{
						float num3 = (float)j / 6f;
						float num4 = Mathf.Sin(age * (13f + (float)i * 0.22f) + num3 * 9f + num) * rootScale * (0.18f + num3 * 0.36f);
						float num5 = num + num3 * 2.4f + age * (2.5f + (float)i * 0.08f);
						Vector3 val2 = right * Mathf.Cos(num5) + up * Mathf.Sin(num5);
						val.SetPosition(j, ((Component)this).transform.position - direction * num2 * num3 + val2 * (rootScale * reach * (0.26f + num3 * 0.52f)) + up * num4);
					}
					val.widthMultiplier = rootScale * thickness * (0.26f + (float)(i % 3) * 0.07f) * JujutsuEase.FlickerScaled(age + num, 0.78f, 17f);
					val.startColor = Color.white;
					val.endColor = new Color(1f, 1f, 1f, 0f);
				}
			}
		}

		private void Head()
		{
			//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_0047: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)head))
			{
				float num = JujutsuEase.FlickerScaled(age, 0.8f, 15f);
				head.localScale = Vector3.one * (1.5f * num);
				JujutsuFxMaterials.SetEnvelope(headMaterial, headColour, num, 4.4f);
			}
		}

		private void Embers(float rootScale)
		{
			//IL_0031: 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_0042: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			emberStopwatch += Time.deltaTime;
			if (!(emberStopwatch < 0.35f))
			{
				emberStopwatch = 0f;
				JujutsuMotes.Burst(((Component)this).transform.position - direction * rootScale, -direction, new Color(1f, 0.6f, 0.14f, 1f), rootScale * 0.7f, (JujutsuMoteKind)0, 0);
			}
		}

		private void OnDestroy()
		{
			for (int i = 0; i < materials.Count; i++)
			{
				if (Object.op_Implicit((Object)(object)materials[i]))
				{
					Object.Destroy((Object)(object)materials[i]);
				}
			}
			materials.Clear();
		}
	}
	internal sealed class RuntimeFugaExplosionVisual : MonoBehaviour
	{
		private sealed class Shock
		{
			internal Mesh Mesh;

			internal Material Material;

			internal Color Tint;

			internal float Glow;
		}

		private const int RingSegments = 72;

		private const int FlameRayCount = 14;

		private const int FlameTongueCount = 24;

		private const int FlameCoreCount = 8;

		private const int FlameTongueSegments = 8;

		private const int ShockwaveCount = 3;

		internal const float BlastDuration = 8.5f;

		internal const float FlareDuration = 1.7f;

		private const int BlastGroundSpokes = 36;

		private const int BlastGroundRings = 12;

		private const int FlareGroundSpokes = 16;

		private const int FlareGroundRings = 5;

		private const float EmberInterval = 0.42f;

		private const float SmokeInterval = 1.35f;

		private static readonly Color RingInner = new Color(1f, 1f, 1f, 0.1f);

		private static readonly Color RingMiddle = new Color(1f, 1f, 1f, 1f);

		private static readonly Color RingOuter = new Color(1f, 1f, 1f, 0f);

		private readonly List<Material> materials = new List<Material>();

		private JujutsuGroundField ground;

		private RuntimeFugaPillar pillar;

		private Shock[] shockwaves;

		private LineRenderer[] flameRays;

		private Material flameRayMaterial;

		private Color flameRayBaseColor;

		private LineRenderer[] flameTongues;

		private Material flameTongueMaterial;

		private Color flameTongueBaseColor;

		private LineRenderer[] flameCores;

		private Material flameCoreMaterial;

		private Color flameCoreBaseColor;

		private Light explosionLight;

		private Vector3 groundPosition;

		private float radius;

		private float duration;

		private float fadeWindow;

		private float age;

		private float emberStopwatch;

		private float smokeStopwatch;

		private bool isBlast;

		private float ringReach;

		private float ringLift;

		private Func<float, float> ringHeight;

		internal void Initialize(Vector3 impactPosition, Vector3 floorPosition, float effectRadius, float lifetime, FugaExplosionDetail detail)
		{
			//IL_0006: 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_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_0105: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.position = Vector3.zero;
			radius = Mathf.Max(2f, effectRadius);
			duration = Mathf.Max(0.4f, lifetime);
			fadeWindow = Mathf.Min(1.05f, duration * 0.35f);
			isBlast = detail == FugaExplosionDetail.Blast;
			ground = JujutsuGroundField.Sample(floorPosition, radius, isBlast ? 36 : 16, isBlast ? 12 : 5);
			groundPosition = ground.PointAt(0f, 0f, 0.08f);
			ringHeight = (float angle) => ground.PointAt(angle, ringReach, ringLift).y - groundPosition.y;
			BuildFlameTongues(isBlast ? 24 : 8);
			BuildFlameCores(isBlast ? 8 : 3);
			if (isBlast)
			{
				BuildPillar();
				BuildShockwave();
				BuildFlameRays();
			}
			BuildLight(isBlast);
			Detonation(impactPosition);
		}

		private void Detonation(Vector3 impactPosition)
		{
			//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_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_007e: 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_00b5: 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_00f5: 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)
			Color val = default(Color);
			((Color)(ref val))..ctor(1f, 0.5f, 0.06f, 1f);
			SukunaVisuals.Flare(impactPosition, val, radius * (isBlast ? 0.85f : 0.3f), isBlast ? 0.55f : 0.24f, 30f);
			if (isBlast)
			{
				JujutsuMotes.Burst(groundPosition, Vector3.up, new Color(0.86f, 0.8f, 0.72f, 1f), radius * 0.5f, (JujutsuMoteKind)1, 0);
				JujutsuFxDebris.Throw(groundPosition, Vector3.up, new Color(0.9f, 0.35f, 0.06f, 1f), radius * 0.35f, 20, 0f, 0.85f);
				JujutsuFxScorch.Mark(groundPosition, val, radius * 0.8f, 26f, true);
				if (SukunaVisuals.NearCamera(impactPosition, radius * 1.6f))
				{
					JujutsuFxScreen.Flash(new Color(1f, 0.72f, 0.4f, 0.3f), 0.28f);
				}
			}
		}

		private void BuildPillar()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("FugaFirePillar");
			val.transform.SetParent(((Component)this).transform, true);
			pillar = val.AddComponent<RuntimeFugaPillar>();
			pillar.Initialize(groundPosition, radius);
		}

		private void BuildShockwave()
		{
			//IL_0049: 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_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_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_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_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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0114: 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)
			int num = JujutsuFxBudget.Available((Kind)3, 3);
			if (num > 0)
			{
				shockwaves = new Shock[num];
				Color colour = default(Color);
				((Color)(ref colour))..ctor(1f, 0.46f, 0.04f, 0.95f);
				for (int i = 0; i < num; i++)
				{
					JujutsuFxLayer layer = (JujutsuFxLayer)(i switch
					{
						1 => 1, 
						0 => 0, 
						_ => 2, 
					});
					float glow;
					Color val = Tier(colour, layer, out glow);
					GameObject val2 = new GameObject("FugaShockwave_" + i);
					val2.transform.SetParent(((Component)this).transform, true);
					val2.transform.position = groundPosition;
					Mesh val3 = JujutsuFxMesh.Create("FugaShockwaveMesh_" + i);
					val2.AddComponent<MeshFilter>().sharedMesh = val3;
					MeshRenderer obj = val2.AddComponent<MeshRenderer>();
					JujutsuFxMaterials.PrepareRenderer((Renderer)(object)obj);
					Material val4 = JujutsuFxMaterials.CreateLineMaterial("matSukunaFugaShockwave" + i, val, glow, (Texture2D)null);
					materials.Add(val4);
					((Renderer)obj).sharedMaterial = val4;
					JujutsuFxBudget.Register(val2, (Kind)3);
					shockwaves[i] = new Shock
					{
						Mesh = val3,
						Material = val4,
						Tint = val,
						Glow = glow
					};
				}
			}
		}

		private void BuildFlameTongues(int count)
		{
			//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_0027: Unknown result type (might be due to invalid IL or missing references)
			flameTongueBaseColor = new Color(1f, 0.32f, 0.015f, 0.88f);
			flameTongueMaterial = Dress("matSukunaFugaFlameTongues", flameTongueBaseColor, 1.6f);
			flameTongues = BuildTongues("FugaFlameTongue_", count, flameTongueMaterial);
		}

		private void BuildFlameCores(int count)
		{
			//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_0027: Unknown result type (might be due to invalid IL or missing references)
			flameCoreBaseColor = new Color(1f, 0.93f, 0.7f, 0.9f);
			flameCoreMaterial = Dress("matSukunaFugaFlameCores", flameCoreBaseColor, 4.4f);
			flameCores = BuildTongues("FugaFlameCore_", count, flameCoreMaterial);
		}

		private LineRenderer[] BuildTongues(string prefix, int count, Material material)
		{
			//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)
			LineRenderer[] array = (LineRenderer[])(object)new LineRenderer[count];
			for (int i = 0; i < count; i++)
			{
				GameObject val = new GameObject(prefix + i);
				val.transform.SetParent(((Component)this).transform, true);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				JujutsuFxMaterials.PrepareRenderer((Renderer)(object)val2);
				val2.useWorldSpace = true;
				val2.positionCount = 8;
				val2.numCornerVertices = 5;
				val2.numCapVertices = 4;
				((Renderer)val2).material = material;
				val2.widthCurve = JujutsuEase.Curve((Func<float, float>)((float t) => Mathf.Lerp(1f, 0.05f, JujutsuEase.InQuad(t))), 8);
				val2.textureMode = (LineTextureMode)0;
				array[i] = val2;
			}
			return array;
		}

		private void BuildFlameRays()
		{
			//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_0027: 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)
			flameRayBaseColor = new Color(0.95f, 0.14f, 0.01f, 0.68f);
			flameRayMaterial = Dress("matSukunaFugaFloorFlames", flameRayBaseColor, 1.6f);
			flameRays = (LineRenderer[])(object)new LineRenderer[14];
			for (int i = 0; i < 14; i++)
			{
				GameObject val = new GameObject("FugaFloorFlame_" + i);
				val.transform.SetParent(((Component)this).transform, true);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				JujutsuFxMaterials.PrepareRenderer((Renderer)(object)val2);
				val2.useWorldSpace = true;
				val2.positionCount = 4;
				val2.numCapVertices = 3;
				((Renderer)val2).material = flameRayMaterial;
				val2.widthCurve = JujutsuEase.Curve((Func<float, float>)((float t) => Mathf.Lerp(1f, 0.08f, JujutsuEase.InQuad(t))), 8);
				val2.textureMode = (LineTextureMode)0;
				flameRays[i] = val2;
			}
		}

		private Material Dress(string name, Color tint, float glow)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Material val = JujutsuFxMaterials.CreateLineMaterial(name, tint, glow, JujutsuFxTextures.Streak);
			materials.Add(val);
			return val;
		}

		private static Color Tier(Color colour, JujutsuFxLayer layer, out float glow)
		{
			//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_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_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)
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0057: 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_0034: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			glow = JujutsuFxMaterials.GlowFor(layer);
			Color result = colour;
			if ((int)layer != 0)
			{
				if ((int)layer == 2)
				{
					result = Color.Lerp(colour, Color.black, 0.15f);
					result.a = colour.a * 0.45f;
				}
			}
			else
			{
				result = Color.Lerp(colour, Color.white, 0.78f);
				result.a = colour.a;
			}
			return result;
		}

		private void BuildLight(bool blast)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("FugaExplosionLight");
			val.transform.SetParent(((Component)this).transform, true);
			val.transform.position = groundPosition + Vector3.up * 7f;
			explosionLight = JujutsuFxLights.TryAdd(val, new Color(1f, 0.2f, 0.02f), 11f, radius * 1.55f, blast);
		}

		private void Update()
		{
			//IL_0098: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			age += Time.deltaTime;
			float ignition = JujutsuEase.OutExpo(Mathf.Clamp01(age / 0.34f));
			float num = Mathf.Clamp01((duration - age) / fadeWindow);
			UpdatePillar(ignition, num);
			UpdateShockwave(num);
			UpdateFlameRays(ignition, num);
			UpdateFlameTongues(flameTongues, ignition, num, 1f, 1f);
			UpdateFlameTongues(flameCores, ignition, num, 0.5f, 0.55f);
			UpdateAftermath(num);
			JujutsuFxMaterials.SetEnvelope(flameRayMaterial, flameRayBaseColor, num, 1.6f);
			JujutsuFxMaterials.SetEnvelope(flameTongueMaterial, flameTongueBaseColor, num, 1.6f);
			JujutsuFxMaterials.SetEnvelope(flameCoreMaterial, flameCoreBaseColor, num * JujutsuEase.FlickerScaled(age, 0.7f, 8.5f), 4.4f);
			if (Object.op_Implicit((Object)(object)explosionLight))
			{
				explosionLight.intensity = 11f * num * JujutsuEase.FlickerScaled(age, 0.78f, 12f);
			}
			if (age >= duration)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void UpdatePillar(float ignition, float fade)
		{
			if (Object.op_Implicit((Object)(object)pillar))
			{
				pillar.SetState(ignition, fade);
			}
		}

		private void UpdateShockwave(float fade)
		{
			//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_00e1: 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)
			if (shockwaves == null)
			{
				return;
			}
			for (int i = 0; i < shockwaves.Length; i++)
			{
				Shock shock = shockwaves[i];
				if (shock != null && Object.op_Implicit((Object)(object)shock.Mesh))
				{
					float num = (float)i * 0.09f;
					float num2 = JujutsuEase.Window(age, num, num + 0.74f + (float)i * 0.12f);
					float num3 = radius * (1.18f + (float)i * 0.16f) * JujutsuEase.OutExpo(num2);
					float num4 = radius * Mathf.Lerp(0.3f, 0.05f, JujutsuEase.OutCubic(num2));
					ringReach = num3;
					ringLift = 0.15f + (float)i * 0.12f;
					JujutsuFxMesh.Ring(shock.Mesh, Mathf.Max(0.05f, num3 - num4), Mathf.Max(0.1f, num3 + num4 * 0.4f), RingInner, RingMiddle, RingOuter, 72, 0.4f, i * 31 + 7, ringHeight);
					JujutsuFxMaterials.SetEnvelope(shock.Material, shock.Tint, JujutsuEase.Snap(num2, 0.1f) * fade, shock.Glow);
				}
			}
		}

		private void UpdateFlameRays(float ignition, float fade)
		{
			//IL_0067: 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_00d5: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_012c: 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_013b: 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_015e: 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_016d: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			if (flameRays == null)
			{
				return;
			}
			Vector3 val2 = default(Vector3);
			Vector3 val3 = default(Vector3);
			for (int i = 0; i < flameRays.Length; i++)
			{
				LineRenderer val = flameRays[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					float num = (float)i / 14f * MathF.PI * 2f + Mathf.Sin((float)i * 4.17f) * 0.18f;
					((Vector3)(ref val2))..ctor(Mathf.Cos(num), 0f, Mathf.Sin(num));
					((Vector3)(ref val3))..ctor(0f - val2.z, 0f, val2.x);
					float num2 = radius * (0.62f + (float)(i % 5) * 0.075f) * ignition;
					float num3 = Mathf.Sin(age * 5f + (float)i * 1.7f) * radius * 0.035f;
					val.SetPosition(0, ground.PointAt(num, 0f, 0.12f));
					val.SetPosition(1, ground.PointAt(num, num2 * 0.34f, 0.18f) + val3 * num3);
					val.SetPosition(2, ground.PointAt(num, num2 * 0.7f, 0.1f) - val3 * num3 * 0.55f);
					val.SetPosition(3, ground.PointAt(num, num2, 0.08f) + val3 * num3 * 0.25f);
					float num4 = ground.CoverageAt(num, num2);
					float num5 = 0.78f + (float)(i % 3) * 0.11f;
					val.startColor = new Color(num5, num5, num5, 1f);
					val.endColor = new Color(num5, num5, num5, 0f);
					val.widthMultiplier = (0.5f + (float)(i % 4) * 0.12f) * fade * num4 * JujutsuEase.FlickerScaled(age + (float)i, 0.8f, 7f);
				}
			}
		}

		private void UpdateFlameTongues(LineRenderer[] set, float ignition, float fade, float band, float weight)
		{
			//IL_00b2: 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_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_0171: 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_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)
			//IL_018c: 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_0195: 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_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_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_01c4: 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_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			if (set == null)
			{
				return;
			}
			Vector3 val2 = default(Vector3);
			Vector3 val3 = default(Vector3);
			for (int i = 0; i < set.Length; i++)
			{
				LineRenderer val = set[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					float num = (float)i / (float)set.Length * MathF.PI * 2f;
					float num2 = (0.16f + (float)(i % 6) * 0.115f) * band;
					float num3 = radius * num2 * Mathf.Lerp(0.12f, 1f, JujutsuEase.OutQuint(ignition));
					float num4 = radius * (0.42f + (float)(i % 7) * 0.105f) * weight * ignition * JujutsuEase.FlickerScaled(age + num, 0.7f, 8f);
					((Vector3)(ref val2))..ctor(Mathf.Cos(num), 0f, Mathf.Sin(num));
					((Vector3)(ref val3))..ctor(0f - val2.z, 0f, val2.x);
					Vector3 val4 = ground.PointAt(num, num3, 0.05f);
					float num5 = ground.CoverageAt(num, num3);
					for (int j = 0; j < 8; j++)
					{
						float num6 = (float)j / 7f;
						float num7 = Mathf.Sin(age * (6.5f + (float)i * 0.035f) + num6 * 8f + num * 2f) * radius * 0.055f * num6;
						float num8 = Mathf.Cos(age * 4.7f + num6 * 11f + num) * radius * 0.024f * num6;
						val.SetPosition(j, val4 + Vector3.up * (num4 * JujutsuEase.OutQuint(num6)) + val3 * num7 + val2 * num8 - val2 * num4 * 0.08f * num6 * num6);
					}
					float num9 = ((i % 4 == 0) ? 1f : 0.82f);
					val.startColor = new Color(num9, num9, num9, 1f);
					val.endColor = new Color(num9, num9, num9, 0f);
					val.widthMultiplier = radius * weight * (0.028f + (float)(i % 5) * 0.005f) * fade * num5 * JujutsuEase.FlickerScaled(age + num, 0.78f, 13f);
				}
			}
		}

		private void UpdateAftermath(float fade)
		{
			//IL_00e1: 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_00ff: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			if (isBlast)
			{
				float deltaTime = Time.deltaTime;
				emberStopwatch += deltaTime;
				smokeStopwatch += deltaTime;
				if (fade > 0.2f && emberStopwatch >= 0.42f)
				{
					emberStopwatch = 0f;
					float num = age * 2.3f;
					JujutsuMotes.Burst(ground.PointAt(num, radius * 0.4f, 0.4f), Vector3.up, new Color(1f, 0.68f, 0.18f, 1f), radius * 0.2f, (JujutsuMoteKind)0, 0);
				}
				if (smokeStopwatch >= 1.35f)
				{
					smokeStopwatch = 0f;
					JujutsuMotes.Burst(ground.PointAt(age * 1.7f, radius * 0.55f, 0.6f), Vector3.up, new Color(0.36f, 0.32f, 0.3f, 1f), radius * 0.32f, (JujutsuMoteKind)3, 0);
				}
			}
		}

		private void OnDestroy()
		{
			for (int i = 0; i < materials.Count; i++)
			{
				if (Object.op_Implicit((Object)(object)materials[i]))
				{
					Object.Destroy((Object)(object)materials[i]);
				}
			}
			materials.Clear();
			if (shockwaves == null)
			{
				return;
			}
			for (int j = 0; j < shockwaves.Length; j++)
			{
				if (shockwaves[j] != null && Object.op_Implicit((Object)(object)shockwaves[j].Mesh))
				{
					Object.Destroy((Object)(object)shockwaves[j].Mesh);
				}
			}
		}
	}
	internal static class SukunaShrineVisuals
	{
		internal static RuntimeMalevolentShrineVisual CreateShrine(Vector3 center, Vector3 facing, float radius, float duration, int rank = 0)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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)
			GameObject val = new GameObject("SukunaMalevolentShrine");
			val.transform.position = center;
			Vector3 val2 = Vector3.ProjectOnPlane(facing, Vector3.up);
			if (((Vector3)(ref val2)).sqrMagnitude > 0.0001f)
			{
				val.transform.rotation = Quaternion.LookRotation(((Vector3)(ref val2)).normalized, Vector3.up);
			}
			RuntimeMalevolentShrineVisual runtimeMalevolentShrineVisual = val.AddComponent<RuntimeMalevolentShrineVisual>();
			runtimeMalevolentShrineVisual.Initialize(radius, duration, rank);
			return runtimeMalevolentShrineVisual;
		}
	}
	internal sealed class RuntimeMalevolentShrineVisual : MonoBehaviour
	{
		private sealed class Shell
		{
			internal Transform Item;

			internal Material Material;

			internal Color Tint;

			internal float Glow;

			internal float Size = 1f;

			internal float Rate = 0.4f;
		}

		private const int RingSegments = 96;

		private const int BaseSigilRayCount = 16;

		private const int CurseWispCount = 18;

		private const int WispSegments = 7;

		private const int DarkShells = 2;

		private int darkShells = 2;

		private int hazeShells = 3;

		private int rank;

		private const float StandOff = 23f;

		private const float RiseDuration = 1.1f;

		private const float UnsealedGrace = 8f;

		private const float BoundarySweep = 0.62f;

		private const float MaximumGroundRise = 8f;

		private const float MaximumGroundDrop = 45f;

		private const float GroundSampleRadius = 7f;

		private const int DomainGroundSpokes = 32;

		private const int DomainGroundRings = 6;

		private static readonly Color RingInner = new Color(1f, 1f, 1f, 0.14f);

		private static readonly Color RingMiddle = new Color(1f, 1f, 1f, 1f);

		private static readonly Color RingOuter = new Color(1f, 1f, 1f, 0f);

		private readonly List<Material> materials = new List<Material>();

		private Renderer[] shrineRenderers;

		private Transform shrineStand;

		private float standDrop;

		private Vector3 domainCentre;

		private bool placementReported;

		private Material shrineMaterial;

		private Material ringMaterial;

		private Color ringBaseColor;

		private Transform sphereRoot;

		private Shell[] shells;

		private JujutsuGroundField ground;

		private float nextAirCutAt;

		private GameObject boundary;

		private Mesh boundaryMesh;

		private float boundarySweepReach;

		private Func<float, float> boundaryHeight;

		private LineRenderer[] sigilRays;

		private LineRenderer[] curseWisps;

		private Material sigilMaterial;

		private Material sigilCoreMaterial;

		private Material wispMaterial;

		private Color sigilBaseColor;

		private Color sigilCoreColor;

		private Color wispBaseColor;

		private Light shrineLight;

		private ParticleSystem shrineEmbers;

		private ParticleSystem shrineSmoke;

		private float radius;

		private float duration;

		private float shrineHeight = 5.5f;

		private float shrineScale = 1f;

		private float lightIntensity = 4.6f;

		private float age;

		private float sealAge = -1f;

		private bool domainSealed;

		internal void Initialize(float domainRadius, float lifetime, int shrineRank = 0)
		{
			//IL_008b: 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_00af: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			radius = Mathf.Max(8f, domainRadius);
			duration = Mathf.Max(1f, lifetime);
			rank = Mathf.Clamp(shrineRank, 0, 5);
			darkShells = 2 + ((rank >= 3) ? 1 : 0);
			hazeShells = darkShells + 1;
			shrineScale = 1f + 0.08f * (float)rank;
			lightIntensity = 4.6f + 0.45f * (float)rank;
			domainCentre = ((Component)this).transform.position;
			shrineMaterial = SukunaVisuals.CreateSafeMaterial("matSukunaShrine", new Color(0.25f, 0.006f, 0.018f, 1f));
			ringBaseColor = Color.Lerp(SukunaAssets.Crimson, new Color(0.35f, 0f, 0.02f, 1f), (float)rank / 5f);
			ringMaterial = JujutsuFxMaterials.CreateLineMaterial("matSukunaShrineBoundary", ringBaseColor, 1.6f, (Texture2D)null);
			materials.Add(ringMaterial);
			BuildShrine();
		}

		internal void Seal()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!domainSealed)
			{
				domainSealed = true;
				sealAge = 0f;
				ground = JujutsuGroundField.Sample(domainCentre, radius, 32, 6);
				BuildBoundary();
				BuildSphere();
				BuildSigil();
				BuildCurseWisps();
				BuildLight();
				MarkTheGround();
				Announce();
			}
		}

		private void Announce()
		{
			//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_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_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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = domainCentre + Vector3.up * (radius * 0.15f);
			SukunaVisuals.Flare(val, SukunaAssets.Crimson, radius * 0.9f, 0.7f, 18f);
			JujutsuFxLights.Borrow(val, Color.Lerp(SukunaAssets.Crimson, Color.white, 0.3f), 14f, radius * 1.4f, 0.22f);
			if (SukunaVisuals.NearCamera(domainCentre, radius * 1.35f))
			{
				JujutsuFxScreen.Flash(new Color(0.7f, 0.03f, 0.05f, 0.55f), 0.4f);
				JujutsuFxScreen.Vignette(new Color(0.24f, 0.005f, 0.02f, 1f), duration, 0.52f);
			}
		}

		private void MarkTheGround()
		{
			//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_003d: 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)
			JujutsuFxScorch.Mark(domainCentre, SukunaAssets.Crimson, radius * 0.94f, duration + 3f, false);
			if (Object.op_Implicit((Object)(object)shrineStand))
			{
				JujutsuFxScorch.Mark(shrineStand.position, new Color(0.32f, 0.02f, 0.03f, 1f), 9f, duration + 6f, true);
			}
		}

		private void BuildSphere()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0072: 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_00b3: 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_01d0: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("MalevolentShrineAir");
			val.transform.SetParent(((Component)this).transform, false);
			sphereRoot = val.transform;
			shells = new Shell[hazeShells];
			float num = 0.6f / (float)Mathf.Max(1, hazeShells - 1);
			Color val3 = default(Color);
			for (int i = 0; i < hazeShells; i++)
			{
				bool flag = i < darkShells;
				GameObject val2 = JujutsuPrimitives.Sphere("ShrineHaze_" + i, Vector3.zero, false);
				val2.transform.SetParent(sphereRoot, false);
				float num2 = radius * (1.98f - (float)i * num);
				val2.transform.localScale = Vector3.one * num2;
				Renderer component = val2.GetComponent<Renderer>();
				if (Object.op_Implicit((Object)(object)component))
				{
					JujutsuFxMaterials.PrepareRenderer(component);
					float num3;
					Material val4;
					if (flag && JujutsuFxMaterials.CanDrawDark)
					{
						((Color)(ref val3))..ctor(0.05f, 0.004f, 0.008f, Mathf.Max(0.04f, 0.16f - (float)i * 0.05f) + 0.005f * (float)rank);
						num3 = 1f;
						val4 = JujutsuFxMaterials.CreateBlendedMaterial("matSukunaShrineHaze" + i, val3, JujutsuFxTextures.Grain);
					}
					else
					{
						((Color)(ref val3))..ctor(0.5f, 0.02f, 0.03f, 0.05f + 0.008f * (float)rank);
						num3 = 0.55f;
						val4 = JujutsuFxMaterials.CreateLineMaterial("matSukunaShrineHaze" + i, val3, num3, JujutsuFxTextures.Grain);
					}
					materials.Add(val4);
					component.sharedMaterial = val4;
					shells[i] = new Shell
					{
						Item = val2.transform,
						Material = val4,
						Tint = val3,
						Glow = num3,
						Size = num2,
						Rate = 0.37f + (float)i * 0.19f
					};
				}
			}
		}

		private void CutTheAir()
		{
			//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_0037: 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_0050: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_009d: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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)
			if (!(age < nextAirCutAt))
			{
				nextAirCutAt = age + Random.Range(0.12f, 0.3f);
				Vector3 position = ((Component)this).transform.position;
				Vector3 val = Random.insideUnitSphere * (radius * 0.85f);
				val.y = Mathf.Abs(val.y) * 0.7f + 0.5f;
				Vector3 onUnitSphere = Random.onUnitSphere;
				float num = radius * Random.Range(0.12f, 0.3f);
				SukunaVisuals.CreateSlash(position + val - onUnitSphere * num, position + val + onUnitSphere * num, Random.Range(0.12f, 0.3f), Random.Range(0.25f, 0.45f), (Random.value > 0.5f) ? SukunaVisuals.DarkSlash : SukunaVisuals.GreySlash, false);
			}
		}

		private void BuildLight()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_003d: 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_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_0058: 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_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)
			GameObject val = new GameObject("MalevolentShrineLight");
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = (Object.op_Implicit((Object)(object)shrineStand) ? shrineStand.localPosition : Vector3.zero) + Vector3.up * (shrineHeight * 0.55f);
			shrineLight = JujutsuFxLights.TryAdd(val, SukunaAssets.Crimson, 3.4f + 0.35f * (float)rank, radius * 0.9f, true);
			if (Object.op_Implicit((Object)(object)shrineStand))
			{
				shrineEmbers = JujutsuMotes.Attach(shrineStand, SukunaAssets.Crimson, shrineHeight * 0.45f, (JujutsuMoteKind)0);
				shrineSmoke = JujutsuMotes.Attach(shrineStand, new Color(0.3f, 0.24f, 0.24f, 1f), shrineHeight * 0.6f, (JujutsuMoteKind)3);
			}
		}

		private Transform CreateStand()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_00e5: 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_004d: 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_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_007b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("MalevolentShrineStand");
			val.transform.SetParent(((Component)this).transform, false);
			float num = 23f;
			float num2 = 0f;
			bool flag = false;
			for (int i = 0; i < 3; i++)
			{
				if (flag)
				{
					break;
				}
				num = 23f * (1f - (float)i * 0.25f);
				flag = TryFindGround(((Component)this).transform.position - ((Component)this).transform.forward * num, out var groundHeight);
				if (flag)
				{
					num2 = groundHeight - ((Component)this).transform.position.y;
				}
			}
			if (!flag)
			{
				num = 23f;
				Plugin.Log.LogWarning((object)("Malevolent Shrine found no ground behind the caster " + $"within {45f:0}m at any stand-off; standing " + "it on his own level."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\RuntimeMalevolentShrineVisual.cs");
			}
			standDrop = num2;
			val.transform.localPosition = new Vector3(0f, num2, 0f - num);
			val.transform.localRotation = Quaternion.Euler(0f, 180f, 0f);
			return val.transform;
		}

		private bool TryFindGround(Vector3 centre, out float groundHeight)
		{
			//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_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_005f: 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_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)
			//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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_00da: 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_00e7: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//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_0103: 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_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_013c: 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)
			groundHeight = 0f;
			bool flag = false;
			RaycastHit val = default(RaycastHit);
			for (int i = 0; i < 5; i++)
			{
				if (Physics.Raycast(centre + (Vector3)(i switch
				{
					1 => (((Component)this).transform.right + ((Component)this).transform.forward) * 7f, 
					2 => (((Component)this).transform.right - ((Component)this).transform.forward) * 7f, 
					3 => (-((Component)this).transform.right + ((Component)this).transform.forward) * 7f, 
					4 => (-((Component)this).transform.right - ((Component)this).transform.forward) * 7f, 
					_ => Vector3.zero, 
				}) + Vector3.up * 8f, Vector3.down, ref val, 53f, LayerMask.op_Implicit(((LayerIndex)(ref LayerIndex.world)).mask), (QueryTriggerInteraction)1) && (!flag || ((RaycastHit)(ref val)).point.y < groundHeight))
				{
					groundHeight = ((RaycastHit)(ref val)).point.y;
					flag = true;
				}
			}
			return flag;
		}

		private void BuildShrine()
		{
			//IL_0050: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_0107: 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_0142: 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_0175: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			shrineStand = CreateStand();
			float num = default(float);
			if (RuntimeShrineModel.TryBuild(shrineStand, ref num))
			{
				shrineHeight = num;
				shrineRenderers = ((Component)shrineStand).GetComponentsInChildren<Renderer>(true);
				ApplyShrineScale();
				return;
			}
			CreateBlock("ShrineBase", new Vector3(0f, 0.18f, 0f), new Vector3(7.5f, 0.36f, 5.2f));
			CreateBlock("ShrineStep", new Vector3(0f, 0.48f, 0f), new Vector3(6.1f, 0.28f, 4.2f));
			for (int i = -1; i <= 1; i += 2)
			{
				CreateBlock("ShrinePillarFront", new Vector3((float)i * 2.55f, 2.7f, 1.35f), new Vector3(0.48f, 4.7f, 0.48f));
				CreateBlock("ShrinePillarBack", new Vector3((float)i * 2.55f, 2.7f, -1.35f), new Vector3(0.48f, 4.7f, 0.48f));
			}
			CreateBlock("ShrineRoofLower", new Vector3(0f, 4.85f, 0f), new Vector3(6.9f, 0.38f, 4.15f));
			CreateBlock("ShrineRoofUpper", new Vector3(0f, 5.35f, 0f), new Vector3(5.45f, 0.34f, 3.35f));
			CreateBlock("ShrineAltar", new Vector3(0f, 1.45f, -0.5f), new Vector3(2.8f, 2.1f, 1.25f));
			shrineRenderers = ((Component)shrineStand).GetComponentsInChildren<Renderer>(true);
			ApplyShrineScale();
		}

		private void ApplyShrineScale()
		{
			//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)
			if (Object.op_Implicit((Object)(object)shrineStand) && !(shrineScale <= 1.0001f))
			{
				shrineStand.localScale = Vector3.one * shrineScale;
				shrineHeight *= shrineScale;
			}
		}

		private void CreateBlock(string blockName, Vector3 localPosition, Vector3 localScale)
		{
			//IL_0001: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = JujutsuPrimitives.Cube(blockName, Vector3.zero, false);
			obj.transform.SetParent(shrineStand, false);
			obj.transform.localPosition = localPosition;
			obj.transform.localScale = localScale;
			Renderer component = obj.GetComponent<Renderer>();
			component.sharedMaterial = shrineMaterial;
			component.shadowCastingMode = (ShadowCastingMode)1;
			component.receiveShadows = true;
		}

		private void BuildBoundary()
		{
			//IL_002f: 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 (JujutsuFxBudget.Available((Kind)3, 1) >= 1)
			{
				MeshRenderer val = default(MeshRenderer);
				boundary = JujutsuFxMesh.Object("MalevolentShrineBoundary", ref boundaryMesh, ref val);
				boundary.transform.position = domainCentre;
				boundary.transform.rotation = Quaternion.identity;
				((Renderer)val).sharedMaterial = ringMaterial;
				JujutsuFxBudget.Register(boundary, (Kind)3);
				boundaryHeight = BoundaryHeight;
				ShapeBoundary(0f);
			}
		}

		private void ShapeBoundary(float sweep)
		{
			//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_0096: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)boundaryMesh) && ground != null)
			{
				float num = Mathf.Max(0.6f, radius * JujutsuEase.OutQuint(sweep));
				float num2 = radius * Mathf.Lerp(0.14f, 0.035f, JujutsuEase.OutCubic(sweep)) * (1f + 0.09f * (float)rank);
				boundarySweepReach = num;
				JujutsuFxMesh.Ring(boundaryMesh, Mathf.Max(0.1f, num - num2), Mathf.Max(0.2f, num + num2 * 0.5f), RingInner, RingMiddle, RingOuter, 96, 0.42f, 17, boundaryHeight);
			}
		}

		private float BoundaryHeight(float angle)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return ground.PointAt(angle, boundarySweepReach, 0.12f).y - domainCentre.y;
		}

		private void BuildSigil()
		{
			//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_0027: 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_0062: 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)
			sigilBaseColor = new Color(0.75f, 0.015f, 0.025f, 0.82f);
			sigilMaterial = Dress("matSukunaShrineSigil", sigilBaseColor, 1.6f);
			sigilCoreColor = new Color(1f, 0.62f, 0.58f, 0.85f);
			sigilCoreMaterial = Dress("matSukunaShrineSigilCore", sigilCoreColor, 4.4f);
			sigilRays = (LineRenderer[])(object)new LineRenderer[16 + 2 * rank];
			for (int i = 0; i < sigilRays.Length; i++)
			{
				GameObject val = new GameObject("ShrineSigilRay_" + i);
				val.transform.SetParent(((Component)this).transform, true);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				JujutsuFxMaterials.PrepareRenderer((Renderer)(object)val2);
				val2.useWorldSpace = true;
				val2.positionCount = 5;
				val2.numCornerVertices = 3;
				val2.numCapVertices = 3;
				((Renderer)val2).material = ((i % 4 == 0) ? sigilCoreMaterial : sigilMaterial);
				val2.widthCurve = JujutsuEase.Curve((Func<float, float>)((float t) => Mathf.Lerp(1f, 0.12f, JujutsuEase.InQuad(t))), 8);
				val2.textureMode = (LineTextureMode)0;
				sigilRays[i] = val2;
			}
		}

		private void BuildCurseWisps()
		{
			//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_0027: 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)
			wispBaseColor = new Color(0.42f, 0.01f, 0.03f, 0.78f);
			wispMaterial = Dress("matSukunaShrineCurseWisps", wispBaseColor, 1.6f);
			curseWisps = (LineRenderer[])(object)new LineRenderer[18];
			for (int i = 0; i < curseWisps.Length; i++)
			{
				GameObject val = new GameObject("ShrineCurseWisp_" + i);
				val.transform.SetParent(((Component)this).transform, true);
				LineRenderer val2 = val.AddComponent<LineRenderer>();
				JujutsuFxMaterials.PrepareRenderer((Renderer)(object)val2);
				val2.useWorldSpace = true;
				val2.positionCount = 7;
				val2.numCornerVertices = 4;
				val2.numCapVertices = 3;
				((Renderer)val2).material = ((i % 4 == 0) ? sigilCoreMaterial : wispMaterial);
				val2.widthCurve = JujutsuEase.Curve((Func<float, float>)((float t) => Mathf.Lerp(1f, 0.06f, JujutsuEase.InQuad(t))), 8);
				val2.textureMode = (LineTextureMode)0;
				curseWisps[i] = val2;
			}
		}

		private Material Dress(string name, Color tint, float glow)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Material val = JujutsuFxMaterials.CreateLineMaterial(name, tint, glow, JujutsuFxTextures.Streak);
			materials.Add(val);
			return val;
		}

		private void Update()
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			age += Time.deltaTime;
			if (domainSealed)
			{
				sealAge += Time.deltaTime;
			}
			float num = Mathf.Clamp01(age / 1.1f);
			float num2 = Mathf.LerpUnclamped(0.12f, 1f, JujutsuEase.OutBack(num, 0.18f));
			float num3 = (domainSealed ? Mathf.Clamp01((duration - sealAge) / 0.8f) : 1f);
			float num4 = Mathf.Min(num, num3);
			float num5 = (domainSealed ? Mathf.Min(Mathf.Clamp01(sealAge / 0.55f), num3) : 0f);
			if (shrineRenderers != null)
			{
				for (int i = 0; i < shrineRenderers.Length; i++)
				{
					if (Object.op_Implicit((Object)(object)shrineRenderers[i]))
					{
						shrineRenderers[i].enabled = num4 > 0.01f;
					}
				}
			}
			UpdateBoundary(num5);
			UpdateShells(num5);
			CutTheAir();
			UpdateSigil(num5);
			UpdateCurseWisps(num5);
			JujutsuFxMaterials.SetEnvelope(sigilMaterial, sigilBaseColor, num5, 1.6f);
			JujutsuFxMaterials.SetEnvelope(sigilCoreMaterial, sigilCoreColor, num5 * JujutsuEase.FlickerScaled(age, 0.7f, 7.5f), 4.4f);
			JujutsuFxMaterials.SetEnvelope(wispMaterial, wispBaseColor, num5, 1.6f);
			((Component)this).transform.localScale = new Vector3(1f, Mathf.Max(0.05f, num2), 1f);
			if (Object.op_Implicit((Object)(object)shrineLight))
			{
				shrineLight.intensity = lightIntensity * num5 * JujutsuEase.FlickerScaled(age, 0.72f, 5.5f);
			}
			if (!placementReported)
			{
				placementReported = true;
				RuntimeShrineModel.ReportPlacement(shrineStand, ((Component)this).transform, domainCentre, standDrop);
			}
			if (domainSealed ? (sealAge >= duration) : (age >= 8f))
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void UpdateBoundary(float alpha)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)boundary) && domainSealed)
			{
				if (sealAge <= 0.62f)
				{
					ShapeBoundary(Mathf.Clamp01(sealAge / 0.62f));
				}
				JujutsuFxMaterials.SetEnvelope(ringMaterial, ringBaseColor, alpha * JujutsuEase.FlickerScaled(age, 0.78f, 4.4f), 1.6f);
			}
		}

		private void UpdateShells(float alpha)
		{
			//IL_0033: 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_0089: 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)
			if (!Object.op_Implicit((Object)(object)sphereRoot) || shells == null)
			{
				return;
			}
			sphereRoot.localRotation = Quaternion.Euler(0f, (0f - age) * 2.5f, 0f);
			for (int i = 0; i < shells.Length; i++)
			{
				Shell shell = shells[i];
				if (shell != null)
				{
					if (Object.op_Implicit((Object)(object)shell.Item))
					{
						float num = Mathf.Lerp(0.55f, 1f, JujutsuEase.OutExpo(Mathf.Clamp01(sealAge / 0.62f)));
						shell.Item.localScale = Vector3.one * (shell.Size * num * JujutsuEase.FlickerScaled(age, 0.985f, shell.Rate));
					}
					JujutsuFxMaterials.SetEnvelope(shell.Material, shell.Tint, alpha, shell.Glow);
				}
			}
		}

		private void UpdateSigil(float alpha)
		{
			//IL_00c2: 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_0104: 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_0140: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			if (sigilRays == null || ground == null)
			{
				return;
			}
			for (int i = 0; i < sigilRays.Length; i++)
			{
				LineRenderer val = sigilRays[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					float num = (float)i / (float)sigilRays.Length * MathF.PI * 2f + age * ((i % 2 == 0) ? 0.08f : (-0.06f));
					float distance = radius * 0.16f;
					float num2 = radius * (0.82f + (float)(i % 4) * 0.045f) * Mathf.Lerp(0.25f, 1f, JujutsuEase.OutQuint(Mathf.Clamp01(sealAge / 0.62f)));
					float num3 = radius * 0.03f;
					val.SetPosition(0, Floor(num, distance, 0.1f));
					val.SetPosition(1, Floor(num + num3 / num2, num2 * 0.34f, 0.11f));
					val.SetPosition(2, Floor(num - num3 / num2, num2 * 0.62f, 0.12f));
					val.SetPosition(3, Floor(num + num3 * 0.6f / num2, num2 * 0.82f, 0.1f));
					val.SetPosition(4, Floor(num, num2, 0.09f));
					float num4 = ground.CoverageAt(num, num2);
					val.startColor = Color.white;
					val.endColor = new Color(1f, 1f, 1f, 0f);
					val.widthMultiplier = (0.15f + (float)(i % 3) * 0.035f) * alpha * num4 * JujutsuEase.FlickerScaled(age + (float)i, 0.82f, 11f);
				}
			}
		}

		private void UpdateCurseWisps(float alpha)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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_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_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_013d: 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)
			if (curseWisps == null || ground == null)
			{
				return;
			}
			Vector3 val3 = default(Vector3);
			for (int i = 0; i < curseWisps.Length; i++)
			{
				LineRenderer val = curseWisps[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					float num = (float)i * 2.39996f;
					float num2 = radius * (0.24f + (float)(i % 7) * 0.095f);
					float num3 = num + age * (0.2f + (float)(i % 3) * 0.09f);
					Vector3 val2 = Floor(num3, num2, 0.15f);
					((Vector3)(ref val3))..ctor(0f - Mathf.Sin(num3), 0f, Mathf.Cos(num3));
					for (int j = 0; j < 7; j++)
					{
						float num4 = (float)j / 6f;
						float num5 = radius * (0.08f + (float)(i % 5) * 0.018f) * JujutsuEase.OutQuint(num4);
						float num6 = Mathf.Sin(age * 4.5f + num + num4 * 8f) * radius * 0.018f * num4;
						val.SetPosition(j, val2 + Vector3.up * num5 + val3 * num6);
					}
					float num7 = ground.CoverageAt(num3, num2);
					val.startColor = Color.white;
					val.endColor = new Color(1f, 1f, 1f, 0f);
					val.widthMultiplier = (0.18f + (float)(i % 4) * 0.035f) * alpha * num7 * JujutsuEase.FlickerScaled(age + num, 0.85f, 6f);
				}
			}
		}

		private Vector3 Floor(float angle, float distance, float lift)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return ground.PointAt(angle, distance, lift);
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)shrineMaterial))
			{
				Object.Destroy((Object)(object)shrineMaterial);
			}
			for (int i = 0; i < materials.Count; i++)
			{
				if (Object.op_Implicit((Object)(object)materials[i]))
				{
					Object.Destroy((Object)(object)materials[i]);
				}
			}
			materials.Clear();
			if (Object.op_Implicit((Object)(object)boundary))
			{
				Object.Destroy((Object)(object)boundary);
			}
			if (Object.op_Implicit((Object)(object)boundaryMesh))
			{
				Object.Destroy((Object)(object)boundaryMesh);
			}
			JujutsuMotes.Stop(shrineEmbers);
			JujutsuMotes.Stop(shrineSmoke);
		}
	}
	internal static class SukunaImportedModel
	{
		private sealed class ModelData
		{
			internal string[] BoneNames;

			internal int[] ParentIndices;

			internal Vector3[] BonePositions;

			internal Quaternion[] BoneRotations;

			internal Vector3[] BoneScales;

			internal MeshData[] Meshes;
		}

		private sealed class MeshData
		{
			internal string Name;

			internal int OutfitIndex;

			internal string MaterialName;

			internal string TextureName;

			internal bool IsDecal;

			internal Vector3[] Vertices;

			internal Vector3[] Normals;

			internal Vector2[] Uvs;

			internal BoneWeight[] BoneWeights;

			internal int[] Triangles;
		}

		private const string ModelFileName = "sukuna.model";

		private const string TextureDirectoryName = "sukuna";

		private const int OutfitCount = 5;

		private const int SharedOutfitIndex = 5;

		private static readonly int[] SelfContainedOutfits = new int[4] { 1, 2, 3, 4 };

		private const int OutfitGroupCount = 6;

		private const int HeianOutfitIndex = 2;

		private const float NativeModelScale = 1.27f;

		private static ModelData cachedModel;

		private static readonly Dictionary<string, Texture2D> textureCache = new Dictionary<string, Texture2D>(StringComparer.Ordinal);

		private static readonly Dictionary<string, Sprite> iconCache = new Dictionary<string, Sprite>(StringComparer.Ordinal);

		private static Material cachedTemplateMaterial;

		private static readonly Dictionary<string, List<Material>> cutoutWaiting = new Dictionary<string, List<Material>>(StringComparer.Ordinal);

		private static readonly Dictionary<string, bool> cutoutDecided = new Dictionary<string, bool>(StringComparer.Ordinal);

		private static readonly HashSet<string> loggedShaders = new HashSet<string>(StringComparer.Ordinal);

		internal static bool Apply(GameObject prefab)
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_0192: 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_01d3: 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_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			try
			{
				Plugin.Log.LogInfo((object)("Preparing supplied Sukuna rig for " + ((Object)prefab).name + "."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
				CharacterModel componentInChildren = prefab.GetComponentInChildren<CharacterModel>(true);
				if (!Object.op_Implicit((Object)(object)componentInChildren))
				{
					Plugin.Log.LogWarning((object)("CharacterModel was not found while applying Sukuna model to " + ((Object)prefab).name + "."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
					return false;
				}
				ModelData modelData = LoadModel();
				Material val2 = FindTemplateMaterial(componentInChildren);
				if (modelData == null)
				{
					Plugin.Log.LogError((object)("Sukuna model data could not be loaded for " + ((Object)prefab).name + "; the Mercenary fallback will remain visible."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
					return false;
				}
				if (!Object.op_Implicit((Object)(object)val2))
				{
					Plugin.Log.LogError((object)("No safe material template was available for " + ((Object)prefab).name + "; the Mercenary fallback will remain visible."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
					return false;
				}
				Plugin.Log.LogInfo((object)("Loaded Sukuna runtime data for " + ((Object)prefab).name + ": " + $"{modelData.BoneNames.Length} bones, " + $"{modelData.Meshes.Length} mesh parts."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
				Renderer[] componentsInChildren = ((Component)componentInChildren).GetComponentsInChildren<Renderer>(true);
				Light[] componentsInChildren2 = ((Component)componentInChildren).GetComponentsInChildren<Light>(true);
				Animator animator = ((Component)componentInChildren).GetComponent<Animator>() ?? ((Component)componentInChildren).GetComponentInChildren<Animator>(true);
				val = new GameObject("SukunaImportedModel");
				val.layer = ((Component)componentInChildren).gameObject.layer;
				Transform transform = val.transform;
				transform.SetParent(((Component)componentInChildren).transform, false);
				transform.localPosition = Vector3.zero;
				transform.localRotation = Quaternion.Euler(-90f, 0f, 0f);
				transform.localScale = SukunaModelBasis.ContainerScale(transform, (JujutsuConfig.SukunaModelScale != null) ? JujutsuConfig.SukunaModelScale.Value : 1.27f);
				Transform[] array = BuildSkeleton(modelData, transform);
				GameObject[] array2 = BuildOutfitGroups(transform);
				List<RendererInfo> list = BuildMeshes(modelData, array, array2, val2, ((Component)componentInChildren).gameObject.layer);
				if (list.Count == 0)
				{
					Object.DestroyImmediate((Object)(object)val);
					Plugin.Log.LogError((object)("Sukuna model contained no usable renderers for " + ((Object)prefab).name + "."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
					return false;
				}
				RendererInfo[] baseRendererInfos = componentInChildren.baseRendererInfos;
				foreach (RendererInfo val3 in baseRendererInfos)
				{
					if (Object.op_Implicit((Object)(object)val3.renderer))
					{
						val3.renderer.enabled = false;
					}
				}
				RendererInfo[] array3 = (componentInChildren.baseRendererInfos = list.ToArray());
				componentInChildren.mainSkinnedMeshRenderer = FindMainRenderer(array3);
				componentInChildren.materialsDirty = true;
				componentInChildren.forceUpdate = true;
				Renderer[] array4 = (Renderer[])(object)new Renderer[array3.Length];
				for (int j = 0; j < array3.Length; j++)
				{
					array4[j] = array3[j].renderer;
				}
				val.AddComponent<GojoModelVisibilityController>().Configure(componentsInChildren, array4, componentsInChildren2);
				val.AddComponent<SukunaMixamoAnimationDriver>().Configure(modelData.BoneNames, array);
				bool flag = Array.IndexOf(modelData.BoneNames, "mixamorig:Hips") >= 0;
				val.AddComponent<GojoModelAnimator>().Configure(componentInChildren, modelData.BoneNames, array);
				SukunaHeianArms sukunaHeianArms = val.AddComponent<SukunaHeianArms>();
				GameObject heianSkinGroup = ((array2.Length > 2) ? array2[2] : null);
				sukunaHeianArms.Configure(modelData.BoneNames, array, heianSkinGroup);
				val.AddComponent<SukunaHeianStature>().Configure(heianSkinGroup, Mathf.Abs(transform.localScale.x));
				val.AddComponent<JujutsuFootPlanting>();
				val.AddComponent<JujutsuRagdoll>();
				val.AddComponent<SukunaBladeTrail>();
				ConfigureSkins(componentInChildren, animator, array3, array2, FindOutfitsWithGeometry(modelData));
				Plugin.Log.LogInfo((object)("Applied supplied Sukuna rig to " + ((Object)prefab).name + ": " + $"{modelData.BoneNames.Length} bones, " + $"{array3.Length} skinned renderers, " + $"{modelData.Meshes.Length} mesh parts, " + (flag ? "native Mixamo animation" : "retarget animation") + "."), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
				return true;
			}
			catch (Exception arg)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.DestroyImmediate((Object)(object)val);
				}
				Plugin.Log.LogError((object)$"Could not build imported Sukuna model: {arg}", "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
				return false;
			}
		}

		private static ModelData LoadModel()
		{
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: 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_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			if (cachedModel != null)
			{
				return cachedModel;
			}
			string text = JujutsuAssetPaths.Find(new string[2] { "assets", "sukuna.model" });
			if (!File.Exists(text))
			{
				Plugin.Log.LogWarning((object)("Sukuna model data was not found: " + text), "C:\\Users\\user\\Documents\\risk of rain 2\\src\\Sukuna\\Visuals\\SukunaImportedModel.cs");
				return null;
			}
			using FileStream fileStream = File.OpenRead(text);
			using BinaryReader binaryReader = new BinaryReader(fileStream);
			byte[] array = new byte[8] { 83, 85, 75, 78, 77, 68, 76, 49 };
			byte[] array2 = binaryReader.ReadBytes(array.Length);
			if (array2.Length != array.Length)
			{
				throw new InvalidDataException("Sukuna model header is incomplete.");
			}
			for (int i = 0; i < array.Length; i++)
			{
				if (array2[i] != array[i])
				{
					throw new InvalidDataException("Sukuna model header is invalid.");
				}
			}
			int num = binaryReader.ReadInt32();
			if (num != 2)
			{
				throw new InvalidDataException($"Unsupported Sukuna model version {num}.");
			}
			int num2 = ReadSafeCount(binaryReader, 1, 1024, "bone");
			ModelData modelData = new ModelData
			{
				BoneNames = new string[num2],
				ParentIndices = new int[num2],
				BonePositions = (Vector3[])(object)new Vector3[num2],
				BoneRotations = (Quaternion[])(object)new Quaternion[num2],
				BoneScales = (Vector3[])(object)new Vector3[num2]
			};
			for (int j = 0; j < num2; j++)
			{
				modelData.BoneNames[j] = binaryReader.ReadString();
				modelDa