using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using AmpMod.SkillStates.Nemesis_Amp.Orbs;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.ContentManagement;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("NemAmpMitrhixFix")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("NemAmpMitrhixFix")]
[assembly: AssemblyTitle("NemAmpMitrhixFix")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace NemAmpMithrixFix
{
	[DefaultExecutionOrder(10000)]
	internal sealed class CrimsonBodyController : MonoBehaviour
	{
		private CharacterModel model;

		private readonly List<Renderer> targets = new List<Renderer>();

		private readonly Dictionary<Renderer, Texture> mainTextures = new Dictionary<Renderer, Texture>();

		private readonly Dictionary<Renderer, Texture> emissionTextures = new Dictionary<Renderer, Texture>();

		private readonly Dictionary<Renderer, Color> mainColors = new Dictionary<Renderer, Color>();

		private readonly Dictionary<Renderer, Color> emissionColors = new Dictionary<Renderer, Color>();

		private readonly MaterialPropertyBlock block = new MaterialPropertyBlock();

		private bool initialized;

		internal unsafe void Initialize(CharacterModel targetModel)
		{
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: 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_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			model = targetModel;
			targets.Clear();
			mainTextures.Clear();
			emissionTextures.Clear();
			mainColors.Clear();
			emissionColors.Clear();
			if (!Object.op_Implicit((Object)(object)model))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON BODY: CharacterModel was NULL.");
				return;
			}
			Renderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val) || (((Object)val).name != "Suit" && ((Object)val).name != "Cape"))
				{
					continue;
				}
				Material sharedMaterial = val.sharedMaterial;
				if (!Object.op_Implicit((Object)(object)sharedMaterial))
				{
					Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON BODY: " + ((Object)val).name + " had no material."));
					continue;
				}
				targets.Add(val);
				if (sharedMaterial.HasProperty("_MainTex"))
				{
					Texture texture = sharedMaterial.GetTexture("_MainTex");
					mainTextures[val] = texture;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON BODY: " + ((Object)val).name + " captured _MainTex=" + (Object.op_Implicit((Object)(object)texture) ? ((Object)texture).name : "NULL")));
				}
				if (sharedMaterial.HasProperty("_EmTex"))
				{
					Texture texture2 = sharedMaterial.GetTexture("_EmTex");
					emissionTextures[val] = texture2;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON BODY: " + ((Object)val).name + " captured _EmTex=" + (Object.op_Implicit((Object)(object)texture2) ? ((Object)texture2).name : "NULL")));
				}
				if (sharedMaterial.HasProperty("_Color"))
				{
					Color color = sharedMaterial.GetColor("_Color");
					mainColors[val] = color;
					string name = ((Object)val).name;
					Color val2 = color;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON BODY: " + name + " captured _Color=" + ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString()));
				}
				if (sharedMaterial.HasProperty("_EmColor"))
				{
					Color color2 = sharedMaterial.GetColor("_EmColor");
					emissionColors[val] = color2;
					string name2 = ((Object)val).name;
					Color val2 = color2;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON BODY: " + name2 + " captured _EmColor=" + ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString()));
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON BODY: Registered renderer=" + ((Object)val).name + ", material=" + ((Object)sharedMaterial).name));
			}
			initialized = true;
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON BODY: Initialized with " + targets.Count + " renderer(s)."));
		}

		private void LateUpdate()
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (!initialized || !Object.op_Implicit((Object)(object)model))
			{
				return;
			}
			foreach (Renderer target in targets)
			{
				if (Object.op_Implicit((Object)(object)target))
				{
					block.Clear();
					target.GetPropertyBlock(block);
					if (mainTextures.TryGetValue(target, out var value) && Object.op_Implicit((Object)(object)value))
					{
						block.SetTexture("_MainTex", value);
					}
					if (mainColors.TryGetValue(target, out var value2))
					{
						block.SetColor("_Color", value2);
					}
					if (emissionTextures.TryGetValue(target, out var value3) && Object.op_Implicit((Object)(object)value3))
					{
						block.SetTexture("_EmTex", value3);
					}
					if (emissionColors.TryGetValue(target, out var value4))
					{
						block.SetColor("_EmColor", value4);
					}
					target.SetPropertyBlock(block);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class CrimsonNemAmp
	{
		private const string LogPrefix = "[NemAmpPersistentCharge] CRIMSON DEBUG: ";

		private const string ColorControllerTypeName = "AmpMod.SkillStates.Nemesis_Amp.Components.NemLightningColorController";

		private const string MasterySkinToken = "NT_NEMAMP_BODY_MASTERY_SKIN_NAME";

		private const float RangeMinimumAlpha = 1f;

		private const float RangeMinimumBrightness = 7f;

		private static readonly Dictionary<int, Texture2D> crimsonBodyTextureCache = new Dictionary<int, Texture2D>();

		private static Texture2D diagnosticBodyTexture;

		private static Texture2D GetDiagnosticBodyTexture()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)diagnosticBodyTexture))
			{
				return diagnosticBodyTexture;
			}
			diagnosticBodyTexture = new Texture2D(4, 4, (TextureFormat)4, false);
			Color32[] array = (Color32[])(object)new Color32[16];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Color32(byte.MaxValue, (byte)0, (byte)0, byte.MaxValue);
			}
			diagnosticBodyTexture.SetPixels32(array);
			diagnosticBodyTexture.Apply(false, false);
			((Object)diagnosticBodyTexture).name = "CRIMSON_DIAGNOSTIC_SOLID_RED";
			((Texture)diagnosticBodyTexture).filterMode = (FilterMode)0;
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR TEST: Created solid red diagnostic texture.");
			return diagnosticBodyTexture;
		}

		private static void RunNuclearBodyDiagnostic(CharacterModel model)
		{
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)model))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR TEST FAILED: model NULL.");
				return;
			}
			Texture2D val = GetDiagnosticBodyTexture();
			Renderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<Renderer>(true);
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: ========================================");
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR TEST START");
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: ========================================");
			Renderer[] array = componentsInChildren;
			foreach (Renderer val2 in array)
			{
				if (!Object.op_Implicit((Object)(object)val2) || (((Object)val2).name != "Suit" && ((Object)val2).name != "Cape"))
				{
					continue;
				}
				Material[] sharedMaterials = val2.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				foreach (Material val3 in sharedMaterials)
				{
					if (Object.op_Implicit((Object)(object)val3))
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR TARGET: renderer=" + ((Object)val2).name + ", material=" + ((Object)val3).name));
						if (val3.HasProperty("_MainTex"))
						{
							Texture texture = val3.GetTexture("_MainTex");
							val3.SetTexture("_MainTex", (Texture)(object)val);
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR _MainTex: " + ((Object)val2).name + " " + (Object.op_Implicit((Object)(object)texture) ? ((Object)texture).name : "NULL") + " -> " + ((Object)val).name));
						}
						if (val3.HasProperty("_Color"))
						{
							val3.SetColor("_Color", Color.white);
						}
						if (val3.HasProperty("_EmTex"))
						{
							val3.SetTexture("_EmTex", (Texture)null);
						}
						if (val3.HasProperty("_EmColor"))
						{
							val3.SetColor("_EmColor", Color.black);
						}
					}
				}
				MaterialPropertyBlock val4 = new MaterialPropertyBlock();
				val2.GetPropertyBlock(val4);
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR PROPERTY BLOCK: renderer=" + ((Object)val2).name + ", wasEmpty=" + val4.isEmpty));
				val2.SetPropertyBlock((MaterialPropertyBlock)null);
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR PROPERTY BLOCK CLEARED: " + ((Object)val2).name));
			}
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY NUCLEAR TEST COMPLETE");
		}

		private static MethodBase TargetMethod()
		{
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: TARGET 1: Looking for NemLightningColorController.");
			Type type = AccessTools.TypeByName("AmpMod.SkillStates.Nemesis_Amp.Components.NemLightningColorController");
			if (type == null)
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: TARGET FAILED: NemLightningColorController not found.");
				return null;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: TARGET 2: Found controller: " + type.FullName));
			MethodInfo methodInfo = AccessTools.Method(type, "Start", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: TARGET FAILED: Start() not found.");
				return null;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: TARGET 3: Found Start(): " + methodInfo));
			return methodInfo;
		}

		private static void Prefix(object __instance, out SkinDef __state)
		{
			__state = null;
			Component val = (Component)((__instance is Component) ? __instance : null);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			CharacterBody component = val.GetComponent<CharacterBody>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			CharacterModel val2 = null;
			ModelLocator component2 = ((Component)component).GetComponent<ModelLocator>();
			if (Object.op_Implicit((Object)(object)component2) && Object.op_Implicit((Object)(object)component2.modelTransform))
			{
				val2 = ((Component)component2.modelTransform).GetComponent<CharacterModel>();
			}
			if (!Object.op_Implicit((Object)(object)val2))
			{
				val2 = val.GetComponentInChildren<CharacterModel>(true);
			}
			if (!Object.op_Implicit((Object)(object)val2))
			{
				return;
			}
			ModelSkinController component3 = ((Component)val2).GetComponent<ModelSkinController>();
			if (!Object.op_Implicit((Object)(object)component3) || component3.skins == null)
			{
				return;
			}
			int skinIndex = (int)component.skinIndex;
			if (skinIndex >= 0 && skinIndex < component3.skins.Length)
			{
				SkinDef val3 = component3.skins[skinIndex];
				if (CrimsonSkin.IsCrimsonSkin(val3))
				{
					__state = val3;
					CrimsonSkin.BeginRuntimeMasquerade(val3);
					__state = val3;
					Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: CRIMSON SKIN SHIM: Temporarily presenting Crimson as mastery so Amp initializes blue VFX.");
					val3.nameToken = "NT_NEMAMP_BODY_MASTERY_SKIN_NAME";
				}
			}
		}

		private static void Postfix(object __instance, SkinDef __state)
		{
			try
			{
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 1: Postfix entered.");
				Component val = (Component)((__instance is Component) ? __instance : null);
				if (!Object.op_Implicit((Object)(object)val))
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 2 FAILED: __instance was not a Component.");
					return;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 2: Controller=" + ((object)val).GetType().FullName));
				CharacterBody component = val.GetComponent<CharacterBody>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 3 FAILED: CharacterBody NULL.");
					return;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 3: body=" + ((Object)component).name + ", skinIndex=" + component.skinIndex));
				CharacterModel characterModel = GetCharacterModel(component, val);
				if (!Object.op_Implicit((Object)(object)characterModel))
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 4 FAILED: CharacterModel NULL.");
					return;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 4: model=" + ((Object)characterModel).name));
				ModelSkinController component2 = ((Component)characterModel).GetComponent<ModelSkinController>();
				if (!Object.op_Implicit((Object)(object)component2) || component2.skins == null)
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 5 FAILED: ModelSkinController unavailable.");
					return;
				}
				int skinIndex = (int)component.skinIndex;
				if (skinIndex < 0 || skinIndex >= component2.skins.Length)
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 6 FAILED: skinIndex out of range.");
					return;
				}
				SkinDef val2 = component2.skins[skinIndex];
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 6: Active skin=" + (Object.op_Implicit((Object)(object)val2) ? val2.nameToken : "NULL")));
				if (!Object.op_Implicit((Object)(object)val2) || !CrimsonSkin.IsCrimsonSkin(val2))
				{
					Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 7 STOP: Not Crimson skin.");
					return;
				}
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 7: Mastery/Crimson test skin confirmed.");
				Assembly assembly = ((object)val).GetType().Assembly;
				if (assembly == null)
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 8 FAILED: Amp assembly NULL.");
					return;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 8: Amp assembly=" + assembly.FullName));
				Texture ampAsset = CrimsonNemAmp.GetAmpAsset<Texture>(assembly, "texRampRedLightning", logFailure: false);
				if (Object.op_Implicit((Object)(object)characterModel))
				{
					ChildLocator component3 = ((Component)characterModel).GetComponent<ChildLocator>();
					if (Object.op_Implicit((Object)(object)component3))
					{
						Transform val3 = component3.FindChild("BuffLightningBlue");
						if (Object.op_Implicit((Object)(object)val3))
						{
							RecolorObjectHierarchyRed(((Component)val3).gameObject, ampAsset, "Model.BuffLightningBlue");
							Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: GATHERING STORM: Recolored BuffLightningBlue for Crimson.");
						}
						else
						{
							Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: GATHERING STORM WARNING: BuffLightningBlue child not found.");
						}
					}
				}
				if (Object.op_Implicit((Object)(object)ampAsset))
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 9: Red ramp=" + ((Object)ampAsset).name));
				}
				else
				{
					Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STEP 9 WARNING: No red lightning ramp found. Color-property recoloring will still run.");
				}
				HashSet<int> hashSet = new HashSet<int>();
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 1 START: Controller visual fields.");
				RecolorControllerFields(val, __instance, ampAsset, hashSet);
				RecolorNemAmpSpawnController(component, ampAsset, hashSet);
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 1 COMPLETE.");
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 2 START: Red Onslaught strike.");
				GameObject ampAsset2 = CrimsonNemAmp.GetAmpAsset<GameObject>(assembly, "lightningStrikePrefabRed", logFailure: true);
				if (Object.op_Implicit((Object)(object)ampAsset2))
				{
					SetControllerGameObjectField(val, __instance, "specialBoltVFX", ampAsset2);
				}
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 2 COMPLETE.");
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 3 START: Extra Amp assets.");
				string[] array = new string[9] { "spawnDustEffect", "spawnSecondaryExplosionEffectBlue", "bladeExpireEffectBlue", "bladeProjectileGhostBlue", "lightningStakeGhostBlue", "lightningBallExplosionEffectBlue", "stormRangeIndicatorBlue", "plasmaCrosshair", "passiveMeter" };
				string[] array2 = array;
				foreach (string text in array2)
				{
					GameObject ampAsset3 = CrimsonNemAmp.GetAmpAsset<GameObject>(assembly, text, logFailure: false);
					if (!Object.op_Implicit((Object)(object)ampAsset3))
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: EXTRA SKIP: " + text + " not found / NULL."));
						continue;
					}
					if (hashSet.Contains(((Object)ampAsset3).GetInstanceID()))
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: EXTRA SKIP: " + text + " already processed."));
						continue;
					}
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: EXTRA RECOLOR: " + text + " -> " + ((Object)ampAsset3).name));
					RecolorObjectHierarchyRed(ampAsset3, ampAsset, text);
					hashSet.Add(((Object)ampAsset3).GetInstanceID());
					if (text == "stormRangeIndicatorBlue")
					{
						BoostRangeIndicatorVisibility(ampAsset3);
					}
				}
				GameObject val4 = FindLoadedGameObjectByName("OmniImpactVFXLightningBlue");
				if (Object.op_Implicit((Object)(object)val4))
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: EXTRA LOADED OBJECT: " + ((Object)val4).name));
					RecolorObjectHierarchyRed(val4, ampAsset, "OmniImpactVFXLightningBlue");
				}
				else
				{
					Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: EXTRA LOADED OBJECT SKIP: OmniImpactVFXLightningBlue not found.");
				}
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 3 COMPLETE.");
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 3B START: Aggressive Static Field recolor.");
				GameObject ampAsset4 = CrimsonNemAmp.GetAmpAsset<GameObject>(assembly, "fieldProjectilePrefabBlue", logFailure: false);
				if (!Object.op_Implicit((Object)(object)ampAsset4))
				{
					ampAsset4 = CrimsonNemAmp.GetAmpAsset<GameObject>(assembly, "staticFieldPrefabBlue", logFailure: false);
				}
				if (Object.op_Implicit((Object)(object)ampAsset4))
				{
					AggressiveEffectRecolor(ampAsset4, ampAsset, "STATIC FIELD");
					OverrideStaticFieldTeamMaterials(ampAsset4);
				}
				else
				{
					FieldInfo fieldInfo = AccessTools.Field(((object)val).GetType(), "fieldPrefab");
					GameObject val5 = (GameObject)((fieldInfo != null) ? /*isinst with value type is only supported in some contexts*/: null);
					if (Object.op_Implicit((Object)(object)val5))
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 3B: Using controller.fieldPrefab fallback=" + ((Object)val5).name));
						AggressiveEffectRecolor(val5, ampAsset, "STATIC FIELD CONTROLLER FALLBACK");
						OverrideStaticFieldTeamMaterials(val5);
					}
					else
					{
						Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 3B FAILED: Could not locate Static Field prefab.");
					}
				}
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 3B COMPLETE.");
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 4 START: Character body.");
				MonoBehaviour val6 = (MonoBehaviour)(object)((val is MonoBehaviour) ? val : null);
				if (Object.op_Implicit((Object)(object)val6))
				{
					Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY: Starting delayed Crimson live-body setup.");
					val6.StartCoroutine(InitializeCrimsonBodyRuntime(characterModel, ampAsset));
				}
				else
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY: Could not start delayed setup. Controller was not MonoBehaviour.");
					RecolorCharacterModelRed(characterModel, ampAsset);
					CrimsonBodyController crimsonBodyController = ((Component)characterModel).GetComponent<CrimsonBodyController>();
					if (!Object.op_Implicit((Object)(object)crimsonBodyController))
					{
						crimsonBodyController = ((Component)characterModel).gameObject.AddComponent<CrimsonBodyController>();
					}
					crimsonBodyController.Initialize(characterModel);
				}
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: PASS 4 COMPLETE.");
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON FULL PASS COMPLETE. Audit the character and report anything still blue/purple, invisible, too bright, or otherwise cursed.");
			}
			catch (Exception ex)
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: UNHANDLED EXCEPTION:");
				Debug.LogError((object)ex);
			}
		}

		private static IEnumerator InitializeCrimsonBodyRuntime(CharacterModel model, Texture redRamp)
		{
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY RUNTIME: Waiting for initial skin application.");
			yield return null;
			yield return (object)new WaitForEndOfFrame();
			if (!Object.op_Implicit((Object)(object)model))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY RUNTIME FAILED: model destroyed.");
				yield break;
			}
			if (!CrimsonSkin.ApplyPreparedCrimsonToLiveModel(model))
			{
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY RUNTIME: Prepared material application failed. Using old runtime recolor fallback.");
				RecolorCharacterModelRed(model, redRamp);
			}
			CrimsonBodyController bodyController = ((Component)model).GetComponent<CrimsonBodyController>();
			if (!Object.op_Implicit((Object)(object)bodyController))
			{
				bodyController = ((Component)model).gameObject.AddComponent<CrimsonBodyController>();
			}
			bodyController.Initialize(model);
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY RUNTIME: First Crimson body application complete.");
			yield return (object)new WaitForSeconds(0.25f);
			if (Object.op_Implicit((Object)(object)model))
			{
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY RUNTIME: Late reapply result=" + CrimsonSkin.ApplyPreparedCrimsonToLiveModel(model)));
				bodyController.Initialize(model);
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY RUNTIME: Crimson body setup COMPLETE.");
			}
		}

		private static IEnumerator DelayedBodyAudit(CharacterModel model, Texture redRamp)
		{
			yield return null;
			AuditAndRepairBody(model, redRamp, "NEXT FRAME");
			yield return (object)new WaitForSeconds(0.25f);
			AuditAndRepairBody(model, redRamp, "0.25 SECONDS");
			yield return (object)new WaitForSeconds(0.75f);
			AuditAndRepairBody(model, redRamp, "1.00 SECOND");
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY DELAYED AUDIT COMPLETE.");
		}

		private unsafe static void AuditAndRepairBody(CharacterModel model, Texture redRamp, string stage)
		{
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Invalid comparison between Unknown and I4
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Invalid comparison between Unknown and I4
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)model))
			{
				Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY AUDIT " + stage + ": model NULL."));
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: ========== BODY AUDIT " + stage + " =========="));
			Renderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<Renderer>(true);
			bool flag = false;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val) || (((Object)val).name != "Suit" && ((Object)val).name != "Cape"))
				{
					continue;
				}
				Material sharedMaterial = val.sharedMaterial;
				if (!Object.op_Implicit((Object)(object)sharedMaterial))
				{
					Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY AUDIT " + stage + ": " + ((Object)val).name + " material=NULL."));
					continue;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY AUDIT " + stage + ": renderer=" + ((Object)val).name + ", material=" + ((Object)sharedMaterial).name + ", shader=" + (Object.op_Implicit((Object)(object)sharedMaterial.shader) ? ((Object)sharedMaterial.shader).name : "NULL")));
				if (sharedMaterial.HasProperty("_Color"))
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY AUDIT " + stage + ": " + ((Object)val).name + " _Color=" + ((object)sharedMaterial.GetColor("_Color")/*cast due to .constrained prefix*/).ToString()));
				}
				if (sharedMaterial.HasProperty("_EmColor"))
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY AUDIT " + stage + ": " + ((Object)val).name + " _EmColor=" + ((object)sharedMaterial.GetColor("_EmColor")/*cast due to .constrained prefix*/).ToString()));
				}
				Shader shader = sharedMaterial.shader;
				if (Object.op_Implicit((Object)(object)shader))
				{
					int propertyCount = shader.GetPropertyCount();
					for (int j = 0; j < propertyCount; j++)
					{
						string propertyName = shader.GetPropertyName(j);
						ShaderPropertyType propertyType = shader.GetPropertyType(j);
						if ((int)propertyType == 4)
						{
							Texture texture = sharedMaterial.GetTexture(propertyName);
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY TEXTURE " + stage + ": " + ((Object)val).name + "." + propertyName + "=" + (Object.op_Implicit((Object)(object)texture) ? ((Object)texture).name : "NULL")));
						}
						else if ((int)propertyType == 0)
						{
							Color color = sharedMaterial.GetColor(propertyName);
							string[] obj = new string[8]
							{
								"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY SHADER COLOR ",
								stage,
								": ",
								((Object)val).name,
								".",
								propertyName,
								"=",
								null
							};
							Color val2 = color;
							obj[7] = ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString();
							Debug.LogWarning((object)string.Concat(obj));
						}
					}
				}
				if (((Object)sharedMaterial).name.IndexOf("_CrimsonBodyRuntime", StringComparison.OrdinalIgnoreCase) < 0)
				{
					flag = true;
					Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY REVERSION DETECTED " + stage + ": " + ((Object)val).name + " reverted to " + ((Object)sharedMaterial).name));
				}
				else
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY MATERIAL STILL CRIMSON " + stage + ": " + ((Object)val).name));
				}
			}
			if (flag)
			{
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY AUDIT " + stage + ": Reversion found. Reapplying crimson body."));
				RecolorCharacterModelRed(model, redRamp);
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: ========== BODY AUDIT END " + stage + " =========="));
		}

		private static void RecolorNemAmpSpawnController(CharacterBody body, Texture redRamp, HashSet<int> processedObjects)
		{
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: SPAWN CONTROLLER: Looking for NemAmpSpawnVFXController.");
			Type type = AccessTools.TypeByName("AmpMod.SkillStates.Nemesis_Amp.Components.NemAmpSpawnVFXController");
			if (type == null)
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: SPAWN CONTROLLER FAILED: NemAmpSpawnVFXController type not found.");
				return;
			}
			Component component = ((Component)body).GetComponent(type);
			if (!Object.op_Implicit((Object)(object)component))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: SPAWN CONTROLLER FAILED: Component was not present on the body.");
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: SPAWN CONTROLLER FOUND: " + ((object)component).GetType().FullName));
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				if (typeof(GameObject).IsAssignableFrom(fieldInfo.FieldType))
				{
					object? value = fieldInfo.GetValue(component);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: SPAWN CONTROLLER FIELD: " + fieldInfo.Name + "=" + (Object.op_Implicit((Object)(object)val) ? ((Object)val).name : "NULL")));
				}
			}
			RecolorControllerFields(component, component, redRamp, processedObjects);
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: SPAWN CONTROLLER: Recolor pass complete.");
		}

		private static void OverrideStaticFieldTeamMaterials(GameObject root)
		{
			if (!Object.op_Implicit((Object)(object)root))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL FAILED: root was NULL.");
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL START: " + ((Object)root).name));
			MeshRenderer[] componentsInChildren = root.GetComponentsInChildren<MeshRenderer>(true);
			Material val = null;
			MeshRenderer[] array = componentsInChildren;
			foreach (MeshRenderer val2 in array)
			{
				if (!Object.op_Implicit((Object)(object)val2))
				{
					continue;
				}
				Material[] sharedMaterials = ((Renderer)val2).sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = sharedMaterials;
				foreach (Material val3 in array2)
				{
					if (Object.op_Implicit((Object)(object)val3))
					{
						bool flag = ((Object)val2).name.IndexOf("Mesh", StringComparison.OrdinalIgnoreCase) >= 0;
						bool flag2 = ((Object)val3).name.IndexOf("FieldSphere", StringComparison.OrdinalIgnoreCase) >= 0;
						if (flag && flag2)
						{
							val = val3;
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL: Found crimson dome material=" + ((Object)val3).name + ", renderer=" + ((Object)val2).name));
							break;
						}
					}
				}
				if (Object.op_Implicit((Object)(object)val))
				{
					break;
				}
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL FAILED: Could not find recolored FieldSphere material.");
				return;
			}
			Component[] componentsInChildren2 = root.GetComponentsInChildren<Component>(true);
			int num = 0;
			int num2 = 0;
			Component[] array3 = componentsInChildren2;
			foreach (Component val4 in array3)
			{
				if (!Object.op_Implicit((Object)(object)val4))
				{
					continue;
				}
				Type type = ((object)val4).GetType();
				if (type.FullName != "RoR2.TeamAreaIndicator" && type.Name != "TeamAreaIndicator")
				{
					continue;
				}
				num++;
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL: Found TeamAreaIndicator at " + ((Object)val4.gameObject).name + ", type=" + type.FullName));
				FieldInfo fieldInfo = AccessTools.Field(type, "teamMaterialPairs");
				if (fieldInfo == null)
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL: teamMaterialPairs field not found.");
					continue;
				}
				if (!(fieldInfo.GetValue(val4) is Array array4))
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL: teamMaterialPairs was NULL.");
					continue;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL: pairCount=" + array4.Length));
				for (int l = 0; l < array4.Length; l++)
				{
					object value = array4.GetValue(l);
					if (value == null)
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL: pair[" + l + "] was NULL."));
						continue;
					}
					Type type2 = value.GetType();
					FieldInfo fieldInfo2 = AccessTools.Field(type2, "teamIndex");
					FieldInfo fieldInfo3 = AccessTools.Field(type2, "sharedMaterial");
					if (fieldInfo3 == null)
					{
						Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL: pair[" + l + "] has no sharedMaterial field. PairType=" + type2.FullName));
						continue;
					}
					object? value2 = fieldInfo3.GetValue(value);
					Material val5 = (Material)((value2 is Material) ? value2 : null);
					string text = ((fieldInfo2 != null) ? Convert.ToString(fieldInfo2.GetValue(value)) : "UNKNOWN");
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL BEFORE: pair=" + l + ", team=" + text + ", material=" + (Object.op_Implicit((Object)(object)val5) ? ((Object)val5).name : "NULL")));
					fieldInfo3.SetValue(value, val);
					array4.SetValue(value, l);
					num2++;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL AFTER: pair=" + l + ", team=" + text + ", material=" + ((Object)val).name));
				}
				fieldInfo.SetValue(val4, array4);
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC TEAM MATERIAL COMPLETE: indicatorCount=" + num + ", replacedPairs=" + num2));
		}

		private unsafe static void DumpVisualHierarchy(GameObject root, string label)
		{
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Expected I4, but got Unknown
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)root))
			{
				Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: VISUAL DUMP FAILED: " + label + " root=NULL."));
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: ========== VISUAL DUMP START: " + label + " / " + ((Object)root).name + " =========="));
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": rendererCount=" + componentsInChildren.Length));
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": RENDERER object=" + GetTransformPath(root.transform, ((Component)val).transform) + ", type=" + ((object)val).GetType().FullName));
				MeshRenderer val2 = (MeshRenderer)(object)((val is MeshRenderer) ? val : null);
				if (Object.op_Implicit((Object)(object)val2))
				{
					MeshFilter component = ((Component)val2).GetComponent<MeshFilter>();
					if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.sharedMesh))
					{
						string[] obj = new string[6]
						{
							"[NemAmpPersistentCharge] CRIMSON DEBUG: ",
							label,
							": MESH=",
							((Object)component.sharedMesh).name,
							", bounds=",
							null
						};
						Bounds bounds = component.sharedMesh.bounds;
						obj[5] = ((object)((Bounds)(ref bounds)).size/*cast due to .constrained prefix*/).ToString();
						Debug.LogWarning((object)string.Concat(obj));
					}
				}
				LineRenderer val3 = (LineRenderer)(object)((val is LineRenderer) ? val : null);
				if (Object.op_Implicit((Object)(object)val3))
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": LINE widthMultiplier=" + val3.widthMultiplier + ", positionCount=" + val3.positionCount + ", loop=" + val3.loop));
				}
				ParticleSystemRenderer val4 = (ParticleSystemRenderer)(object)((val is ParticleSystemRenderer) ? val : null);
				if (Object.op_Implicit((Object)(object)val4))
				{
					ParticleSystem component2 = ((Component)val4).GetComponent<ParticleSystem>();
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": PARTICLE renderer=" + ((Object)val).name + ", renderMode=" + ((object)val4.renderMode/*cast due to .constrained prefix*/).ToString() + ", particle=" + (Object.op_Implicit((Object)(object)component2) ? ((Object)component2).name : "NULL")));
				}
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null)
				{
					continue;
				}
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val5 = sharedMaterials[j];
					if (!Object.op_Implicit((Object)(object)val5))
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": MATERIAL slot=" + j + " NULL"));
						continue;
					}
					Shader shader = val5.shader;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": MATERIAL object=" + GetTransformPath(root.transform, ((Component)val).transform) + ", slot=" + j + ", name=" + ((Object)val5).name + ", shader=" + (Object.op_Implicit((Object)(object)shader) ? ((Object)shader).name : "NULL") + ", renderQueue=" + val5.renderQueue));
					if (!Object.op_Implicit((Object)(object)shader))
					{
						continue;
					}
					int propertyCount = shader.GetPropertyCount();
					for (int k = 0; k < propertyCount; k++)
					{
						string propertyName = shader.GetPropertyName(k);
						ShaderPropertyType propertyType = shader.GetPropertyType(k);
						try
						{
							ShaderPropertyType val6 = propertyType;
							ShaderPropertyType val7 = val6;
							switch ((int)val7)
							{
							case 0:
							{
								Color color = val5.GetColor(propertyName);
								string[] obj2 = new string[6] { "[NemAmpPersistentCharge] CRIMSON DEBUG: ", label, ":   COLOR ", propertyName, "=", null };
								Color val8 = color;
								obj2[5] = ((object)(*(Color*)(&val8))/*cast due to .constrained prefix*/).ToString();
								Debug.LogWarning((object)string.Concat(obj2));
								break;
							}
							case 4:
							{
								Texture texture = val5.GetTexture(propertyName);
								Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ":   TEX " + propertyName + "=" + (Object.op_Implicit((Object)(object)texture) ? ((Object)texture).name : "NULL")));
								break;
							}
							case 2:
							case 3:
							{
								float num = val5.GetFloat(propertyName);
								Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ":   FLOAT " + propertyName + "=" + num));
								break;
							}
							case 1:
								break;
							}
						}
						catch (Exception ex)
						{
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": property dump failed " + propertyName + " -> " + ex.Message));
						}
					}
				}
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: ========== VISUAL DUMP END: " + label + " =========="));
		}

		private static string GetTransformPath(Transform root, Transform child)
		{
			if (!Object.op_Implicit((Object)(object)child))
			{
				return "NULL";
			}
			string text = ((Object)child).name;
			Transform parent = child.parent;
			while (Object.op_Implicit((Object)(object)parent) && (Object)(object)parent != (Object)(object)root)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static void ForceStormRangeIndicatorRed(GameObject root, Assembly ampAssembly)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Invalid comparison between Unknown and I4
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)root))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING FAILED: root was NULL.");
				return;
			}
			Material ampAsset = CrimsonNemAmp.GetAmpAsset<Material>(ampAssembly, "matLightningLongRed", logFailure: true);
			if (!Object.op_Implicit((Object)(object)ampAsset))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING FAILED: matLightningLongRed unavailable.");
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING START: root=" + ((Object)root).name));
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			int num = 0;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = (Material[])(object)new Material[sharedMaterials.Length];
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = new Material(ampAsset);
					((Object)val2).name = "CrimsonStormRange_" + ((Object)val).name + "_" + j;
					ForceStrongRedMaterial(val2, 5.5f, 1f);
					array2[j] = val2;
					num++;
				}
				val.sharedMaterials = array2;
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING MATERIAL REPLACED: renderer=" + ((Object)val).name + ", slots=" + array2.Length));
				LineRenderer val3 = (LineRenderer)(object)((val is LineRenderer) ? val : null);
				if (Object.op_Implicit((Object)(object)val3))
				{
					float widthMultiplier = val3.widthMultiplier;
					val3.widthMultiplier = Mathf.Max(widthMultiplier * 3f, 0.14f);
					val3.startColor = new Color(4f, 0.02f, 0.02f, 1f);
					val3.endColor = new Color(4f, 0.02f, 0.02f, 1f);
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING LINE: " + ((Object)val).name + " width " + widthMultiplier + " -> " + val3.widthMultiplier));
				}
				ParticleSystemRenderer val4 = (ParticleSystemRenderer)(object)((val is ParticleSystemRenderer) ? val : null);
				if (!Object.op_Implicit((Object)(object)val4))
				{
					continue;
				}
				ParticleSystem component = ((Component)val4).GetComponent<ParticleSystem>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					continue;
				}
				try
				{
					MainModule main = component.main;
					MinMaxCurve startSize = ((MainModule)(ref main)).startSize;
					if ((int)((MinMaxCurve)(ref startSize)).mode == 0)
					{
						float constant = ((MinMaxCurve)(ref startSize)).constant;
						((MainModule)(ref main)).startSize = new MinMaxCurve(constant * 1.8f);
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING PARTICLE SIZE: " + ((Object)component).name + " " + constant + " -> " + constant * 1.8f));
					}
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING PARTICLE WARNING: " + ex.Message));
				}
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STORM RING COMPLETE: materialSlotsReplaced=" + num));
		}

		private static bool ContainsAnyIgnoreCase(string value, params string[] terms)
		{
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			foreach (string value2 in terms)
			{
				if (value.IndexOf(value2, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private unsafe static void ForceStrongRedMaterial(Material material, float minimumBrightness, float minimumAlpha)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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)
			if (!Object.op_Implicit((Object)(object)material))
			{
				return;
			}
			string[] array = new string[10] { "_Color", "_TintColor", "_EmissionColor", "_EmColor", "_EmColor0", "_EmColor1", "_MainColor", "_CloudColor", "_FresnelColor", "_RimColor" };
			string[] array2 = array;
			Color val = default(Color);
			foreach (string text in array2)
			{
				if (material.HasProperty(text))
				{
					Color color = material.GetColor(text);
					float num = Mathf.Max(minimumBrightness, ((Color)(ref color)).maxColorComponent);
					((Color)(ref val))..ctor(num, num * 0.015f, num * 0.02f, Mathf.Max(color.a, minimumAlpha));
					material.SetColor(text, val);
					string[] obj = new string[8]
					{
						"[NemAmpPersistentCharge] CRIMSON DEBUG: FORCE RED MATERIAL: ",
						((Object)material).name,
						".",
						text,
						" ",
						null,
						null,
						null
					};
					Color val2 = color;
					obj[5] = ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString();
					obj[6] = " -> ";
					val2 = val;
					obj[7] = ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString();
					Debug.LogWarning((object)string.Concat(obj));
				}
			}
		}

		private static void ForceStaticFieldDomeRed(GameObject root, Assembly ampAssembly)
		{
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)root))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC DOME FAILED: root was NULL.");
				return;
			}
			Material ampAsset = CrimsonNemAmp.GetAmpAsset<Material>(ampAssembly, "matLightningSphereRed", logFailure: true);
			if (!Object.op_Implicit((Object)(object)ampAsset))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC DOME FAILED: matLightningSphereRed unavailable.");
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC DOME START: root=" + ((Object)root).name + ", redMaterial=" + ((Object)ampAsset).name));
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			int num = 0;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val) || val is TrailRenderer || val is LineRenderer)
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC DOME CANDIDATE: renderer=" + ((Object)val).name + ", rendererType=" + ((object)val).GetType().Name));
				bool flag = ContainsAnyIgnoreCase(((Object)val).name, "sphere", "dome", "shell", "bubble", "field");
				Material[] array2 = (Material[])(object)new Material[sharedMaterials.Length];
				bool flag2 = false;
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = (array2[j] = sharedMaterials[j]);
					if (Object.op_Implicit((Object)(object)val2))
					{
						string text = (Object.op_Implicit((Object)(object)val2.shader) ? ((Object)val2.shader).name : "");
						bool flag3 = ContainsAnyIgnoreCase(((Object)val2).name, "sphere", "dome", "shell", "bubble", "field", "blue");
						bool flag4 = text.IndexOf("intersectioncloud", StringComparison.OrdinalIgnoreCase) >= 0;
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC DOME MATERIAL: renderer=" + ((Object)val).name + ", material=" + ((Object)val2).name + ", shader=" + text + ", rendererNameMatch=" + flag + ", materialNameMatch=" + flag3 + ", intersectionShader=" + flag4));
						if (flag4 || flag3 || flag)
						{
							Material val3 = new Material(ampAsset);
							((Object)val3).name = "CrimsonStaticFieldSphere_" + ((Object)val).name + "_" + j;
							ForceStrongRedMaterial(val3, 2.75f, 0.9f);
							array2[j] = val3;
							flag2 = true;
							num++;
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC DOME REPLACED: " + ((Object)val).name + " slot=" + j + " " + ((Object)val2).name + " -> " + ((Object)val3).name));
						}
					}
				}
				if (flag2)
				{
					val.sharedMaterials = array2;
				}
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: STATIC DOME COMPLETE: replacements=" + num));
		}

		private static CharacterModel GetCharacterModel(CharacterBody body, Component controller)
		{
			CharacterModel val = null;
			ModelLocator component = ((Component)body).GetComponent<ModelLocator>();
			if (Object.op_Implicit((Object)(object)component) && Object.op_Implicit((Object)(object)component.modelTransform))
			{
				val = ((Component)component.modelTransform).GetComponent<CharacterModel>();
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = controller.GetComponentInChildren<CharacterModel>(true);
			}
			return val;
		}

		private unsafe static void AggressiveEffectRecolor(GameObject root, Texture redRamp, string label)
		{
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Invalid comparison between Unknown and I4
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Invalid comparison between Unknown and I4
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)root))
			{
				Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": aggressive recolor root was NULL."));
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": AGGRESSIVE RECOLOR START root=" + ((Object)root).name));
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": rendererCount=" + componentsInChildren.Length));
			Renderer[] array = componentsInChildren;
			Color val3 = default(Color);
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null)
				{
					continue;
				}
				Material[] array2 = sharedMaterials;
				foreach (Material val2 in array2)
				{
					if (!Object.op_Implicit((Object)(object)val2) || !Object.op_Implicit((Object)(object)val2.shader))
					{
						continue;
					}
					Shader shader = val2.shader;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": MATERIAL renderer=" + ((Object)val).name + ", mat=" + ((Object)val2).name + ", shader=" + ((Object)shader).name));
					int propertyCount = shader.GetPropertyCount();
					for (int k = 0; k < propertyCount; k++)
					{
						string propertyName = shader.GetPropertyName(k);
						ShaderPropertyType propertyType = shader.GetPropertyType(k);
						if ((int)propertyType == 0)
						{
							try
							{
								Color color = val2.GetColor(propertyName);
								float num = Mathf.Max(2.5f, ((Color)(ref color)).maxColorComponent);
								((Color)(ref val3))..ctor(num, num * 0.015f, num * 0.02f, Mathf.Max(color.a, 0.8f));
								val2.SetColor(propertyName, val3);
								string[] obj = new string[10]
								{
									"[NemAmpPersistentCharge] CRIMSON DEBUG: ",
									label,
									": COLOR ",
									((Object)val2).name,
									".",
									propertyName,
									" ",
									null,
									null,
									null
								};
								Color val4 = color;
								obj[7] = ((object)(*(Color*)(&val4))/*cast due to .constrained prefix*/).ToString();
								obj[8] = " -> ";
								val4 = val3;
								obj[9] = ((object)(*(Color*)(&val4))/*cast due to .constrained prefix*/).ToString();
								Debug.LogWarning((object)string.Concat(obj));
							}
							catch (Exception ex)
							{
								Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": COLOR WARNING " + propertyName + " -> " + ex.Message));
							}
						}
						if ((int)propertyType != 4 || !Object.op_Implicit((Object)(object)redRamp))
						{
							continue;
						}
						string text = propertyName.ToLowerInvariant();
						if (text.Contains("remap") || text.Contains("ramp"))
						{
							try
							{
								Texture texture = val2.GetTexture(propertyName);
								val2.SetTexture(propertyName, redRamp);
								Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": TEXTURE " + ((Object)val2).name + "." + propertyName + " " + (Object.op_Implicit((Object)(object)texture) ? ((Object)texture).name : "NULL") + " -> " + ((Object)redRamp).name));
							}
							catch (Exception ex2)
							{
								Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": TEXTURE WARNING " + propertyName + " -> " + ex2.Message));
							}
						}
					}
				}
			}
			ParticleSystem[] componentsInChildren2 = root.GetComponentsInChildren<ParticleSystem>(true);
			ParticleSystem[] array3 = componentsInChildren2;
			foreach (ParticleSystem val5 in array3)
			{
				if (!Object.op_Implicit((Object)(object)val5))
				{
					continue;
				}
				try
				{
					ColorOverLifetimeModule colorOverLifetime = val5.colorOverLifetime;
					if (((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled)
					{
						MinMaxGradient color2 = ((ColorOverLifetimeModule)(ref colorOverLifetime)).color;
						Gradient val6 = BuildStrongRedGradient(color2);
						if (val6 != null)
						{
							((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(val6);
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": ColorOverLifetime recolored on " + ((Object)val5).name));
						}
					}
				}
				catch (Exception ex3)
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": ColorOverLifetime WARNING " + ((Object)val5).name + " -> " + ex3.Message));
				}
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: " + label + ": AGGRESSIVE RECOLOR COMPLETE."));
		}

		private static Gradient BuildStrongRedGradient(MinMaxGradient source)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			Gradient val = new Gradient();
			GradientColorKey[] array = (GradientColorKey[])(object)new GradientColorKey[2]
			{
				new GradientColorKey(new Color(2.5f, 0.025f, 0.03f, 1f), 0f),
				new GradientColorKey(new Color(1.6f, 0.01f, 0.015f, 1f), 1f)
			};
			GradientAlphaKey[] array2 = (GradientAlphaKey[])(object)new GradientAlphaKey[2]
			{
				new GradientAlphaKey(1f, 0f),
				new GradientAlphaKey(0f, 1f)
			};
			val.SetKeys(array, array2);
			return val;
		}

		private static void RecolorControllerFields(Component controller, object instance, Texture redRamp, HashSet<int> processedObjects)
		{
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			FieldInfo[] fields = ((object)controller).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER SWEEP: " + fields.Length + " field(s) found."));
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				try
				{
					if (typeof(GameObject).IsAssignableFrom(fieldInfo.FieldType))
					{
						if (fieldInfo.Name == "specialBoltVFX")
						{
							Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER SKIP: specialBoltVFX reserved for red strike replacement.");
							continue;
						}
						object? value = fieldInfo.GetValue(instance);
						GameObject val = (GameObject)((value is GameObject) ? value : null);
						if (!Object.op_Implicit((Object)(object)val))
						{
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER NULL: " + fieldInfo.Name));
							continue;
						}
						int instanceID = ((Object)val).GetInstanceID();
						if (processedObjects.Contains(instanceID))
						{
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER DUPLICATE: " + fieldInfo.Name + " -> " + ((Object)val).name));
							continue;
						}
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER RECOLOR: " + fieldInfo.Name + " -> " + ((Object)val).name));
						RecolorObjectHierarchyRed(val, redRamp, "Controller." + fieldInfo.Name);
						processedObjects.Add(instanceID);
					}
					else if (typeof(Material).IsAssignableFrom(fieldInfo.FieldType))
					{
						object? value2 = fieldInfo.GetValue(instance);
						Material val2 = (Material)((value2 is Material) ? value2 : null);
						if (!Object.op_Implicit((Object)(object)val2))
						{
							Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER MATERIAL NULL: " + fieldInfo.Name));
							continue;
						}
						Material val3 = new Material(val2);
						((Object)val3).name = ((Object)val2).name + "_CrimsonBodyRuntime";
						RecolorBodyMaterial(val3, redRamp);
						fieldInfo.SetValue(instance, val3);
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER MATERIAL: " + fieldInfo.Name + " " + ((Object)val2).name + " -> " + ((Object)val3).name));
					}
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CONTROLLER FIELD WARNING: " + fieldInfo.Name + " -> " + ex.Message));
				}
			}
		}

		internal unsafe static void RecolorNemAmpBodyTextures(Material material, string rendererName)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)material))
			{
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY TEXTURE RECOLOR START: renderer=" + rendererName + ", material=" + ((Object)material).name));
			if (material.HasProperty("_MainTex"))
			{
				Texture texture = material.GetTexture("_MainTex");
				if (Object.op_Implicit((Object)(object)texture))
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY MAIN TEXTURE BEFORE: " + rendererName + " = " + ((Object)texture).name));
					Texture2D val = CreateCrimsonTexture(texture, rendererName + "_Main");
					if (Object.op_Implicit((Object)(object)val))
					{
						material.SetTexture("_MainTex", (Texture)(object)val);
						if (material.HasProperty("_Color"))
						{
							material.SetColor("_Color", Color.white);
						}
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY MAIN TEXTURE AFTER: " + rendererName + " = " + ((Object)val).name));
					}
				}
			}
			if (material.HasProperty("_EmTex"))
			{
				Texture texture2 = material.GetTexture("_EmTex");
				if (Object.op_Implicit((Object)(object)texture2))
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY EMISSION TEXTURE BEFORE: " + rendererName + " = " + ((Object)texture2).name));
					Texture2D val2 = CreateCrimsonTexture(texture2, rendererName + "_Emission");
					if (Object.op_Implicit((Object)(object)val2))
					{
						material.SetTexture("_EmTex", (Texture)(object)val2);
						if (material.HasProperty("_EmColor"))
						{
							material.SetColor("_EmColor", new Color(2.6f, 0.05f, 0.065f, 1f));
						}
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY EMISSION TEXTURE AFTER: " + rendererName + " = " + ((Object)val2).name));
					}
				}
			}
			if (rendererName == "Cape" && material.HasProperty("_EmColor"))
			{
				Color color = material.GetColor("_EmColor");
				material.SetColor("_EmColor", Color.black);
				Color val3 = color;
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY CAPE EMISSION: " + ((object)(*(Color*)(&val3))/*cast due to .constrained prefix*/).ToString() + " -> " + ((object)Color.black/*cast due to .constrained prefix*/).ToString()));
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY TEXTURE RECOLOR COMPLETE: " + rendererName));
		}

		private static Texture2D CreateCrimsonTexture(Texture source, string label)
		{
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_014e: 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_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: 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)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)source))
			{
				Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CRIMSON TEXTURE FAILED: " + label + " source=NULL."));
				return null;
			}
			int instanceID = ((Object)source).GetInstanceID();
			if (crimsonBodyTextureCache.TryGetValue(instanceID, out var value) && Object.op_Implicit((Object)(object)value))
			{
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CRIMSON TEXTURE CACHE HIT: " + ((Object)source).name));
				return value;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CRIMSON TEXTURE START: " + label + ", source=" + ((Object)source).name + ", size=" + source.width + "x" + source.height));
			RenderTexture temporary = RenderTexture.GetTemporary(source.width, source.height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)0);
			RenderTexture active = RenderTexture.active;
			Texture2D val = null;
			try
			{
				Graphics.Blit(source, temporary);
				RenderTexture.active = temporary;
				Texture2D val2 = (Texture2D)(object)((source is Texture2D) ? source : null);
				bool flag = val2 != null && ((Texture)val2).mipmapCount > 1;
				val = new Texture2D(source.width, source.height, (TextureFormat)4, flag);
				val.ReadPixels(new Rect(0f, 0f, (float)source.width, (float)source.height), 0, 0);
				val.Apply(false, false);
				Color32[] pixels = val.GetPixels32();
				int num = 0;
				float num2 = default(float);
				float num3 = default(float);
				float num4 = default(float);
				for (int i = 0; i < pixels.Length; i++)
				{
					Color32 val3 = pixels[i];
					Color val4 = Color32.op_Implicit(val3);
					Color.RGBToHSV(val4, ref num2, ref num3, ref num4);
					if (num3 >= 0.12f && num2 >= 0.45f && num2 <= 0.9f)
					{
						float num5 = 0.995f;
						Color val5 = Color.HSVToRGB(num5, num3, num4);
						val5.a = val4.a;
						pixels[i] = Color32.op_Implicit(val5);
						num++;
					}
				}
				val.SetPixels32(pixels);
				val.Apply(flag, false);
				((Object)val).name = ((Object)source).name + "_CrimsonRuntime";
				Texture2D val6 = (Texture2D)(object)((source is Texture2D) ? source : null);
				if (val6 != null)
				{
					((Texture)val).filterMode = ((Texture)val6).filterMode;
					((Texture)val).wrapMode = ((Texture)val6).wrapMode;
					((Texture)val).anisoLevel = ((Texture)val6).anisoLevel;
				}
				crimsonBodyTextureCache[instanceID] = val;
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CRIMSON TEXTURE COMPLETE: " + ((Object)source).name + " -> " + ((Object)val).name + ", changedPixels=" + num + "/" + pixels.Length));
				return val;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: CRIMSON TEXTURE FAILED: " + ((Object)source).name));
				Debug.LogError((object)ex);
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Destroy((Object)(object)val);
				}
				return null;
			}
			finally
			{
				RenderTexture.active = active;
				RenderTexture.ReleaseTemporary(temporary);
			}
		}

		private static bool SetControllerGameObjectField(Component controller, object instance, string fieldName, GameObject value)
		{
			FieldInfo fieldInfo = AccessTools.Field(((object)controller).GetType(), fieldName);
			if (fieldInfo == null)
			{
				Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: FIELD FAILED: " + fieldName + " not found."));
				return false;
			}
			object? value2 = fieldInfo.GetValue(instance);
			GameObject val = (GameObject)((value2 is GameObject) ? value2 : null);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: FIELD BEFORE: " + fieldName + "=" + (Object.op_Implicit((Object)(object)val) ? ((Object)val).name : "NULL")));
			fieldInfo.SetValue(instance, value);
			object? value3 = fieldInfo.GetValue(instance);
			GameObject val2 = (GameObject)((value3 is GameObject) ? value3 : null);
			bool result = (Object)(object)val2 == (Object)(object)value;
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: FIELD AFTER: " + fieldName + "=" + (Object.op_Implicit((Object)(object)val2) ? ((Object)val2).name : "NULL") + ", success=" + result));
			return result;
		}

		internal static void RecolorObjectHierarchyRed(GameObject root, Texture redRamp, string label)
		{
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Invalid comparison between Unknown and I4
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Invalid comparison between Unknown and I4
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)root))
			{
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RECOLOR START: " + label + " root=" + ((Object)root).name));
			Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RECOLOR: " + label + " rendererCount=" + componentsInChildren.Length));
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = (Material[])(object)new Material[sharedMaterials.Length];
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!Object.op_Implicit((Object)(object)val2))
					{
						array2[j] = null;
						continue;
					}
					Material val3 = new Material(val2);
					((Object)val3).name = ((Object)val2).name + "_CrimsonRuntime";
					RecolorMaterialRed(val3, redRamp, strongEffectColor: true);
					array2[j] = val3;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RECOLOR MATERIAL: " + label + " renderer=" + ((Object)val).name + ", " + ((Object)val2).name + " -> " + ((Object)val3).name));
				}
				val.sharedMaterials = array2;
				ParticleSystemRenderer val4 = (ParticleSystemRenderer)(object)((val is ParticleSystemRenderer) ? val : null);
				if (Object.op_Implicit((Object)(object)val4) && Object.op_Implicit((Object)(object)val4.trailMaterial))
				{
					Material trailMaterial = val4.trailMaterial;
					Material val5 = new Material(trailMaterial);
					((Object)val5).name = ((Object)trailMaterial).name + "_CrimsonTrailRuntime";
					RecolorMaterialRed(val5, redRamp, strongEffectColor: true);
					val4.trailMaterial = val5;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RECOLOR TRAIL MATERIAL: " + label + " renderer=" + ((Object)val).name));
				}
			}
			ParticleSystem[] componentsInChildren2 = root.GetComponentsInChildren<ParticleSystem>(true);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RECOLOR: " + label + " particleCount=" + componentsInChildren2.Length));
			ParticleSystem[] array3 = componentsInChildren2;
			foreach (ParticleSystem val6 in array3)
			{
				if (!Object.op_Implicit((Object)(object)val6))
				{
					continue;
				}
				try
				{
					MainModule main = val6.main;
					MinMaxGradient startColor = ((MainModule)(ref main)).startColor;
					if ((int)((MinMaxGradient)(ref startColor)).mode == 0)
					{
						((MainModule)(ref main)).startColor = new MinMaxGradient(ToCrimson(((MinMaxGradient)(ref startColor)).color, minimumBrightness: false));
						continue;
					}
					if ((int)((MinMaxGradient)(ref startColor)).mode == 2)
					{
						((MainModule)(ref main)).startColor = new MinMaxGradient(ToCrimson(((MinMaxGradient)(ref startColor)).colorMin, minimumBrightness: false), ToCrimson(((MinMaxGradient)(ref startColor)).colorMax, minimumBrightness: false));
						continue;
					}
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: PARTICLE GRADIENT PRESERVED: " + label + " particle=" + ((Object)val6).name + ", mode=" + ((object)((MinMaxGradient)(ref startColor)).mode/*cast due to .constrained prefix*/).ToString()));
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: PARTICLE WARNING: " + ((Object)val6).name + " -> " + ex.Message));
				}
			}
			TrailRenderer[] componentsInChildren3 = root.GetComponentsInChildren<TrailRenderer>(true);
			TrailRenderer[] array4 = componentsInChildren3;
			foreach (TrailRenderer val7 in array4)
			{
				if (Object.op_Implicit((Object)(object)val7))
				{
					val7.colorGradient = RecolorGradientRed(val7.colorGradient);
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: TRAIL GRADIENT: " + label + " trail=" + ((Object)val7).name));
				}
			}
			LineRenderer[] componentsInChildren4 = root.GetComponentsInChildren<LineRenderer>(true);
			LineRenderer[] array5 = componentsInChildren4;
			foreach (LineRenderer val8 in array5)
			{
				if (Object.op_Implicit((Object)(object)val8))
				{
					val8.colorGradient = RecolorGradientRed(val8.colorGradient);
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: LINE GRADIENT: " + label + " line=" + ((Object)val8).name));
				}
			}
			Light[] componentsInChildren5 = root.GetComponentsInChildren<Light>(true);
			Light[] array6 = componentsInChildren5;
			foreach (Light val9 in array6)
			{
				if (Object.op_Implicit((Object)(object)val9))
				{
					val9.color = new Color(1f, 0.015f, 0.015f, 1f);
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: LIGHT: " + label + " light=" + ((Object)val9).name));
				}
			}
			RecolorUiImagesByReflection(root, label);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RECOLOR COMPLETE: " + label));
		}

		private unsafe static void RecolorCharacterModelRed(CharacterModel model, Texture redRamp)
		{
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0608: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)model))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY FAILED: CharacterModel was NULL.");
				return;
			}
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: ==========================================");
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY PASS START: " + ((Object)model).name));
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: ==========================================");
			Renderer[] componentsInChildren = ((Component)model).GetComponentsInChildren<Renderer>(true);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY: rendererCount=" + componentsInChildren.Length));
			Dictionary<Renderer, Material> dictionary = new Dictionary<Renderer, Material>();
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Material[] sharedMaterials = val.sharedMaterials;
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY RENDERER: " + ((Object)val).name + ", type=" + ((object)val).GetType().FullName + ", materialSlots=" + ((sharedMaterials != null) ? sharedMaterials.Length : 0)));
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = (Material[])(object)new Material[sharedMaterials.Length];
				for (int j = 0; j < sharedMaterials.Length; j++)
				{
					Material val2 = sharedMaterials[j];
					if (!Object.op_Implicit((Object)(object)val2))
					{
						array2[j] = null;
						continue;
					}
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY BEFORE: renderer=" + ((Object)val).name + ", slot=" + j + ", material=" + ((Object)val2).name + ", shader=" + (Object.op_Implicit((Object)(object)val2.shader) ? ((Object)val2.shader).name : "NULL")));
					Material val3 = new Material(val2);
					((Object)val3).name = ((Object)val2).name + "_CrimsonBodyRuntime";
					RecolorBodyMaterial(val3, redRamp);
					if (((Object)val).name == "Suit" || ((Object)val).name == "Cape")
					{
						RecolorNemAmpBodyTextures(val3, ((Object)val).name);
					}
					array2[j] = val3;
					if (j == 0 && !dictionary.ContainsKey(val))
					{
						dictionary.Add(val, val3);
					}
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY AFTER: renderer=" + ((Object)val).name + ", slot=" + j + ", material=" + ((Object)val3).name));
				}
				val.sharedMaterials = array2;
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY ASSIGNED LIVE MATERIALS: " + ((Object)val).name));
			}
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY BASE INFO: Looking for baseRendererInfos.");
			FieldInfo fieldInfo = AccessTools.Field(((object)model).GetType(), "baseRendererInfos");
			if (fieldInfo == null)
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY BASE INFO FAILED: baseRendererInfos field not found.");
			}
			else if (!(fieldInfo.GetValue(model) is Array array3))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY BASE INFO FAILED: baseRendererInfos was NULL.");
			}
			else
			{
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY BASE INFO: entryCount=" + array3.Length));
				int num = 0;
				for (int k = 0; k < array3.Length; k++)
				{
					object value = array3.GetValue(k);
					if (value == null)
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY INFO[" + k + "] was NULL."));
						continue;
					}
					Type type = value.GetType();
					FieldInfo fieldInfo2 = AccessTools.Field(type, "renderer");
					FieldInfo fieldInfo3 = AccessTools.Field(type, "defaultMaterial");
					if (fieldInfo2 == null || fieldInfo3 == null)
					{
						Debug.LogError((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY INFO[" + k + "] FAILED: fields missing. type=" + type.FullName));
						continue;
					}
					object? value2 = fieldInfo2.GetValue(value);
					Renderer val4 = (Renderer)((value2 is Renderer) ? value2 : null);
					object? value3 = fieldInfo3.GetValue(value);
					Material val5 = (Material)((value3 is Material) ? value3 : null);
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY INFO BEFORE [" + k + "]: renderer=" + (Object.op_Implicit((Object)(object)val4) ? ((Object)val4).name : "NULL") + ", defaultMaterial=" + (Object.op_Implicit((Object)(object)val5) ? ((Object)val5).name : "NULL")));
					if (!Object.op_Implicit((Object)(object)val4) || !dictionary.TryGetValue(val4, out var value4))
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY INFO[" + k + "]: no matching crimson renderer material."));
						continue;
					}
					fieldInfo3.SetValue(value, value4);
					array3.SetValue(value, k);
					num++;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY INFO AFTER [" + k + "]: renderer=" + ((Object)val4).name + ", defaultMaterial=" + ((Object)value4).name));
				}
				fieldInfo.SetValue(model, array3);
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY BASE INFO COMPLETE: patched=" + num));
			}
			Light[] componentsInChildren2 = ((Component)model).GetComponentsInChildren<Light>(true);
			Light[] array4 = componentsInChildren2;
			foreach (Light val6 in array4)
			{
				if (Object.op_Implicit((Object)(object)val6))
				{
					Color color = val6.color;
					val6.color = new Color(1f, 0.02f, 0.02f, 1f);
					string[] obj = new string[6]
					{
						"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY LIGHT: ",
						((Object)val6).name,
						" ",
						null,
						null,
						null
					};
					Color val7 = color;
					obj[3] = ((object)(*(Color*)(&val7))/*cast due to .constrained prefix*/).ToString();
					obj[4] = " -> ";
					obj[5] = ((object)val6.color/*cast due to .constrained prefix*/).ToString();
					Debug.LogWarning((object)string.Concat(obj));
				}
			}
			MethodInfo methodInfo = AccessTools.Method(((object)model).GetType(), "UpdateMaterials", Type.EmptyTypes, (Type[])null);
			if (methodInfo != null)
			{
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY: Calling CharacterModel.UpdateMaterials().");
				try
				{
					methodInfo.Invoke(model, null);
					Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY: UpdateMaterials() completed.");
				}
				catch (Exception ex)
				{
					Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY: UpdateMaterials() threw:");
					Debug.LogError((object)ex);
				}
			}
			else
			{
				Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY: No zero-argument UpdateMaterials() found.");
			}
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY READBACK START.");
			Renderer[] array5 = componentsInChildren;
			foreach (Renderer val8 in array5)
			{
				if (!Object.op_Implicit((Object)(object)val8))
				{
					continue;
				}
				Material[] sharedMaterials2 = val8.sharedMaterials;
				if (sharedMaterials2 != null)
				{
					for (int n = 0; n < sharedMaterials2.Length; n++)
					{
						Material val9 = sharedMaterials2[n];
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY READBACK: renderer=" + ((Object)val8).name + ", slot=" + n + ", material=" + (Object.op_Implicit((Object)(object)val9) ? ((Object)val9).name : "NULL")));
					}
				}
			}
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: ==========================================");
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY PASS COMPLETE.");
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: ==========================================");
		}

		internal unsafe static void RecolorBodyMaterial(Material material, Texture redRamp)
		{
			//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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)material))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)redRamp) && material.HasProperty("_RemapTex"))
			{
				material.SetTexture("_RemapTex", redRamp);
			}
			if (material.HasProperty("_Color"))
			{
				Color color = material.GetColor("_Color");
				material.SetColor("_Color", new Color(0.72f, 0.035f, 0.045f, color.a));
				string[] obj = new string[6]
				{
					"[NemAmpPersistentCharge] CRIMSON DEBUG: BODY COLOR: ",
					((Object)material).name,
					" _Color ",
					null,
					null,
					null
				};
				Color val = color;
				obj[3] = ((object)(*(Color*)(&val))/*cast due to .constrained prefix*/).ToString();
				obj[4] = " -> ";
				obj[5] = ((object)material.GetColor("_Color")/*cast due to .constrained prefix*/).ToString();
				Debug.LogWarning((object)string.Concat(obj));
			}
			string[] array = new string[6] { "_EmissionColor", "_EmColor", "_EmColor0", "_EmColor1", "_FresnelColor", "_RimColor" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (material.HasProperty(text))
				{
					Color color2 = material.GetColor(text);
					float num = Mathf.Max(2f, ((Color)(ref color2)).maxColorComponent);
					material.SetColor(text, new Color(num, num * 0.02f, num * 0.025f, color2.a));
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: BODY EMISSION: " + ((Object)material).name + "." + text));
				}
			}
		}

		private unsafe static void RecolorMaterialRed(Material material, Texture redRamp, bool strongEffectColor)
		{
			//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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)material))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)redRamp) && material.HasProperty("_RemapTex"))
			{
				material.SetTexture("_RemapTex", redRamp);
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: MATERIAL REMAP: " + ((Object)material).name));
			}
			string[] array = new string[10] { "_Color", "_TintColor", "_EmissionColor", "_EmColor", "_EmColor0", "_EmColor1", "_MainColor", "_CloudColor", "_FresnelColor", "_RimColor" };
			string[] array2 = array;
			Color val = default(Color);
			foreach (string text in array2)
			{
				if (material.HasProperty(text))
				{
					Color color = material.GetColor(text);
					float num = Mathf.Max(strongEffectColor ? 1.35f : 1f, ((Color)(ref color)).maxColorComponent);
					((Color)(ref val))..ctor(num, num * 0.025f, num * 0.03f, color.a);
					material.SetColor(text, val);
					string[] obj = new string[8]
					{
						"[NemAmpPersistentCharge] CRIMSON DEBUG: MATERIAL COLOR: ",
						((Object)material).name,
						".",
						text,
						" ",
						null,
						null,
						null
					};
					Color val2 = color;
					obj[5] = ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString();
					obj[6] = " -> ";
					val2 = val;
					obj[7] = ((object)(*(Color*)(&val2))/*cast due to .constrained prefix*/).ToString();
					Debug.LogWarning((object)string.Concat(obj));
				}
			}
		}

		private unsafe static void BoostRangeIndicatorVisibility(GameObject root)
		{
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)root))
			{
				Debug.LogError((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE BOOST FAILED: root was NULL.");
				return;
			}
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE BOOST START: " + ((Object)root).name));
			MeshRenderer[] componentsInChildren = root.GetComponentsInChildren<MeshRenderer>(true);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE BOOST: MeshRenderer count=" + componentsInChildren.Length));
			MeshRenderer[] array = componentsInChildren;
			Color val3 = default(Color);
			foreach (MeshRenderer val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Material[] sharedMaterials = ((Renderer)val).sharedMaterials;
				if (sharedMaterials == null || sharedMaterials.Length == 0)
				{
					continue;
				}
				Material[] array2 = sharedMaterials;
				foreach (Material val2 in array2)
				{
					if (!Object.op_Implicit((Object)(object)val2))
					{
						continue;
					}
					if (((Object)val).name.IndexOf("Radius", StringComparison.OrdinalIgnoreCase) < 0 && ((Object)val2).name.IndexOf("StormRange", StringComparison.OrdinalIgnoreCase) < 0)
					{
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE BOOST SKIP: renderer=" + ((Object)val).name + ", material=" + ((Object)val2).name));
						continue;
					}
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE BOOST TARGET FOUND: renderer=" + ((Object)val).name + ", material=" + ((Object)val2).name + ", oldQueue=" + val2.renderQueue + ", oldSortingOrder=" + ((Renderer)val).sortingOrder));
					if (val2.HasProperty("_TintColor"))
					{
						Color color = val2.GetColor("_TintColor");
						((Color)(ref val3))..ctor(Mathf.Max(7f, color.r), 0.12f, 0.12f, 1f);
						val2.SetColor("_TintColor", val3);
						Color val4 = color;
						string? text = ((object)(*(Color*)(&val4))/*cast due to .constrained prefix*/).ToString();
						val4 = val3;
						Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE _TintColor: " + text + " -> " + ((object)(*(Color*)(&val4))/*cast due to .constrained prefix*/).ToString()));
					}
					SetRangeFloat(val2, "_Boost", 3.25f);
					SetRangeFloat(val2, "_AlphaBoost", 2f);
					SetRangeFloat(val2, "_IntersectionStrength", 1.35f);
					SetRangeFloat(val2, "_ExternalAlpha", 1f);
					SetRangeFloat(val2, "_SoftPower", 0.85f);
					int renderQueue = val2.renderQueue;
					int sortingOrder = ((Renderer)val).sortingOrder;
					val2.renderQueue = 3500;
					((Renderer)val).sortingOrder = 50;
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE ORDER: queue " + renderQueue + " -> " + val2.renderQueue + ", sortingOrder " + sortingOrder + " -> " + ((Renderer)val).sortingOrder));
					Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE FINAL: Boost=" + ReadRangeFloat(val2, "_Boost") + ", AlphaBoost=" + ReadRangeFloat(val2, "_AlphaBoost") + ", IntersectionStrength=" + ReadRangeFloat(val2, "_IntersectionStrength")));
				}
			}
			Debug.LogWarning((object)"[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE BOOST COMPLETE.");
		}

		private static void SetRangeFloat(Material material, string property, float value)
		{
			if (!Object.op_Implicit((Object)(object)material) || !material.HasProperty(property))
			{
				Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE PROPERTY MISSING: " + property));
				return;
			}
			float num = material.GetFloat(property);
			material.SetFloat(property, value);
			Debug.LogWarning((object)("[NemAmpPersistentCharge] CRIMSON DEBUG: RANGE FLOAT: " + property + " " + num + " -> " + value));
		}

		private static string ReadRangeFloat(Material material, string property)
		{
			if (!Object.op_Implicit((Object)(object)material) || !material.HasProperty(property))
			{
				return "MISSING";
			}
			return material.GetFloat(property).ToString("0.###");
		}

		private static Color ToCrimson(Color source, bool minimumBrightness)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			float num = ((Color)(ref source)).maxColorComponent;
			if (minimumBrightness)
			{
				num = Mathf.Max(1f, num);
			}
			if (num <= 0.001f)
			{
				return source;
			}
			return new Color(num, num * 0.025f, num * 0.03f, source.a);
		}

		private static Gradient RecolorGradientRed(Gradient original)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			if (original == null)
			{
				return original;
			}
			Gradient val = new Gradient();
			GradientColorKey[] colorKeys = original.colorKeys;
			GradientColorKey[] array = (GradientColorKey[])(object)new GradientColorKey[colorKeys.Length];
			for (int i = 0; i < colorKeys