using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using Steamworks;
using Steamworks.Data;
using TMPro;
using UnityEngine;
using UnityEngine.Localization.Components;
using UnityEngine.UI;
[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("HamiltonMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HamiltonMod")]
[assembly: AssemblyTitle("HamiltonMod")]
[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 HamiltonMod
{
[BepInPlugin("codex.superbattlegolf.hamilton", "Hamilton", "0.1.17")]
public sealed class HamiltonPlugin : BaseUnityPlugin
{
private enum ShotOutcome
{
Normal,
Jam,
Backfire
}
[HarmonyPatch(typeof(PlayerInventory), "DecrementUseFromSlotAt")]
private static class KeepPistolLoadedPatch
{
private static bool Prefix(PlayerInventory __instance, int index)
{
return !IsReservedPistolSlot(__instance, index);
}
}
[HarmonyPatch(typeof(PlayerInventory), "RemoveIfOutOfUses")]
private static class PreventLoadedPistolRemovalPatch
{
private static bool Prefix(PlayerInventory __instance, int index)
{
return !IsReservedPistolSlot(__instance, index);
}
}
[HarmonyPatch(typeof(PlayerInventorySettings), "get_MaxItems")]
private static class MaxInventorySlotsPatch
{
private static void Postfix(ref int __result)
{
if (IsHamiltonEnabled())
{
__result = Mathf.Max(__result, 4);
}
}
}
[HarmonyPatch(typeof(PlayerInventory), "OnStartServer")]
private static class ServerStartReservedPistolPatch
{
private static void Postfix(PlayerInventory __instance)
{
if (IsHamiltonEnabled() && NetworkServer.active)
{
EnsureReservedPistol(__instance);
}
}
}
[HarmonyPatch(typeof(PlayerInventory), "OnStartClient")]
private static class ClientStartReservedPistolPatch
{
private static void Postfix(PlayerInventory __instance)
{
}
}
[HarmonyPatch(typeof(PlayerInventory), "OnStartLocalPlayer")]
private static class LocalPlayerStartReservedPistolPatch
{
private static void Postfix(PlayerInventory __instance)
{
if (IsHamiltonEnabled() && NetworkServer.active)
{
EnsureReservedPistol(__instance);
}
}
}
[HarmonyPatch(typeof(PlayerInventory), "ServerTryAddItem")]
private static class ReservedSlotItemGrantPatch
{
private static bool Prefix(PlayerInventory __instance, ItemType itemToAdd, int remainingUses, ref bool __result)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Invalid comparison between Unknown and I4
if (!IsHamiltonEnabled() || !NetworkServer.active)
{
return true;
}
if ((int)itemToAdd == 2)
{
EnsureReservedPistol(__instance);
__result = true;
return false;
}
EnsureReservedPistol(__instance);
return true;
}
}
[HarmonyPatch(typeof(PlayerInventory), "DropItem")]
private static class PreventDroppingReservedPistolPatch
{
private static bool Prefix(PlayerInventory __instance)
{
if (IsHamiltonEnabled())
{
return __instance.EquippedItemIndex != 0;
}
return true;
}
}
[HarmonyPatch(typeof(MatchSetupRules), "Initialize")]
private static class MatchSetupRulesInitializePatch
{
private static void Postfix()
{
instance?.TryInstallHamiltonRulesToggle();
}
}
[HarmonyPatch(typeof(MatchSetupRules), "OnStartClient")]
private static class MatchSetupRulesStartClientPatch
{
private static void Postfix()
{
instance?.TryInstallHamiltonRulesToggle();
}
}
[HarmonyPatch(typeof(ItemPool), "GetWeightedRandomItem")]
private static class RemovePistolFromItemPoolsPatch
{
private static bool Prefix(ItemPool __instance, ref ItemType __result)
{
if (!IsHamiltonEnabled())
{
return true;
}
return !TryGetWeightedRandomNonPistolItem(__instance, out __result);
}
}
[HarmonyPatch]
private static class DuelingPistolShotPatch
{
private static MethodBase TargetMethod()
{
return AccessTools.Method(typeof(PlayerInventory), "<ShootDuelingPistolRoutine>g__Shoot|164_0", (Type[])null, (Type[])null);
}
private static bool Prefix(PlayerInventory __instance)
{
if (!IsHamiltonEnabled() || (Object)(object)__instance == (Object)null || !((NetworkBehaviour)__instance).isLocalPlayer)
{
return true;
}
switch (RollShotOutcome())
{
case ShotOutcome.Jam:
QueueReloadJam(__instance);
return true;
case ShotOutcome.Backfire:
Backfire(__instance);
return false;
default:
return true;
}
}
private static void Postfix(PlayerInventory __instance)
{
if (IsHamiltonEnabled() && (Object)(object)__instance != (Object)null && ((NetworkBehaviour)__instance).isLocalPlayer)
{
ApplyReloadJam(__instance);
}
}
}
private const string PluginGuid = "codex.superbattlegolf.hamilton";
private const string PluginName = "Hamilton";
private const string PluginVersion = "0.1.17";
private const string LobbyEnabledStateKey = "codex_hamilton_enabled";
private const string LobbyEnabledVersionKey = "codex_hamilton_enabled_version";
private const string LobbyRequiredVersionKey = "codex_hamilton_required_version";
private const string LobbyMemberVersionKey = "codex_hamilton_member_version";
private const string ProGolfActiveStateKey = "codex_progolfplus_active";
private const float LobbyPollInterval = 1f;
private const float LocalMemberVersionPublishInterval = 2f;
private const float RulesUiRefreshInterval = 0.5f;
private const int ReservedPistolSlotIndex = 0;
private const int TotalInventorySlots = 4;
private static HamiltonPlugin instance;
private static FieldInfo inventorySlotsField;
private static FieldInfo itemPoolSpawnChancesField;
private static MethodInfo giveItemToLocalPlayerMethod;
private static FieldInfo itemUseTimestampField;
private static int syntheticItemUseIndex;
private static bool hasLobbyEnabledState;
private static bool lobbyEnabledState;
private static string lastObservedLobbyEnabledVersion = string.Empty;
private static float nextLobbyPollTime;
private static float nextLocalMemberVersionPublishTime;
private static bool allLobbyMembersCompatible = true;
private static string incompatibleLobbyMembers = string.Empty;
private static float nextCompatibilityWarningTime;
private static bool lastEffectiveEnabled;
private static bool proGolfPlusLobbyActive;
private static readonly Dictionary<Type, FieldInfo> spawnChanceItemFields = new Dictionary<Type, FieldInfo>();
private static readonly Dictionary<Type, FieldInfo> spawnChanceWeightFields = new Dictionary<Type, FieldInfo>();
private static readonly HashSet<PlayerInventory> pendingReloadJams = new HashSet<PlayerInventory>();
private Harmony harmony;
private ConfigEntry<bool> enabledConfig;
private ConfigEntry<float> grantCheckIntervalConfig;
private ConfigEntry<float> jamChanceConfig;
private ConfigEntry<float> jamReloadDelaySecondsConfig;
private ConfigEntry<float> backfireChanceConfig;
private ConfigEntry<bool> autoSelectPistolConfig;
private float nextGrantCheckTime;
private float nextRulesUiCheckTime;
private float nextRulesUiRefreshTime;
private DropdownOption hamiltonRulesDropdown;
private bool suppressHamiltonDropdownChanged;
private void Awake()
{
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Expected O, but got Unknown
instance = this;
enabledConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", false, "Enable Hamilton when Custom rules are selected.");
grantCheckIntervalConfig = ((BaseUnityPlugin)this).Config.Bind<float>("General", "GrantCheckIntervalSeconds", 1f, "How often the mod checks whether the local player needs a pistol.");
jamChanceConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Chaos", "JamChance", 0.15f, "Chance from 0 to 1 that a pistol shot fires but reloads more slowly.");
jamReloadDelaySecondsConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Chaos", "JamReloadDelaySeconds", 1.5f, "Extra seconds added to the pistol reload when a jam happens.");
backfireChanceConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Chaos", "BackfireChance", 0.1f, "Chance from 0 to 1 that a pistol shot hits the shooter instead.");
autoSelectPistolConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "AutoSelectPistol", false, "Automatically select the permanent pistol slot when the mod grants one.");
inventorySlotsField = AccessTools.Field(typeof(PlayerInventory), "slots");
itemUseTimestampField = AccessTools.Field(typeof(PlayerInventory), "<ItemUseTimestamp>k__BackingField");
itemPoolSpawnChancesField = AccessTools.Field(typeof(ItemPool), "spawnChances");
giveItemToLocalPlayerMethod = AccessTools.Method(typeof(PlayerInventory), "GiveItemToLocalPlayer", (Type[])null, (Type[])null);
harmony = new Harmony("codex.superbattlegolf.hamilton");
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Hamilton 0.1.17 loaded.");
}
private void OnDestroy()
{
Harmony obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
if (instance == this)
{
instance = null;
}
}
private void Update()
{
PollSteamLobbyEnabledState();
TryInstallHamiltonRulesToggle();
RefreshHamiltonRulesToggleThrottled();
if (!IsHamiltonEnabled())
{
if (lastEffectiveEnabled && NetworkServer.active)
{
RemoveHamiltonPistolsFromAllPlayers();
}
lastEffectiveEnabled = false;
return;
}
lastEffectiveEnabled = true;
if (!(Time.unscaledTime < nextGrantCheckTime))
{
nextGrantCheckTime = Time.unscaledTime + Mathf.Max(0.25f, grantCheckIntervalConfig.Value);
TryEnsureLocalPlayerHasPistol();
}
}
private static bool IsHamiltonEnabled()
{
if (!IsHamiltonAllowedForCurrentPreset())
{
return false;
}
if (IsProGolfMatchUnderway())
{
return false;
}
if (NetworkServer.active && !allLobbyMembersCompatible)
{
return false;
}
if (hasLobbyEnabledState)
{
return lobbyEnabledState;
}
return instance?.enabledConfig.Value ?? false;
}
private static bool IsHamiltonAllowedForCurrentPreset()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Invalid comparison between Unknown and I4
MatchSetupRules val = FindMatchSetupRules();
if ((Object)(object)val != (Object)null)
{
return (int)val.CurrentPreset == 2;
}
return false;
}
private static bool IsProGolfMatchUnderway()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Invalid comparison between Unknown and I4
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: 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_0020: Invalid comparison between Unknown and I4
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Invalid comparison between Unknown and I4
MatchSetupRules val = FindMatchSetupRules();
if ((Object)(object)val != (Object)null && (int)val.CurrentPreset == 1)
{
MatchState matchState = CourseManager.MatchState;
if ((int)matchState >= 1)
{
return (int)matchState < 6;
}
return false;
}
return proGolfPlusLobbyActive;
}
private void RefreshHamiltonRulesToggleThrottled()
{
if (!(Time.unscaledTime < nextRulesUiRefreshTime))
{
nextRulesUiRefreshTime = Time.unscaledTime + 0.5f;
RefreshHamiltonRulesToggle();
}
}
private static int DropdownValueFromEnabled(bool enabled)
{
return (!enabled) ? 1 : 0;
}
private static bool EnabledFromDropdownValue(int value)
{
return value == 0;
}
private static void PollSteamLobbyEnabledState()
{
//IL_005b: 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)
if (Time.unscaledTime < nextLobbyPollTime)
{
return;
}
nextLobbyPollTime = Time.unscaledTime + 1f;
Lobby lobby = default(Lobby);
if (!BNetworkManager.TryGetSteamLobby(ref lobby))
{
if (!NetworkServer.active && !NetworkClient.active)
{
hasLobbyEnabledState = false;
lastObservedLobbyEnabledVersion = string.Empty;
allLobbyMembersCompatible = true;
incompatibleLobbyMembers = string.Empty;
proGolfPlusLobbyActive = false;
}
return;
}
PublishLocalMemberVersion(lobby);
proGolfPlusLobbyActive = string.Equals(((Lobby)(ref lobby)).GetData("codex_progolfplus_active"), "1", StringComparison.Ordinal);
if (NetworkServer.active)
{
UpdateLobbyCompatibility(lobby);
}
string data = ((Lobby)(ref lobby)).GetData("codex_hamilton_enabled");
if (string.IsNullOrEmpty(data))
{
if (NetworkServer.active)
{
PublishSteamLobbyEnabledState(instance?.enabledConfig.Value ?? false);
}
return;
}
string data2 = ((Lobby)(ref lobby)).GetData("codex_hamilton_enabled_version");
bool flag = data == "1";
bool num = !hasLobbyEnabledState || lobbyEnabledState != flag || data2 != lastObservedLobbyEnabledVersion;
hasLobbyEnabledState = true;
lobbyEnabledState = flag;
lastObservedLobbyEnabledVersion = data2;
if (num)
{
if (NetworkServer.active)
{
ApplyServerEnabledState(flag);
}
instance?.RefreshHamiltonRulesToggle();
}
}
private static void PublishLocalMemberVersion(Lobby lobby)
{
if (SteamClient.IsValid && !(Time.unscaledTime < nextLocalMemberVersionPublishTime))
{
nextLocalMemberVersionPublishTime = Time.unscaledTime + 2f;
((Lobby)(ref lobby)).SetMemberData("codex_hamilton_member_version", "0.1.17");
}
}
private unsafe static void UpdateLobbyCompatibility(Lobby lobby)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: 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)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkServer.active)
{
return;
}
if (!string.Equals(((Lobby)(ref lobby)).GetData("codex_hamilton_required_version"), "0.1.17", StringComparison.Ordinal))
{
((Lobby)(ref lobby)).SetData("codex_hamilton_required_version", "0.1.17");
}
List<string> list = new List<string>();
foreach (Friend member in ((Lobby)(ref lobby)).Members)
{
Friend current = member;
string memberData = ((Lobby)(ref lobby)).GetMemberData(current, "codex_hamilton_member_version");
if (!string.Equals(memberData, "0.1.17", StringComparison.Ordinal))
{
string? text;
if (!string.IsNullOrEmpty(((Friend)(ref current)).Name))
{
text = ((Friend)(ref current)).Name;
}
else
{
SteamId id = current.Id;
text = ((object)(*(SteamId*)(&id))/*cast due to .constrained prefix*/).ToString();
}
string text2 = text;
list.Add(string.IsNullOrEmpty(memberData) ? (text2 + " (missing Hamilton 0.1.17)") : (text2 + " (Hamilton " + memberData + ", needs 0.1.17)"));
}
}
allLobbyMembersCompatible = list.Count == 0;
incompatibleLobbyMembers = string.Join(", ", list);
if (allLobbyMembersCompatible)
{
return;
}
if (hasLobbyEnabledState && lobbyEnabledState)
{
PublishSteamLobbyEnabledState(enabled: false);
}
if (Time.unscaledTime >= nextCompatibilityWarningTime)
{
nextCompatibilityWarningTime = Time.unscaledTime + 10f;
HamiltonPlugin hamiltonPlugin = instance;
if (hamiltonPlugin != null)
{
((BaseUnityPlugin)hamiltonPlugin).Logger.LogWarning((object)("Hamilton disabled until every lobby member is running Hamilton 0.1.17: " + incompatibleLobbyMembers));
}
}
}
private static void PublishSteamLobbyEnabledState(bool enabled)
{
if (enabled && !IsHamiltonAllowedForCurrentPreset())
{
enabled = false;
}
if (enabled && NetworkServer.active && !allLobbyMembersCompatible)
{
enabled = false;
HamiltonPlugin hamiltonPlugin = instance;
if (hamiltonPlugin != null)
{
((BaseUnityPlugin)hamiltonPlugin).Logger.LogWarning((object)("Hamilton cannot be enabled yet. Waiting for: " + incompatibleLobbyMembers));
}
}
hasLobbyEnabledState = true;
lobbyEnabledState = enabled;
lastObservedLobbyEnabledVersion = Time.unscaledTime.ToString("R");
Lobby val = default(Lobby);
if (BNetworkManager.TryGetSteamLobby(ref val))
{
((Lobby)(ref val)).SetData("codex_hamilton_enabled", enabled ? "1" : "0");
((Lobby)(ref val)).SetData("codex_hamilton_enabled_version", lastObservedLobbyEnabledVersion);
}
ApplyServerEnabledState(enabled);
instance?.RefreshHamiltonRulesToggle();
}
private static ulong GetPlayerGuid(PlayerInfo player)
{
if (!((Object)(object)((player != null) ? player.PlayerId : null) != (Object)null))
{
return 0uL;
}
return player.PlayerId.Guid;
}
private static void ApplyServerEnabledState(bool enabled)
{
if (!NetworkServer.active)
{
return;
}
PlayerInventory[] array = Object.FindObjectsByType<PlayerInventory>((FindObjectsSortMode)0);
foreach (PlayerInventory val in array)
{
if (!((Object)(object)val == (Object)null))
{
if (enabled)
{
EnsureReservedPistol(val);
}
else
{
RemoveReservedPistol(val);
}
}
}
}
private void TryInstallHamiltonRulesToggle()
{
if ((Object)(object)hamiltonRulesDropdown != (Object)null || Time.unscaledTime < nextRulesUiCheckTime)
{
return;
}
nextRulesUiCheckTime = Time.unscaledTime + 1f;
MatchSetupRules val = FindMatchSetupRules();
if ((Object)(object)val == (Object)null)
{
return;
}
DropdownOption val2 = (((Object)(object)val.hitOtherPlayers != (Object)null) ? val.hitOtherPlayers : val.homingShots);
if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).transform == (Object)null) && !((Object)(object)((Component)val2).transform.parent == (Object)null))
{
GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject, ((Component)val2).transform.parent);
((Object)val3).name = "HamiltonRulesDropdown";
val3.transform.SetSiblingIndex(((Component)val2).transform.GetSiblingIndex() + 1);
LocalizeStringEvent[] componentsInChildren = val3.GetComponentsInChildren<LocalizeStringEvent>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
((Behaviour)componentsInChildren[i]).enabled = false;
}
hamiltonRulesDropdown = val3.GetComponent<DropdownOption>();
if ((Object)(object)hamiltonRulesDropdown == (Object)null)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)"Could not create Hamilton custom rules dropdown.");
Object.Destroy((Object)(object)val3);
return;
}
hamiltonRulesDropdown.SetOptions(new List<string> { "On", "Off" });
hamiltonRulesDropdown.Initialize((Action)OnHamiltonRulesDropdownChanged, DropdownValueFromEnabled(IsHamiltonEnabled()));
SetHamiltonRulesRowText();
RefreshHamiltonRulesToggle();
RebuildRulesLayout(((Component)val2).transform.parent);
((BaseUnityPlugin)this).Logger.LogInfo((object)"Added Hamilton toggle to custom rules.");
}
}
private static MatchSetupRules FindMatchSetupRules()
{
if (SingletonNetworkBehaviour<MatchSetupRules>.HasInstance)
{
return SingletonNetworkBehaviour<MatchSetupRules>.Instance;
}
if (SingletonBehaviour<MatchSetupRules>.HasInstance)
{
return SingletonBehaviour<MatchSetupRules>.Instance;
}
return Object.FindFirstObjectByType<MatchSetupRules>((FindObjectsInactive)1);
}
private static void RebuildRulesLayout(Transform parent)
{
RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
if ((Object)(object)val == (Object)null)
{
val = ((Component)parent).GetComponent<RectTransform>();
}
if ((Object)(object)val != (Object)null)
{
LayoutRebuilder.ForceRebuildLayoutImmediate(val);
}
}
private void SetHamiltonRulesRowText()
{
if ((Object)(object)hamiltonRulesDropdown == (Object)null)
{
return;
}
TMP_Text captionText = hamiltonRulesDropdown.captionText;
TMP_Text[] componentsInChildren = ((Component)hamiltonRulesDropdown).GetComponentsInChildren<TMP_Text>(true);
foreach (TMP_Text val in componentsInChildren)
{
if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)captionText) && !val.text.Equals("On", StringComparison.OrdinalIgnoreCase) && !val.text.Equals("Off", StringComparison.OrdinalIgnoreCase))
{
val.text = GetHamiltonRulesLabel();
break;
}
}
}
private static string GetHamiltonRulesLabel()
{
if (NetworkServer.active && !allLobbyMembersCompatible)
{
return "Hamilton Needs Update";
}
return "Hamilton";
}
private void RefreshHamiltonRulesToggle()
{
if (!((Object)(object)hamiltonRulesDropdown == (Object)null))
{
suppressHamiltonDropdownChanged = true;
hamiltonRulesDropdown.valueWithoutNotify = DropdownValueFromEnabled(IsHamiltonEnabled());
suppressHamiltonDropdownChanged = false;
hamiltonRulesDropdown.Interactable = NetworkServer.active && allLobbyMembersCompatible && IsHamiltonAllowedForCurrentPreset();
SetHamiltonRulesRowText();
}
}
private void OnHamiltonRulesDropdownChanged()
{
if (!suppressHamiltonDropdownChanged && !((Object)(object)hamiltonRulesDropdown == (Object)null))
{
if (!NetworkServer.active)
{
RefreshHamiltonRulesToggle();
}
else
{
PublishSteamLobbyEnabledState(EnabledFromDropdownValue(hamiltonRulesDropdown.value));
}
}
}
private void TryEnsureLocalPlayerHasPistol()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkServer.active)
{
return;
}
PlayerInventory localPlayerInventory = GameManager.LocalPlayerInventory;
if ((Object)(object)localPlayerInventory == (Object)null || !((NetworkBehaviour)localPlayerInventory).isLocalPlayer)
{
return;
}
EnsureSlotCount(localPlayerInventory);
int index;
if (TryGetSlot(localPlayerInventory, 0, out var slot) && IsPistol(slot))
{
if (autoSelectPistolConfig.Value && localPlayerInventory.EquippedItemIndex != 0 && localPlayerInventory.CanSelectItemAt(0))
{
localPlayerInventory.TrySelectItemSlot(0);
}
}
else if (TryFindPistolSlot(localPlayerInventory, out index) && index != 0)
{
MovePistolToReservedSlot(localPlayerInventory, index);
}
else
{
giveItemToLocalPlayerMethod?.Invoke(localPlayerInventory, new object[1] { (object)(ItemType)2 });
((BaseUnityPlugin)this).Logger.LogInfo((object)"Granted local player a dueling pistol.");
}
}
private static bool TryFindPistolSlot(PlayerInventory inventory, out int index)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
index = -1;
SyncList<InventorySlot> slots = GetSlots(inventory);
if (slots == null)
{
return false;
}
for (int i = 0; i < slots.Count; i++)
{
if (IsPistol(slots[i]))
{
index = i;
return true;
}
}
return false;
}
private static bool TryGetSlot(PlayerInventory inventory, int index, out InventorySlot slot)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
slot = InventorySlot.Empty;
SyncList<InventorySlot> slots = GetSlots(inventory);
if (slots == null || index < 0 || index >= slots.Count)
{
return false;
}
slot = slots[index];
return true;
}
private static bool IsPistol(InventorySlot slot)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
if ((int)slot.itemType == 2)
{
return slot.remainingUses > 0;
}
return false;
}
private static bool IsEmpty(InventorySlot slot)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
if ((int)slot.itemType != 0)
{
return slot.remainingUses <= 0;
}
return true;
}
private static bool IsReservedPistolSlot(PlayerInventory inventory, int index)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if (IsHamiltonEnabled() && index == 0 && TryGetSlot(inventory, index, out var slot))
{
return IsPistol(slot);
}
return false;
}
private static SyncList<InventorySlot> GetSlots(PlayerInventory inventory)
{
return inventorySlotsField?.GetValue(inventory) as SyncList<InventorySlot>;
}
private static void EnsureSlotCount(PlayerInventory inventory)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
SyncList<InventorySlot> slots = GetSlots(inventory);
if (slots != null)
{
while (slots.Count < 4)
{
slots.Add(InventorySlot.Empty);
}
}
}
private static void MovePistolToReservedSlot(PlayerInventory inventory, int existingPistolIndex)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: 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_0041: Unknown result type (might be due to invalid IL or missing references)
SyncList<InventorySlot> slots = GetSlots(inventory);
if (slots != null && existingPistolIndex >= 0 && existingPistolIndex < slots.Count)
{
EnsureSlotCount(inventory);
InventorySlot val = slots[0];
slots[0] = new InventorySlot((ItemType)2, 1);
if (existingPistolIndex != 0)
{
slots[existingPistolIndex] = (IsEmpty(val) ? InventorySlot.Empty : val);
}
}
}
private static void EnsureReservedPistol(PlayerInventory inventory)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
if (!IsHamiltonEnabled())
{
return;
}
SyncList<InventorySlot> slots = GetSlots(inventory);
if (slots == null)
{
return;
}
EnsureSlotCount(inventory);
InventorySlot val = slots[0];
if (IsPistol(val))
{
return;
}
if (TryFindPistolSlot(inventory, out var index) && index != 0)
{
MovePistolToReservedSlot(inventory, index);
return;
}
if (!IsEmpty(val))
{
MoveReservedItemToFirstNormalSlot(slots, val);
}
slots[0] = new InventorySlot((ItemType)2, 1);
}
private static void RemoveReservedPistol(PlayerInventory inventory)
{
//IL_0016: 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)
SyncList<InventorySlot> slots = GetSlots(inventory);
if (slots != null && 0 < slots.Count && IsPistol(slots[0]))
{
slots[0] = InventorySlot.Empty;
}
}
private static void RemoveHamiltonPistolsFromAllPlayers()
{
PlayerInventory[] array = Object.FindObjectsByType<PlayerInventory>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
RemoveAllPistols(array[i]);
}
}
private static void RemoveAllPistols(PlayerInventory inventory)
{
//IL_0011: 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)
SyncList<InventorySlot> slots = GetSlots(inventory);
if (slots == null)
{
return;
}
for (int i = 0; i < slots.Count; i++)
{
if (IsPistol(slots[i]))
{
slots[i] = InventorySlot.Empty;
}
}
}
private static void MoveReservedItemToFirstNormalSlot(SyncList<InventorySlot> slots, InventorySlot reservedSlot)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
for (int i = 1; i < 4; i++)
{
if (IsEmpty(slots[i]))
{
slots[i] = reservedSlot;
break;
}
}
}
private static bool TryGetWeightedRandomNonPistolItem(ItemPool pool, out ItemType item)
{
//IL_0055: 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_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Invalid comparison between Unknown and I4
//IL_0071: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Invalid comparison between Unknown and I4
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Expected I4, but got Unknown
item = (ItemType)0;
if (!(itemPoolSpawnChancesField?.GetValue(pool) is Array { Length: not 0 } array))
{
return false;
}
float num = 0f;
foreach (object item2 in array)
{
if (TryGetSpawnChanceFields(item2, out var itemField, out var weightField))
{
ItemType val = (ItemType)itemField.GetValue(item2);
float num2 = (float)weightField.GetValue(item2);
if ((int)val != 2 && (int)val != 0 && num2 > 0f)
{
num += num2;
}
}
}
if (num <= 0f)
{
item = (ItemType)1;
return true;
}
float num3 = Random.value * num;
foreach (object item3 in array)
{
if (!TryGetSpawnChanceFields(item3, out var itemField2, out var weightField2))
{
continue;
}
ItemType val2 = (ItemType)itemField2.GetValue(item3);
float num4 = (float)weightField2.GetValue(item3);
if ((int)val2 != 2 && (int)val2 != 0 && !(num4 <= 0f))
{
num3 -= num4;
if (num3 <= 0f)
{
item = (ItemType)(int)val2;
return true;
}
}
}
item = (ItemType)1;
return true;
}
private static bool TryGetSpawnChanceFields(object spawnChance, out FieldInfo itemField, out FieldInfo weightField)
{
itemField = null;
weightField = null;
if (spawnChance == null)
{
return false;
}
Type type = spawnChance.GetType();
if (!spawnChanceItemFields.TryGetValue(type, out itemField))
{
itemField = AccessTools.Field(type, "item");
spawnChanceItemFields[type] = itemField;
}
if (!spawnChanceWeightFields.TryGetValue(type, out weightField))
{
weightField = AccessTools.Field(type, "spawnChanceWeight");
spawnChanceWeightFields[type] = weightField;
}
if (itemField != null)
{
return weightField != null;
}
return false;
}
private static ShotOutcome RollShotOutcome()
{
float num = Mathf.Clamp01(instance?.backfireChanceConfig.Value ?? 0f);
float num2 = Mathf.Clamp01(instance?.jamChanceConfig.Value ?? 0f);
float value = Random.value;
if (value < num)
{
return ShotOutcome.Backfire;
}
if (value < num + num2)
{
return ShotOutcome.Jam;
}
return ShotOutcome.Normal;
}
private static void Backfire(PlayerInventory inventory)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: 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_0061: 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_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
PlayerInfo playerInfo = inventory.PlayerInfo;
PlayerMovement val = ((playerInfo != null) ? playerInfo.Movement : null);
Hittable val2 = ((playerInfo != null) ? playerInfo.AsHittable : null);
if (!((Object)(object)playerInfo == (Object)null) && !((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
{
Vector3 val3 = -((Component)playerInfo).transform.forward + Vector3.up * 0.35f;
Vector3 normalized = ((Vector3)(ref val3)).normalized;
Vector3 val4 = ((Component)val2).transform.InverseTransformPoint(inventory.GetDuelingPistolBarrelEndPosition());
Vector3 val5 = normalized * 12f;
ItemUseId val6 = CreateSyntheticItemUseId(playerInfo, (ItemType)2);
bool flag = default(bool);
val.TryKnockOut(playerInfo, (KnockoutType)4, false, val4, 0f, val5, false, val6, true, true, ref flag);
HamiltonPlugin hamiltonPlugin = instance;
if (hamiltonPlugin != null)
{
((BaseUnityPlugin)hamiltonPlugin).Logger.LogInfo((object)"Dueling pistol backfired.");
}
}
}
private static ItemUseId CreateSyntheticItemUseId(PlayerInfo player, ItemType itemType)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
return new ItemUseId(((Object)(object)((player != null) ? player.PlayerId : null) != (Object)null) ? player.PlayerId.Guid : 0, ++syntheticItemUseIndex, itemType);
}
private static void QueueReloadJam(PlayerInventory inventory)
{
if ((Object)(object)inventory != (Object)null)
{
pendingReloadJams.Add(inventory);
}
}
private static void ApplyReloadJam(PlayerInventory inventory)
{
if ((Object)(object)inventory == (Object)null || !pendingReloadJams.Remove(inventory))
{
return;
}
float num = Mathf.Max(0f, instance?.jamReloadDelaySecondsConfig.Value ?? 0f);
if (!(num <= 0f) && !(itemUseTimestampField == null))
{
itemUseTimestampField.SetValue(inventory, Time.timeAsDouble + (double)num);
HamiltonPlugin hamiltonPlugin = instance;
if (hamiltonPlugin != null)
{
((BaseUnityPlugin)hamiltonPlugin).Logger.LogInfo((object)$"Dueling pistol jammed; reload delayed by {num:0.##} seconds.");
}
}
}
}
}
