using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Landfall.TABS;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("BreakableShields")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BreakableShields")]
[assembly: AssemblyTitle("BreakableShields")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BreakableShields
{
[HarmonyPatch(typeof(Holdable), "Start")]
internal static class HoldableStartPatch
{
private static void Postfix(Holdable __instance)
{
if (Plugin.Enabled.Value && !((Object)(object)__instance == (Object)null))
{
ShieldHealth.EnsureOn(__instance);
}
}
}
[HarmonyPatch(typeof(Holdable), "WasGrabbed")]
internal static class HoldableGrabPatch
{
private static void Postfix(Holdable __instance)
{
if (Plugin.Enabled.Value && !((Object)(object)__instance == (Object)null))
{
ShieldHealth shieldHealth = ShieldHealth.EnsureOn(__instance);
if ((Object)(object)shieldHealth != (Object)null)
{
shieldHealth.InitStats();
shieldHealth.TryApplyHolderHealth();
}
}
}
}
[HarmonyPatch(typeof(BlockMove), "ProjectileBlock")]
internal static class BlockMoveProjectilePatch
{
private static void Postfix(BlockMove __instance, GameObject projectile, HitData hit, bool __result)
{
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Unknown result type (might be due to invalid IL or missing references)
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_018b: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.Enabled.Value || !__result || (Object)(object)__instance == (Object)null)
{
return;
}
ShieldHealth shieldHealth = ((Component)__instance).GetComponentInParent<ShieldHealth>();
if ((Object)(object)shieldHealth == (Object)null && (Object)(object)__instance.rig != (Object)null)
{
shieldHealth = ((Component)__instance.rig).GetComponentInParent<ShieldHealth>();
}
if ((Object)(object)shieldHealth == (Object)null)
{
DataHandler componentInChildren = ((Component)((Component)__instance).transform.root).GetComponentInChildren<DataHandler>();
if ((Object)(object)componentInChildren != (Object)null)
{
HoldingHandler component = ((Component)componentInChildren).GetComponent<HoldingHandler>();
if ((Object)(object)component != (Object)null)
{
if ((Object)(object)component.leftObject != (Object)null)
{
shieldHealth = ((Component)component.leftObject).GetComponent<ShieldHealth>() ?? ShieldHealth.EnsureOn(component.leftObject);
}
if ((Object)(object)shieldHealth == (Object)null && (Object)(object)component.rightObject != (Object)null)
{
shieldHealth = ((Component)component.rightObject).GetComponent<ShieldHealth>() ?? ShieldHealth.EnsureOn(component.rightObject);
}
}
}
}
if (!((Object)(object)shieldHealth == (Object)null) && !shieldHealth.broken)
{
float num = 0f;
ProjectileHit val = (((Object)(object)projectile != (Object)null) ? projectile.GetComponent<ProjectileHit>() : null);
if ((Object)(object)val != (Object)null)
{
num = val.damage;
}
if (num <= 0f)
{
num = 25f;
}
num *= Plugin.ProjectileDamageMultiplier.Value;
Vector3 direction = ((hit != null) ? (-hit.normal) : Vector3.forward);
Unit damager = null;
TeamHolder val2 = (((Object)(object)projectile != (Object)null) ? projectile.GetComponent<TeamHolder>() : null);
if ((Object)(object)val2 != (Object)null && (Object)(object)val2.spawner != (Object)null)
{
damager = val2.spawner.GetComponentInParent<Unit>();
}
shieldHealth.ApplyDamage(num, direction, damager, "ProjectileBlock");
}
}
}
[HarmonyPatch(typeof(CollisionWeapon), "OnCollisionEnter")]
internal static class CollisionWeaponShieldPatch
{
private static void Prefix(CollisionWeapon __instance, Collision collision)
{
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.Enabled.Value || (Object)(object)__instance == (Object)null || collision == null || (Object)(object)collision.rigidbody == (Object)null)
{
return;
}
Holdable componentInParent = ((Component)collision.rigidbody).GetComponentInParent<Holdable>();
if ((Object)(object)componentInParent == (Object)null || !componentInParent.held || !ShieldHealth.IsShieldObject(((Component)componentInParent).gameObject))
{
return;
}
if ((Object)(object)componentInParent.holderData != (Object)null)
{
Unit componentInParent2 = ((Component)__instance).GetComponentInParent<Unit>();
if ((Object)(object)componentInParent2 == (Object)null)
{
Holdable component = ((Component)__instance).GetComponent<Holdable>();
if ((Object)(object)component != (Object)null && (Object)(object)component.holderData != (Object)null)
{
componentInParent2 = ((Component)component.holderData).GetComponentInParent<Unit>();
}
}
Unit componentInParent3 = ((Component)componentInParent.holderData).GetComponentInParent<Unit>();
if ((Object)(object)componentInParent2 != (Object)null && (Object)(object)componentInParent3 != (Object)null && componentInParent2.Team == componentInParent3.Team)
{
return;
}
}
ShieldHealth.EnsureOn(componentInParent);
}
}
[HarmonyPatch(typeof(ShieldHealth), "TakeDamage")]
internal static class ShieldTakeDamageMultPatch
{
private static void Prefix(ref float damage)
{
if (Plugin.Enabled.Value)
{
damage *= Plugin.MeleeDamageMultiplier.Value;
}
}
}
[HarmonyPatch(typeof(WeaponHandler), "Start")]
internal static class WeaponHandlerStartPatch
{
private static void Postfix(WeaponHandler __instance)
{
if (Plugin.Enabled.Value && !((Object)(object)__instance == (Object)null))
{
TryAttach(__instance.leftWeapon);
TryAttach(__instance.rightWeapon);
}
}
private static void TryAttach(Weapon weapon)
{
if ((Object)(object)weapon == (Object)null)
{
return;
}
Holdable component = ((Component)weapon).GetComponent<Holdable>();
if ((Object)(object)component != (Object)null)
{
ShieldHealth shieldHealth = ShieldHealth.EnsureOn(component);
if ((Object)(object)shieldHealth != (Object)null)
{
shieldHealth.TryApplyHolderHealth();
}
}
}
}
[BepInPlugin("local.breakableshields", "BreakableShields", "1.2.0")]
public class Plugin : BaseUnityPlugin
{
public const string GUID = "local.breakableshields";
public const string Name = "BreakableShields";
public const string Version = "1.2.0";
internal static Plugin Instance;
internal static ManualLogSource Log;
internal static ConfigEntry<bool> Enabled;
internal static ConfigEntry<float> BaseHealth;
internal static ConfigEntry<float> HolderHealthMultiplier;
internal static ConfigEntry<float> MeleeDamageMultiplier;
internal static ConfigEntry<float> ProjectileDamageMultiplier;
internal static ConfigEntry<bool> BreakDropsShield;
internal static ConfigEntry<bool> DisableBlockOnBreak;
internal static ConfigEntry<bool> DebugLog;
private void Awake()
{
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable breakable shields.");
DebugLog = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DebugLog", false, "Log shield attach/damage/break events.");
BaseHealth = ((BaseUnityPlugin)this).Config.Bind<float>("Health", "BaseHealth", 400f, "Base shield HP. Final = BaseHealth + HolderHealthMultiplier * holder max HP.");
HolderHealthMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Health", "HolderHealthMultiplier", 3f, "Shield HP adds this * holder's maxHealth.");
MeleeDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Damage", "MeleeDamageMultiplier", 1f, "Multiplier for melee damage applied to shields.");
ProjectileDamageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Damage", "ProjectileDamageMultiplier", 1f, "Multiplier for projectile damage applied to shields.");
BreakDropsShield = ((BaseUnityPlugin)this).Config.Bind<bool>("Break", "DropOnBreak", true, "Drop the shield from the unit's hands when HP reaches 0.");
DisableBlockOnBreak = ((BaseUnityPlugin)this).Config.Bind<bool>("Break", "DisableBlockOnBreak", true, "Disable projectile blocking when the shield breaks.");
new Harmony("local.breakableshields").PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"BreakableShields 1.2.0 loaded.");
}
internal static void Dbg(string msg)
{
if (DebugLog != null && DebugLog.Value)
{
Log.LogInfo((object)msg);
}
}
}
public class ShieldHealth : Damagable
{
public float maxHealth = 400f;
public float health = 400f;
public bool broken;
private Holdable _holdable;
private BlockMove _blockMove;
private BlockMoveHealth _blockMoveHealth;
private Rigidbody _rig;
private bool _initialized;
private bool _statsFromHolderApplied;
private static readonly FieldInfo LeftHandJointField = typeof(HoldingHandler).GetField("leftHandJoint", BindingFlags.Instance | BindingFlags.NonPublic);
private static readonly FieldInfo RightHandJointField = typeof(HoldingHandler).GetField("rightHandJoint", BindingFlags.Instance | BindingFlags.NonPublic);
private static readonly FieldInfo UnitApiField = typeof(WeaponHandler).GetField("m_unitAPI", BindingFlags.Instance | BindingFlags.NonPublic);
private static readonly FieldInfo WhUnitField = typeof(WeaponHandler).GetField("unit", BindingFlags.Instance | BindingFlags.NonPublic);
private static readonly FieldInfo WhDataField = typeof(WeaponHandler).GetField("data", BindingFlags.Instance | BindingFlags.NonPublic);
public static bool IsShieldObject(GameObject go)
{
if ((Object)(object)go == (Object)null)
{
return false;
}
if ((Object)(object)go.GetComponentInChildren<BlockMove>(true) != (Object)null)
{
return true;
}
if ((Object)(object)go.GetComponentInChildren<SurfaceBlock>(true) != (Object)null)
{
return true;
}
string name = ((Object)go).name;
if (string.IsNullOrEmpty(name))
{
return false;
}
name = name.ToLowerInvariant();
if (!name.Contains("shield") && !name.Contains("buckler"))
{
return name.Contains("pavise");
}
return true;
}
public static ShieldHealth EnsureOn(Holdable holdable)
{
if ((Object)(object)holdable == (Object)null)
{
return null;
}
ShieldHealth component = ((Component)holdable).GetComponent<ShieldHealth>();
if ((Object)(object)component != (Object)null)
{
return component;
}
if (!IsShieldObject(((Component)holdable).gameObject))
{
return null;
}
return ((Component)holdable).gameObject.AddComponent<ShieldHealth>();
}
private void Awake()
{
_holdable = ((Component)this).GetComponent<Holdable>();
_blockMove = ((Component)this).GetComponentInChildren<BlockMove>(true);
_blockMoveHealth = ((Component)this).GetComponentInChildren<BlockMoveHealth>(true);
_rig = ((Component)this).GetComponent<Rigidbody>();
if ((Object)(object)_rig == (Object)null)
{
_rig = ((Component)this).GetComponentInChildren<Rigidbody>();
}
}
private void Start()
{
InitStats();
}
public void InitStats()
{
if (!_initialized)
{
_initialized = true;
maxHealth = Mathf.Max(1f, Plugin.BaseHealth.Value);
health = maxHealth;
if ((Object)(object)_blockMoveHealth != (Object)null)
{
((Behaviour)_blockMoveHealth).enabled = false;
}
TryApplyHolderHealth();
Plugin.Dbg("[BreakableShields] Init " + ((Object)((Component)this).gameObject).name + " HP=" + maxHealth);
}
}
public void TryApplyHolderHealth()
{
if (!broken && !_statsFromHolderApplied && !((Object)(object)_holdable == (Object)null) && !((Object)(object)_holdable.holderData == (Object)null))
{
float num = _holdable.holderData.maxHealth;
if (num <= 0f)
{
num = _holdable.holderData.health;
}
if (!(num <= 0f))
{
float num2 = Plugin.BaseHealth.Value + Plugin.HolderHealthMultiplier.Value * num;
maxHealth = Mathf.Max(1f, num2);
health = maxHealth;
_statsFromHolderApplied = true;
Plugin.Dbg("[BreakableShields] Stats from holder " + ((Object)((Component)this).gameObject).name + " holderHP=" + num + " shieldHP=" + maxHealth);
}
}
}
public override void TakeDamage(float damage, Vector3 direction, Unit damager = null, DamageType damageType = (DamageType)0)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
ApplyDamage(damage, direction, damager, "TakeDamage");
}
public void ApplyDamage(float damage, Vector3 direction, Unit damager, string source)
{
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
if (!Plugin.Enabled.Value || broken)
{
return;
}
if (!_initialized)
{
InitStats();
}
if (!_statsFromHolderApplied)
{
TryApplyHolderHealth();
}
if (!(damage <= 0f) && !float.IsNaN(damage) && !float.IsInfinity(damage) && (!((Object)(object)_holdable != (Object)null) || _holdable.held || broken))
{
health -= damage;
Plugin.Dbg("[BreakableShields] " + ((Object)((Component)this).gameObject).name + " -" + damage.ToString("0.#") + " via " + source + " => " + health.ToString("0.#") + "/" + maxHealth.ToString("0.#"));
if (health <= 0f)
{
Break(direction, damager);
}
}
}
public void Break(Vector3 direction, Unit damager)
{
//IL_00f2: 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_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
if (broken)
{
return;
}
broken = true;
health = 0f;
Plugin.Dbg("[BreakableShields] BREAK " + ((Object)((Component)this).gameObject).name);
if (Plugin.DisableBlockOnBreak.Value)
{
if ((Object)(object)_blockMove != (Object)null)
{
_blockMove.SetDisabled();
}
SurfaceBlock[] componentsInChildren = ((Component)this).GetComponentsInChildren<SurfaceBlock>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
((Behaviour)componentsInChildren[i]).enabled = false;
}
}
if (!((Object)((Component)this).gameObject).name.EndsWith("_Broken"))
{
((Object)((Component)this).gameObject).name = ((Object)((Component)this).gameObject).name + "_Broken";
}
if (Plugin.BreakDropsShield.Value)
{
ForceDropCompletely();
}
if ((Object)(object)_rig != (Object)null)
{
_rig.isKinematic = false;
if (((Vector3)(ref direction)).sqrMagnitude > 0.01f)
{
_rig.AddForce(((Vector3)(ref direction)).normalized * 8f + Vector3.up * 2f, (ForceMode)1);
}
}
}
public void ForceDropCompletely()
{
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Invalid comparison between Unknown and I4
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Invalid comparison between Unknown and I4
//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_holdable == (Object)null)
{
return;
}
HoldingHandler val = null;
DataHandler holderData = _holdable.holderData;
if ((Object)(object)holderData != (Object)null)
{
val = ((Component)holderData).GetComponent<HoldingHandler>();
}
if ((Object)(object)val == (Object)null && (Object)(object)_holdable.holdingHandler != (Object)null)
{
val = _holdable.holdingHandler;
}
bool ignoreDissarm = _holdable.ignoreDissarm;
_holdable.ignoreDissarm = false;
try
{
bool flag = false;
bool flag2 = false;
if ((Object)(object)val != (Object)null)
{
bool flag3 = (Object)(object)val.rightObject == (Object)(object)_holdable;
bool flag4 = (Object)(object)val.leftObject == (Object)(object)_holdable;
bool flag5 = flag3 && (int)val.leftHandActivity == 1;
bool flag6 = flag4 && (int)val.rightHandActivity == 2;
if (!flag3 && !flag4)
{
WeaponHandler component = ((Component)val).GetComponent<WeaponHandler>();
if ((Object)(object)component != (Object)null)
{
if ((Object)(object)component.leftWeapon != (Object)null && (Object)(object)((Component)component.leftWeapon).gameObject == (Object)(object)((Component)this).gameObject)
{
component.leftWeapon = null;
flag = true;
}
if ((Object)(object)component.rightWeapon != (Object)null && (Object)(object)((Component)component.rightWeapon).gameObject == (Object)(object)((Component)this).gameObject)
{
component.rightWeapon = null;
flag2 = true;
}
}
val.LetGoOfWeapon(((Component)this).gameObject);
if (_holdable.held)
{
_holdable.WasDropped();
}
}
else
{
if (_holdable.held)
{
_holdable.WasDropped();
}
flag2 = flag3 || flag6;
flag = flag4 || flag5;
if (flag2)
{
val.rightHandActivity = (HandActivity)0;
}
if (flag)
{
val.leftHandActivity = (HandActivity)0;
}
DestroyJointField(val, RightHandJointField, flag2);
DestroyJointField(val, LeftHandJointField, flag);
if (flag3)
{
if ((Object)(object)_holdable.rig != (Object)null)
{
_holdable.rig.isKinematic = false;
}
if ((Object)(object)((Component)_holdable).GetComponent<SetInterpolation>() == (Object)null)
{
((Component)_holdable).gameObject.AddComponent<SetInterpolation>();
}
val.rightObject = null;
}
if (flag4)
{
if ((Object)(object)_holdable.rig != (Object)null)
{
_holdable.rig.isKinematic = false;
}
if ((Object)(object)((Component)_holdable).GetComponent<SetInterpolation>() == (Object)null)
{
((Component)_holdable).gameObject.AddComponent<SetInterpolation>();
}
val.leftObject = null;
}
if ((Object)(object)_holdable.rig != (Object)null)
{
_holdable.rig.isKinematic = false;
}
WeaponHandler component2 = ((Component)val).GetComponent<WeaponHandler>();
if ((Object)(object)component2 != (Object)null)
{
if ((Object)(object)component2.leftWeapon != (Object)null && (Object)(object)((Component)component2.leftWeapon).gameObject == (Object)(object)((Component)this).gameObject)
{
component2.leftWeapon = null;
flag = true;
}
if ((Object)(object)component2.rightWeapon != (Object)null && (Object)(object)((Component)component2.rightWeapon).gameObject == (Object)(object)((Component)this).gameObject)
{
component2.rightWeapon = null;
flag2 = true;
}
}
}
ReenableHandColliders(val, flag, flag2);
WeaponHandler component3 = ((Component)val).GetComponent<WeaponHandler>();
if ((Object)(object)component3 != (Object)null)
{
EquipFistsForFreedHands(component3, flag, flag2);
}
}
else if (_holdable.held)
{
_holdable.WasDropped();
if ((Object)(object)_holdable.rig != (Object)null)
{
_holdable.rig.isKinematic = false;
}
}
if ((Object)(object)holderData != (Object)null)
{
BreakJointsToHolder(((Component)holderData).transform.root);
}
}
finally
{
_holdable.ignoreDissarm = ignoreDissarm;
}
}
private static void EquipFistsForFreedHands(WeaponHandler wh, bool left, bool right)
{
if ((Object)(object)wh == (Object)null || (!left && !right))
{
return;
}
DataHandler val = (DataHandler)((WhDataField != null) ? ((object)/*isinst with value type is only supported in some contexts*/) : ((object)((Component)wh).GetComponent<DataHandler>()));
if ((Object)(object)val != (Object)null && val.Dead)
{
return;
}
GameObject fistRefernce = wh.fistRefernce;
if ((Object)(object)fistRefernce == (Object)null)
{
if ((Object)(object)wh.leftWeapon == (Object)null && (Object)(object)wh.rightWeapon == (Object)null)
{
wh.UseHands();
}
return;
}
MeleeWeapon component = fistRefernce.GetComponent<MeleeWeapon>();
CollisionWeapon component2 = fistRefernce.GetComponent<CollisionWeapon>();
CollisionSound component3 = fistRefernce.GetComponent<CollisionSound>();
if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null)
{
if ((Object)(object)wh.leftWeapon == (Object)null && (Object)(object)wh.rightWeapon == (Object)null)
{
wh.UseHands();
}
return;
}
Unit val2 = (Unit)((WhUnitField != null) ? ((object)/*isinst with value type is only supported in some contexts*/) : ((object)((Component)wh).GetComponentInParent<Unit>()));
object obj = ((UnitApiField != null) ? UnitApiField.GetValue(wh) : null);
if (obj == null && (Object)(object)val2 != (Object)null)
{
Component[] components = ((Component)val2).GetComponents<Component>();
for (int i = 0; i < components.Length; i++)
{
if ((Object)(object)components[i] != (Object)null && ((object)components[i]).GetType().Name == "UnitAPI")
{
obj = components[i];
break;
}
}
}
if (right && (Object)(object)wh.rightWeapon == (Object)null)
{
HandRight componentInChildren = ((Component)wh).GetComponentInChildren<HandRight>();
if ((Object)(object)componentInChildren != (Object)null)
{
MeleeWeapon val3 = EnsureFistOnHand(((Component)componentInChildren).gameObject, component, component2, component3);
wh.SetWeapon((Weapon)(object)val3, (HandType)0);
Plugin.Dbg("[BreakableShields] Equipped fist on RIGHT hand");
}
}
if (left && (Object)(object)wh.leftWeapon == (Object)null)
{
HandLeft componentInChildren2 = ((Component)wh).GetComponentInChildren<HandLeft>();
if ((Object)(object)componentInChildren2 != (Object)null)
{
MeleeWeapon val4 = EnsureFistOnHand(((Component)componentInChildren2).gameObject, component, component2, component3);
wh.SetWeapon((Weapon)(object)val4, (HandType)1);
Plugin.Dbg("[BreakableShields] Equipped fist on LEFT hand");
}
}
Weapon val5 = null;
if ((Object)(object)wh.rightWeapon != (Object)null && !IsFistWeapon(wh.rightWeapon))
{
val5 = wh.rightWeapon;
}
else if ((Object)(object)wh.leftWeapon != (Object)null && !IsFistWeapon(wh.leftWeapon))
{
val5 = wh.leftWeapon;
}
else if ((Object)(object)wh.rightWeapon != (Object)null)
{
val5 = wh.rightWeapon;
}
else if ((Object)(object)wh.leftWeapon != (Object)null)
{
val5 = wh.leftWeapon;
}
if ((Object)(object)val2 != (Object)null && (Object)(object)val5 != (Object)null)
{
val2.m_AttackDistance = val5.maxRange;
val2.m_PreferedDistance = val5.maxRange - 0.3f;
}
if (obj != null)
{
MethodInfo method = obj.GetType().GetMethod("UpdateECSValues", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method != null)
{
method.Invoke(obj, null);
}
}
}
private static bool IsFistWeapon(Weapon weapon)
{
if ((Object)(object)weapon == (Object)null)
{
return false;
}
if (!((Object)(object)((Component)weapon).GetComponent<HandLeft>() != (Object)null) && !((Object)(object)((Component)weapon).GetComponent<HandRight>() != (Object)null) && !((Object)(object)((Component)weapon).GetComponentInParent<HandLeft>() != (Object)null))
{
return (Object)(object)((Component)weapon).GetComponentInParent<HandRight>() != (Object)null;
}
return true;
}
private static MeleeWeapon EnsureFistOnHand(GameObject handGo, MeleeWeapon srcMelee, CollisionWeapon srcCol, CollisionSound srcSound)
{
MeleeWeapon component = handGo.GetComponent<MeleeWeapon>();
CollisionWeapon component2 = handGo.GetComponent<CollisionWeapon>();
if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
{
CopyMeleeStats(component, srcMelee);
CopyCollisionStats(component2, srcCol);
return component;
}
if ((Object)(object)component != (Object)null)
{
Object.Destroy((Object)(object)component);
}
if ((Object)(object)component2 != (Object)null)
{
Object.Destroy((Object)(object)component2);
}
MeleeWeapon obj = handGo.AddComponent<MeleeWeapon>();
CollisionWeapon dst = handGo.AddComponent<CollisionWeapon>();
if ((Object)(object)srcSound != (Object)null)
{
CollisionSound val = handGo.GetComponent<CollisionSound>();
if ((Object)(object)val == (Object)null)
{
val = handGo.AddComponent<CollisionSound>();
}
val.SoundEffectRef = srcSound.SoundEffectRef;
}
CopyMeleeStats(obj, srcMelee);
CopyCollisionStats(dst, srcCol);
return obj;
}
private static void CopyMeleeStats(MeleeWeapon dst, MeleeWeapon src)
{
dst.forceCurve = src.forceCurve;
dst.curveForce = src.curveForce;
((Weapon)dst).internalCooldown = ((Weapon)src).internalCooldown;
((Weapon)dst).maxRange = ((Weapon)src).maxRange;
dst.setDirectionContinious = src.setDirectionContinious;
dst.SoundRef = src.SoundRef;
dst.soundDelay = src.soundDelay;
dst.canDealDamageOutSideOfSwing = true;
dst.canDealDamage = true;
}
private static void CopyCollisionStats(CollisionWeapon dst, CollisionWeapon src)
{
dst.impactMultiplier = src.impactMultiplier;
dst.damage = src.damage;
dst.onImpactForce = src.onImpactForce;
}
private static void ReenableHandColliders(HoldingHandler hh, bool left, bool right)
{
if ((Object)(object)hh == (Object)null)
{
return;
}
if (right)
{
HandRight componentInChildren = ((Component)hh).GetComponentInChildren<HandRight>();
if ((Object)(object)componentInChildren != (Object)null)
{
Collider[] componentsInChildren = ((Component)componentInChildren).GetComponentsInChildren<Collider>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].enabled = true;
}
Rigidbody component = ((Component)componentInChildren).GetComponent<Rigidbody>();
if ((Object)(object)component != (Object)null)
{
component.isKinematic = false;
}
}
}
if (!left)
{
return;
}
HandLeft componentInChildren2 = ((Component)hh).GetComponentInChildren<HandLeft>();
if ((Object)(object)componentInChildren2 != (Object)null)
{
Collider[] componentsInChildren2 = ((Component)componentInChildren2).GetComponentsInChildren<Collider>(true);
for (int j = 0; j < componentsInChildren2.Length; j++)
{
componentsInChildren2[j].enabled = true;
}
Rigidbody component2 = ((Component)componentInChildren2).GetComponent<Rigidbody>();
if ((Object)(object)component2 != (Object)null)
{
component2.isKinematic = false;
}
}
}
private static void DestroyJointField(HoldingHandler hh, FieldInfo field, bool should)
{
if (should && !(field == null))
{
object? value = field.GetValue(hh);
ConfigurableJoint val = (ConfigurableJoint)((value is ConfigurableJoint) ? value : null);
if (val != null && (Object)(object)val != (Object)null)
{
Object.Destroy((Object)(object)val);
field.SetValue(hh, null);
}
}
}
private void BreakJointsToHolder(Transform holderRoot)
{
if ((Object)(object)holderRoot == (Object)null)
{
return;
}
ConfigurableJoint[] componentsInChildren = ((Component)this).GetComponentsInChildren<ConfigurableJoint>(true);
foreach (ConfigurableJoint val in componentsInChildren)
{
if (!((Object)(object)val == (Object)null))
{
Rigidbody connectedBody = ((Joint)val).connectedBody;
if ((Object)(object)connectedBody != (Object)null && (Object)(object)((Component)connectedBody).transform.root == (Object)(object)holderRoot)
{
Object.Destroy((Object)(object)val);
}
}
}
ConfigurableJoint[] componentsInChildren2 = ((Component)holderRoot).GetComponentsInChildren<ConfigurableJoint>(true);
foreach (ConfigurableJoint val2 in componentsInChildren2)
{
if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Joint)val2).connectedBody == (Object)null) && ((Object)(object)((Component)((Joint)val2).connectedBody).transform == (Object)(object)((Component)this).transform || ((Component)((Joint)val2).connectedBody).transform.IsChildOf(((Component)this).transform)))
{
Object.Destroy((Object)(object)val2);
}
}
}
}
}
