using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using EntityStates;
using EntityStates.Engi.EngiWeapon;
using HG.Reflection;
using R2API;
using R2API.Utils;
using RoR2;
using RoR2.Projectile;
using RoR2.UI.MainMenu;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Rendering;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: AssemblyVersion("0.0.0.0")]
namespace EngineerMineSurveyorPlaytest;

[BepInPlugin("eclipseplaytest.engineer.e2", "Engineer - Mine Surveyor (Playtest)", "0.1.2")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class EngineerMineSurveyor : BaseUnityPlugin
{
	private sealed class Prepared
	{
		public string BodyName;

		public GameObject Model;

		public ModelSkinController Controller;

		public SkinDef Skin;

		public Mesh Mesh;

		public Mesh Reference;

		public Material Material;
	}

	private sealed class Design
	{
		public string Slug;

		public string Name;

		public Color32[] Colors;

		public Design(string slug, string name, Color32[] colors)
		{
			Slug = slug;
			Name = name;
			Colors = colors;
		}
	}

	public sealed class MineSurveyorVisuals : MonoBehaviour
	{
		private sealed class Saved
		{
			public Renderer Renderer;

			public Mesh Mesh;

			public Material[] Materials;

			public Bounds Bounds;

			public bool Offscreen;

			public bool ChangeMesh;

			public bool ChangeMaterial;

			public Mesh AssignedMesh;

			public Material[] AssignedMaterials;

			public bool ChangeBounds;

			public Bounds AssignedBounds;

			public bool ChangeOffscreen;

			public bool AssignedOffscreen;
		}

		private readonly Dictionary<Renderer, Saved> changed = new Dictionary<Renderer, Saved>();

		private ModelSkinController controller;

		private CharacterBody body;

		private EntityStateMachine[] machines;

		private bool lobbyDirty = true;

		private static readonly FieldInfo Blueprint = typeof(PlaceTurret).GetField("blueprints", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private static readonly FieldInfo Wrist = typeof(PlaceTurret).GetField("wristDisplayObject", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private void Applied(int index)
		{
			if (!OwnSkin() && changed.Count > 0)
			{
				Restore();
			}
			lobbyDirty = true;
		}

		private void Start()
		{
			controller = ((Component)this).GetComponentInChildren<ModelSkinController>(true);
			body = ((Component)this).GetComponentInParent<CharacterBody>();
			machines = (EntityStateMachine[])(Object.op_Implicit((Object)(object)body) ? ((Array)((Component)body).GetComponents<EntityStateMachine>()) : ((Array)new EntityStateMachine[0]));
			if (Object.op_Implicit((Object)(object)controller))
			{
				controller.onSkinApplied += Applied;
			}
		}

		private bool OwnSkin()
		{
			if (!Object.op_Implicit((Object)(object)controller) || controller.skins == null)
			{
				return false;
			}
			int currentSkinIndex = controller.currentSkinIndex;
			if (currentSkinIndex >= 0 && currentSkinIndex < controller.skins.Length && Object.op_Implicit((Object)(object)controller.skins[currentSkinIndex]))
			{
				return ((Object)controller.skins[currentSkinIndex]).name.StartsWith("skinEclipsePlaytestEngineerE2_", StringComparison.Ordinal);
			}
			return false;
		}

		private Saved Save(Renderer r)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (changed.TryGetValue(r, out var value))
			{
				return value;
			}
			SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((r is SkinnedMeshRenderer) ? r : null);
			MeshFilter component = ((Component)r).GetComponent<MeshFilter>();
			value = new Saved
			{
				Renderer = r,
				Materials = r.sharedMaterials,
				Mesh = (Object.op_Implicit((Object)(object)val) ? val.sharedMesh : (Object.op_Implicit((Object)(object)component) ? component.sharedMesh : null)),
				Bounds = (Bounds)(Object.op_Implicit((Object)(object)val) ? ((Renderer)val).localBounds : default(Bounds)),
				Offscreen = (Object.op_Implicit((Object)(object)val) && val.updateWhenOffscreen)
			};
			changed.Add(r, value);
			return value;
		}

		private void ApplySkinned(SkinnedMeshRenderer r, string asset, bool keepMaterial)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			Saved saved = Save((Renderer)(object)r);
			saved.ChangeMesh = true;
			saved.ChangeMaterial = !keepMaterial;
			Mesh val = (saved.AssignedMesh = instance.MeshFor(asset, r));
			if ((Object)(object)r.sharedMesh != (Object)(object)val)
			{
				r.sharedMesh = val;
				Mesh val2 = new Mesh();
				r.BakeMesh(val2);
				Bounds bounds = saved.Bounds;
				Bounds bounds2 = val2.bounds;
				((Bounds)(ref bounds)).Encapsulate(((Bounds)(ref bounds2)).min);
				bounds2 = val2.bounds;
				((Bounds)(ref bounds)).Encapsulate(((Bounds)(ref bounds2)).max);
				((Bounds)(ref bounds)).Expand(((Bounds)(ref bounds)).size * 0.5f);
				((Renderer)r).localBounds = bounds;
				saved.ChangeBounds = true;
				saved.AssignedBounds = bounds;
				Object.Destroy((Object)(object)val2);
			}
			r.updateWhenOffscreen = true;
			saved.ChangeOffscreen = true;
			saved.AssignedOffscreen = true;
			if (!keepMaterial)
			{
				((Renderer)r).sharedMaterial = instance.prepared.Single((Prepared p) => p.BodyName == ((asset == "walker") ? "EngiWalkerTurretBody" : "EngiTurretBody")).Material;
				saved.AssignedMaterials = ((Renderer)r).sharedMaterials;
			}
		}

		private void Restore()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			foreach (Saved value in changed.Values)
			{
				if (!Object.op_Implicit((Object)(object)value.Renderer))
				{
					continue;
				}
				Renderer renderer = value.Renderer;
				SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
				MeshFilter component = ((Component)value.Renderer).GetComponent<MeshFilter>();
				if (Object.op_Implicit((Object)(object)val))
				{
					if (value.ChangeMesh && (Object)(object)val.sharedMesh == (Object)(object)value.AssignedMesh)
					{
						if (value.ChangeBounds && ((Renderer)val).localBounds == value.AssignedBounds)
						{
							((Renderer)val).localBounds = value.Bounds;
						}
						if (value.ChangeOffscreen && val.updateWhenOffscreen == value.AssignedOffscreen)
						{
							val.updateWhenOffscreen = value.Offscreen;
						}
						val.sharedMesh = value.Mesh;
					}
				}
				else if (Object.op_Implicit((Object)(object)component) && value.ChangeMesh && (Object)(object)component.sharedMesh == (Object)(object)value.AssignedMesh)
				{
					component.sharedMesh = value.Mesh;
				}
				if (value.ChangeMaterial && value.AssignedMaterials != null && value.Renderer.sharedMaterials.SequenceEqual(value.AssignedMaterials))
				{
					value.Renderer.sharedMaterials = value.Materials;
				}
			}
			changed.Clear();
		}

		private void LateUpdate()
		{
			if (!Object.op_Implicit((Object)(object)instance) || !instance.registered)
			{
				return;
			}
			Renderer[] array = changed.Keys.Where((Renderer r) => !Object.op_Implicit((Object)(object)r)).ToArray();
			foreach (Renderer key in array)
			{
				changed.Remove(key);
			}
			if (!OwnSkin())
			{
				if (changed.Count > 0)
				{
					Restore();
				}
				lobbyDirty = true;
				return;
			}
			if (!Object.op_Implicit((Object)(object)body))
			{
				if (!lobbyDirty)
				{
					return;
				}
				lobbyDirty = false;
				SkinnedMeshRenderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<SkinnedMeshRenderer>(true);
				foreach (SkinnedMeshRenderer val in componentsInChildren)
				{
					if (val.bones.Length == 15 && Object.op_Implicit((Object)(object)((Component)this).transform.Find("TurretHolder")) && ((Component)val).transform.IsChildOf(((Component)this).transform.Find("TurretHolder")))
					{
						ApplySkinned(val, "turret", keepMaterial: false);
					}
					else if (((Object)val).name.IndexOf("Mine", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						Saved saved = Save((Renderer)(object)val);
						saved.ChangeMaterial = true;
						((Renderer)val).sharedMaterials = instance.PaintMine(saved.Materials);
						saved.AssignedMaterials = ((Renderer)val).sharedMaterials;
					}
				}
				MeshRenderer[] componentsInChildren2 = ((Component)this).GetComponentsInChildren<MeshRenderer>(true);
				foreach (MeshRenderer val2 in componentsInChildren2)
				{
					if (((Object)val2).name == "EngiMineMesh")
					{
						Saved saved2 = Save((Renderer)(object)val2);
						saved2.ChangeMaterial = true;
						((Renderer)val2).sharedMaterials = instance.PaintMine(saved2.Materials);
						saved2.AssignedMaterials = ((Renderer)val2).sharedMaterials;
					}
				}
				return;
			}
			EntityStateMachine[] array2 = machines;
			for (int num = 0; num < array2.Length; num++)
			{
				EntityState state = array2[num].state;
				PlaceTurret val3 = (PlaceTurret)(object)((state is PlaceTurret) ? state : null);
				if (val3 == null)
				{
					continue;
				}
				string asset = ((val3 is PlaceWalkerTurret) ? "walker" : "turret");
				object? obj = Blueprint?.GetValue(val3);
				BlueprintController val4 = (BlueprintController)((obj is BlueprintController) ? obj : null);
				if (Object.op_Implicit((Object)(object)val4))
				{
					SkinnedMeshRenderer[] componentsInChildren = ((Component)val4).GetComponentsInChildren<SkinnedMeshRenderer>(true);
					foreach (SkinnedMeshRenderer val5 in componentsInChildren)
					{
						if (val5.bones.Length == 15)
						{
							ApplySkinned(val5, asset, keepMaterial: true);
						}
					}
				}
				object? obj2 = Wrist?.GetValue(val3);
				GameObject val6 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				if (!Object.op_Implicit((Object)(object)val6))
				{
					continue;
				}
				MeshFilter[] componentsInChildren3 = val6.GetComponentsInChildren<MeshFilter>(true);
				foreach (MeshFilter val7 in componentsInChildren3)
				{
					if (((Object)val7).name == "EngiTurretMesh")
					{
						Renderer component = ((Component)val7).GetComponent<Renderer>();
						Saved saved3 = Save(component);
						saved3.ChangeMesh = true;
						val7.sharedMesh = instance.WristMesh(asset);
						saved3.AssignedMesh = val7.sharedMesh;
					}
				}
			}
		}

		private void OnDisable()
		{
			Restore();
			lobbyDirty = true;
		}

		private void OnDestroy()
		{
			if (Object.op_Implicit((Object)(object)controller))
			{
				controller.onSkinApplied -= Applied;
			}
		}
	}

	public const string Guid = "eclipseplaytest.engineer.e2";

	public const string Version = "0.1.2";

	private static EngineerMineSurveyor instance;

	private readonly List<AsyncOperationHandle> retainedAssets = new List<AsyncOperationHandle>();

	private float registrationDeadline;

	private string folder;

	private SkinDef skin;

	private GameObject modelPrefab;

	private readonly List<Prepared> prepared = new List<Prepared>();

	private bool registered;

	private static readonly Design[] Designs = new Design[1]
	{
		new Design("mine-surveyor", "Mine Surveyor (Playtest)", (Color32[])(object)new Color32[4]
		{
			new Color32((byte)214, (byte)160, (byte)48, byte.MaxValue),
			new Color32((byte)223, (byte)211, (byte)175, byte.MaxValue),
			new Color32((byte)91, (byte)93, (byte)82, byte.MaxValue),
			new Color32((byte)47, (byte)53, (byte)49, byte.MaxValue)
		})
	};

	private GameObject cosmeticStorage;

	private Texture2D minePaint;

	private readonly Dictionary<string, Mesh> remappedMeshes = new Dictionary<string, Mesh>();

	private readonly Dictionary<Material, Material> mineMaterials = new Dictionary<Material, Material>();

	private readonly Dictionary<string, Mesh> wristMeshes = new Dictionary<string, Mesh>();

	private void Awake()
	{
		folder = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
		instance = this;
		SystemInitializerInjector.InjectDependency(typeof(SkinCatalog), typeof(EngineerMineSurveyor));
		RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(SyncDisplaySkins));
		MainMenuController.OnMainMenuInitialised += SyncDisplaySkins;
	}

	[SystemInitializer(new Type[] { typeof(BodyCatalog) })]
	private static IEnumerator InitializeSkin()
	{
		if (!Object.op_Implicit((Object)(object)instance))
		{
			yield break;
		}
		instance.registrationDeadline = Time.realtimeSinceStartup + 45f;
		IEnumerator routine = instance.RegisterAsync();
		while (true)
		{
			bool flag;
			try
			{
				flag = routine.MoveNext();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)instance).Logger.LogError((object)("ENGINEER_E2_REGISTRATION_FAILED: " + ex));
				break;
			}
			if (!flag)
			{
				break;
			}
			yield return null;
		}
		(routine as IDisposable)?.Dispose();
	}

	private IEnumerator RegisterAsync()
	{
		((BaseUnityPlugin)this).Logger.LogInfo((object)"ENGINEER_E2_REGISTRATION_BEGIN 0.1.2");
		string[][] array = new string[3][]
		{
			new string[4] { "EngiTurretBody", "turret", "15", "skinEngiTurretDefault" },
			new string[4] { "EngiWalkerTurretBody", "walker", "15", "skinEngiWalkerTurretDefault" },
			new string[4] { "EngiBody", "mine-surveyor", "83", "skinEngiDefault" }
		};
		foreach (string[] array2 in array)
		{
			IEnumerator routine = Prepare(array2[0], array2[1], int.Parse(array2[2]), array2[3]);
			while (routine.MoveNext())
			{
				yield return null;
			}
		}
		Prepared bodySkin = prepared.Single((Prepared p) => p.BodyName == "EngiBody");
		bodySkin.Skin.skinDefParams.minionSkinReplacements = (MinionSkinReplacement[])(object)new MinionSkinReplacement[2]
		{
			new MinionSkinReplacement
			{
				minionBodyPrefab = BodyCatalog.FindBodyPrefab("EngiTurretBody"),
				minionSkin = prepared.Single((Prepared p) => p.BodyName == "EngiTurretBody").Skin
			},
			new MinionSkinReplacement
			{
				minionBodyPrefab = BodyCatalog.FindBodyPrefab("EngiWalkerTurretBody"),
				minionSkin = prepared.Single((Prepared p) => p.BodyName == "EngiWalkerTurretBody").Skin
			}
		};
		IEnumerator ghostRoutine = PrepareMineGhosts(bodySkin.Skin);
		while (ghostRoutine.MoveNext())
		{
			yield return null;
		}
		foreach (Prepared item in prepared)
		{
			item.Controller.skins = item.Controller.skins.Concat((IEnumerable<SkinDef>)(object)new SkinDef[1] { item.Skin }).ToArray();
		}
		modelPrefab = bodySkin.Model;
		skin = bodySkin.Skin;
		registered = true;
		foreach (Prepared item2 in prepared)
		{
			if (!Object.op_Implicit((Object)(object)item2.Model.GetComponent<MineSurveyorVisuals>()))
			{
				item2.Model.AddComponent<MineSurveyorVisuals>();
			}
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)"ENGINEER_E2_REGISTERED Mine Surveyor, both turret variants, unlocked=true version=0.1.2");
	}

	private IEnumerator Prepare(string bodyName, string assetName, int boneCount, string defaultName)
	{
		GameObject val = BodyCatalog.FindBodyPrefab(bodyName);
		if (!Object.op_Implicit((Object)(object)val))
		{
			throw new InvalidOperationException("Missing body " + bodyName);
		}
		GameObject model = ((Component)val.GetComponent<ModelLocator>().modelTransform).gameObject;
		ModelSkinController controller = model.GetComponent<ModelSkinController>();
		SkinDef baseSkin = null;
		if (Object.op_Implicit((Object)(object)controller) && controller.skins != null && controller.skins.Length != 0)
		{
			baseSkin = controller.skins[0];
		}
		if (!Object.op_Implicit((Object)(object)baseSkin))
		{
			AsyncOperationHandle<SkinDef> h = Addressables.LoadAssetAsync<SkinDef>((object)("RoR2/Base/Engi/" + defaultName + ".asset"));
			retainedAssets.Add(AsyncOperationHandle<SkinDef>.op_Implicit(h));
			while (!h.IsDone)
			{
				CheckLoadDeadline("default skin " + bodyName);
				yield return null;
			}
			baseSkin = h.Result;
		}
		if (!Object.op_Implicit((Object)(object)baseSkin))
		{
			throw new InvalidOperationException("Missing default skin " + bodyName);
		}
		SkinDefParams bp = baseSkin.skinDefParams;
		if (!Object.op_Implicit((Object)(object)bp) && baseSkin.skinDefParamsAddress != null && ((AssetReference)baseSkin.skinDefParamsAddress).RuntimeKeyIsValid())
		{
			AsyncOperationHandle<SkinDefParams> h2 = Addressables.LoadAssetAsync<SkinDefParams>(((AssetReference)baseSkin.skinDefParamsAddress).RuntimeKey);
			retainedAssets.Add(AsyncOperationHandle<SkinDefParams>.op_Implicit(h2));
			while (!h2.IsDone)
			{
				CheckLoadDeadline("parameters " + bodyName);
				yield return null;
			}
			bp = h2.Result;
		}
		if (!Object.op_Implicit((Object)(object)bp))
		{
			throw new InvalidOperationException("Missing parameters " + bodyName);
		}
		SkinnedMeshRenderer target = model.GetComponentsInChildren<SkinnedMeshRenderer>(true).Single((SkinnedMeshRenderer r) => r.bones.Length == boneCount);
		Mesh reference = target.sharedMesh;
		if (!Object.op_Implicit((Object)(object)reference))
		{
			MeshReplacement val2 = bp.meshReplacements.First((MeshReplacement r) => (Object)(object)r.renderer == (Object)(object)target);
			reference = val2.mesh;
			if (!Object.op_Implicit((Object)(object)reference))
			{
				AsyncOperationHandle<Mesh> h3 = Addressables.LoadAssetAsync<Mesh>(((AssetReference)val2.meshAddress).RuntimeKey);
				retainedAssets.Add(AsyncOperationHandle<Mesh>.op_Implicit(h3));
				while (!h3.IsDone)
				{
					CheckLoadDeadline("mesh " + bodyName);
					yield return null;
				}
				reference = h3.Result;
			}
		}
		if (!Object.op_Implicit((Object)(object)reference) || reference.bindposes.Length != target.bones.Length)
		{
			throw new InvalidOperationException("Bind pose mismatch " + bodyName);
		}
		RendererInfo ri = bp.rendererInfos.First((RendererInfo r) => (Object)(object)r.renderer == (Object)(object)target);
		Material val3 = ri.defaultMaterial;
		if (!Object.op_Implicit((Object)(object)val3) && ri.defaultMaterialAddress != null && ((AssetReference)ri.defaultMaterialAddress).RuntimeKeyIsValid())
		{
			AsyncOperationHandle<Material> h4 = Addressables.LoadAssetAsync<Material>(((AssetReference)ri.defaultMaterialAddress).RuntimeKey);
			retainedAssets.Add(AsyncOperationHandle<Material>.op_Implicit(h4));
			while (!h4.IsDone)
			{
				CheckLoadDeadline("material " + bodyName);
				yield return null;
			}
			val3 = h4.Result;
		}
		if (!Object.op_Implicit((Object)(object)val3))
		{
			val3 = ((Renderer)target).sharedMaterial;
		}
		if (!Object.op_Implicit((Object)(object)val3) || !Object.op_Implicit((Object)(object)val3.shader))
		{
			throw new InvalidOperationException("Missing native material " + bodyName);
		}
		Mesh val4 = ReadMesh(Path.Combine(folder, assetName + ".meshbin"), target, reference);
		((Object)val4).name = "EclipsePlaytest_EngineerE2_" + assetName;
		Material val5 = new Material(val3)
		{
			name = "matEclipsePlaytest_EngineerE2_" + assetName
		};
		val5.SetTexture("_MainTex", (Texture)(object)ReadTexture("albedo-spec.png", linear: false));
		val5.SetTexture("_NormalTex", (Texture)(object)ReadTexture("normal.png", linear: true));
		val5.SetColor("_Color", Color.white);
		val5.SetFloat("_NormalStrength", 0.3f);
		val5.SetFloat("_Smoothness", 0.28f);
		val5.SetFloat("_SpecularStrength", 0.35f);
		val5.SetFloat("_SpecularExponent", 8f);
		val5.SetFloat("_EmPower", 0f);
		val5.SetTexture("_EmTex", (Texture)(object)Texture2D.blackTexture);
		val5.DisableKeyword("LIMBREMOVAL");
		val5.SetFloat("_LimbRemovalOn", 0f);
		ri.defaultMaterial = val5;
		ri.defaultMaterialAddress = new AssetReferenceT<Material>("");
		SkinDefParams val6 = ScriptableObject.CreateInstance<SkinDefParams>();
		val6.rendererInfos = (RendererInfo[])(object)new RendererInfo[1] { ri };
		val6.meshReplacements = (MeshReplacement[])(object)new MeshReplacement[1]
		{
			new MeshReplacement
			{
				renderer = (Renderer)(object)target,
				mesh = val4,
				meshAddress = new AssetReferenceT<Mesh>("")
			}
		};
		SkinDef val7 = ScriptableObject.CreateInstance<SkinDef>();
		((Object)val7).name = "skinEclipsePlaytestEngineerE2_" + assetName;
		val7.nameToken = "ECLIPSEPLAYTEST_ENGINEER_E2_" + assetName.ToUpperInvariant().Replace('-', '_');
		LanguageAPI.Add(val7.nameToken, (bodyName == "EngiBody") ? "Mine Surveyor (Playtest)" : ("Mine Surveyor " + assetName));
		val7.icon = CreateIcon(Designs[0].Colors);
		val7.unlockableDef = null;
		val7.rootObject = model;
		val7.baseSkins = (SkinDef[])(object)new SkinDef[1] { baseSkin };
		val7.skinDefParams = val6;
		if (!Object.op_Implicit((Object)(object)controller))
		{
			controller = model.AddComponent<ModelSkinController>();
			controller.skins = (SkinDef[])(object)new SkinDef[1] { baseSkin };
		}
		prepared.Add(new Prepared
		{
			BodyName = bodyName,
			Model = model,
			Controller = controller,
			Skin = val7,
			Mesh = val4,
			Reference = reference,
			Material = val5
		});
		((BaseUnityPlugin)this).Logger.LogInfo((object)("ENGINEER_E2_PREPARED body=" + bodyName + " vertices=" + val4.vertexCount + " unlocked=true"));
	}

	private static Sprite CreateIcon(Color32[] colors)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		//IL_00c6: 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_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
		Color32[] array = (Color32[])(object)new Color32[4096];
		for (int i = 0; i < 64; i++)
		{
			for (int j = 0; j < 64; j++)
			{
				int num = ((i > j) ? ((i <= 63 - j) ? 1 : 0) : ((i > 63 - j) ? 2 : 3));
				array[i * 64 + j] = (Color32)((j < 2 || j > 61 || i < 2 || i > 61 || Math.Abs(i - j) < 2 || Math.Abs(i - (63 - j)) < 2) ? new Color32((byte)48, (byte)48, (byte)48, byte.MaxValue) : colors[num]);
			}
		}
		val.SetPixels32(array);
		val.Apply(false, true);
		return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
	}

	private void CheckLoadDeadline(string asset)
	{
		if (Time.realtimeSinceStartup > registrationDeadline)
		{
			throw new TimeoutException("Stopped loading " + asset + "; continuing startup without the skin.");
		}
	}

	private void SyncDisplaySkins()
	{
		if (!registered)
		{
			return;
		}
		SurvivorDef val = SurvivorCatalog.allSurvivorDefs.FirstOrDefault((Func<SurvivorDef, bool>)((SurvivorDef s) => Object.op_Implicit((Object)(object)s) && Object.op_Implicit((Object)(object)s.bodyPrefab) && ((Object)s.bodyPrefab).name == "EngiBody"));
		if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val.displayPrefab))
		{
			return;
		}
		CharacterModel componentInChildren = val.displayPrefab.GetComponentInChildren<CharacterModel>(true);
		if (Object.op_Implicit((Object)(object)componentInChildren))
		{
			ModelSkinController val2 = ((Component)componentInChildren).GetComponent<ModelSkinController>() ?? ((Component)componentInChildren).gameObject.AddComponent<ModelSkinController>();
			val2.skins = (SkinDef[])modelPrefab.GetComponent<ModelSkinController>().skins.Clone();
			if (!Object.op_Implicit((Object)(object)val.displayPrefab.GetComponent<MineSurveyorVisuals>()))
			{
				val.displayPrefab.AddComponent<MineSurveyorVisuals>();
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)("ENGINEER_E2_DISPLAY_READY skins=" + val2.skins.Length));
		}
	}

	private Texture2D ReadTexture(string name, bool linear)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Expected O, but got Unknown
		//IL_004b: Expected O, but got Unknown
		Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true, linear)
		{
			name = name,
			anisoLevel = 4,
			filterMode = (FilterMode)2
		};
		if (!ImageConversion.LoadImage(val, File.ReadAllBytes(Path.Combine(folder, name)), false))
		{
			throw new InvalidDataException("Cannot decode " + name);
		}
		return val;
	}

	private Mesh ReadMesh(string path, SkinnedMeshRenderer renderer, Mesh reference)
	{
		//IL_0139: 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_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0229: Unknown result type (might be due to invalid IL or missing references)
		//IL_022e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0400: Unknown result type (might be due to invalid IL or missing references)
		//IL_0405: Unknown result type (might be due to invalid IL or missing references)
		//IL_0410: Unknown result type (might be due to invalid IL or missing references)
		//IL_0422: Unknown result type (might be due to invalid IL or missing references)
		//IL_042a: 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_043a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0442: Unknown result type (might be due to invalid IL or missing references)
		//IL_044a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0452: Unknown result type (might be due to invalid IL or missing references)
		//IL_0458: Unknown result type (might be due to invalid IL or missing references)
		//IL_0460: Expected O, but got Unknown
		//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_030f: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_038a: Unknown result type (might be due to invalid IL or missing references)
		//IL_038c: Unknown result type (might be due to invalid IL or missing references)
		using BinaryReader binaryReader = new BinaryReader(File.OpenRead(path));
		if (new string(binaryReader.ReadChars(4)) != "PWE2")
		{
			throw new InvalidDataException("Invalid mesh signature.");
		}
		int num = binaryReader.ReadInt32();
		int num2 = binaryReader.ReadInt32();
		int num3 = binaryReader.ReadInt32();
		if (num < 3 || num > 200000 || num2 < 3 || num2 > 1200000 || num2 % 3 != 0 || num3 != renderer.bones.Length)
		{
			throw new InvalidDataException("Invalid mesh dimensions.");
		}
		int[] array = new int[num3];
		HashSet<int> hashSet = new HashSet<int>();
		for (int i = 0; i < num3; i++)
		{
			int num4 = binaryReader.ReadInt32();
			if (num4 < 1 || num4 > 128)
			{
				throw new InvalidDataException("Invalid bone name.");
			}
			string name = Encoding.UTF8.GetString(binaryReader.ReadBytes(num4));
			array[i] = Array.FindIndex(renderer.bones, (Transform t) => Object.op_Implicit((Object)(object)t) && ((Object)t).name == name);
			if (array[i] < 0 || !hashSet.Add(array[i]))
			{
				throw new InvalidDataException("Missing/duplicate reference bone: " + name);
			}
		}
		Matrix4x4[] array2 = (Matrix4x4[])(object)new Matrix4x4[num3];
		for (int num5 = 0; num5 < num3; num5++)
		{
			Matrix4x4 val = default(Matrix4x4);
			for (int num6 = 0; num6 < 4; num6++)
			{
				for (int num7 = 0; num7 < 4; num7++)
				{
					float num8 = binaryReader.ReadSingle();
					if (float.IsNaN(num8) || float.IsInfinity(num8))
					{
						throw new InvalidDataException("Invalid bind matrix.");
					}
					((Matrix4x4)(ref val))[num6, num7] = num8;
				}
			}
			if (Math.Abs(((Matrix4x4)(ref val)).determinant) < 1E-05f)
			{
				throw new InvalidDataException("Singular bind matrix.");
			}
			array2[array[num5]] = val;
		}
		Vector3[] array3 = (Vector3[])(object)new Vector3[num];
		Vector3[] array4 = (Vector3[])(object)new Vector3[num];
		Vector2[] array5 = (Vector2[])(object)new Vector2[num];
		BoneWeight[] array6 = (BoneWeight[])(object)new BoneWeight[num];
		for (int num9 = 0; num9 < num; num9++)
		{
			array3[num9] = new Vector3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
			array4[num9] = new Vector3(binaryReader.ReadSingle(), binaryReader.ReadSingle(), binaryReader.ReadSingle());
			array5[num9] = new Vector2(binaryReader.ReadSingle(), binaryReader.ReadSingle());
			int[] array7 = new int[4];
			for (int num10 = 0; num10 < 4; num10++)
			{
				int num11 = binaryReader.ReadInt32();
				if (num11 < 0 || num11 >= num3)
				{
					throw new InvalidDataException("Bone out of range.");
				}
				array7[num10] = array[num11];
			}
			float[] array8 = new float[4];
			for (int num12 = 0; num12 < 4; num12++)
			{
				array8[num12] = binaryReader.ReadSingle();
			}
			if (array8.Any((float n) => float.IsNaN(n) || float.IsInfinity(n) || n < 0f) || Math.Abs(array8.Sum() - 1f) > 0.002f)
			{
				throw new InvalidDataException("Invalid skin weight.");
			}
			if (!Finite(array3[num9]) || !Finite(array4[num9]))
			{
				throw new InvalidDataException("Non-finite vertex.");
			}
			int num13 = num9;
			BoneWeight val2 = default(BoneWeight);
			((BoneWeight)(ref val2)).boneIndex0 = array7[0];
			((BoneWeight)(ref val2)).boneIndex1 = array7[1];
			((BoneWeight)(ref val2)).boneIndex2 = array7[2];
			((BoneWeight)(ref val2)).boneIndex3 = array7[3];
			((BoneWeight)(ref val2)).weight0 = array8[0];
			((BoneWeight)(ref val2)).weight1 = array8[1];
			((BoneWeight)(ref val2)).weight2 = array8[2];
			((BoneWeight)(ref val2)).weight3 = array8[3];
			array6[num13] = val2;
		}
		int[] array9 = new int[num2];
		for (int num14 = 0; num14 < num2; num14++)
		{
			array9[num14] = binaryReader.ReadInt32();
			if (array9[num14] < 0 || array9[num14] >= num)
			{
				throw new InvalidDataException("Triangle out of range.");
			}
		}
		if (binaryReader.BaseStream.Position != binaryReader.BaseStream.Length)
		{
			throw new InvalidDataException("Unexpected trailing mesh data.");
		}
		Mesh val3 = new Mesh
		{
			name = "EclipsePlaytestEngineerMineSurveyor",
			indexFormat = (IndexFormat)(num > 65535),
			vertices = array3,
			normals = array4,
			uv = array5,
			boneWeights = array6,
			bindposes = array2,
			triangles = array9
		};
		val3.RecalculateBounds();
		val3.RecalculateTangents();
		return val3;
	}

	private IEnumerator PrepareMineGhosts(SkinDef bodySkin)
	{
		cosmeticStorage = new GameObject("MineSurveyorCosmeticPrefabs");
		cosmeticStorage.SetActive(false);
		Object.DontDestroyOnLoad((Object)(object)cosmeticStorage);
		minePaint = new Texture2D(2, 2, (TextureFormat)4, false);
		minePaint.SetPixels(Enumerable.Repeat<Color>(new Color(0.65f, 0.39f, 0.07f, 0.2f), 4).ToArray());
		minePaint.Apply();
		List<ProjectileGhostReplacement> replacements = new List<ProjectileGhostReplacement>();
		string[] array = new string[2] { "EngiMine", "SpiderMine" };
		foreach (string name in array)
		{
			AsyncOperationHandle<GameObject> h = Addressables.LoadAssetAsync<GameObject>((object)("RoR2/Base/Engi/" + name + ".prefab"));
			retainedAssets.Add(AsyncOperationHandle<GameObject>.op_Implicit(h));
			while (!h.IsDone)
			{
				CheckLoadDeadline(name);
				yield return null;
			}
			if (!Object.op_Implicit((Object)(object)h.Result))
			{
				throw new InvalidOperationException("Missing mine projectile " + name);
			}
			ProjectileController component = h.Result.GetComponent<ProjectileController>();
			GameObject val = component.ghostPrefab;
			if (!Object.op_Implicit((Object)(object)val) && component.ghostPrefabAddress != null && ((AssetReference)component.ghostPrefabAddress).RuntimeKeyIsValid())
			{
				AsyncOperationHandle<GameObject> gh = Addressables.LoadAssetAsync<GameObject>(((AssetReference)component.ghostPrefabAddress).RuntimeKey);
				retainedAssets.Add(AsyncOperationHandle<GameObject>.op_Implicit(gh));
				while (!gh.IsDone)
				{
					CheckLoadDeadline(name + " ghost");
					yield return null;
				}
				val = gh.Result;
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				throw new InvalidOperationException("Missing mine ghost " + name);
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, cosmeticStorage.transform);
			((Object)val2).name = "EclipseMineSurveyor_" + name + "Ghost";
			val2.SetActive(true);
			SkinnedMeshRenderer[] componentsInChildren = val2.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val3 in componentsInChildren)
			{
				((Renderer)val3).sharedMaterials = PaintMine(((Renderer)val3).sharedMaterials);
			}
			replacements.Add(new ProjectileGhostReplacement
			{
				projectilePrefab = h.Result,
				projectileGhostReplacementPrefab = val2,
				ghostReplacementAddress = new AssetReferenceT<GameObject>("")
			});
		}
		bodySkin.skinDefParams.projectileGhostReplacements = replacements.ToArray();
	}

	private Material[] PaintMine(Material[] sources)
	{
		return ((IEnumerable<Material>)sources).Select((Func<Material, Material>)delegate(Material src)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)src))
			{
				return src;
			}
			if (mineMaterials.TryGetValue(src, out var value))
			{
				return value;
			}
			value = new Material(src)
			{
				name = "MineSurveyorMine_" + ((Object)src).name
			};
			value.SetTexture("_MainTex", (Texture)(object)minePaint);
			value.SetColor("_Color", Color.white);
			value.SetFloat("_Smoothness", 0.25f);
			value.SetFloat("_SpecularStrength", 0.3f);
			mineMaterials.Add(src, value);
			return value;
		}).ToArray();
	}

	private Mesh MeshFor(string asset, SkinnedMeshRenderer target)
	{
		string key = asset + "|" + string.Join("|", target.bones.Select((Transform b) => (!Object.op_Implicit((Object)(object)b)) ? "<null>" : ((Object)b).name));
		if (!remappedMeshes.TryGetValue(key, out var value))
		{
			value = ReadMesh(Path.Combine(folder, asset + ".meshbin"), target, target.sharedMesh);
			remappedMeshes.Add(key, value);
		}
		return value;
	}

	private Mesh WristMesh(string asset)
	{
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		if (wristMeshes.TryGetValue(asset, out var value))
		{
			return value;
		}
		Prepared prepared = this.prepared.Single((Prepared p) => p.BodyName == ((asset == "walker") ? "EngiWalkerTurretBody" : "EngiTurretBody"));
		prepared.Model.GetComponentsInChildren<SkinnedMeshRenderer>(true).Single((SkinnedMeshRenderer x) => x.bones.Length == 15);
		Matrix4x4 val = ((Matrix4x4)(ref prepared.Reference.bindposes[0])).inverse * prepared.Mesh.bindposes[0];
		value = Object.Instantiate<Mesh>(prepared.Mesh);
		Vector3[] vertices = value.vertices;
		Vector3[] normals = value.normals;
		Matrix4x4 inverse = ((Matrix4x4)(ref val)).inverse;
		Matrix4x4 transpose = ((Matrix4x4)(ref inverse)).transpose;
		for (int num = 0; num < vertices.Length; num++)
		{
			vertices[num] = ((Matrix4x4)(ref val)).MultiplyPoint3x4(vertices[num]);
			int num2 = num;
			Vector3 val2 = ((Matrix4x4)(ref transpose)).MultiplyVector(normals[num]);
			normals[num2] = ((Vector3)(ref val2)).normalized;
		}
		value.vertices = vertices;
		value.normals = normals;
		value.RecalculateBounds();
		value.RecalculateTangents();
		wristMeshes.Add(asset, value);
		return value;
	}

	private static bool Finite(Vector3 v)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!float.IsNaN(v.x + v.y + v.z))
		{
			return !float.IsInfinity(v.x + v.y + v.z);
		}
		return false;
	}
}