using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace RuneMagicSentinels;

[BepInPlugin("danpe.RuneMagicSentinels", "Rune Magic - Sentinel Stones", "1.0.1")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class SentinelsPlugin : BaseUnityPlugin
{
	public const string PluginGuid = "danpe.RuneMagicSentinels";

	public const string PluginName = "Rune Magic - Sentinel Stones";

	public const string PluginVersion = "1.0.1";

	internal const string RuneMagicGuid = "hyleanlegend.RuneMagic";

	internal const string StonePrefab = "runemagic_StandingStone";

	internal const string WaygateName = "runemagic_waygate";

	internal const string NamePrefix = "runemagic_sentinel_";

	private const string RuneFocusItemName = "$item_runemagic_runefocus";

	private const int TestedMajor = 1;

	private const int TestedMinor = 5;

	internal static ManualLogSource Log;

	internal static ConfigEntry<bool> Enabled;

	internal static ConfigEntry<float> Range;

	internal static ConfigEntry<bool> ShootWildlife;

	internal static ConfigEntry<bool> SpareTaming;

	internal static ConfigEntry<float> EnergyCost;

	internal static ConfigEntry<bool> AllowUntestedVersion;

	internal static readonly Element[] Elements = Element.All();

	internal static bool Armed;

	private static Harmony _harmony;

	private static MethodInfo _sceneAwake;

	private static GameObject _container;

	private static PieceTable _table;

	private static bool _piecesConfigured;

	private static Texture _staveTexture;

	private static List<GameObject> _rmPrefabs;

	private void Awake()
	{
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Expected O, but got Unknown
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Expected O, but got Unknown
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Master switch (restart required). Every player on the server needs this add-on: the sentinels are new pieces. Off: no new sentinels and placed ones stand inert, but they are kept (never deleted), also by a host that has it switched off.");
		Range = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Range", 30f, new ConfigDescription("How far a sentinel sees and shoots, in metres (the vanilla ballista sees 30 m).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 60f), new object[0]));
		ShootWildlife = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Shoot wildlife", false, "Also shoot deer, hares and chickens. Off: only creatures that fight back are targets. Players, tames, your training dummy and Dvergers you have not angered are never targets, and sentinel shots pass through them, through your buildings and player-raised stones, and through crops.");
		SpareTaming = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Spare creatures being tamed", true, "Do not shoot a creature that has been fed and is partway through taming (boar, wolf, lox...). Off: every untamed creature that fights back is a target.");
		EnergyCost = ((BaseUnityPlugin)this).Config.Bind<float>("General", "Energy cost", 150f, new ConfigDescription("Runic energy to raise a sentinel (refunded when you remove it).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1000f), new object[0]));
		AllowUntestedVersion = ((BaseUnityPlugin)this).Config.Bind<bool>("Advanced", "Allow untested Rune Magic version", false, "This add-on was verified against Rune Magic 1.5.x. With any other version sentinels stay inert unless this is true.");
		for (int i = 0; i < Elements.Length; i++)
		{
			Elements[i].BindConfig(((BaseUnityPlugin)this).Config);
		}
		((BaseUnityPlugin)this).Config.SettingChanged += delegate
		{
			Tuning.LocalChanged();
		};
		_harmony = new Harmony("danpe.RuneMagicSentinels");
		try
		{
			PreparePersistence();
		}
		catch (Exception ex)
		{
			Log.LogError((object)("Could not register the sentinel pieces; a host without them deletes placed sentinels. " + ex));
			return;
		}
		if (!Enabled.Value)
		{
			Log.LogInfo((object)"Sentinel Stones is OFF: placed sentinels are kept but inert.");
			return;
		}
		try
		{
			Setup();
			Armed = true;
			Log.LogInfo((object)"Sentinel Stones ready; the sentinels appear in the Rune Focus menu once a world is loaded.");
		}
		catch (Exception ex2)
		{
			Log.LogError((object)("Setup failed - sentinels stay inert and are not offered in the menu (placed ones are kept). " + ex2));
			Disarm();
		}
	}

	private void Update()
	{
		if ((Object)(object)_container != (Object)null)
		{
			Tuning.Tick();
		}
	}

	private void OnDestroy()
	{
		Teardown();
	}

	private static void PreparePersistence()
	{
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Expected O, but got Unknown
		Type type = AccessTools.TypeByName("ValheimMod.CustomContentSetupHandler");
		FieldInfo fieldInfo = ((type != null) ? AccessTools.Field(type, "RegisteredNonItemPrefabs") : null);
		_rmPrefabs = ((fieldInfo != null) ? (fieldInfo.GetValue(null) as List<GameObject>) : null);
		GameObject val = FindStone();
		if ((Object)(object)val != (Object)null)
		{
			CaptureStave(val);
		}
		_container = new GameObject("RuneMagicSentinels_Prefabs");
		_container.SetActive(false);
		Object.DontDestroyOnLoad((Object)(object)_container);
		_sceneAwake = RequireMethod(typeof(ZNetScene), "Awake", Type.EmptyTypes);
		HarmonyMethod val2 = H("ZNetSceneAwakePrefix");
		val2.priority = 200;
		_harmony.Patch((MethodBase)_sceneAwake, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
	}

	private static void Disarm()
	{
		Armed = false;
		_table = null;
		if (_harmony == null)
		{
			return;
		}
		List<MethodBase> list;
		try
		{
			list = new List<MethodBase>(_harmony.GetPatchedMethods());
		}
		catch (Exception)
		{
			list = new List<MethodBase>();
		}
		foreach (MethodBase item in list)
		{
			if (!(item == _sceneAwake))
			{
				try
				{
					_harmony.Unpatch(item, (HarmonyPatchType)0, "danpe.RuneMagicSentinels");
				}
				catch (Exception ex2)
				{
					Log.LogWarning((object)("Unpatch failed for " + item.Name + ": " + ex2.Message));
				}
			}
		}
	}

	private static void Teardown()
	{
		Armed = false;
		try
		{
			for (int i = 0; i < Elements.Length; i++)
			{
				GameObject prefab = Elements[i].Prefab;
				if (!((Object)(object)prefab == (Object)null))
				{
					if ((Object)(object)_table != (Object)null)
					{
						_table.m_pieces.Remove(prefab);
					}
					if ((Object)(object)ZNetScene.instance != (Object)null)
					{
						ZNetScene.instance.m_prefabs.Remove(prefab);
					}
					Elements[i].Prefab = null;
				}
			}
			if ((Object)(object)_container != (Object)null)
			{
				Object.Destroy((Object)(object)_container);
			}
		}
		catch (Exception ex)
		{
			Log.LogWarning((object)("Unregister failed: " + ex.Message));
		}
		_container = null;
		_table = null;
		_piecesConfigured = false;
		if (_harmony != null)
		{
			try
			{
				_harmony.UnpatchSelf();
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("Unpatch failed: " + ex2.Message));
			}
			_harmony = null;
		}
	}

	private static void CheckRuneMagicVersion()
	{
		if (!Chainloader.PluginInfos.TryGetValue("hyleanlegend.RuneMagic", out var value) || value == null)
		{
			throw new InvalidOperationException("Rune Magic is not loaded");
		}
		Version version = value.Metadata.Version;
		if (version.Major != 1 || version.Minor != 5)
		{
			if (!AllowUntestedVersion.Value)
			{
				throw new InvalidOperationException(string.Concat("Rune Magic ", version, " is untested with this add-on (verified with 1.5.x). Set 'Allow untested Rune Magic version' to true to try anyway."));
			}
			Log.LogWarning((object)string.Concat("Rune Magic ", version, " is untested with this add-on (verified with 1.5.x); continuing because the config allows it."));
		}
	}

	private static Type RequireType(string name)
	{
		Type type = AccessTools.TypeByName(name);
		if (type == null)
		{
			throw new InvalidOperationException("Type not found: " + name);
		}
		return type;
	}

	private static MethodInfo RequireMethod(Type t, string name, Type[] args)
	{
		MethodInfo methodInfo = ((args == null) ? AccessTools.Method(t, name, (Type[])null, (Type[])null) : AccessTools.Method(t, name, args, (Type[])null));
		if (methodInfo == null)
		{
			throw new InvalidOperationException("Method not found: " + t.FullName + "." + name);
		}
		return methodInfo;
	}

	private static FieldInfo RequireField(Type t, string name)
	{
		FieldInfo fieldInfo = AccessTools.Field(t, name);
		if (fieldInfo == null)
		{
			throw new InvalidOperationException("Field not found: " + t.FullName + "." + name);
		}
		return fieldInfo;
	}

	private static HarmonyMethod H(string name)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Expected O, but got Unknown
		MethodInfo methodInfo = AccessTools.Method(typeof(Patches), name, (Type[])null, (Type[])null);
		if (methodInfo == null)
		{
			throw new InvalidOperationException("Patch method missing: " + name);
		}
		return new HarmonyMethod(methodInfo);
	}

	private static void Setup()
	{
		CheckRuneMagicVersion();
		Type t = RequireType("ValheimMod.ValheimMod");
		MethodInfo methodInfo = RequireMethod(t, "get_isModAwake", Type.EmptyTypes);
		if (!(bool)methodInfo.Invoke(null, null))
		{
			throw new InvalidOperationException("Rune Magic did not finish initialising (isModAwake is false)");
		}
		Type t2 = RequireType("ValheimMod.UnlockManager");
		Type t3 = RequireType("ValheimMod.RunemagicPieceConfig");
		Type t4 = RequireType("ValheimMod.CustomContentSetupHandler");
		Type t5 = RequireType("ValheimMod.BoulderSetupHandler");
		MethodInfo methodInfo2 = RequireMethod(t2, "isUnlockable", new Type[1] { typeof(Piece) });
		MethodInfo methodInfo3 = RequireMethod(t2, "isUnlocked", new Type[2]
		{
			typeof(Player),
			typeof(Piece)
		});
		MethodInfo methodInfo4 = RequireMethod(t3, "getEnergyCost", new Type[1] { typeof(Piece) });
		MethodInfo methodInfo5 = RequireMethod(t5, "SetUpCustomBoulderFeatures", Type.EmptyTypes);
		MethodInfo methodInfo6 = RequireMethod(typeof(Projectile), "IsValidTarget", new Type[1] { typeof(IDestructible) });
		MethodInfo methodInfo7 = RequireMethod(typeof(Aoe), "ShouldHit", new Type[1] { typeof(Collider) });
		MethodInfo methodInfo8 = RequireMethod(typeof(Character), "Damage", new Type[1] { typeof(HitData) });
		MethodInfo methodInfo9 = RequireMethod(typeof(WearNTear), "Damage", new Type[1] { typeof(HitData) });
		MethodInfo methodInfo10 = RequireMethod(typeof(ShieldGenerator), "CheckProjectile", new Type[1] { typeof(Projectile) });
		FieldInfo fieldInfo = RequireField(typeof(Projectile), "m_ammo");
		RequireField(typeof(Aoe), "m_ammo");
		if (fieldInfo.FieldType != typeof(ItemData))
		{
			throw new InvalidOperationException("Projectile.m_ammo has an unexpected type");
		}
		Patches.ProjectileAmmo = MakeGetter(fieldInfo);
		if (!(RequireField(t4, "RegisteredItemPrefabs").GetValue(null) is List<GameObject> list))
		{
			throw new InvalidOperationException("Rune Magic's item prefab list has an unexpected type");
		}
		PieceTable val = null;
		foreach (GameObject item in list)
		{
			ItemDrop val2 = (((Object)(object)item != (Object)null) ? item.GetComponent<ItemDrop>() : null);
			if ((Object)(object)val2 != (Object)null && val2.m_itemData != null && val2.m_itemData.m_shared != null && val2.m_itemData.m_shared.m_name == "$item_runemagic_runefocus")
			{
				val = val2.m_itemData.m_shared.m_buildPieces;
				break;
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			throw new InvalidOperationException("Rune Focus piece table not found");
		}
		GameObject val3 = FindStone();
		if ((Object)(object)val3 == (Object)null || (Object)(object)val3.GetComponent<Piece>() == (Object)null || (Object)(object)val3.GetComponent<WearNTear>() == (Object)null || (Object)(object)val3.GetComponent<ZNetView>() == (Object)null)
		{
			throw new InvalidOperationException("Rune Magic's Standing Stone prefab was not found or has an unexpected shape");
		}
		_harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, H("IsUnlockablePostfix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo3, (HarmonyMethod)null, H("IsUnlockedPostfix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo4, (HarmonyMethod)null, H("EnergyCostPostfix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo5, (HarmonyMethod)null, H("BoulderSetupPostfix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo6, H("ValidTargetPrefix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo7, H("ShouldHitPrefix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo8, H("CharacterDamagePrefix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo9, H("WearNTearDamagePrefix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		_harmony.Patch((MethodBase)methodInfo10, H("ShieldCheckPrefix"), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodBase[] array = new MethodBase[5] { methodInfo6, methodInfo7, methodInfo8, methodInfo9, methodInfo10 };
		for (int i = 0; i < array.Length; i++)
		{
			if (!HasOurPrefix(array[i]))
			{
				throw new InvalidOperationException("The friendly-fire filter on " + array[i].DeclaringType.Name + "." + array[i].Name + " did not apply");
			}
		}
		_table = val;
	}

	private static Func<Projectile, ItemData> MakeGetter(FieldInfo field)
	{
		DynamicMethod dynamicMethod = new DynamicMethod("Sentinel_GetAmmo", typeof(ItemData), new Type[1] { typeof(Projectile) }, typeof(Projectile), skipVisibility: true);
		ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
		iLGenerator.Emit(OpCodes.Ldarg_0);
		iLGenerator.Emit(OpCodes.Ldfld, field);
		iLGenerator.Emit(OpCodes.Ret);
		return (Func<Projectile, ItemData>)dynamicMethod.CreateDelegate(typeof(Func<Projectile, ItemData>));
	}

	private static bool HasOurPrefix(MethodBase m)
	{
		Patches patchInfo = Harmony.GetPatchInfo(m);
		if (patchInfo == null || patchInfo.Prefixes == null)
		{
			return false;
		}
		foreach (Patch prefix in patchInfo.Prefixes)
		{
			if (prefix.owner == "danpe.RuneMagicSentinels")
			{
				return true;
			}
		}
		return false;
	}

	private static GameObject FindStone()
	{
		if (_rmPrefabs == null)
		{
			return null;
		}
		for (int i = 0; i < _rmPrefabs.Count; i++)
		{
			if ((Object)(object)_rmPrefabs[i] != (Object)null && ((Object)_rmPrefabs[i]).name == "runemagic_StandingStone")
			{
				return _rmPrefabs[i];
			}
		}
		return null;
	}

	private static void CaptureStave(GameObject stone)
	{
		try
		{
			Transform val = stone.transform.Find("StandingStone");
			MeshRenderer val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<MeshRenderer>() : null);
			Material val3 = (((Object)(object)val2 != (Object)null) ? ((Renderer)val2).sharedMaterial : null);
			if ((Object)(object)val3 != (Object)null && val3.HasProperty("_EmissionMap"))
			{
				_staveTexture = val3.GetTexture("_EmissionMap");
			}
		}
		catch (Exception ex)
		{
			Log.LogWarning((object)("Could not read the standing stone's stave texture (sentinels will not glow): " + ex.Message));
		}
		if ((Object)(object)_staveTexture == (Object)null)
		{
			Log.LogInfo((object)"The standing stone's stave texture is not available; sentinels will not glow.");
		}
	}

	internal static void OnZNetSceneAwake(ZNetScene scene)
	{
		if ((Object)(object)scene == (Object)null || scene.m_prefabs == null || (Object)(object)_container == (Object)null)
		{
			return;
		}
		Dictionary<string, GameObject> dictionary = new Dictionary<string, GameObject>();
		for (int i = 0; i < scene.m_prefabs.Count; i++)
		{
			GameObject val = scene.m_prefabs[i];
			if ((Object)(object)val != (Object)null && !dictionary.ContainsKey(((Object)val).name))
			{
				dictionary[((Object)val).name] = val;
			}
		}
		if (!dictionary.TryGetValue("runemagic_StandingStone", out var value) || (Object)(object)value == (Object)null)
		{
			value = FindStone();
		}
		for (int j = 0; j < Elements.Length; j++)
		{
			Element element = Elements[j];
			if ((Object)(object)element.Prefab == (Object)null)
			{
				try
				{
					element.Resolve(dictionary);
				}
				catch (Exception ex)
				{
					element.Failed = true;
					Log.LogWarning((object)("The " + element.Title + " sentinel cannot fire and is not offered: " + ex.Message));
				}
				try
				{
					element.Prefab = (((Object)(object)value != (Object)null) ? Prefabs.Build(value, element, j, _staveTexture, _container.transform) : null);
				}
				catch (Exception ex2)
				{
					element.Failed = true;
					element.Prefab = null;
					Log.LogWarning((object)("The " + element.Title + " sentinel could not be built: " + ex2.Message));
				}
				if ((Object)(object)element.Prefab == (Object)null)
				{
					element.Failed = true;
					element.Prefab = Prefabs.Placeholder(element, _container.transform);
				}
			}
			if (!scene.m_prefabs.Contains(element.Prefab))
			{
				scene.m_prefabs.Add(element.Prefab);
			}
		}
		TryFinishPieceSetup();
	}

	internal static void TryFinishPieceSetup()
	{
		if ((Object)(object)_table == (Object)null || !Armed)
		{
			return;
		}
		if (!_piecesConfigured && (Object)(object)ObjectDB.instance != (Object)null && ObjectDB.instance.m_items != null && ObjectDB.instance.m_items.Count > 0)
		{
			GameObject val = FindStone();
			Sprite stoneIcon = (((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<Piece>() != (Object)null) ? val.GetComponent<Piece>().m_icon : null);
			int category = ((_table.m_categoryLabels != null && _table.m_categoryLabels.Count > 3) ? 3 : 0);
			bool piecesConfigured = false;
			for (int i = 0; i < Elements.Length; i++)
			{
				if (Elements[i].Offerable())
				{
					Prefabs.ConfigurePiece(Elements[i], stoneIcon, category);
					piecesConfigured = true;
				}
			}
			_piecesConfigured = piecesConfigured;
		}
		if (!_piecesConfigured)
		{
			return;
		}
		List<GameObject> pieces = _table.m_pieces;
		for (int num = pieces.Count - 1; num >= 0; num--)
		{
			GameObject val2 = pieces[num];
			if ((Object)(object)val2 != (Object)null && ((Object)val2).name.StartsWith("runemagic_sentinel_", StringComparison.Ordinal) && Array.IndexOf(PrefabList(), val2) < 0)
			{
				pieces.RemoveAt(num);
			}
		}
		for (int j = 0; j < Elements.Length; j++)
		{
			Element element = Elements[j];
			if ((Object)(object)element.Prefab == (Object)null)
			{
				continue;
			}
			bool flag = element.Offerable() && Tuning.HostAllows() && Tuning.Current.Offer[j];
			bool flag2 = pieces.Contains(element.Prefab);
			if (!flag)
			{
				if (flag2)
				{
					pieces.Remove(element.Prefab);
				}
			}
			else
			{
				if (flag2)
				{
					continue;
				}
				int index = pieces.Count;
				for (int k = 0; k < pieces.Count; k++)
				{
					if ((Object)(object)pieces[k] != (Object)null && ((Object)pieces[k]).name == "runemagic_waygate")
					{
						index = k;
						break;
					}
				}
				pieces.Insert(index, element.Prefab);
			}
		}
	}

	private static GameObject[] PrefabList()
	{
		GameObject[] array = (GameObject[])(object)new GameObject[Elements.Length];
		for (int i = 0; i < Elements.Length; i++)
		{
			array[i] = Elements[i].Prefab;
		}
		return array;
	}

	internal static int IndexFor(Piece piece)
	{
		if ((Object)(object)piece == (Object)null)
		{
			return -1;
		}
		string prefabName = Utils.GetPrefabName(((Component)piece).gameObject);
		for (int i = 0; i < Elements.Length; i++)
		{
			if (Elements[i].PrefabName == prefabName)
			{
				return i;
			}
		}
		return -1;
	}
}
internal sealed class Element
{
	internal string Key;

	internal string Title;

	internal string ProjectileName;

	internal string[][] OrbParts;

	internal Color LightColor;

	internal bool Flicker;

	internal Color StaveColor;

	internal string IconItem;

	internal float Speed;

	internal float DefaultSpread;

	internal float OrbScale;

	internal float DefaultDamage;

	internal float DefaultPhysical;

	internal float DefaultCooldown;

	internal int DefaultShots;

	internal string Blurb;

	internal ConfigEntry<bool> Enabled;

	internal ConfigEntry<float> Damage;

	internal ConfigEntry<float> Physical;

	internal ConfigEntry<float> Cooldown;

	internal ConfigEntry<int> Shots;

	internal ConfigEntry<float> Spread;

	internal GameObject Projectile;

	internal float Gravity;

	internal float RayRadius;

	internal List<GameObject> OrbSources = new List<GameObject>();

	internal GameObject Prefab;

	internal bool Failed;

	internal string PrefabName => "runemagic_sentinel_" + Key;

	internal bool Offerable()
	{
		if ((Object)(object)Prefab != (Object)null && !Failed && (Object)(object)Projectile != (Object)null)
		{
			return (Object)(object)Prefab.GetComponent<Piece>() != (Object)null;
		}
		return false;
	}

	internal static Element[] All()
	{
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0111: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: 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_0254: Unknown result type (might be due to invalid IL or missing references)
		//IL_0269: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_030e: Unknown result type (might be due to invalid IL or missing references)
		return new Element[5]
		{
			Make("fire", "Fire", "Imp_fireball_projectile", new string[1][] { new string[4] { "Imp_fireball_projectile", "Sphere", "flames", "flames_world" } }, new Color(1f, 0.69f, 0.45f), flicker: false, new Color(3f, 0.9f, 0.1f), "StaffFireball", 25f, 1f, 1.75f, 50f, 15f, 2f, 1, "hurls fireballs that set hostile creatures burning (fire damage over time, plus a blunt blow). Surtlings, serpents, leeches and stone golems shrug off the fire."),
			Make("frost", "Frost", "staff_iceshard_projectile", new string[1][] { new string[4] { "hatchling_cold_projectile", "Sphere", "flames", "sparcs_world" } }, new Color(0.45f, 0.84f, 1f), flicker: false, new Color(0.3f, 1.5f, 3.5f), "StaffIceShards", 35f, 1.5f, 1.75f, 30f, 10f, 2f, 2, "fires volleys of ice shards that chill and slow hostile creatures. Drakes, wraiths, bats, abominations and stone golems are immune to the frost."),
			Make("lightning", "Lightning", "staff_lightning_projectile", new string[2][]
			{
				new string[2] { "fx_Lightning_red", "Sparcs" },
				new string[2] { "Imp_fireball_projectile", "Sphere" }
			}, new Color(1f, 0.35f, 0.15f), flicker: true, new Color(5f, 0.6f, 0.3f), "StaffLightning", 150f, 1.5f, 1.25f, 20f, 0f, 2.5f, 3, "strikes hostile creatures with bolts of lightning that land almost instantly. Few creatures resist lightning."),
			Make("poison", "Poison", "staff_greenroots_projectile", new string[1][] { new string[4] { "staff_greenroots_projectile", "Sphere", "flames", "Spores_World" } }, new Color(0.49f, 1f, 0.3f), flicker: false, new Color(0.5f, 2.5f, 0.2f), "StaffGreenRoots", 25f, 1f, 1.75f, 60f, 10f, 3f, 1, "lobs bursting orbs of venom that poison hostile creatures over time. The undead, surtlings, bats, abominations, golems and most blobs are immune to poison."),
			Make("spirit", "Spirit", "staff_skeleton_projectile", new string[1][] { new string[4] { "staff_skeleton_projectile", "fi_vil_combs_props_bone_skull", "fi_vil_combs_props_bone_skull (1)", "flames" } }, new Color(0.86f, 0.3f, 1f), flicker: false, new Color(1.8f, 0.2f, 3f), "StaffSkeleton", 22f, 1f, 1.5f, 50f, 25f, 2f, 1, "sends spirit skulls that sear the undead. Most living creatures are immune to spirit and take only the skull's piercing blow.")
		};
	}

	private static Element Make(string key, string title, string projectile, string[][] orbParts, Color light, bool flicker, Color stave, string iconItem, float speed, float spread, float orbScale, float damage, float physical, float cooldown, int shots, string blurb)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		Element element = new Element();
		element.Key = key;
		element.Title = title;
		element.ProjectileName = projectile;
		element.OrbParts = orbParts;
		element.LightColor = light;
		element.Flicker = flicker;
		element.StaveColor = stave;
		element.IconItem = iconItem;
		element.Speed = speed;
		element.DefaultSpread = spread;
		element.OrbScale = orbScale;
		element.DefaultDamage = damage;
		element.DefaultPhysical = physical;
		element.DefaultCooldown = cooldown;
		element.DefaultShots = shots;
		element.Blurb = blurb;
		return element;
	}

	internal void BindConfig(ConfigFile config)
	{
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Expected O, but got Unknown
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Expected O, but got Unknown
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Expected O, but got Unknown
		//IL_0195: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Expected O, but got Unknown
		//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Expected O, but got Unknown
		string text = Title + " sentinel";
		string text2 = PhysicalKind();
		Enabled = config.Bind<bool>(text, "Enabled", true, "Offer the " + Title + " sentinel in the Rune Focus menu (the host's choice applies to everyone). Sentinels already raised keep working.");
		Damage = config.Bind<float>(text, Title + " damage", DefaultDamage, new ConfigDescription(Title + " damage per projectile" + ((Key == "fire" || Key == "poison" || Key == "spirit") ? " (dealt over a few seconds)" : "") + ".", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1000f), new object[0]));
		Physical = config.Bind<float>(text, "Physical damage", DefaultPhysical, new ConfigDescription("Extra " + text2 + " damage per projectile, so creatures immune to " + Title.ToLowerInvariant() + " still get hurt.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1000f), new object[0]));
		Cooldown = config.Bind<float>(text, "Seconds between volleys", DefaultCooldown, new ConfigDescription("Time between volleys.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f), new object[0]));
		Shots = config.Bind<int>(text, "Projectiles per volley", DefaultShots, new ConfigDescription("Projectiles fired at once, fanned out slightly.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 12), new object[0]));
		Spread = config.Bind<float>(text, "Spread (degrees)", DefaultSpread, new ConfigDescription("Largest random aim error per projectile. It is also capped so a volley stays about 0.7 m wide at the target.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), new object[0]));
	}

	internal string PhysicalKind()
	{
		if (!(Key == "fire") && !(Key == "poison"))
		{
			return "pierce";
		}
		return "blunt";
	}

	internal DamageTypes DamageTypes(float element, float physical)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		DamageTypes result = default(DamageTypes);
		switch (Key)
		{
		case "fire":
			result.m_fire = element;
			break;
		case "frost":
			result.m_frost = element;
			break;
		case "lightning":
			result.m_lightning = element;
			break;
		case "poison":
			result.m_poison = element;
			break;
		case "spirit":
			result.m_spirit = element;
			break;
		}
		if (PhysicalKind() == "blunt")
		{
			result.m_blunt = physical;
		}
		else
		{
			result.m_pierce = physical;
		}
		return result;
	}

	internal void Resolve(Dictionary<string, GameObject> byName)
	{
		OrbSources.Clear();
		for (int i = 0; i < OrbParts.Length; i++)
		{
			OrbSources.Add(byName.TryGetValue(OrbParts[i][0], out var value) ? value : null);
		}
		if (!byName.TryGetValue(ProjectileName, out var value2) || (Object)(object)value2 == (Object)null || (Object)(object)value2.GetComponent<Projectile>() == (Object)null)
		{
			throw new InvalidOperationException("vanilla projectile " + ProjectileName + " not found");
		}
		Projectile = value2;
		Projectile component = value2.GetComponent<Projectile>();
		Gravity = Mathf.Max(0f, component.m_gravity);
		RayRadius = Mathf.Max(0f, component.m_rayRadius);
	}
}
internal static class Tuning
{
	internal sealed class Values
	{
		internal float Range = 30f;

		internal bool Wild;

		internal bool SpareTaming = true;

		internal float Cost = 150f;

		internal float[] Damage = new float[SentinelsPlugin.Elements.Length];

		internal float[] Physical = new float[SentinelsPlugin.Elements.Length];

		internal float[] Cooldown = new float[SentinelsPlugin.Elements.Length];

		internal int[] Shots = new int[SentinelsPlugin.Elements.Length];

		internal float[] Spread = new float[SentinelsPlugin.Elements.Length];

		internal bool[] Offer = new bool[SentinelsPlugin.Elements.Length];

		internal bool Armed;
	}

	private const string RpcRequest = "danpe_Sentinels_ConfigRequest";

	private const string RpcConfig = "danpe_Sentinels_Config";

	private const int Version = 2;

	private static Values _local;

	private static Values _host;

	private static ZRoutedRpc _registeredOn;

	private static float _nextRequest;

	private static bool _broadcast;

	private static Values _menuValues;

	private static bool _menuAllowed = true;

	internal static Values Current
	{
		get
		{
			if (_host != null && (Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				return _host;
			}
			if (_local == null)
			{
				_local = FromConfig();
			}
			return _local;
		}
	}

	internal static void LocalChanged()
	{
		_local = null;
		_broadcast = true;
	}

	private static Values FromConfig()
	{
		Values values = new Values();
		values.Range = ((SentinelsPlugin.Range != null) ? SentinelsPlugin.Range.Value : 30f);
		values.Wild = SentinelsPlugin.ShootWildlife != null && SentinelsPlugin.ShootWildlife.Value;
		values.SpareTaming = SentinelsPlugin.SpareTaming == null || SentinelsPlugin.SpareTaming.Value;
		values.Cost = ((SentinelsPlugin.EnergyCost != null) ? SentinelsPlugin.EnergyCost.Value : 150f);
		for (int i = 0; i < SentinelsPlugin.Elements.Length; i++)
		{
			Element element = SentinelsPlugin.Elements[i];
			values.Damage[i] = ((element.Damage != null) ? element.Damage.Value : element.DefaultDamage);
			values.Physical[i] = ((element.Physical != null) ? element.Physical.Value : element.DefaultPhysical);
			values.Cooldown[i] = ((element.Cooldown != null) ? element.Cooldown.Value : element.DefaultCooldown);
			values.Shots[i] = ((element.Shots != null) ? element.Shots.Value : element.DefaultShots);
			values.Spread[i] = ((element.Spread != null) ? element.Spread.Value : element.DefaultSpread);
			values.Offer[i] = element.Enabled == null || element.Enabled.Value;
		}
		return Sanitize(values);
	}

	private static Values Sanitize(Values v)
	{
		v.Range = Mathf.Clamp(v.Range, 10f, 60f);
		v.Cost = Mathf.Clamp(v.Cost, 0f, 1000f);
		for (int i = 0; i < v.Damage.Length; i++)
		{
			v.Damage[i] = Mathf.Clamp(v.Damage[i], 0f, 1000f);
			v.Physical[i] = Mathf.Clamp(v.Physical[i], 0f, 1000f);
			v.Cooldown[i] = Mathf.Clamp(v.Cooldown[i], 0.5f, 30f);
			v.Shots[i] = Mathf.Clamp(v.Shots[i], 1, 12);
			v.Spread[i] = Mathf.Clamp(v.Spread[i], 0f, 10f);
		}
		return v;
	}

	private static ZPackage Pack(Values v)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		ZPackage val = new ZPackage();
		val.Write(2);
		val.Write(v.Damage.Length);
		val.Write(SentinelsPlugin.Armed);
		val.Write(v.Range);
		val.Write(v.Wild);
		val.Write(v.SpareTaming);
		val.Write(v.Cost);
		for (int i = 0; i < v.Damage.Length; i++)
		{
			val.Write(v.Damage[i]);
			val.Write(v.Physical[i]);
			val.Write(v.Cooldown[i]);
			val.Write(v.Shots[i]);
			val.Write(v.Spread[i]);
			val.Write(v.Offer[i]);
		}
		return val;
	}

	private static Values Unpack(ZPackage pkg)
	{
		if (pkg.ReadInt() != 2 || pkg.ReadInt() != SentinelsPlugin.Elements.Length)
		{
			return null;
		}
		Values values = new Values();
		values.Armed = pkg.ReadBool();
		values.Range = pkg.ReadSingle();
		values.Wild = pkg.ReadBool();
		values.SpareTaming = pkg.ReadBool();
		values.Cost = pkg.ReadSingle();
		for (int i = 0; i < values.Damage.Length; i++)
		{
			values.Damage[i] = pkg.ReadSingle();
			values.Physical[i] = pkg.ReadSingle();
			values.Cooldown[i] = pkg.ReadSingle();
			values.Shots[i] = pkg.ReadInt();
			values.Spread[i] = pkg.ReadSingle();
			values.Offer[i] = pkg.ReadBool();
		}
		return Sanitize(values);
	}

	internal static bool HostAllows()
	{
		if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer())
		{
			return true;
		}
		if (_host != null)
		{
			return _host.Armed;
		}
		return false;
	}

	internal static void Tick()
	{
		Values current = Current;
		bool flag = HostAllows();
		if (!object.ReferenceEquals(current, _menuValues) || flag != _menuAllowed)
		{
			_menuValues = current;
			_menuAllowed = flag;
			SentinelsPlugin.TryFinishPieceSetup();
		}
		ZRoutedRpc instance = ZRoutedRpc.instance;
		if (instance == null || (Object)(object)ZNet.instance == (Object)null)
		{
			_host = null;
			return;
		}
		if (!object.ReferenceEquals(instance, _registeredOn))
		{
			_registeredOn = instance;
			_host = null;
			_nextRequest = 0f;
			instance.Register("danpe_Sentinels_ConfigRequest", (Action<long>)OnRequest);
			instance.Register<ZPackage>("danpe_Sentinels_Config", (Action<long, ZPackage>)OnConfig);
		}
		if (ZNet.instance.IsServer())
		{
			if (_broadcast)
			{
				_broadcast = false;
				instance.InvokeRoutedRPC(0L, "danpe_Sentinels_Config", new object[1] { Pack(Current) });
			}
		}
		else if (_host == null && SentinelsPlugin.Armed && (Object)(object)Player.m_localPlayer != (Object)null && Time.time >= _nextRequest)
		{
			_nextRequest = Time.time + 30f;
			instance.InvokeRoutedRPC("danpe_Sentinels_ConfigRequest", new object[0]);
		}
	}

	private static void OnRequest(long sender)
	{
		if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && ZRoutedRpc.instance != null)
		{
			ZRoutedRpc.instance.InvokeRoutedRPC(sender, "danpe_Sentinels_Config", new object[1] { Pack(Current) });
		}
	}

	private static void OnConfig(long sender, ZPackage pkg)
	{
		ZNetPeer val = (((Object)(object)ZNet.instance != (Object)null) ? ZNet.instance.GetServerPeer() : null);
		if ((Object)(object)ZNet.instance == (Object)null || ZNet.instance.IsServer() || val == null || sender != val.m_uid)
		{
			return;
		}
		try
		{
			Values values = Unpack(pkg);
			if (values != null)
			{
				_host = values;
				SentinelsPlugin.Log.LogInfo((object)(values.Armed ? "Using the host's sentinel settings." : "The host has Sentinel Stones switched off or unavailable: sentinels here stay inert."));
			}
		}
		catch (Exception ex)
		{
			SentinelsPlugin.Log.LogWarning((object)("Could not read the host's sentinel settings: " + ex.Message));
		}
	}
}
internal static class Prefabs
{
	internal const float StoneScale = 0.7f;

	internal const float OrbHeight = 2.6f;

	internal static GameObject Build(GameObject stone, Element el, int index, Texture stave, Transform container)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Expected O, but got Unknown
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Expected O, but got Unknown
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Expected O, but got Unknown
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Object.Instantiate<GameObject>(stone, container, false);
		((Object)val).name = el.PrefabName;
		for (int i = 0; i < val.transform.childCount; i++)
		{
			Transform child = val.transform.GetChild(i);
			child.localScale *= 0.7f;
			child.localPosition *= 0.7f;
		}
		Piece component = val.GetComponent<Piece>();
		component.m_enabled = false;
		component.m_resources = (Requirement[])(object)new Requirement[0];
		component.m_craftingStation = null;
		component.m_notOnWood = false;
		component.m_name = "Rune of the Sentinel: " + el.Title;
		GameObject val2 = new GameObject("OrbPivot");
		val2.transform.SetParent(val.transform, false);
		val2.transform.localPosition = new Vector3(0f, 2.6f, 0f);
		GameObject val3 = new GameObject("Orb");
		val3.transform.SetParent(val2.transform, false);
		if (!Application.isBatchMode)
		{
			val3.transform.localScale = Vector3.one * el.OrbScale;
			BuildOrb(el, val3.transform);
			GameObject val4 = new GameObject("SentinelLight");
			val4.transform.SetParent(val2.transform, false);
			Light val5 = val4.AddComponent<Light>();
			val5.type = (LightType)2;
			val5.color = el.LightColor;
			val5.range = 6f;
			val5.intensity = 2.5f;
			val5.shadows = (LightShadows)0;
			if ((Object)(object)stave != (Object)null)
			{
				ApplyStave(val, stave, el.StaveColor);
			}
		}
		RuneTurret runeTurret = val.AddComponent<RuneTurret>();
		runeTurret.ElementIndex = index;
		return val;
	}

	internal static GameObject Placeholder(Element el, Transform container)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		GameObject val = new GameObject(el.PrefabName);
		val.transform.SetParent(container, false);
		ZNetView val2 = val.AddComponent<ZNetView>();
		val2.m_persistent = true;
		return val;
	}

	internal static void ConfigurePiece(Element el, Sprite stoneIcon, int category)
	{
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		Piece component = el.Prefab.GetComponent<Piece>();
		component.m_name = "Rune of the Sentinel: " + el.Title;
		component.m_description = "Raises a sentinel stone that " + el.Blurb + " Players, tames and your buildings are never harmed.";
		component.m_category = (PieceCategory)category;
		Sprite front = null;
		GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab(el.IconItem) : null);
		ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
		if ((Object)(object)val2 != (Object)null && val2.m_itemData != null)
		{
			try
			{
				front = val2.m_itemData.GetIcon();
			}
			catch (Exception)
			{
			}
		}
		Sprite val3 = Icon.Compose(stoneIcon, front);
		if ((Object)(object)val3 != (Object)null)
		{
			component.m_icon = val3;
		}
		component.m_enabled = true;
	}

	private static void ApplyStave(GameObject clone, Texture stave, Color hdr)
	{
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Transform val = clone.transform.Find("StandingStone");
			MeshRenderer val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<MeshRenderer>() : null);
			if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Renderer)val2).sharedMaterial == (Object)null) && ((Renderer)val2).sharedMaterial.HasProperty("_EmissionColor") && ((Renderer)val2).sharedMaterial.HasProperty("_EmissionMap"))
			{
				Material val3 = new Material(((Renderer)val2).sharedMaterial);
				((Object)val3).name = "Sentinel_" + ((Object)clone).name;
				val3.SetTexture("_EmissionMap", stave);
				val3.SetColor("_EmissionColor", hdr);
				val3.EnableKeyword("_EMISSION");
				((Renderer)val2).sharedMaterial = val3;
			}
		}
		catch (Exception ex)
		{
			SentinelsPlugin.Log.LogWarning((object)("Could not light the " + ((Object)clone).name + " stave: " + ex.Message));
		}
	}

	private static void BuildOrb(Element el, Transform orb)
	{
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		int num = 0;
		for (int i = 0; i < el.OrbParts.Length; i++)
		{
			GameObject val = ((i < el.OrbSources.Count) ? el.OrbSources[i] : null);
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			for (int j = 1; j < el.OrbParts[i].Length; j++)
			{
				string text = el.OrbParts[i][j];
				Transform val2 = val.transform.Find(text);
				if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeSelf)
				{
					GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject, orb, false);
					((Object)val3).name = text;
					val3.transform.localPosition = val2.localPosition;
					val3.transform.localRotation = val2.localRotation;
					StripVisual(val3);
					num++;
				}
			}
		}
		if (num == 0)
		{
			SentinelsPlugin.Log.LogWarning((object)("The " + el.Title + " sentinel's orb has no visuals; it will show only its light."));
		}
	}

	private static void StripVisual(GameObject go)
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 6; i++)
		{
			bool flag = false;
			Component[] componentsInChildren = go.GetComponentsInChildren<Component>(true);
			Component[] array = componentsInChildren;
			foreach (Component val in array)
			{
				if (!((Object)(object)val == (Object)null) && !(val is Transform) && !(val is MeshFilter) && !(val is MeshRenderer) && !(val is ParticleSystem) && !(val is ParticleSystemRenderer) && !(val is LODGroup))
				{
					try
					{
						Object.DestroyImmediate((Object)(object)val);
					}
					catch (Exception)
					{
					}
					if ((Object)(object)val != (Object)null)
					{
						flag = true;
					}
				}
			}
			if (!flag)
			{
				break;
			}
		}
		ParticleSystem[] componentsInChildren2 = go.GetComponentsInChildren<ParticleSystem>(true);
		foreach (ParticleSystem val2 in componentsInChildren2)
		{
			MainModule main = val2.main;
			EmissionModule emission = val2.emission;
			bool flag2 = ((EmissionModule)(ref emission)).rateOverTimeMultiplier <= 0f;
			if (!((MainModule)(ref main)).loop || flag2)
			{
				((EmissionModule)(ref emission)).enabled = false;
			}
			else
			{
				((MainModule)(ref main)).scalingMode = (ParticleSystemScalingMode)0;
			}
		}
		Renderer[] componentsInChildren3 = go.GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val3 in componentsInChildren3)
		{
			val3.shadowCastingMode = (ShadowCastingMode)0;
		}
	}
}
internal static class Hostility
{
	private const int FactionPlayers = 0;

	private const int FactionDverger = 10;

	private const int FactionPlayerSpawned = 11;

	internal static bool IsHostile(Character c)
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Expected I4, but got Unknown
		if ((Object)(object)c == (Object)null || c.IsDead() || c.IsPlayer() || c.IsTamed())
		{
			return false;
		}
		if (c.m_aiSkipTarget || (Object)(object)((Component)c).GetComponent<Piece>() != (Object)null)
		{
			return false;
		}
		int num = (int)c.GetFaction();
		if (num == 0 || num == 11)
		{
			return false;
		}
		BaseAI baseAI = c.GetBaseAI();
		if (num == 10 && ((Object)(object)baseAI == (Object)null || !baseAI.IsAggravated()))
		{
			return false;
		}
		Tuning.Values current = Tuning.Current;
		if (baseAI is AnimalAI && !current.Wild)
		{
			return false;
		}
		if (current.SpareTaming && BeingTamed(c))
		{
			return false;
		}
		return true;
	}

	private static bool BeingTamed(Character c)
	{
		Tameable component = ((Component)c).GetComponent<Tameable>();
		if ((Object)(object)component == (Object)null)
		{
			return false;
		}
		ZNetView component2 = ((Component)c).GetComponent<ZNetView>();
		if ((Object)(object)component2 == (Object)null || !component2.IsValid())
		{
			return false;
		}
		if (!component.IsHungry())
		{
			return component2.GetZDO().GetFloat(ZDOVars.s_tameTimeLeft, component.m_tamingTime) < component.m_tamingTime;
		}
		return false;
	}

	internal static bool AllowHit(object target)
	{
		if (target == null)
		{
			return true;
		}
		Character val = (Character)((target is Character) ? target : null);
		if ((Object)(object)val != (Object)null)
		{
			return IsHostile(val);
		}
		Component val2 = (Component)((target is Component) ? target : null);
		if ((Object)(object)val2 == (Object)null)
		{
			return true;
		}
		if ((Object)(object)val2.GetComponentInParent<RuneTurret>() != (Object)null || (Object)(object)val2.GetComponentInParent<WearNTear>() != (Object)null || (Object)(object)val2.GetComponentInParent<Plant>() != (Object)null || (Object)(object)val2.GetComponentInParent<Pickable>() != (Object)null)
		{
			return false;
		}
		Piece componentInParent = val2.GetComponentInParent<Piece>();
		if ((Object)(object)componentInParent != (Object)null && componentInParent.IsPlacedByPlayer())
		{
			return false;
		}
		Character componentInParent2 = val2.GetComponentInParent<Character>();
		if (!((Object)(object)componentInParent2 == (Object)null))
		{
			return IsHostile(componentInParent2);
		}
		return true;
	}
}
internal static class Shot
{
	internal const HitType Marker = (HitType)150;

	internal static readonly ItemData Tag = MakeTag();

	private static ItemData MakeTag()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Expected O, but got Unknown
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Expected O, but got Unknown
		ItemData val = new ItemData();
		val.m_shared = new SharedData();
		val.m_shared.m_name = "$danpe_sentinel_shot";
		val.m_shared.m_attack = new Attack();
		val.m_shared.m_secondaryAttack = new Attack();
		return val;
	}
}
public class RuneTurret : MonoBehaviour
{
	private const string RpcTarget = "danpe_Sentinel_Target";

	public int ElementIndex;

	private static int _sightMask = -1;

	private static float _nextErrorLog;

	private ZNetView _nview;

	private Element _el;

	private Transform _pivot;

	private Transform _orb;

	private Light _light;

	private float _lightBase = 2.5f;

	private Character _target;

	private float _retarget;

	private bool _ghost;

	private float _phase;

	private float _idleYaw;

	private void Awake()
	{
		_ghost = ZNetView.m_forceDisableInit;
		_el = ((ElementIndex >= 0 && ElementIndex < SentinelsPlugin.Elements.Length) ? SentinelsPlugin.Elements[ElementIndex] : null);
		_pivot = ((Component)this).transform.Find("OrbPivot");
		_orb = (((Object)(object)_pivot != (Object)null) ? _pivot.Find("Orb") : null);
		Transform val = (((Object)(object)_pivot != (Object)null) ? _pivot.Find("SentinelLight") : null);
		_light = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Light>() : null);
		if ((Object)(object)_light != (Object)null)
		{
			_lightBase = _light.intensity;
		}
		_phase = Random.Range(0f, 10f);
		_idleYaw = Random.Range(0f, 360f);
		if (!_ghost)
		{
			_nview = ((Component)this).GetComponent<ZNetView>();
			if (!((Object)(object)_nview == (Object)null) && _nview.GetZDO() != null)
			{
				_nview.Register<ZDOID>("danpe_Sentinel_Target", (Action<long, ZDOID>)RPC_Target);
				_retarget = Random.Range(0f, 1f);
			}
		}
	}

	private Vector3 Eye()
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)_pivot != (Object)null))
		{
			return ((Component)this).transform.position + Vector3.up * 2.6f;
		}
		return _pivot.position;
	}

	private void FixedUpdate()
	{
		if (_ghost || !SentinelsPlugin.Armed || _el == null || _el.Failed || (Object)(object)_el.Projectile == (Object)null || (Object)(object)_nview == (Object)null || !_nview.IsValid() || !_nview.IsOwner() || (Object)(object)ZNet.instance == (Object)null || !Tuning.HostAllows())
		{
			return;
		}
		try
		{
			Tuning.Values current = Tuning.Current;
			UpdateTarget(Time.fixedDeltaTime, current);
			TryShoot(current);
		}
		catch (Exception ex)
		{
			_retarget = 5f;
			if (Time.time >= _nextErrorLog)
			{
				_nextErrorLog = Time.time + 60f;
				SentinelsPlugin.Log.LogWarning((object)("Sentinel error: " + ex));
			}
		}
	}

	private void Update()
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: 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_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
		float num = Time.time + _phase;
		if ((Object)(object)_orb != (Object)null)
		{
			_orb.localPosition = new Vector3(0f, Mathf.Sin(num * 1.8f) * 0.08f, 0f);
		}
		if ((Object)(object)_pivot != (Object)null)
		{
			Character target = _target;
			Quaternion val2;
			if ((Object)(object)target != (Object)null && !target.IsDead())
			{
				Vector3 val = target.GetCenterPoint() - _pivot.position;
				val2 = ((((Vector3)(ref val)).sqrMagnitude > 0.01f) ? Quaternion.LookRotation(val) : _pivot.rotation);
			}
			else
			{
				_idleYaw += 25f * Time.deltaTime;
				val2 = Quaternion.Euler(0f, _idleYaw, 0f);
			}
			_pivot.rotation = Quaternion.RotateTowards(_pivot.rotation, val2, 270f * Time.deltaTime);
		}
		if ((Object)(object)_light != (Object)null && _el != null && _el.Flicker)
		{
			_light.intensity = _lightBase * (0.55f + 0.9f * Mathf.PerlinNoise(num * 9f, _phase));
		}
	}

	private void RPC_Target(long sender, ZDOID id)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		if (((ZDOID)(ref id)).IsNone() || (Object)(object)ZNetScene.instance == (Object)null)
		{
			_target = null;
			return;
		}
		GameObject val = ZNetScene.instance.FindInstance(id);
		_target = (((Object)(object)val != (Object)null) ? val.GetComponent<Character>() : null);
	}

	private void SetTarget(Character c)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		_target = c;
		_nview.InvokeRPC(ZNetView.Everybody, "danpe_Sentinel_Target", new object[1] { ((Object)(object)c != (Object)null) ? c.GetZDOID() : ZDOID.None });
	}

	private void UpdateTarget(float dt, Tuning.Values v)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = Eye();
		float range = v.Range;
		if ((Object)(object)_target != (Object)null && (!Hostility.IsHostile(_target) || Vector3.Distance(val, _target.GetCenterPoint()) > range + 2f))
		{
			SetTarget(null);
		}
		_retarget -= dt;
		if (_retarget > 0f)
		{
			return;
		}
		_retarget = (Character.IsCharacterInRange(((Component)this).transform.position, 40f) ? 1f : 4f);
		Character val2 = null;
		float num = float.MaxValue;
		List<Character> allCharacters = Character.GetAllCharacters();
		for (int i = 0; i < allCharacters.Count; i++)
		{
			Character val3 = allCharacters[i];
			if (!Hostility.IsHostile(val3))
			{
				continue;
			}
			float num2 = Vector3.Distance(val, val3.GetCenterPoint());
			if (!(num2 > range) && !(num2 >= num))
			{
				BaseAI baseAI = val3.GetBaseAI();
				if ((!((Object)(object)baseAI != (Object)null) || !baseAI.IsSleeping()) && CanSee(val, val3))
				{
					val2 = val3;
					num = num2;
				}
			}
		}
		if ((Object)(object)val2 != (Object)(object)_target)
		{
			SetTarget(val2);
		}
	}

	private bool CanSee(Vector3 eye, Character c)
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		if (_sightMask < 0)
		{
			_sightMask = LayerMask.GetMask(new string[7] { "Default", "static_solid", "Default_small", "piece", "terrain", "viewblock", "vehicle" });
		}
		Vector3 val = c.GetCenterPoint() - eye;
		float magnitude = ((Vector3)(ref val)).magnitude;
		if (magnitude < 0.05f)
		{
			return true;
		}
		RaycastHit[] array = Physics.RaycastAll(eye, val / magnitude, magnitude, _sightMask, (QueryTriggerInteraction)1);
		for (int i = 0; i < array.Length; i++)
		{
			Collider collider = ((RaycastHit)(ref array[i])).collider;
			if (!((Object)(object)collider == (Object)null) && !((Component)collider).transform.IsChildOf(((Component)this).transform) && !((Object)(object)((Component)collider).GetComponentInParent<Character>() == (Object)(object)c) && Hostility.AllowHit(collider))
			{
				return false;
			}
		}
		return true;
	}

	private void TryShoot(Tuning.Values v)
	{
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: 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_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0150: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		Character target = _target;
		if ((Object)(object)target == (Object)null || !Hostility.IsHostile(target))
		{
			return;
		}
		int elementIndex = ElementIndex;
		ZDO zDO = _nview.GetZDO();
		double timeSeconds = ZNet.instance.GetTimeSeconds();
		float num = zDO.GetFloat(ZDOVars.s_lastAttack, 0f);
		if ((double)(num + v.Cooldown[elementIndex]) > timeSeconds && (double)num <= timeSeconds + 1.0)
		{
			return;
		}
		zDO.Set(ZDOVars.s_lastAttack, (float)timeSeconds);
		Vector3 val = Eye();
		Vector3 val2 = Aim(val, target);
		int num2 = v.Shots[elementIndex];
		float num3 = Vector3.Distance(val, target.GetCenterPoint());
		float num4 = ((num3 > 0.5f) ? Mathf.Min(v.Spread[elementIndex], Mathf.Atan2(0.35f, num3) * 57.29578f) : v.Spread[elementIndex]);
		DamageTypes damage = _el.DamageTypes(v.Damage[elementIndex], v.Physical[elementIndex]);
		for (int i = 0; i < num2; i++)
		{
			Vector3 val3 = val2;
			if (num4 > 0.01f)
			{
				Vector3 val4 = Vector3.Cross(Vector3.up, val3);
				if (((Vector3)(ref val4)).sqrMagnitude < 0.0001f)
				{
					val4 = Vector3.right;
				}
				val3 = Quaternion.AngleAxis(Random.Range(0f - num4, num4), Vector3.up) * (Quaternion.AngleAxis(Random.Range(0f - num4, num4), ((Vector3)(ref val4)).normalized) * val3);
			}
			Fire(val, ((Vector3)(ref val3)).normalized, damage, v.Range);
		}
	}

	private Vector3 Aim(Vector3 eye, Character target)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		Vector3 centerPoint = target.GetCenterPoint();
		Vector3 velocity = target.GetVelocity();
		if (!target.IsFlying())
		{
			Vector3 val = new Vector3(velocity.x, 0f, velocity.z);
			float magnitude = ((Vector3)(ref val)).magnitude;
			velocity.y = Mathf.Clamp(velocity.y, 0f - magnitude, magnitude);
		}
		float speed = _el.Speed;
		float gravity = _el.Gravity;
		Vector3 val2 = centerPoint;
		Vector3 val3 = val2 - eye;
		Vector3 dir = ((Vector3)(ref val3)).normalized;
		for (int i = 0; i < 3; i++)
		{
			if (!Solve(eye, val2, speed, gravity, out dir, out var t))
			{
				t = Vector3.Distance(eye, val2) / speed;
			}
			val2 = centerPoint + velocity * t;
		}
		Solve(eye, val2, speed, gravity, out dir, out var _);
		return dir;
	}

	private static bool Solve(Vector3 eye, Vector3 point, float v, float g, out Vector3 dir, out float t)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: 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_0092: 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_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = point - eye;
		Vector3 val2 = default(Vector3);
		((Vector3)(ref val2))..ctor(val.x, 0f, val.z);
		float magnitude = ((Vector3)(ref val2)).magnitude;
		if (g < 0.001f || magnitude < 0.05f)
		{
			dir = ((((Vector3)(ref val)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref val)).normalized : Vector3.forward);
			t = ((Vector3)(ref val)).magnitude / v;
			return true;
		}
		float y = val.y;
		float num = v * v;
		float num2 = num * num - g * (g * magnitude * magnitude + 2f * y * num);
		Vector3 val3 = val2 / magnitude;
		if (num2 < 0f)
		{
			Vector3 val4 = val3 + Vector3.up;
			dir = ((Vector3)(ref val4)).normalized;
			t = magnitude / (v * 0.7071f);
			return false;
		}
		float num3 = Mathf.Atan((num - Mathf.Sqrt(num2)) / (g * magnitude));
		dir = val3 * Mathf.Cos(num3) + Vector3.up * Mathf.Sin(num3);
		t = magnitude / Mathf.Max(0.01f, v * Mathf.Cos(num3));
		return true;
	}

	private void Fire(Vector3 eye, Vector3 dir, DamageTypes damage, float range)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Expected O, but got Unknown
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		float speed = _el.Speed;
		Vector3 val = eye + dir * (0.5f * speed * Time.fixedDeltaTime + Mathf.Min(_el.RayRadius, 0.25f));
		GameObject val2 = Object.Instantiate<GameObject>(_el.Projectile, val, Quaternion.LookRotation(dir));
		Projectile component = val2.GetComponent<Projectile>();
		if ((Object)(object)component != (Object)null)
		{
			component.m_onHit = null;
			component.m_spawnOnHit = null;
			component.m_randomSpawnOnHit = new List<GameObject>();
			component.m_spawnOnTtl = false;
			component.m_respawnItemOnHit = false;
			component.m_aoeSkipWearNTear = true;
			component.m_noDamageFriendly = false;
			component.m_rayRadius = Mathf.Min(component.m_rayRadius, 0.25f);
			component.m_ttl = Mathf.Max(component.m_ttl, range / speed + 1f);
		}
		IProjectile component2 = val2.GetComponent<IProjectile>();
		if (component2 == null)
		{
			Object.Destroy((Object)(object)val2);
			return;
		}
		HitData val3 = new HitData();
		val3.m_damage = damage;
		val3.m_pushForce = 10f;
		val3.m_backstabBonus = 1f;
		val3.m_blockable = true;
		val3.m_dodgeable = true;
		val3.m_skill = (SkillType)0;
		val3.m_hitType = (HitType)150;
		val3.m_statusEffectHash = (((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.m_statusEffect)) ? StringExtensionMethods.GetStableHashCode(component.m_statusEffect) : 0);
		try
		{
			component2.Setup((Character)null, dir * speed, 0f, val3, (ItemData)null, Shot.Tag);
		}
		catch (Exception ex)
		{
			if (!((Object)(object)component != (Object)null) || Patches.ProjectileAmmo == null || !object.ReferenceEquals(Patches.ProjectileAmmo(component), Shot.Tag))
			{
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					ZNetScene.instance.Destroy(val2);
				}
				else
				{
					Object.Destroy((Object)(object)val2);
				}
			}
			if (Time.time >= _nextErrorLog)
			{
				_nextErrorLog = Time.time + 60f;
				SentinelsPlugin.Log.LogWarning((object)("Another mod failed while a sentinel shot was set up (the volley goes on): " + ex.Message));
			}
		}
	}
}
public static class Patches
{
	internal static Func<Projectile, ItemData> ProjectileAmmo;

	public static void IsUnlockablePostfix(Piece piece, ref bool __result)
	{
		if (!__result && SentinelsPlugin.IndexFor(piece) >= 0)
		{
			__result = true;
		}
	}

	public static void IsUnlockedPostfix(Piece piece, ref bool __result)
	{
		if (SentinelsPlugin.IndexFor(piece) >= 0)
		{
			__result = true;
		}
	}

	public static void EnergyCostPostfix(Piece piece, ref float __result)
	{
		if (SentinelsPlugin.IndexFor(piece) >= 0)
		{
			__result = Tuning.Current.Cost;
		}
	}

	public static bool ValidTargetPrefix(IDestructible destr, ItemData ___m_ammo, ref bool __result)
	{
		if (!object.ReferenceEquals(___m_ammo, Shot.Tag))
		{
			return true;
		}
		try
		{
			if (!Hostility.AllowHit(destr))
			{
				__result = false;
				return false;
			}
		}
		catch (Exception)
		{
			__result = false;
			return false;
		}
		return true;
	}

	public static bool ShouldHitPrefix(Collider collider, ItemData ___m_ammo, ref bool __result)
	{
		if (!object.ReferenceEquals(___m_ammo, Shot.Tag))
		{
			return true;
		}
		try
		{
			GameObject val = (((Object)(object)collider != (Object)null) ? Projectile.FindHitObject(collider) : null);
			if ((Object)(object)val != (Object)null)
			{
				Character component = val.GetComponent<Character>();
				object target = (((Object)(object)component != (Object)null) ? ((object)component) : ((object)val.transform));
				if (!Hostility.AllowHit(target))
				{
					__result = false;
					return false;
				}
			}
		}
		catch (Exception)
		{
			__result = false;
			return false;
		}
		return true;
	}

	public static bool CharacterDamagePrefix(Character __instance, HitData hit)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Invalid comparison between Unknown and I4
		if (hit != null && (int)hit.m_hitType == 150 && !Hostility.IsHostile(__instance))
		{
			return false;
		}
		return true;
	}

	public static bool WearNTearDamagePrefix(HitData hit)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Invalid comparison between Unknown and I4
		if (hit != null)
		{
			return (int)hit.m_hitType != 150;
		}
		return true;
	}

	public static bool ShieldCheckPrefix(Projectile projectile)
	{
		try
		{
			return (Object)(object)projectile == (Object)null || ProjectileAmmo == null || !object.ReferenceEquals(ProjectileAmmo(projectile), Shot.Tag);
		}
		catch (Exception)
		{
			return true;
		}
	}

	public static void ZNetSceneAwakePrefix(ZNetScene __instance)
	{
		try
		{
			SentinelsPlugin.OnZNetSceneAwake(__instance);
		}
		catch (Exception ex)
		{
			SentinelsPlugin.Log.LogError((object)("The sentinels could not be prepared for this world: " + ex));
		}
	}

	public static void BoulderSetupPostfix()
	{
		try
		{
			SentinelsPlugin.TryFinishPieceSetup();
		}
		catch (Exception ex)
		{
			SentinelsPlugin.Log.LogError((object)("The sentinels could not be added to the menu: " + ex));
		}
	}
}
internal static class Icon
{
	private const int Size = 128;

	internal static Sprite Compose(Sprite back, Sprite front)
	{
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Expected O, but got Unknown
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)back == (Object)null || (Object)(object)back.texture == (Object)null || Application.isBatchMode)
		{
			if (!((Object)(object)front != (Object)null))
			{
				return back;
			}
			return front;
		}
		try
		{
			int width;
			int height;
			Color[] src = ReadSprite(back, out width, out height);
			Color[] array = (Color[])(object)new Color[16384];
			Stamp(array, src, width, height, 51.2f, 71.68f, 107.52f);
			if ((Object)(object)front != (Object)null && (Object)(object)front.texture != (Object)null)
			{
				int width2;
				int height2;
				Color[] src2 = ReadSprite(front, out width2, out height2);
				Stamp(array, src2, width2, height2, 92.16f, 38.4f, 74.24f);
			}
			Texture2D val = new Texture2D(128, 128, (TextureFormat)4, false);
			((Object)val).name = "SentinelIcon";
			((Texture)val).wrapMode = (TextureWrapMode)1;
			val.SetPixels(array);
			val.Apply(false, false);
			return Sprite.Create(val, new Rect(0f, 0f, 128f, 128f), new Vector2(0.5f, 0.5f), 100f);
		}
		catch (Exception ex)
		{
			SentinelsPlugin.Log.LogWarning((object)("Could not draw a sentinel icon: " + ex.Message));
			return ((Object)(object)front != (Object)null) ? front : back;
		}
	}

	private static Color[] ReadSprite(Sprite sprite, out int width, out int height)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Expected O, but got Unknown
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		Texture texture = (Texture)(object)sprite.texture;
		Rect textureRect = sprite.textureRect;
		width = Mathf.Max(1, Mathf.RoundToInt(((Rect)(ref textureRect)).width));
		height = Mathf.Max(1, Mathf.RoundToInt(((Rect)(ref textureRect)).height));
		RenderTexture temporary = RenderTexture.GetTemporary(texture.width, texture.height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)2);
		RenderTexture active = RenderTexture.active;
		Texture2D val = null;
		try
		{
			Graphics.Blit(texture, temporary);
			RenderTexture.active = temporary;
			val = new Texture2D(width, height, (TextureFormat)4, false);
			val.ReadPixels(new Rect(((Rect)(ref textureRect)).x, ((Rect)(ref textureRect)).y, (float)width, (float)height), 0, 0);
			val.Apply();
			return val.GetPixels();
		}
		finally
		{
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)val);
			}
		}
	}

	private static void Stamp(Color[] dst, Color[] src, int sw, int sh, float cx, float cy, float target)
	{
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		float num = (float)sw / (float)sh;
		float num2 = ((num >= 1f) ? target : (target * num));
		float num3 = ((num >= 1f) ? (target / num) : target);
		float num4 = cx - num2 / 2f;
		float num5 = cy - num3 / 2f;
		int num6 = Mathf.Max(0, Mathf.FloorToInt(num4));
		int num7 = Mathf.Min(128, Mathf.CeilToInt(num4 + num2));
		int num8 = Mathf.Max(0, Mathf.FloorToInt(num5));
		int num9 = Mathf.Min(128, Mathf.CeilToInt(num5 + num3));
		for (int i = num8; i < num9; i++)
		{
			float num10 = ((float)i + 0.5f - num5) / num3;
			if (num10 < 0f || num10 >= 1f)
			{
				continue;
			}
			for (int j = num6; j < num7; j++)
			{
				float num11 = ((float)j + 0.5f - num4) / num2;
				if (num11 < 0f || num11 >= 1f)
				{
					continue;
				}
				Color val = Sample(src, sw, sh, num11, num10);
				if (!(val.a <= 0f))
				{
					int num12 = i * 128 + j;
					Color val2 = dst[num12];
					float num13 = val.a + val2.a * (1f - val.a);
					if (!(num13 <= 0f))
					{
						ref Color reference = ref dst[num12];
						reference = new Color((val.r * val.a + val2.r * val2.a * (1f - val.a)) / num13, (val.g * val.a + val2.g * val2.a * (1f - val.a)) / num13, (val.b * val.a + val2.b * val2.a * (1f - val.a)) / num13, num13);
					}
				}
			}
		}
	}

	private static Color Sample(Color[] src, int sw, int sh, float u, float v)
	{
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		float num = u * (float)sw - 0.5f;
		float num2 = v * (float)sh - 0.5f;
		int num3 = Mathf.Clamp(Mathf.FloorToInt(num), 0, sw - 1);
		int num4 = Mathf.Clamp(Mathf.FloorToInt(num2), 0, sh - 1);
		int num5 = Mathf.Min(num3 + 1, sw - 1);
		int num6 = Mathf.Min(num4 + 1, sh - 1);
		float num7 = Mathf.Clamp01(num - (float)num3);
		float num8 = Mathf.Clamp01(num2 - (float)num4);
		Color val = Color.Lerp(src[num4 * sw + num3], src[num4 * sw + num5], num7);
		Color val2 = Color.Lerp(src[num6 * sw + num3], src[num6 * sw + num5], num7);
		return Color.Lerp(val, val2, num8);
	}
}