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

[assembly: AssemblyTitle("RideableTames Fai Controls")]
[assembly: AssemblyFileVersion("1.4.12.0")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("1.4.12.0")]
namespace Fai.RideableTames.Controls;

internal sealed class AttackChoice
{
	internal ItemData Item;

	internal bool Secondary;

	internal static List<AttackChoice> For(Humanoid mount)
	{
		List<ItemData> list = (from i in mount.GetInventory().GetAllItems()
			where i != null && i.m_shared != null && i.HavePrimaryAttack() && (int)i.m_shared.m_aiTargetType == 0 && Damage(i) > 0f
			select i).ToList();
		List<ItemData> list2 = list.Where((ItemData i) => (!((Character)mount).IsFlying()) ? i.m_shared.m_aiWhenWalking : i.m_shared.m_aiWhenFlying).ToList();
		if (list2.Count == 0)
		{
			list2 = list;
		}
		List<ItemData> list3 = list2.OrderBy((ItemData i) => i.m_shared.m_aiAttackInterval).ThenBy(Damage).ThenBy<ItemData, string>((ItemData i) => i.m_shared.m_name, StringComparer.Ordinal)
			.ThenBy<ItemData, string>((ItemData i) => (!((Object)(object)i.m_dropPrefab != (Object)null)) ? string.Empty : ((Object)i.m_dropPrefab).name, StringComparer.Ordinal)
			.ToList();
		List<AttackChoice> list4 = new List<AttackChoice>();
		foreach (ItemData item in list3)
		{
			if (!list4.Any((AttackChoice c) => c.Item.m_shared == item.m_shared))
			{
				list4.Add(new AttackChoice
				{
					Item = item
				});
				if (list4.Count == 3)
				{
					break;
				}
			}
		}
		foreach (ItemData item2 in list3)
		{
			if (list4.Count == 3)
			{
				break;
			}
			if (item2.HaveSecondaryAttack() && !list4.Any((AttackChoice c) => c.Secondary && c.Item.m_shared == item2.m_shared))
			{
				list4.Add(new AttackChoice
				{
					Item = item2,
					Secondary = true
				});
			}
		}
		return list4;
	}

	private static float Damage(ItemData item)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		DamageTypes damages = item.m_shared.m_damages;
		return damages.m_damage + damages.m_blunt + damages.m_slash + damages.m_pierce + damages.m_fire + damages.m_frost + damages.m_lightning + damages.m_poison + damages.m_spirit;
	}
}
internal static class CollarPlacement
{
	internal const float ForwardDistance = 0.1f;

	internal const float BaseForwardTiltDegrees = 30f;

	internal static Quaternion BaseRotation(Quaternion original)
	{
		//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_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: 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)
		Quaternion val = original * Quaternion.AngleAxis(-30f, Vector3.right);
		return ((Quaternion)(ref val)).normalized;
	}

	internal static Vector3 LocalOffset(Transform neck, Transform root, Quaternion gripRotation)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: 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_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: 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_009e: 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_00a7: 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)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: 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_006c: Unknown result type (might be due to invalid IL or missing references)
		Transform val = neck.Find("Head");
		Vector3 val2 = ((!((Object)(object)val == (Object)null)) ? (val.position - neck.position) : (neck.rotation * gripRotation * Vector3.forward));
		if (((Vector3)(ref val2)).sqrMagnitude < 1E-06f)
		{
			val2 = neck.rotation * gripRotation * Vector3.forward;
		}
		float num = Math.Max(1E-06f, Math.Abs(root.lossyScale.x));
		Vector3 val3 = ((Vector3)(ref val2)).normalized * (0.1f * num);
		return neck.InverseTransformPoint(neck.position + val3);
	}
}
internal static class ControlMath
{
	internal const int Stop = 0;

	internal const int Walk = 1;

	internal const int Jog = 2;

	internal const int Run = 3;

	internal static int Mode(float ahead, float stickMagnitude, bool analog, bool sprint, int previous, float threshold)
	{
		if (!Finite(ahead) || !Finite(stickMagnitude) || ahead <= 0.05f)
		{
			return 0;
		}
		if (sprint)
		{
			return 3;
		}
		if (!analog)
		{
			return 1;
		}
		float num = ((previous != 1) ? threshold : Math.Min(0.98f, threshold + 0.06f));
		return (stickMagnitude <= num) ? 1 : 2;
	}

	internal static bool Finite(float value)
	{
		return !float.IsNaN(value) && !float.IsInfinity(value);
	}

	internal static bool SenderAllowed(long sender, long rider, bool owner, bool validUser)
	{
		return owner && validUser && rider != 0 && sender == rider;
	}

	internal static float Cost(int slot, float maximum, float skill)
	{
		return Math.Max(0f, maximum) * ((slot != 0) ? 0.12f : 0.06f) * (1f - 0.5f * Math.Max(0f, Math.Min(1f, skill)));
	}
}
internal struct HarnessSample
{
	internal Vector3 Point;

	internal Vector3 Normal;

	internal HarnessSample(Vector3 point, Vector3 normal)
	{
		//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_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		Point = point;
		Normal = normal;
	}
}
internal static class HarnessGeometry
{
	internal const float RestHeight = 0.035f;

	internal const float Width = 0.036f;

	internal const float Thickness = 0.004f;

	internal const float ForwardTiltDegrees = 35f;

	internal static HarnessSample[] ChestLoop(int segments = 48)
	{
		//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_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		float num = (float)Math.Asin(0.3400000035762787);
		float num2 = (float)Math.Cos(num);
		float num3 = 0.02f / (1f + num2);
		float num4 = 0.0625f + num3 * num3;
		float num5 = (float)Math.PI / 36f;
		float num6 = (float)Math.Cos(num5);
		float num7 = (float)Math.Sin(num5);
		HarnessSample[] array = new HarnessSample[segments + 1];
		Vector3 point = default(Vector3);
		Vector3 val = default(Vector3);
		for (int i = 0; i <= segments; i++)
		{
			float num8 = 0f - num - (float)(Math.PI * 2.0 - (double)(2f * num)) * (float)i / (float)segments;
			float num9 = (float)Math.Sin(num8);
			float num10 = (float)Math.Cos(num8);
			((Vector3)(ref point))..ctor(0.225f * num9, 0.012f + 0.25f * (num10 - num2), num3 * (num2 - num10));
			((Vector3)(ref val))..ctor(num9 / 0.225f, 0.25f * num10 / num4, (0f - num3) * num10 / num4);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if (i == 0)
			{
				((Vector3)(ref point))..ctor(-0.085f, 0.012f, 0f);
			}
			if (i == segments)
			{
				((Vector3)(ref point))..ctor(0.085f, 0.012f, 0f);
			}
			((Vector3)(ref point))..ctor(point.x, 0.012f + (point.y - 0.012f) * num6 + point.z * num7, (0f - (point.y - 0.012f)) * num7 + point.z * num6);
			((Vector3)(ref normalized))..ctor(normalized.x, normalized.y * num6 + normalized.z * num7, (0f - normalized.y) * num7 + normalized.z * num6);
			ref HarnessSample reference = ref array[i];
			reference = new HarnessSample(point, normalized);
		}
		return array;
	}

	internal static void AddRibbon(HarnessSample[] points, List<Vector3> vertices, List<Vector2> uv, List<int> triangles)
	{
		//IL_0027: 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_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: 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_00e2: 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_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: 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_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0201: Unknown result type (might be due to invalid IL or missing references)
		int count = vertices.Count;
		float num = 0f;
		float[] array = new float[points.Length];
		for (int i = 1; i < points.Length; i++)
		{
			num = (array[i] = num + Vector3.Distance(points[i - 1].Point, points[i].Point));
		}
		Vector3 val = Vector3.zero;
		for (int j = 0; j < points.Length; j++)
		{
			Vector3 val2 = points[Math.Min(j + 1, points.Length - 1)].Point - points[Math.Max(j - 1, 0)].Point;
			Vector3 normalized = ((Vector3)(ref points[j].Normal)).normalized;
			Vector3 val3 = Vector3.Cross(val2, normalized);
			Vector3 val4 = ((Vector3)(ref val3)).normalized;
			if (((Vector3)(ref val4)).sqrMagnitude < 0.01f)
			{
				Vector3 val5 = Vector3.Cross(normalized, Vector3.forward);
				val4 = ((Vector3)(ref val5)).normalized;
			}
			if (((Vector3)(ref val4)).sqrMagnitude < 0.01f)
			{
				val4 = Vector3.right;
			}
			if (((Vector3)(ref val)).sqrMagnitude > 0f && Vector3.Dot(val, val4) < 0f)
			{
				val4 *= -1f;
			}
			val = val4;
			float num2 = ((!(num > 0.001f)) ? 0f : (array[j] / num));
			for (int k = 0; k < 4; k++)
			{
				float num3 = ((k != 0 && k != 3) ? 1f : (-1f));
				float num4 = ((k >= 2) ? (-1f) : 1f);
				vertices.Add(points[j].Point + val4 * (0.018f * num3) + normalized * (0.002f * num4));
				uv.Add(new Vector2(0.0009765625f + num2 * 0.9980469f, 0.37597656f + ((!(num3 < 0f)) ? 1f : 0f) * 0.123046875f));
			}
			if (j != 0)
			{
				for (int l = 0; l < 4; l++)
				{
					int num5 = count + (j - 1) * 4 + l;
					int num6 = count + (j - 1) * 4 + (l + 1) % 4;
					int c = num6 + 4;
					int d = num5 + 4;
					Quad(triangles, num5, num6, c, d);
				}
			}
		}
		Quad(triangles, count + 3, count + 2, count + 1, count);
		int num7 = count + (points.Length - 1) * 4;
		Quad(triangles, num7, num7 + 1, num7 + 2, num7 + 3);
	}

	internal static bool IsCompact(IList<Vector3> vertices, Vector3 origin, float radius)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0080: Unknown result type (might be due to invalid IL or missing references)
		foreach (Vector3 vertex in vertices)
		{
			if (!float.IsNaN(vertex.x) && !float.IsNaN(vertex.y) && !float.IsNaN(vertex.z) && !float.IsInfinity(vertex.x) && !float.IsInfinity(vertex.y) && !float.IsInfinity(vertex.z))
			{
				Vector3 val = vertex - origin;
				if (!(((Vector3)(ref val)).sqrMagnitude > radius * radius))
				{
					continue;
				}
			}
			return false;
		}
		return true;
	}

	private static void Quad(List<int> t, int a, int b, int c, int d)
	{
		t.Add(a);
		t.Add(b);
		t.Add(c);
		t.Add(a);
		t.Add(c);
		t.Add(d);
	}
}
internal sealed class MountControl : MonoBehaviour
{
	private const string MoveRpc = "fai_rt_move_v130";

	private const string AttackRpc = "fai_rt_attack_v130";

	private static readonly Func<Sadle, long> User = AccessTools.MethodDelegate<Func<Sadle, long>>(AccessTools.Method(typeof(Sadle), "GetUser", (Type[])null, (Type[])null), (object)null, true);

	private static readonly Action<Sadle, long, Vector3, int, float> NativeControls = AccessTools.MethodDelegate<Action<Sadle, long, Vector3, int, float>>(AccessTools.Method(typeof(Sadle), "RPC_Controls", (Type[])null, (Type[])null), (object)null, true);

	private static readonly Action<Sadle, float> Spend = AccessTools.MethodDelegate<Action<Sadle, float>>(AccessTools.Method(typeof(Sadle), "UseStamina", (Type[])null, (Type[])null), (object)null, true);

	private static readonly FieldInfo WalkField = AccessTools.Field(typeof(Character), "m_walk");

	private static readonly HashSet<MountControl> Active = new HashSet<MountControl>();

	internal Sadle Saddle;

	internal Character Creature;

	internal MonsterAI AI;

	private ZNetView view;

	private bool registered;

	private bool changedWalk;

	private bool oldWalk;

	internal int Mode;

	private int sentMode = -1;

	private Vector3 sentDirection;

	private float sentAt = -1000f;

	private float receivedAt = -1000f;

	private float lastAttack = -1000f;

	private int localMode;

	internal static MountControl Attach(Sadle saddle)
	{
		if (!Plugin.Ours(saddle))
		{
			return null;
		}
		MountControl mountControl = ((Component)saddle).GetComponent<MountControl>();
		if ((Object)(object)mountControl == (Object)null)
		{
			mountControl = ((Component)saddle).gameObject.AddComponent<MountControl>();
		}
		mountControl.Saddle = saddle;
		mountControl.Creature = saddle.GetCharacter();
		if ((Object)(object)mountControl.Creature == (Object)null)
		{
			return mountControl;
		}
		mountControl.AI = ((Component)mountControl.Creature).GetComponent<MonsterAI>();
		mountControl.view = ((Component)mountControl.Creature).GetComponent<ZNetView>();
		if (!mountControl.registered && (Object)(object)mountControl.view != (Object)null && mountControl.view.IsValid())
		{
			mountControl.view.Register<Vector3, int, float>("fai_rt_move_v130", (Action<long, Vector3, int, float>)mountControl.ReceiveMove);
			mountControl.view.Register<int, Vector3>("fai_rt_attack_v130", (Action<long, int, Vector3>)mountControl.ReceiveAttack);
			mountControl.registered = true;
		}
		Active.Add(mountControl);
		return mountControl;
	}

	private bool Accept(long sender)
	{
		return registered && (Object)(object)Saddle != (Object)null && (Object)(object)Creature != (Object)null && (Object)(object)view != (Object)null && view.IsValid() && ControlMath.SenderAllowed(sender, User(Saddle), view.IsOwner(), Saddle.HaveValidUser()) && Creature.IsTamed() && !Creature.IsDead();
	}

	internal void SendMove(Vector3 move, Vector3 look, bool sprint)
	{
		//IL_000c: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: 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_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		if (!registered)
		{
			return;
		}
		Vector2 joyLeftStick = ZInput.GetJoyLeftStick();
		bool analog = !ZInput.GetButton("Forward") && !ZInput.GetButton("Backward") && !ZInput.GetButton("Left") && !ZInput.GetButton("Right") && ((Vector2)(ref joyLeftStick)).sqrMagnitude > 0.0025f;
		localMode = ControlMath.Mode(move.z, ((Vector2)(ref joyLeftStick)).magnitude, analog, sprint, localMode, Plugin.WalkThreshold.Value);
		Vector3 forward = default(Vector3);
		((Vector3)(ref forward))..ctor(look.x, 0f, look.z);
		if (((Vector3)(ref forward)).sqrMagnitude < 0.0001f)
		{
			forward = ((Component)Creature).transform.forward;
		}
		((Vector3)(ref forward)).Normalize();
		if (localMode == sentMode)
		{
			Vector3 val = forward - sentDirection;
			if (((Vector3)(ref val)).sqrMagnitude < 0.0004f && Time.time - sentAt < 0.15f)
			{
				return;
			}
		}
		Player localPlayer = Player.m_localPlayer;
		if (!((Object)(object)localPlayer == (Object)null) && !((Object)/*isinst with value type is only supported in some contexts*/ != (Object)(object)Saddle))
		{
			view.InvokeRPC("fai_rt_move_v130", new object[3]
			{
				forward,
				localMode,
				((Character)localPlayer).GetSkillFactor((SkillType)110)
			});
			sentMode = localMode;
			sentDirection = forward;
			sentAt = Time.time;
		}
	}

	private void ReceiveMove(long sender, Vector3 direction, int mode, float skill)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
		if (Accept(sender) && mode >= 0 && mode <= 3 && Finite(direction) && ControlMath.Finite(skill))
		{
			direction.y = 0f;
			if (((Vector3)(ref direction)).sqrMagnitude < 0.0001f)
			{
				direction = ((Component)Creature).transform.forward;
			}
			((Vector3)(ref direction)).Normalize();
			Mode = mode;
			receivedAt = Time.time;
			NativeControls(Saddle, sender, direction, mode switch
			{
				0 => 0, 
				3 => 2, 
				_ => 1, 
			}, Math.Max(0f, Math.Min(1f, skill)));
		}
	}

	internal bool OverrideIdle(ref bool result)
	{
		if ((Object)(object)view == (Object)null || !view.IsValid() || !view.IsOwner() || (Object)(object)Saddle == (Object)null || !Saddle.HaveValidUser() || (Object)(object)Creature == (Object)null || Creature.IsDead() || !Creature.IsTamed())
		{
			RestoreWalk();
			return false;
		}
		if (!changedWalk)
		{
			oldWalk = WalkField != null && (bool)WalkField.GetValue(Creature);
			changedWalk = true;
		}
		if (Time.time - receivedAt > 0.9f)
		{
			Mode = 0;
		}
		Creature.SetWalk(Mode == 1);
		if (Mode != 0 || (Object)(object)AI == (Object)null)
		{
			return false;
		}
		((BaseAI)AI).StopMoving();
		Creature.SetRun(false);
		((BaseAI)AI).ResetRandomMovement();
		result = true;
		return true;
	}

	internal void RequestAttack(int slot, Vector3 look)
	{
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		Player localPlayer = Player.m_localPlayer;
		if (registered && slot >= 0 && slot < 3 && (Object)(object)localPlayer != (Object)null && (Object)/*isinst with value type is only supported in some contexts*/ == (Object)(object)Saddle)
		{
			view.InvokeRPC("fai_rt_attack_v130", new object[2] { slot, look });
		}
	}

	private void ReceiveAttack(long sender, int slot, Vector3 look)
	{
		//IL_001a: 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_0171: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		if (!Accept(sender) || slot < 0 || slot > 2 || !Finite(look) || Time.time - lastAttack < 0.12f || Creature.InAttack() || Creature.InDodge() || Creature.IsKnockedBack() || Creature.IsStaggering())
		{
			return;
		}
		Character creature = Creature;
		Humanoid val = (Humanoid)(object)((creature is Humanoid) ? creature : null);
		if ((Object)(object)val == (Object)null || val.GetInventory() == null)
		{
			return;
		}
		List<AttackChoice> list = AttackChoice.For(val);
		if (slot >= list.Count)
		{
			return;
		}
		AttackChoice attackChoice = list[slot];
		float num = ControlMath.Cost(slot, Saddle.GetMaxStamina(), Saddle.GetRiderSkill());
		if (Saddle.GetStamina() + 0.01f < num || (val.GetCurrentWeapon() != attackChoice.Item && !val.EquipItem(attackChoice.Item, false)) || val.GetCurrentWeapon() != attackChoice.Item)
		{
			return;
		}
		Vector3 val2 = default(Vector3);
		((Vector3)(ref val2))..ctor(look.x, 0f, look.z);
		if (((Vector3)(ref val2)).sqrMagnitude > 0.0001f)
		{
			((Vector3)(ref val2)).Normalize();
			((Character)val).SetLookDir(((Vector3)(ref look)).normalized, 0f);
			((Component)val).transform.rotation = Quaternion.LookRotation(val2, Vector3.up);
		}
		if (((Character)val).StartAttack((Character)null, attackChoice.Secondary))
		{
			lastAttack = Time.time;
			if (num > 0f)
			{
				Spend(Saddle, num);
			}
		}
	}

	private static bool Finite(Vector3 value)
	{
		return ControlMath.Finite(value.x) && ControlMath.Finite(value.y) && ControlMath.Finite(value.z);
	}

	private void RestoreWalk()
	{
		if (changedWalk && (Object)(object)Creature != (Object)null)
		{
			Creature.SetWalk(oldWalk);
		}
		changedWalk = false;
		Mode = 0;
		localMode = 0;
		sentMode = -1;
	}

	private void OnDisable()
	{
		RestoreWalk();
		Active.Remove(this);
	}

	private void OnDestroy()
	{
		RestoreWalk();
		Active.Remove(this);
	}

	internal static void RestoreAll()
	{
		foreach (MountControl item in Active)
		{
			if ((Object)(object)item != (Object)null)
			{
				item.RestoreWalk();
			}
		}
		Active.Clear();
	}
}
[HarmonyPatch(typeof(Sadle), "Awake")]
internal static class RegisterControls
{
	private static void Postfix(Sadle __instance)
	{
		MountControl.Attach(__instance);
	}
}
[HarmonyPatch(typeof(Sadle), "ApplyControlls")]
internal static class HoldToMove
{
	private static bool Prefix(Sadle __instance, Vector3 moveDir, Vector3 lookDir, bool run)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Ours(__instance))
		{
			return true;
		}
		MountControl mountControl = MountControl.Attach(__instance);
		if ((Object)(object)mountControl != (Object)null)
		{
			mountControl.SendMove(moveDir, lookDir, run);
		}
		return false;
	}
}
[HarmonyPatch(typeof(Sadle), "UpdateRiding")]
internal static class TrueWalkAndIdle
{
	private static bool Prefix(Sadle __instance, ref bool __result)
	{
		if (!Plugin.Ours(__instance))
		{
			return true;
		}
		MountControl mountControl = MountControl.Attach(__instance);
		return (Object)(object)mountControl == (Object)null || !mountControl.OverrideIdle(ref __result);
	}
}
[HarmonyPatch(typeof(Player), "SetControls")]
internal static class AttackInputs
{
	[HarmonyPriority(800)]
	private static void Prefix(Player __instance, ref bool attack, ref bool attackHold, ref bool secondaryAttack, ref bool secondaryAttackHold, ref bool block, ref bool blockHold)
	{
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
		{
			return;
		}
		IDoodadController doodadController = __instance.GetDoodadController();
		Sadle saddle = (Sadle)(object)((doodadController is Sadle) ? doodadController : null);
		if (!Plugin.Ours(saddle))
		{
			return;
		}
		int num = ((!attack) ? (block ? 1 : ((!secondaryAttack) ? (-1) : 2)) : 0);
		if (num >= 0)
		{
			MountControl mountControl = MountControl.Attach(saddle);
			if ((Object)(object)mountControl != (Object)null)
			{
				mountControl.RequestAttack(num, ((Character)__instance).GetLookDir());
			}
		}
		attack = (attackHold = (secondaryAttack = (secondaryAttackHold = (block = (blockHold = false)))));
	}
}
internal static class PaletteMath
{
	internal static Color32 Saddle(Color32 p, bool cloth)
	{
		//IL_000c: 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_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		if (p.a == 0)
		{
			return p;
		}
		float num = (int)p.r;
		float num2 = (int)p.g;
		float num3 = (int)p.b;
		if (cloth && num > num2 * 1.65f && num > num3 * 1.65f)
		{
			return Pixel(num * 0.2f, num * 0.34f, num * 0.56f, p.a);
		}
		if (num > num2 && num2 > num3 * 1.35f && num2 > 85f && num < num2 * 1.65f)
		{
			return Pixel(num * 0.56f, num2 * 0.44f, num3 * 0.36f, p.a);
		}
		return Pixel(num * 0.55f, num2 * 0.5f, num3 * 0.45f, p.a);
	}

	internal static Color32 Handle(Color32 p, bool metal)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		if (p.a == 0)
		{
			return p;
		}
		float num = (int)Math.Max(p.r, Math.Max(p.g, p.b));
		return (!metal) ? Pixel(num * 0.58f, num * 0.35f, num * 0.19f, p.a) : Pixel(num * 0.28f, num * 0.28f, num * 0.28f, p.a);
	}

	private static Color32 Pixel(float r, float g, float b, byte a)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		return new Color32(Byte(r), Byte(g), Byte(b), a);
	}

	private static byte Byte(float n)
	{
		return (byte)Math.Max(0, Math.Min(255, (int)Math.Round(n)));
	}
}
internal static class Palette
{
	private static readonly HashSet<Material> done = new HashSet<Material>();

	internal static void Saddle(Material material)
	{
		Apply(material, 0);
	}

	internal static void Handles(Material[] materials)
	{
		if (materials != null)
		{
			if (materials.Length > 0)
			{
				Apply(materials[0], 2);
			}
			if (materials.Length > 1)
			{
				Apply(materials[1], 2);
			}
			if (materials.Length > 2)
			{
				Apply(materials[2], 1);
			}
		}
	}

	private static void Apply(Material material, int kind)
	{
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Expected O, but got Unknown
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: 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_00ac: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)material == (Object)null || done.Contains(material))
		{
			return;
		}
		Texture mainTexture = material.mainTexture;
		Texture2D val = (Texture2D)(object)((mainTexture is Texture2D) ? mainTexture : null);
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		try
		{
			Color32[] pixels = val.GetPixels32();
			for (int i = 0; i < ((Texture)val).height; i++)
			{
				for (int j = 0; j < ((Texture)val).width; j++)
				{
					int num = i * ((Texture)val).width + j;
					ref Color32 reference = ref pixels[num];
					reference = ((kind != 0) ? PaletteMath.Handle(pixels[num], kind == 1) : PaletteMath.Saddle(pixels[num], j >= ((Texture)val).width / 2 && i >= ((Texture)val).height / 2));
				}
			}
			Texture2D val2 = new Texture2D(((Texture)val).width, ((Texture)val).height, (TextureFormat)4, true);
			((Object)val2).name = "fai_navy_brown_" + ((Object)val).name;
			((Texture)val2).filterMode = ((Texture)val).filterMode;
			((Texture)val2).wrapMode = ((Texture)val).wrapMode;
			((Texture)val2).anisoLevel = ((Texture)val).anisoLevel;
			((Object)val2).hideFlags = (HideFlags)32;
			Texture2D val3 = val2;
			val3.SetPixels32(pixels);
			val3.Apply(true, false);
			material.mainTexture = (Texture)(object)val3;
			done.Add(material);
		}
		catch (Exception ex)
		{
			done.Add(material);
			Plugin.Log.LogWarning((object)("Could not recolour saddle/handle material: " + ex.Message));
		}
	}
}
[HarmonyPatch]
internal static class SaddleColours
{
	private static MethodBase TargetMethod()
	{
		return AccessTools.PropertyGetter(AccessTools.TypeByName("RideableTames.SaddleLook"), "Material");
	}

	private static void Postfix(Material __result)
	{
		Palette.Saddle(__result);
	}
}
[HarmonyPatch]
internal static class HandleColours
{
	private static MethodBase TargetMethod()
	{
		return AccessTools.Method(AccessTools.TypeByName("Fai.RideableTames.HandleVisuals"), "MaterialsFor", (Type[])null, (Type[])null);
	}

	private static void Postfix(Material[] __result)
	{
		Palette.Handles(__result);
	}
}
[BepInPlugin("fai.rideabletames.controls", "RideableTames Fai Controls", "1.4.12")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class Plugin : BaseUnityPlugin
{
	internal static Type Marker;

	internal static ConfigEntry<float> WalkThreshold;

	internal static ManualLogSource Log;

	private Harmony harmony;

	private void Awake()
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		Marker = AccessTools.TypeByName("RideableTames.MountMarker");
		if (Marker == null)
		{
			throw new InvalidOperationException("RideableTames mount marker is unavailable.");
		}
		WalkThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "AnalogWalkThreshold", 0.8f, new ConfigDescription("Up to this processed stick deflection uses true walking. A small hysteresis prevents animation flicker. Full push uses the original jog; the game's Run input sprints.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 0.95f), Array.Empty<object>()));
		harmony = new Harmony("fai.rideabletames.controls.v1412");
		try
		{
			harmony.PatchAll(typeof(Plugin).Assembly);
		}
		catch
		{
			harmony.UnpatchSelf();
			harmony = null;
			throw;
		}
		Sadle[] array = Resources.FindObjectsOfTypeAll<Sadle>();
		foreach (Sadle saddle in array)
		{
			if (Ours(saddle))
			{
				MountControl.Attach(saddle);
				WolfHarness.Refresh(saddle);
			}
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)"V4.1 riding retained. Controls, a forward wolf neck collar and a low resting handle loaded.");
	}

	internal static bool Ours(Sadle saddle)
	{
		return (Object)(object)saddle != (Object)null && Marker != null && (Object)(object)((Component)saddle).GetComponent(Marker) != (Object)null;
	}

	private void OnDestroy()
	{
		MountControl.RestoreAll();
		WolfHarness.Shutdown();
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		harmony = null;
	}
}
internal sealed class RestingHandle
{
	private readonly Transform bar;

	private readonly Transform grip;

	private readonly Transform capL;

	private readonly Transform capR;

	private readonly Transform left;

	private readonly Transform right;

	private readonly float height;

	private bool rested;

	internal RestingHandle(Transform parts, float originalHeight)
	{
		bar = parts.Find("bar");
		left = parts.Find("strapL");
		right = parts.Find("strapR");
		grip = bar.Find("grip");
		capL = bar.Find("capL");
		capR = bar.Find("capR");
		height = originalHeight;
	}

	internal void Apply(bool occupied)
	{
		//IL_002f: 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_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		if (occupied)
		{
			rested = false;
		}
		else if (!rested)
		{
			bar.localPosition = new Vector3(0f, 0.047f, 0f);
			bar.localRotation = Quaternion.identity;
			grip.localScale = Vector3.one;
			capL.localPosition = new Vector3(-0.112f, 0f, 0f);
			capR.localPosition = new Vector3(0.112f, 0f, 0f);
			Upright(left, -0.085f);
			Upright(right, 0.085f);
			rested = true;
		}
	}

	private void Upright(Transform upright, float x)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		upright.localPosition = new Vector3(x, 0.0295f, 0f);
		upright.localRotation = Quaternion.identity;
		upright.localScale = new Vector3(1f, 0.035f / height, 1f);
	}
}
internal sealed class WolfHarness : MonoBehaviour
{
	private const string HandleName = "fai_packbeasts_handle";

	private static readonly HashSet<WolfHarness> Active = new HashSet<WolfHarness>();

	private Character creature;

	private Transform parts;

	private Transform left;

	private RestingHandle rest;

	private Mesh mesh;

	private GameObject display;

	private bool configured;

	private bool failed;

	private object movedFit;

	private FieldInfo gripLocalField;

	private FieldInfo gripRotationField;

	private Vector3 originalGripLocal;

	private Vector3 collarGripLocal;

	private Quaternion originalGripRotation;

	private Quaternion collarGripRotation;

	internal static WolfHarness Prepare(Sadle saddle)
	{
		if (!Plugin.Ours(saddle))
		{
			return null;
		}
		Character componentInParent = ((Component)saddle).GetComponentInParent<Character>();
		if ((Object)(object)componentInParent == (Object)null || Utils.GetPrefabName(((Component)componentInParent).gameObject) != "Wolf")
		{
			return null;
		}
		Transform val = ((Component)saddle).transform.Find("fai_packbeasts_handle");
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		WolfHarness wolfHarness = ((Component)val).GetComponent<WolfHarness>();
		if ((Object)(object)wolfHarness == (Object)null)
		{
			wolfHarness = ((Component)val).gameObject.AddComponent<WolfHarness>();
		}
		if (!wolfHarness.configured)
		{
			wolfHarness.Configure(saddle, componentInParent);
		}
		if (!wolfHarness.configured)
		{
			return null;
		}
		wolfHarness.MoveBaseToNeck(saddle);
		return wolfHarness;
	}

	internal static void Refresh(Sadle saddle)
	{
		WolfHarness wolfHarness = Prepare(saddle);
		if ((Object)(object)wolfHarness == (Object)null)
		{
			return;
		}
		wolfHarness.rest.Apply(saddle.HaveValidUser());
		if ((Object)(object)wolfHarness.display != (Object)null)
		{
			wolfHarness.display.SetActive(((Component)wolfHarness).gameObject.activeInHierarchy);
		}
		if ((Object)(object)wolfHarness.mesh != (Object)null || wolfHarness.failed || !((Component)wolfHarness).gameObject.activeInHierarchy)
		{
			return;
		}
		ZNetView component = ((Component)wolfHarness.creature).GetComponent<ZNetView>();
		if ((Object)(object)component == (Object)null || !component.IsValid())
		{
			return;
		}
		try
		{
			wolfHarness.Build();
		}
		catch (Exception ex)
		{
			wolfHarness.failed = true;
			wolfHarness.ReleaseMesh();
			Plugin.Log.LogWarning((object)("Wolf neck collar could not be created: " + ex.Message));
		}
	}

	private void Configure(Sadle target, Character owner)
	{
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		parts = ((Component)this).transform.Find("parts");
		if ((Object)(object)parts == (Object)null)
		{
			return;
		}
		Transform val = parts.Find("bar");
		Transform val2 = parts.Find("strapR");
		left = parts.Find("strapL");
		if (!((Object)(object)val == (Object)null) && !((Object)(object)left == (Object)null) && !((Object)(object)val2 == (Object)null))
		{
			Transform val3 = val.Find("grip");
			Transform val4 = val.Find("capL");
			Transform val5 = val.Find("capR");
			MeshFilter component = ((Component)left).GetComponent<MeshFilter>();
			if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val4 == (Object)null) && !((Object)(object)val5 == (Object)null) && !((Object)(object)component == (Object)null) && !((Object)(object)component.sharedMesh == (Object)null))
			{
				Transform obj = parts;
				Bounds bounds = component.sharedMesh.bounds;
				rest = new RestingHandle(obj, Math.Max(0.06f, ((Bounds)(ref bounds)).size.y));
				creature = owner;
				configured = true;
				Active.Add(this);
			}
		}
	}

	private void MoveBaseToNeck(Sadle target)
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Expected O, but got Unknown
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		if (movedFit != null)
		{
			return;
		}
		Type type = AccessTools.TypeByName("Fai.RideableTames.MountedRig");
		Component component = ((Component)target).GetComponent(type);
		if ((Object)(object)component == (Object)null)
		{
			return;
		}
		object obj = AccessTools.PropertyGetter(type, "Fit").Invoke(component, null);
		if (obj != null)
		{
			Type type2 = obj.GetType();
			Transform val = (Transform)AccessTools.Field(type2, "GripBone").GetValue(obj);
			if (!((Object)(object)val == (Object)null))
			{
				gripRotationField = AccessTools.Field(type2, "GripRotation");
				originalGripRotation = (Quaternion)gripRotationField.GetValue(obj);
				gripLocalField = AccessTools.Field(type2, "GripLocal");
				originalGripLocal = (Vector3)gripLocalField.GetValue(obj);
				collarGripLocal = originalGripLocal + CollarPlacement.LocalOffset(val, ((Component)creature).transform, originalGripRotation);
				collarGripRotation = CollarPlacement.BaseRotation(originalGripRotation);
				gripLocalField.SetValue(obj, collarGripLocal);
				gripRotationField.SetValue(obj, collarGripRotation);
				movedFit = obj;
			}
		}
	}

	private void RestoreBase()
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: 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_005f: 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)
		if (movedFit != null && !(gripLocalField == null))
		{
			Vector3 val = (Vector3)gripLocalField.GetValue(movedFit);
			Vector3 val2 = val - collarGripLocal;
			if (((Vector3)(ref val2)).sqrMagnitude < 1E-08f)
			{
				gripLocalField.SetValue(movedFit, originalGripLocal);
			}
			Quaternion val3 = (Quaternion)gripRotationField.GetValue(movedFit);
			if (Quaternion.Angle(val3, collarGripRotation) < 0.01f)
			{
				gripRotationField.SetValue(movedFit, originalGripRotation);
			}
			movedFit = null;
		}
	}

	private void Build()
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Expected O, but got Unknown
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Expected O, but got Unknown
		List<Vector3> list = new List<Vector3>();
		List<Vector2> list2 = new List<Vector2>();
		List<int> list3 = new List<int>();
		HarnessGeometry.AddRibbon(HarnessGeometry.ChestLoop(), list, list2, list3);
		if (!HarnessGeometry.IsCompact(list, Vector3.zero, 1f))
		{
			throw new InvalidOperationException("Collar geometry exceeds its local extent limit.");
		}
		display = new GameObject("fai_wolf_neck_collar");
		display.layer = ((Component)parts).gameObject.layer;
		display.transform.SetParent(parts, false);
		Mesh val = new Mesh();
		((Object)val).name = "fai_wolf_neck_collar";
		((Object)val).hideFlags = (HideFlags)32;
		mesh = val;
		mesh.SetVertices(list);
		mesh.SetUVs(0, list2);
		mesh.SetTriangles(list3, 0);
		mesh.RecalculateNormals();
		mesh.RecalculateBounds();
		display.AddComponent<MeshFilter>().sharedMesh = mesh;
		MeshRenderer val2 = display.AddComponent<MeshRenderer>();
		Transform val3 = ((Component)this).transform.parent.Find("model");
		MeshRenderer val4 = ((!((Object)(object)val3 == (Object)null)) ? ((Component)val3).GetComponent<MeshRenderer>() : null);
		Material val5 = ((!((Object)(object)val4 == (Object)null)) ? ((Renderer)val4).sharedMaterial : null);
		if ((Object)(object)val5 == (Object)null)
		{
			val5 = (Material)AccessTools.PropertyGetter(AccessTools.TypeByName("RideableTames.SaddleLook"), "Material").Invoke(null, null);
		}
		((Renderer)val2).sharedMaterial = val5;
		((Renderer)val2).shadowCastingMode = (ShadowCastingMode)0;
		((Renderer)val2).enabled = true;
		AccessTools.Method(AccessTools.TypeByName("RideableTames.Mounts"), "AddToLods", (Type[])null, (Type[])null).Invoke(null, new object[2]
		{
			((Component)creature).gameObject,
			val2
		});
		Plugin.Log.LogInfo((object)("Wolf neck collar 1.4.12 created: " + list.Count + " vertices; 10 cm offset / 30 deg base / 35 deg collar."));
	}

	private void ReleaseMesh()
	{
		if ((Object)(object)display != (Object)null)
		{
			Object.Destroy((Object)(object)display);
		}
		display = null;
		if ((Object)(object)mesh != (Object)null)
		{
			Object.Destroy((Object)(object)mesh);
		}
		mesh = null;
	}

	private void OnEnable()
	{
		if ((Object)(object)display != (Object)null)
		{
			display.SetActive(true);
		}
	}

	private void OnDisable()
	{
		if ((Object)(object)display != (Object)null)
		{
			display.SetActive(false);
		}
	}

	private void OnDestroy()
	{
		RestoreBase();
		ReleaseMesh();
		Active.Remove(this);
	}

	internal static void Shutdown()
	{
		foreach (WolfHarness item in new List<WolfHarness>(Active))
		{
			if ((Object)(object)item != (Object)null)
			{
				item.RestoreBase();
				item.ReleaseMesh();
				Object.Destroy((Object)(object)item);
			}
		}
		Active.Clear();
	}
}
[HarmonyPatch]
internal static class WolfHarnessVisuals
{
	private static MethodBase TargetMethod()
	{
		return AccessTools.Method(AccessTools.TypeByName("Fai.RideableTames.MountedRig"), "Hold", (Type[])null, (Type[])null);
	}

	private static void Prefix(object __instance)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		WolfHarness.Prepare(((Component)__instance).GetComponent<Sadle>());
	}

	private static void Postfix(object __instance)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		WolfHarness.Refresh(((Component)__instance).GetComponent<Sadle>());
	}
}