using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LastUsedWeapons")]
[assembly: AssemblyDescription("Adds new shortcut to equip items you last held in your hands. Think 'Q' in CS.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("bakaspaceman")]
[assembly: AssemblyProduct("LastUsedWeapons")]
[assembly: AssemblyCopyright("Copyright © bakaspaceman 2021-2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("840eefbf-ed22-45a8-9db3-b7e50d11d3fa")]
[assembly: AssemblyFileVersion("2.0.1")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.0.1.0")]
[module: UnverifiableCode]
public class BepInPluginTemplate : BaseUnityPlugin
{
public enum LogMessageType
{
LogInfo,
LogMessage,
LogDebug,
LogWarning,
LogError,
LogFatal
}
public static ConfigEntry<bool> enableLogging;
public static ConfigEntry<bool> enableTranspilerLogging;
protected BepInPlugin BepInAttr { get; set; }
protected static Harmony harmonyInst { get; set; }
protected static BepInPluginTemplate modInst { get; set; }
protected static ManualLogSource Logger { get; set; }
public static void DebugTranspilerLog(object message, LogMessageType msgType = LogMessageType.LogInfo)
{
DebugLog(message, msgType, transpilerlogs: true);
}
public static void DebugLog(object message, LogMessageType msgType = LogMessageType.LogInfo, bool transpilerlogs = false)
{
if (enableLogging != null && enableLogging.Value && (!transpilerlogs || enableTranspilerLogging == null || enableTranspilerLogging.Value))
{
switch (msgType)
{
case LogMessageType.LogMessage:
Logger.LogMessage(message);
break;
case LogMessageType.LogDebug:
Logger.LogDebug(message);
break;
case LogMessageType.LogWarning:
Logger.LogWarning(message);
break;
case LogMessageType.LogError:
Logger.LogError(message);
break;
case LogMessageType.LogFatal:
Logger.LogFatal(message);
break;
default:
Logger.LogInfo(message);
break;
}
}
}
public static void PrintOutInstructions(List<CodeInstruction> instructions)
{
DebugTranspilerLog("");
DebugTranspilerLog("#############################################################");
DebugTranspilerLog($"######## MODIFIED INSTRUCTIONS - {instructions.Count} ########");
DebugTranspilerLog("#############################################################");
DebugTranspilerLog("");
for (int i = 0; i < instructions.Count; i++)
{
CodeInstruction arg = instructions[i];
DebugTranspilerLog($"{i} {arg}");
}
}
protected virtual void Awake()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
modInst = this;
BepInAttr = (BepInPlugin)Attribute.GetCustomAttribute(((object)this).GetType(), typeof(BepInPlugin));
Logger = Logger.CreateLogSource(BepInAttr.Name);
harmonyInst = new Harmony(BepInAttr.GUID);
DebugLog("Loading..");
}
protected virtual void OnDestroy()
{
if (harmonyInst != null)
{
harmonyInst.UnpatchSelf();
}
DebugLog("Unloading..");
Logger.Sources.Remove((ILogSource)(object)Logger);
}
}
internal static class BepInExHelpers
{
public static ObjectDB FindObjectDB()
{
GameObject val = GameObject.Find("_GameMain");
if ((Object)(object)val != (Object)null)
{
ObjectDB component = val.GetComponent<ObjectDB>();
if ((Object)(object)component != (Object)null)
{
return component;
}
}
return null;
}
}
public static class MathUtils
{
public static string ColorRGBToHexString(int r, int g, int b)
{
return $"#{r:X2}{g:X2}{b:X2}";
}
public static float ConvertRange(float originalStart, float originalEnd, float newStart, float newEnd, float value)
{
double num = (double)(newEnd - newStart) / (double)(originalEnd - originalStart);
return (float)((double)newStart + (double)(value - originalStart) * num);
}
public static float Clamp(float value, float min, float max)
{
if (!(value < min))
{
if (!(value > max))
{
return value;
}
return max;
}
return min;
}
}
public static class EasingFunctions
{
public enum Ease
{
EaseInQuad,
EaseOutQuad,
EaseInOutQuad,
EaseInCubic,
EaseOutCubic,
EaseInOutCubic,
EaseInQuart,
EaseOutQuart,
EaseInOutQuart,
EaseInQuint,
EaseOutQuint,
EaseInOutQuint,
EaseInSine,
EaseOutSine,
EaseInOutSine,
EaseInExpo,
EaseOutExpo,
EaseInOutExpo,
EaseInCirc,
EaseOutCirc,
EaseInOutCirc,
Linear,
Spring,
EaseInBounce,
EaseOutBounce,
EaseInOutBounce,
EaseInBack,
EaseOutBack,
EaseInOutBack,
EaseInElastic,
EaseOutElastic,
EaseInOutElastic
}
public delegate float Function(float s, float e, float v);
private const float NATURAL_LOG_OF_2 = 0.6931472f;
public static float Linear(float start, float end, float value)
{
return Mathf.Lerp(start, end, value);
}
public static float Spring(float start, float end, float value)
{
value = Mathf.Clamp01(value);
value = (Mathf.Sin(value * (float)Math.PI * (0.2f + 2.5f * value * value * value)) * Mathf.Pow(1f - value, 2.2f) + value) * (1f + 1.2f * (1f - value));
return start + (end - start) * value;
}
public static float EaseInQuad(float start, float end, float value)
{
end -= start;
return end * value * value + start;
}
public static float EaseOutQuad(float start, float end, float value)
{
end -= start;
return (0f - end) * value * (value - 2f) + start;
}
public static float EaseInOutQuad(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value + start;
}
value -= 1f;
return (0f - end) * 0.5f * (value * (value - 2f) - 1f) + start;
}
public static float EaseInCubic(float start, float end, float value)
{
end -= start;
return end * value * value * value + start;
}
public static float EaseOutCubic(float start, float end, float value)
{
value -= 1f;
end -= start;
return end * (value * value * value + 1f) + start;
}
public static float EaseInOutCubic(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value * value + start;
}
value -= 2f;
return end * 0.5f * (value * value * value + 2f) + start;
}
public static float EaseInQuart(float start, float end, float value)
{
end -= start;
return end * value * value * value * value + start;
}
public static float EaseOutQuart(float start, float end, float value)
{
value -= 1f;
end -= start;
return (0f - end) * (value * value * value * value - 1f) + start;
}
public static float EaseInOutQuart(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value * value * value + start;
}
value -= 2f;
return (0f - end) * 0.5f * (value * value * value * value - 2f) + start;
}
public static float EaseInQuint(float start, float end, float value)
{
end -= start;
return end * value * value * value * value * value + start;
}
public static float EaseOutQuint(float start, float end, float value)
{
value -= 1f;
end -= start;
return end * (value * value * value * value * value + 1f) + start;
}
public static float EaseInOutQuint(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value * value * value * value + start;
}
value -= 2f;
return end * 0.5f * (value * value * value * value * value + 2f) + start;
}
public static float EaseInSine(float start, float end, float value)
{
end -= start;
return (0f - end) * Mathf.Cos(value * ((float)Math.PI / 2f)) + end + start;
}
public static float EaseOutSine(float start, float end, float value)
{
end -= start;
return end * Mathf.Sin(value * ((float)Math.PI / 2f)) + start;
}
public static float EaseInOutSine(float start, float end, float value)
{
end -= start;
return (0f - end) * 0.5f * (Mathf.Cos((float)Math.PI * value) - 1f) + start;
}
public static float EaseInExpo(float start, float end, float value)
{
end -= start;
return end * Mathf.Pow(2f, 10f * (value - 1f)) + start;
}
public static float EaseOutExpo(float start, float end, float value)
{
end -= start;
return end * (0f - Mathf.Pow(2f, -10f * value) + 1f) + start;
}
public static float EaseInOutExpo(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * Mathf.Pow(2f, 10f * (value - 1f)) + start;
}
value -= 1f;
return end * 0.5f * (0f - Mathf.Pow(2f, -10f * value) + 2f) + start;
}
public static float EaseInCirc(float start, float end, float value)
{
end -= start;
return (0f - end) * (Mathf.Sqrt(1f - value * value) - 1f) + start;
}
public static float EaseOutCirc(float start, float end, float value)
{
value -= 1f;
end -= start;
return end * Mathf.Sqrt(1f - value * value) + start;
}
public static float EaseInOutCirc(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return (0f - end) * 0.5f * (Mathf.Sqrt(1f - value * value) - 1f) + start;
}
value -= 2f;
return end * 0.5f * (Mathf.Sqrt(1f - value * value) + 1f) + start;
}
public static float EaseInBounce(float start, float end, float value)
{
end -= start;
float num = 1f;
return end - EaseOutBounce(0f, end, num - value) + start;
}
public static float EaseOutBounce(float start, float end, float value)
{
value /= 1f;
end -= start;
if (value < 0.36363637f)
{
return end * (7.5625f * value * value) + start;
}
if (value < 0.72727275f)
{
value -= 0.54545456f;
return end * (7.5625f * value * value + 0.75f) + start;
}
if ((double)value < 0.9090909090909091)
{
value -= 0.8181818f;
return end * (7.5625f * value * value + 0.9375f) + start;
}
value -= 21f / 22f;
return end * (7.5625f * value * value + 63f / 64f) + start;
}
public static float EaseInOutBounce(float start, float end, float value)
{
end -= start;
float num = 1f;
if (value < num * 0.5f)
{
return EaseInBounce(0f, end, value * 2f) * 0.5f + start;
}
return EaseOutBounce(0f, end, value * 2f - num) * 0.5f + end * 0.5f + start;
}
public static float EaseInBack(float start, float end, float value)
{
end -= start;
value /= 1f;
float num = 1.70158f;
return end * value * value * ((num + 1f) * value - num) + start;
}
public static float EaseOutBack(float start, float end, float value)
{
float num = 1.70158f;
end -= start;
value -= 1f;
return end * (value * value * ((num + 1f) * value + num) + 1f) + start;
}
public static float EaseInOutBack(float start, float end, float value)
{
float num = 1.70158f;
end -= start;
value /= 0.5f;
if (value < 1f)
{
num *= 1.525f;
return end * 0.5f * (value * value * ((num + 1f) * value - num)) + start;
}
value -= 2f;
num *= 1.525f;
return end * 0.5f * (value * value * ((num + 1f) * value + num) + 2f) + start;
}
public static float EaseInElastic(float start, float end, float value)
{
end -= start;
float num = 1f;
float num2 = num * 0.3f;
float num3 = 0f;
if (value == 0f)
{
return start;
}
if ((value /= num) == 1f)
{
return start + end;
}
float num4;
if (num3 == 0f || num3 < Mathf.Abs(end))
{
num3 = end;
num4 = num2 / 4f;
}
else
{
num4 = num2 / ((float)Math.PI * 2f) * Mathf.Asin(end / num3);
}
return 0f - num3 * Mathf.Pow(2f, 10f * (value -= 1f)) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2) + start;
}
public static float EaseOutElastic(float start, float end, float value)
{
end -= start;
float num = 1f;
float num2 = num * 0.3f;
float num3 = 0f;
if (value == 0f)
{
return start;
}
if ((value /= num) == 1f)
{
return start + end;
}
float num4;
if (num3 == 0f || num3 < Mathf.Abs(end))
{
num3 = end;
num4 = num2 * 0.25f;
}
else
{
num4 = num2 / ((float)Math.PI * 2f) * Mathf.Asin(end / num3);
}
return num3 * Mathf.Pow(2f, -10f * value) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2) + end + start;
}
public static float EaseInOutElastic(float start, float end, float value)
{
end -= start;
float num = 1f;
float num2 = num * 0.3f;
float num3 = 0f;
if (value == 0f)
{
return start;
}
if ((value /= num * 0.5f) == 2f)
{
return start + end;
}
float num4;
if (num3 == 0f || num3 < Mathf.Abs(end))
{
num3 = end;
num4 = num2 / 4f;
}
else
{
num4 = num2 / ((float)Math.PI * 2f) * Mathf.Asin(end / num3);
}
if (value < 1f)
{
return -0.5f * (num3 * Mathf.Pow(2f, 10f * (value -= 1f)) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2)) + start;
}
return num3 * Mathf.Pow(2f, -10f * (value -= 1f)) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2) * 0.5f + end + start;
}
public static Function GetEasingFunction(Ease easingFunction)
{
return easingFunction switch
{
Ease.EaseInQuad => EaseInQuad,
Ease.EaseOutQuad => EaseOutQuad,
Ease.EaseInOutQuad => EaseInOutQuad,
Ease.EaseInCubic => EaseInCubic,
Ease.EaseOutCubic => EaseOutCubic,
Ease.EaseInOutCubic => EaseInOutCubic,
Ease.EaseInQuart => EaseInQuart,
Ease.EaseOutQuart => EaseOutQuart,
Ease.EaseInOutQuart => EaseInOutQuart,
Ease.EaseInQuint => EaseInQuint,
Ease.EaseOutQuint => EaseOutQuint,
Ease.EaseInOutQuint => EaseInOutQuint,
Ease.EaseInSine => EaseInSine,
Ease.EaseOutSine => EaseOutSine,
Ease.EaseInOutSine => EaseInOutSine,
Ease.EaseInExpo => EaseInExpo,
Ease.EaseOutExpo => EaseOutExpo,
Ease.EaseInOutExpo => EaseInOutExpo,
Ease.EaseInCirc => EaseInCirc,
Ease.EaseOutCirc => EaseOutCirc,
Ease.EaseInOutCirc => EaseInOutCirc,
Ease.Linear => Linear,
Ease.Spring => Spring,
Ease.EaseInBounce => EaseInBounce,
Ease.EaseOutBounce => EaseOutBounce,
Ease.EaseInOutBounce => EaseInOutBounce,
Ease.EaseInBack => EaseInBack,
Ease.EaseOutBack => EaseOutBack,
Ease.EaseInOutBack => EaseInOutBack,
Ease.EaseInElastic => EaseInElastic,
Ease.EaseOutElastic => EaseOutElastic,
Ease.EaseInOutElastic => EaseInOutElastic,
_ => null,
};
}
}
namespace LastUsedWeapons;
[BepInPlugin("bakaSpaceman.LastUsedWeapons", "Last Used Weapons", "2.0.1")]
public class LastUsedWeapons : BepInPluginTemplate
{
public static ConfigEntry<int> nexusID;
private ConfigEntry<KeyboardShortcut> toggleLastEquippedShortcut;
public static ConfigEntry<bool> autoEquipAfterSwimming;
private static MethodInfo _toggleEquipedMethod = typeof(Humanoid).GetMethod("ToggleEquipped", BindingFlags.Instance | BindingFlags.NonPublic);
private static MethodInfo _takeInputMethod = typeof(Player).GetMethod("TakeInput", BindingFlags.Instance | BindingFlags.NonPublic);
private static FieldInfo _hiddenRightItemField = typeof(Humanoid).GetField("m_hiddenRightItem", BindingFlags.Instance | BindingFlags.NonPublic);
private static FieldInfo _hiddenLeftItemField = typeof(Humanoid).GetField("m_hiddenLeftItem", BindingFlags.Instance | BindingFlags.NonPublic);
private static FieldInfo _rightItemField = typeof(Humanoid).GetField("m_rightItem", BindingFlags.Instance | BindingFlags.NonPublic);
private static FieldInfo _leftItemField = typeof(Humanoid).GetField("m_leftItem", BindingFlags.Instance | BindingFlags.NonPublic);
private static ItemData _lastRightItem = null;
private static ItemData _lastLeftItem = null;
private static ItemData _equippedRightItem = null;
private static ItemData _equippedLeftItem = null;
private static bool _cacheLastitems = true;
private static bool _hiddenItemsForSwimming = false;
private void SetupConfig()
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
nexusID = ((BaseUnityPlugin)this).Config.Bind<int>("General", "NexusID", 259, "Nexus mod ID for updates");
toggleLastEquippedShortcut = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Key Bindings", "ToggleLastUsedWeapons", new KeyboardShortcut((KeyCode)116, Array.Empty<KeyCode>()), "Equips previous set of weapons");
autoEquipAfterSwimming = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "AutoEquipOnLeavingWater", true, "Will automatically restore weapons that were unequipped on entering water");
}
protected override void Awake()
{
base.Awake();
SetupConfig();
BepInPluginTemplate.harmonyInst.PatchAll(typeof(LastUsedWeapons));
}
private void Update()
{
//IL_002f: 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_0037: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)Player.m_localPlayer != (Object)null))
{
return;
}
if ((bool)_takeInputMethod.Invoke(Player.m_localPlayer, new object[0]))
{
KeyboardShortcut value = toggleLastEquippedShortcut.Value;
if (Input.GetKeyDown(((KeyboardShortcut)(ref value)).MainKey))
{
ToggleLastEquippedItems();
}
}
if (autoEquipAfterSwimming.Value && (!((Character)Player.m_localPlayer).IsSwimming() || ((Character)Player.m_localPlayer).IsOnGround()))
{
if (_hiddenItemsForSwimming)
{
((Humanoid)Player.m_localPlayer).ShowHandItems();
}
_hiddenItemsForSwimming = false;
}
}
private static void SetLastRightItem(ItemData newRightItem)
{
//IL_003d: 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)
//IL_0084: Invalid comparison between Unknown and I4
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Invalid comparison between Unknown and I4
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Invalid comparison between Unknown and I4
string name = new StackFrame(1).GetMethod().Name;
_lastRightItem = newRightItem;
if (_lastRightItem != null)
{
BepInPluginTemplate.DebugLog($"SetLastRightItem: ({name}) set - {_lastRightItem.m_shared.m_name}, type - {_lastRightItem.m_shared.m_itemType}");
}
else
{
BepInPluginTemplate.DebugLog("SetLastRightItem: (" + name + ") set to empty.");
}
if ((_lastRightItem != null && (int)_lastRightItem.m_shared.m_itemType == 14) || (_lastRightItem != null && (int)_lastRightItem.m_shared.m_itemType == 19) || (_lastLeftItem != null && (int)_lastLeftItem.m_shared.m_itemType == 4))
{
_lastLeftItem = null;
BepInPluginTemplate.DebugLog("SetLastRightItem: (" + name + ") last LEFT set to empty.");
}
}
private static void SetLastLeftItem(ItemData newLeftItem)
{
//IL_003d: 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)
//IL_0083: Invalid comparison between Unknown and I4
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Invalid comparison between Unknown and I4
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Invalid comparison between Unknown and I4
string name = new StackFrame(1).GetMethod().Name;
_lastLeftItem = newLeftItem;
if (_lastLeftItem != null)
{
BepInPluginTemplate.DebugLog($"SetLastLeftItem: ({name}) set - {_lastLeftItem.m_shared.m_name}, type - {_lastLeftItem.m_shared.m_itemType}");
}
else
{
BepInPluginTemplate.DebugLog("SetLastLeftItem: (" + name + ") set to empty.");
}
if ((_lastLeftItem != null && (int)_lastLeftItem.m_shared.m_itemType == 4) || (_lastRightItem != null && ((int)_lastRightItem.m_shared.m_itemType == 14 || (int)_lastRightItem.m_shared.m_itemType == 19)))
{
_lastRightItem = null;
BepInPluginTemplate.DebugLog("SetLastLeftItem: (" + name + ") last RIGHT set to empty.");
}
}
[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
[HarmonyPrefix]
private static bool UnequipItem_Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects = true)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
{
return true;
}
if (!_cacheLastitems)
{
return true;
}
if (item != null && item.m_shared != null)
{
BepInPluginTemplate.DebugLog($"UnequipItem_Prefix: item - {item.m_shared.m_name}, type - {item.m_shared.m_itemType}");
return CacheCurrentlyEquippedItems(__instance, ref _equippedRightItem, ref _equippedLeftItem);
}
return true;
}
[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
[HarmonyPostfix]
private static void UnequipItem_Postfix(Humanoid __instance, ItemData item, bool triggerEquipEffects = true)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Invalid comparison between O and Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Invalid comparison between O and Unknown
if (!_cacheLastitems || item == null || item.m_shared == null)
{
return;
}
BepInPluginTemplate.DebugLog($"UnequipItem_Postfix: item - {item.m_shared.m_name}, type - {item.m_shared.m_itemType}");
if (!((Object)(object)Player.m_localPlayer != (Object)(object)__instance))
{
if ((object)_equippedRightItem != (object)(ItemData)_rightItemField.GetValue(__instance))
{
SetLastRightItem(_equippedRightItem);
}
if ((object)_equippedLeftItem != (object)(ItemData)_leftItemField.GetValue(__instance))
{
SetLastLeftItem(_equippedLeftItem);
}
_equippedRightItem = null;
_equippedLeftItem = null;
}
}
[HarmonyPatch(typeof(Humanoid), "EquipItem")]
[HarmonyPrefix]
private static bool EquipItem_Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects = true)
{
//IL_003c: 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_006f: Invalid comparison between Unknown and I4
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Expected O, but got Unknown
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Expected O, but got Unknown
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Invalid comparison between Unknown and I4
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Invalid comparison between Unknown and I4
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Invalid comparison between Unknown and I4
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Invalid comparison between Unknown and I4
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Invalid comparison between Unknown and I4
if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
{
return true;
}
BepInPluginTemplate.DebugLog("");
if (item != null && item.m_shared != null)
{
BepInPluginTemplate.DebugLog($"EquipItem_Prefix: item - {item.m_shared.m_name}, type - {item.m_shared.m_itemType}");
if ((int)item.m_shared.m_itemType == 19 || (int)item.m_shared.m_itemType == 15 || (int)item.m_shared.m_itemType == 3 || (int)item.m_shared.m_itemType == 5 || (int)item.m_shared.m_itemType == 4 || (int)item.m_shared.m_itemType == 14)
{
ItemData val = (ItemData)_hiddenLeftItemField.GetValue(__instance);
ItemData val2 = (ItemData)_hiddenRightItemField.GetValue(__instance);
if (val2 != null)
{
SetLastRightItem(val2);
}
if (val != null)
{
SetLastLeftItem(val);
}
}
return true;
}
BepInPluginTemplate.DebugLog("EquipItem_Prefix: item - NULL");
return true;
}
[HarmonyPatch(typeof(Humanoid), "HideHandItems")]
[HarmonyPrefix]
private static bool HideHandItems_Prefix(Humanoid __instance)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
{
return true;
}
if (((Character)__instance).IsSwimming() && !((Character)__instance).IsOnGround() && ((int)(ItemData)_rightItemField.GetValue(__instance) != 0 || (int)(ItemData)_leftItemField.GetValue(__instance) != 0))
{
_hiddenItemsForSwimming = true;
}
_cacheLastitems = false;
return true;
}
[HarmonyPatch(typeof(Humanoid), "HideHandItems")]
[HarmonyPostfix]
private static void HideHandItems_Postfix(Humanoid __instance)
{
if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
{
_cacheLastitems = true;
}
}
private void ToggleLastEquippedItems()
{
//IL_002a: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Invalid comparison between Unknown and I4
//IL_028a: Unknown result type (might be due to invalid IL or missing references)
//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
//IL_0147: Unknown result type (might be due to invalid IL or missing references)
//IL_014e: Invalid comparison between Unknown and I4
//IL_0203: Unknown result type (might be due to invalid IL or missing references)
//IL_0323: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Player.m_localPlayer == (Object)null || ((Character)Player.m_localPlayer).IsRunning())
{
return;
}
if ((int)(ItemData)_hiddenLeftItemField.GetValue(Player.m_localPlayer) != 0 || (int)(ItemData)_hiddenRightItemField.GetValue(Player.m_localPlayer) != 0)
{
if (!((Character)Player.m_localPlayer).IsSwimming() || ((Character)Player.m_localPlayer).IsOnGround())
{
BepInPluginTemplate.DebugLog("");
BepInPluginTemplate.DebugLog("--- [Toggle Last Equipped] START ---");
((Humanoid)Player.m_localPlayer).ShowHandItems();
BepInPluginTemplate.DebugLog("ShowHandItems() instead");
BepInPluginTemplate.DebugLog("");
}
return;
}
BepInPluginTemplate.DebugLog("");
BepInPluginTemplate.DebugLog("--- [Toggle Last Equipped] START ---");
_cacheLastitems = false;
ItemData rightItem = null;
ItemData leftItem = null;
CacheCurrentlyEquippedItems((Humanoid)(object)Player.m_localPlayer, ref rightItem, ref leftItem);
bool flag = false;
bool flag2 = false;
bool flag3 = leftItem != null && _lastRightItem != null && (int)_lastRightItem.m_shared.m_itemType == 19;
if (_lastRightItem != null)
{
if (rightItem != null && _lastRightItem.m_shared.m_name == rightItem.m_shared.m_name)
{
_lastRightItem = null;
BepInPluginTemplate.DebugLog("ToggleLastEquippedItems: last RIGHT item is same as current equipped one. Setting to empty.");
}
else
{
if (_lastLeftItem != null && (int)_lastLeftItem.m_shared.m_itemType == 15)
{
_lastLeftItem = null;
BepInPluginTemplate.DebugLog("ToggleLastEquippedItems: last LEFT set to empty because its a torch.");
}
BepInPluginTemplate.DebugLog($"Trying to equip {_lastRightItem.m_shared.m_name}({_lastRightItem.m_shared.m_itemType}) to right arm");
_ = _lastRightItem.m_shared.m_itemType;
flag = (bool)_toggleEquipedMethod.Invoke(Player.m_localPlayer, new object[1] { _lastRightItem });
if (flag)
{
BepInPluginTemplate.DebugLog("Successful");
_lastRightItem = rightItem;
if (_lastRightItem != null)
{
BepInPluginTemplate.DebugLog($"ToggleLastEquippedItems: last RIGHT set - {_lastRightItem.m_shared.m_name}, type - {_lastRightItem.m_shared.m_itemType}");
}
else
{
BepInPluginTemplate.DebugLog("ToggleLastEquippedItems: last RIGHT set to empty.");
}
}
}
}
if (_lastLeftItem != null)
{
if (leftItem != null && _lastLeftItem.m_shared.m_name == leftItem.m_shared.m_name)
{
_lastLeftItem = null;
BepInPluginTemplate.DebugLog("ToggleLastEquippedItems: last LEFT item is same as current equipped one. Setting to empty.");
}
else
{
BepInPluginTemplate.DebugLog($"Trying to equip {_lastLeftItem.m_shared.m_name}({_lastLeftItem.m_shared.m_itemType}) to left arm");
_ = _lastLeftItem.m_shared.m_itemType;
if ((!flag) ? ((bool)_toggleEquipedMethod.Invoke(Player.m_localPlayer, new object[1] { _lastLeftItem })) : ((Humanoid)Player.m_localPlayer).EquipItem(_lastLeftItem, true))
{
BepInPluginTemplate.DebugLog("Successful");
_lastLeftItem = leftItem;
if (_lastLeftItem != null)
{
BepInPluginTemplate.DebugLog($"ToggleLastEquippedItems: last LEFT set - {_lastLeftItem.m_shared.m_name}, type - {_lastLeftItem.m_shared.m_itemType}");
}
else
{
BepInPluginTemplate.DebugLog("ToggleLastEquippedItems: last LEFT set to empty.");
}
}
}
}
else if (flag3)
{
_lastLeftItem = leftItem;
}
_cacheLastitems = true;
BepInPluginTemplate.DebugLog("--- [Toggle Last Equipped] END ---");
BepInPluginTemplate.DebugLog("");
}
private static bool CacheCurrentlyEquippedItems(Humanoid __instance, ref ItemData rightItem, ref ItemData leftItem)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Expected O, but got Unknown
//IL_005c: 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)
if ((Object)(object)Player.m_localPlayer != (Object)(object)__instance || (Object)(object)__instance == (Object)null)
{
return true;
}
if (_rightItemField != null)
{
rightItem = (ItemData)_rightItemField.GetValue(__instance);
if (rightItem != null && rightItem.m_shared != null)
{
BepInPluginTemplate.DebugLog($"Currently equipped RIGHT item - {rightItem.m_shared.m_name}, type - {rightItem.m_shared.m_itemType}");
}
}
if (_leftItemField != null)
{
leftItem = (ItemData)_leftItemField.GetValue(__instance);
if (leftItem != null && leftItem.m_shared != null)
{
BepInPluginTemplate.DebugLog($"Currently equipped LEFT item - {leftItem.m_shared.m_name}, type - {leftItem.m_shared.m_itemType}");
}
}
return true;
}
}
