using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using Steamworks.Data;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
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("HostPauseMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HostPauseMod")]
[assembly: AssemblyTitle("HostPauseMod")]
[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 HostPauseMod
{
[BepInPlugin("codex.superbattlegolf.hostpause", "Host Pause", "0.2.8")]
public sealed class HostPausePlugin : BaseUnityPlugin
{
private sealed class RigidbodySnapshot
{
public Rigidbody Body;
public bool IsKinematic;
public bool UseGravity;
public bool DetectCollisions;
public Vector3 LinearVelocity;
public Vector3 AngularVelocity;
}
[HarmonyPatch(typeof(PauseMenu), "Awake")]
private static class PauseMenuAwakePatch
{
private static void Postfix(PauseMenu __instance)
{
instance?.AddPauseButton(__instance);
}
}
[HarmonyPatch(typeof(PauseMenu), "OnEnable")]
private static class PauseMenuOnEnablePatch
{
private static void Postfix(PauseMenu __instance)
{
if ((Object)(object)instance?.pauseButton != (Object)null)
{
RefreshPauseMenuButtonList(__instance);
FitPauseMenuButtonStack(__instance);
instance.RefreshPauseButton();
}
}
}
[HarmonyPatch(typeof(BNetworkManager), "OnStartClient")]
private static class NetworkStartClientPatch
{
private static void Postfix()
{
lastObservedLobbyPauseVersion = string.Empty;
lastObservedLobbyPauseState = "0";
nextLobbyPollTime = 0f;
}
}
[HarmonyPatch(typeof(BNetworkManager), "OnStopServer")]
private static class NetworkStopServerPatch
{
private static void Prefix()
{
pendingRemotePause = false;
PublishSteamLobbyPauseState(paused: false);
ForceLocalResume();
}
}
[HarmonyPatch(typeof(BNetworkManager), "OnStopClient")]
private static class NetworkStopClientPatch
{
private static void Prefix()
{
lastObservedLobbyPauseVersion = string.Empty;
lastObservedLobbyPauseState = "0";
nextLobbyPollTime = 0f;
pendingRemotePause = false;
ForceLocalResume();
}
}
[HarmonyPatch(typeof(PlayerMovement), "Update")]
private static class PlayerMovementUpdatePatch
{
private static bool Prefix()
{
return !ShouldBlockGameplay();
}
}
[HarmonyPatch(typeof(PlayerMovement), "FixedUpdate")]
private static class PlayerMovementFixedUpdatePatch
{
private static bool Prefix()
{
return !ShouldBlockGameplay();
}
}
[HarmonyPatch(typeof(PlayerMovement), "CanMove")]
private static class PlayerMovementCanMovePatch
{
private static void Postfix(ref bool __result)
{
if (ShouldBlockGameplay())
{
__result = false;
}
}
}
[HarmonyPatch(typeof(PlayerMovement), "CanJump")]
private static class PlayerMovementCanJumpPatch
{
private static void Postfix(ref bool __result)
{
if (ShouldBlockGameplay())
{
__result = false;
}
}
}
[HarmonyPatch(typeof(PlayerInput), "Update")]
private static class PlayerInputUpdatePatch
{
private static bool Prefix(PlayerInput __instance)
{
if (!ShouldBlockGameplay())
{
return true;
}
ClearPausedInput(__instance);
return false;
}
}
[HarmonyPatch(typeof(PlayerInput), "StartChargingSwing")]
private static class PlayerInputStartChargingSwingPatch
{
private static bool Prefix(PlayerInput __instance)
{
if (!ShouldBlockGameplay())
{
return true;
}
ClearPausedInput(__instance);
return false;
}
}
[HarmonyPatch(typeof(PlayerInput), "FinishChargingSwing")]
private static class PlayerInputFinishChargingSwingPatch
{
private static bool Prefix(PlayerInput __instance)
{
if (!ShouldBlockGameplay())
{
return true;
}
ClearPausedInput(__instance);
return false;
}
}
[HarmonyPatch(typeof(PlayerInput), "UseItem")]
private static class PlayerInputUseItemPatch
{
private static bool Prefix(PlayerInput __instance, ref bool __result)
{
if (!ShouldBlockGameplay())
{
return true;
}
ClearPausedInput(__instance);
__result = false;
return false;
}
}
[HarmonyPatch(typeof(PlayerInput), "Jump")]
private static class PlayerInputJumpPatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "Interact")]
private static class PlayerInputInteractPatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "DropItem")]
private static class PlayerInputDropItemPatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "Dive")]
private static class PlayerInputDivePatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "CycleSwingAngle")]
private static class PlayerInputCycleSwingAnglePatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "GolfCartJump")]
private static class PlayerInputGolfCartJumpPatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "GolfCartHonk")]
private static class PlayerInputGolfCartHonkPatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "ExitGolfCart")]
private static class PlayerInputExitGolfCartPatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInput), "DiveOutOfGolfCart")]
private static class PlayerInputDiveOutOfGolfCartPatch
{
private static bool Prefix(PlayerInput __instance)
{
return AllowPausedInputAction(__instance);
}
}
[HarmonyPatch(typeof(PlayerInfo), "SetIsAimingSwing")]
private static class PlayerInfoSetIsAimingSwingPatch
{
private static bool Prefix(bool __0)
{
if (ShouldBlockGameplay())
{
return !__0;
}
return true;
}
}
[HarmonyPatch(typeof(PlayerInfo), "SetIsAimingItem")]
private static class PlayerInfoSetIsAimingItemPatch
{
private static bool Prefix(bool __0)
{
if (ShouldBlockGameplay())
{
return !__0;
}
return true;
}
}
[HarmonyPatch(typeof(PlayerGolfer), "OnPlayerHitOwnBall")]
private static class PlayerGolferOnPlayerHitOwnBallPatch
{
private static bool Prefix()
{
return !ShouldBlockGameplay();
}
}
[HarmonyPatch(typeof(GolfBall), "OnWillApplyGolfSwingHitPhysics")]
private static class GolfBallApplySwingPhysicsPatch
{
private static bool Prefix()
{
return !ShouldBlockGameplay();
}
}
[HarmonyPatch(typeof(GolfBall), "UpdatePhysics")]
private static class GolfBallUpdatePhysicsPatch
{
private static bool Prefix()
{
return !ShouldBlockGameplay();
}
}
[CompilerGenerated]
private static class <>O
{
public static UnityAction <0>__TogglePauseFromPauseMenu;
public static UnityAction <1>__ReturnToLobbyFromPauseMenu;
}
private const string PluginGuid = "codex.superbattlegolf.hostpause";
private const string PluginName = "Host Pause";
private const string PluginVersion = "0.2.8";
private const string LobbyPauseStateKey = "codex_hostpause_state";
private const string LobbyPauseVersionKey = "codex_hostpause_version";
private const string PauseStatePaused = "1";
private const string PauseStateRunning = "0";
private const string PauseStateResumeCountdown = "2";
private static HostPausePlugin instance;
private static bool isPaused;
private static string lastObservedLobbyPauseVersion = string.Empty;
private static string lastObservedLobbyPauseState = "0";
private static float nextLobbyPollTime;
private static bool pendingRemotePause;
private static bool isResumeCountdownActive;
private static bool pauseMenuStackAdjusted;
private static Vector3 pauseMenuOriginalScale;
private static Vector2 pauseMenuOriginalAnchoredPosition;
private static bool pauseBannerApplied;
private static bool aheadBannerWasVisibleBeforePause;
private static readonly List<RigidbodySnapshot> frozenRigidbodies = new List<RigidbodySnapshot>();
private static readonly Dictionary<TMP_Text, string> pauseBannerOriginalTexts = new Dictionary<TMP_Text, string>();
private static readonly List<LocalizeStringEvent> pauseBannerDisabledLocalizers = new List<LocalizeStringEvent>();
private static readonly Dictionary<PlayerAnimatorIo, int> pauseDanceOriginalValues = new Dictionary<PlayerAnimatorIo, int>();
private static GUIStyle pauseOverlayBoxStyle;
private static GUIStyle pauseOverlayTitleStyle;
private static GUIStyle pauseOverlayDetailStyle;
private static Texture2D pauseOverlayTexture;
private static FieldInfo animatorField;
private static FieldInfo victoryDanceHashField;
private static FieldInfo playerInputPlayerInfoField;
private static FieldInfo playerInputHoldingAimSwingField;
private static FieldInfo playerInputHoldingChargeSwingField;
private Harmony harmony;
private Button pauseButton;
private TMP_Text pauseButtonLabel;
private Button backToLobbyButton;
private TMP_Text backToLobbyButtonLabel;
private Coroutine resumeCountdownRoutine;
private void Awake()
{
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Expected O, but got Unknown
instance = this;
animatorField = AccessTools.Field(typeof(PlayerAnimatorIo), "animator");
victoryDanceHashField = AccessTools.Field(typeof(PlayerAnimatorIo), "victoryDanceHash");
playerInputPlayerInfoField = AccessTools.Field(typeof(PlayerInput), "playerInfo");
playerInputHoldingAimSwingField = AccessTools.Field(typeof(PlayerInput), "<IsHoldingAimSwing>k__BackingField");
playerInputHoldingChargeSwingField = AccessTools.Field(typeof(PlayerInput), "<IsHoldingChargeSwing>k__BackingField");
harmony = new Harmony("codex.superbattlegolf.hostpause");
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Host Pause 0.2.8 loaded.");
}
private void OnDestroy()
{
ForceLocalResume();
DestroyPauseOverlayStyles();
Harmony obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
if (instance == this)
{
instance = null;
}
}
private void OnGUI()
{
DrawPauseOverlay();
}
private void Update()
{
if (ShouldBlockGameplay())
{
if (!CanApplyPauseState())
{
ForceLocalResume();
return;
}
MaintainFrozenRigidbodies();
CancelPausedPlayerActions();
if (!isResumeCountdownActive)
{
ShowPauseBanner();
MaintainPauseDances();
}
}
PollSteamLobbyPauseState();
TryApplyPendingRemotePause();
if (isPaused && !NetworkServer.active && !NetworkClient.active)
{
ForceLocalResume();
}
RefreshPauseButton();
}
private static void PollSteamLobbyPauseState()
{
if (NetworkServer.active || !NetworkClient.active || !NetworkClient.isConnected || NetworkClient.connection == null || !((NetworkConnection)NetworkClient.connection).isAuthenticated || Time.unscaledTime < nextLobbyPollTime)
{
return;
}
nextLobbyPollTime = Time.unscaledTime + 0.5f;
Lobby val = default(Lobby);
if (!BNetworkManager.TryGetSteamLobby(ref val))
{
return;
}
string data = ((Lobby)(ref val)).GetData("codex_hostpause_version");
string data2 = ((Lobby)(ref val)).GetData("codex_hostpause_state");
if (!string.IsNullOrEmpty(data))
{
bool flag = data != lastObservedLobbyPauseVersion;
lastObservedLobbyPauseVersion = data;
lastObservedLobbyPauseState = data2;
if (flag || ShouldReapplyObservedPauseState(data2))
{
ApplyRemotePauseState(data2);
}
}
}
private static bool ShouldReapplyObservedPauseState(string state)
{
if (state == "1")
{
if (ShouldBlockGameplay() && !pendingRemotePause)
{
return isResumeCountdownActive;
}
return true;
}
if (state == "2")
{
if (isPaused)
{
return !isResumeCountdownActive;
}
return false;
}
if (!isPaused && !pendingRemotePause)
{
return isResumeCountdownActive;
}
return true;
}
private static void TogglePauseFromPauseMenu()
{
if (!NetworkServer.active)
{
return;
}
bool flag = !ShouldBlockGameplay();
if (flag && !CanApplyPauseState())
{
HostPausePlugin hostPausePlugin = instance;
if (hostPausePlugin != null)
{
((BaseUnityPlugin)hostPausePlugin).Logger.LogWarning((object)"Ignoring pause request because the game is not in a playable match state.");
}
return;
}
PauseMenu.Unpause();
if (flag)
{
ApplyPauseLocal(paused: true);
PublishSteamLobbyPauseState("1");
}
else
{
BeginResumeCountdownLocal();
PublishSteamLobbyPauseState("2");
}
}
private static void ReturnToLobbyFromPauseMenu()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Invalid comparison between Unknown and I4
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Invalid comparison between Unknown and I4
if (!NetworkServer.active)
{
return;
}
MatchState matchState = CourseManager.MatchState;
if ((int)matchState < 1 || (int)matchState > 6)
{
HostPausePlugin hostPausePlugin = instance;
if (hostPausePlugin != null)
{
((BaseUnityPlugin)hostPausePlugin).Logger.LogWarning((object)"Ignoring Back to Lobby request because no course is currently active.");
}
return;
}
PauseMenu.Unpause();
PublishSteamLobbyPauseState("0");
ForceLocalResume();
CourseManager.EndCourse();
HostPausePlugin hostPausePlugin2 = instance;
if (hostPausePlugin2 != null)
{
((BaseUnityPlugin)hostPausePlugin2).Logger.LogInfo((object)"Host requested return to lobby through the native course end flow.");
}
}
private static void PublishSteamLobbyPauseState(bool paused)
{
PublishSteamLobbyPauseState(paused ? "1" : "0");
}
private static void PublishSteamLobbyPauseState(string state)
{
Lobby val = default(Lobby);
if (NetworkServer.active && BNetworkManager.TryGetSteamLobby(ref val))
{
((Lobby)(ref val)).SetData("codex_hostpause_state", state);
((Lobby)(ref val)).SetData("codex_hostpause_version", Time.unscaledTime.ToString("R"));
}
}
private static void ApplyPauseLocal(bool paused)
{
if (paused)
{
if (!CanApplyPauseState())
{
pendingRemotePause = true;
ForceLocalResume();
return;
}
if (!ShouldBlockGameplay())
{
FreezeRigidbodies();
CancelPausedPlayerActions();
ShowPauseBanner();
ApplyPauseDances();
}
else if (isResumeCountdownActive)
{
instance?.StopResumeCountdown();
CancelPausedPlayerActions();
ShowPauseBanner();
ApplyPauseDances();
}
isPaused = true;
}
else
{
instance?.StopResumeCountdown();
pendingRemotePause = false;
isResumeCountdownActive = false;
isPaused = false;
RestorePauseDances();
RestoreRigidbodies();
RestorePauseBanner();
}
instance?.RefreshPauseButton();
}
private static void BeginResumeCountdownLocal()
{
if (!ShouldBlockGameplay())
{
ApplyPauseLocal(paused: false);
}
else if (!CanApplyPauseState())
{
ApplyPauseLocal(paused: false);
}
else
{
instance?.StartResumeCountdown();
}
}
private void StartResumeCountdown()
{
StopResumeCountdown();
resumeCountdownRoutine = ((MonoBehaviour)this).StartCoroutine(ResumeCountdownRoutine());
}
private void StopResumeCountdown()
{
if (resumeCountdownRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(resumeCountdownRoutine);
resumeCountdownRoutine = null;
}
if (isResumeCountdownActive)
{
TeeOffCountdown.Hide();
}
isResumeCountdownActive = false;
}
private IEnumerator ResumeCountdownRoutine()
{
isResumeCountdownActive = true;
pendingRemotePause = false;
RestorePauseDances();
RestorePauseBanner();
float remainingTime = GetResumeCountdownDuration();
TeeOffCountdown.Show();
while (remainingTime > 0f && isPaused && CanApplyPauseState())
{
TeeOffCountdown.SetRemainingTime(remainingTime);
remainingTime -= Time.unscaledDeltaTime;
yield return null;
}
TeeOffCountdown.SetRemainingTime(0f);
TeeOffCountdown.Hide();
resumeCountdownRoutine = null;
isResumeCountdownActive = false;
ApplyPauseLocal(paused: false);
if (NetworkServer.active)
{
PublishSteamLobbyPauseState("0");
}
}
private static float GetResumeCountdownDuration()
{
float num = (((Object)(object)GameManager.MatchSettings != (Object)null) ? GameManager.MatchSettings.TeeOffCountdownDuration : 3f);
return Mathf.Max(1f, num);
}
private static void ApplyRemotePause(bool paused)
{
ApplyRemotePauseState(paused ? "1" : "0");
}
private static void ApplyRemotePauseState(string state)
{
if (state == "2")
{
pendingRemotePause = false;
BeginResumeCountdownLocal();
}
else if (state != "1")
{
pendingRemotePause = false;
ApplyPauseLocal(paused: false);
}
else if (!CanApplyPauseState())
{
pendingRemotePause = true;
ForceLocalResume();
}
else
{
pendingRemotePause = false;
ApplyPauseLocal(paused: true);
}
}
private static void TryApplyPendingRemotePause()
{
if (pendingRemotePause && !isPaused && CanApplyPauseState())
{
pendingRemotePause = false;
ApplyPauseLocal(paused: true);
}
}
private static void ForceLocalResume()
{
instance?.StopResumeCountdown();
isPaused = false;
isResumeCountdownActive = false;
RestorePauseDances();
RestoreRigidbodies();
RestorePauseBanner();
instance?.RefreshPauseButton();
}
private static bool ShouldBlockGameplay()
{
return isPaused;
}
private static bool CanApplyPauseState()
{
//IL_003f: 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_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Invalid comparison between Unknown and I4
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Invalid comparison between Unknown and I4
if (!NetworkServer.active && (!NetworkClient.active || NetworkClient.connection == null || !((NetworkConnection)NetworkClient.connection).isAuthenticated))
{
return false;
}
if ((Object)(object)GameManager.LocalPlayerInfo == (Object)null || (Object)(object)GameManager.LocalPlayerMovement == (Object)null)
{
return false;
}
MatchState matchState = CourseManager.MatchState;
if ((int)matchState >= 1)
{
return (int)matchState < 6;
}
return false;
}
private static void ShowPauseBanner()
{
AheadOfBallMessage aheadOfBallMessage = GetAheadOfBallMessage();
if ((Object)(object)aheadOfBallMessage == (Object)null)
{
return;
}
if (!pauseBannerApplied)
{
aheadBannerWasVisibleBeforePause = GetAheadBannerVisible(aheadOfBallMessage);
pauseBannerOriginalTexts.Clear();
pauseBannerDisabledLocalizers.Clear();
LocalizeStringEvent[] componentsInChildren = ((Component)aheadOfBallMessage).GetComponentsInChildren<LocalizeStringEvent>(true);
foreach (LocalizeStringEvent val in componentsInChildren)
{
if (((Behaviour)val).enabled)
{
((Behaviour)val).enabled = false;
pauseBannerDisabledLocalizers.Add(val);
}
}
TMP_Text[] componentsInChildren2 = ((Component)aheadOfBallMessage).GetComponentsInChildren<TMP_Text>(true);
foreach (TMP_Text val2 in componentsInChildren2)
{
pauseBannerOriginalTexts[val2] = val2.text;
val2.text = "Game Paused";
}
pauseBannerApplied = true;
}
else
{
foreach (TMP_Text key in pauseBannerOriginalTexts.Keys)
{
if ((Object)(object)key != (Object)null)
{
key.text = "Game Paused";
}
}
}
AheadOfBallMessage.Show();
}
private static void RestorePauseBanner()
{
if (!pauseBannerApplied)
{
return;
}
foreach (KeyValuePair<TMP_Text, string> pauseBannerOriginalText in pauseBannerOriginalTexts)
{
if ((Object)(object)pauseBannerOriginalText.Key != (Object)null)
{
pauseBannerOriginalText.Key.text = pauseBannerOriginalText.Value;
}
}
foreach (LocalizeStringEvent pauseBannerDisabledLocalizer in pauseBannerDisabledLocalizers)
{
if ((Object)(object)pauseBannerDisabledLocalizer != (Object)null)
{
((Behaviour)pauseBannerDisabledLocalizer).enabled = true;
}
}
pauseBannerOriginalTexts.Clear();
pauseBannerDisabledLocalizers.Clear();
pauseBannerApplied = false;
if (aheadBannerWasVisibleBeforePause)
{
AheadOfBallMessage.Show();
}
else
{
AheadOfBallMessage.Hide();
}
}
private static void DrawPauseOverlay()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
if (ShouldBlockGameplay() && !isResumeCountdownActive)
{
EnsurePauseOverlayStyles();
float num = Mathf.Min(520f, (float)Screen.width - 48f);
float num2 = 132f;
Rect val = default(Rect);
((Rect)(ref val))..ctor(((float)Screen.width - num) * 0.5f, 42f, num, num2);
GUI.Box(val, GUIContent.none, pauseOverlayBoxStyle);
GUI.Label(new Rect(((Rect)(ref val)).x + 24f, ((Rect)(ref val)).y + 20f, ((Rect)(ref val)).width - 48f, 42f), "Game Paused", pauseOverlayTitleStyle);
GUI.Label(new Rect(((Rect)(ref val)).x + 24f, ((Rect)(ref val)).y + 70f, ((Rect)(ref val)).width - 48f, 42f), NetworkServer.active ? "Host pause is active" : "Waiting for the host to resume", pauseOverlayDetailStyle);
}
}
private static void EnsurePauseOverlayStyles()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
//IL_0031: 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_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: 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_0077: Expected O, but got Unknown
//IL_0077: 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)
//IL_008a: Expected O, but got Unknown
//IL_008f: Expected O, but got Unknown
//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_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Expected O, but got Unknown
//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_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Expected O, but got Unknown
if (pauseOverlayBoxStyle == null)
{
pauseOverlayTexture = new Texture2D(1, 1, (TextureFormat)4, false);
pauseOverlayTexture.SetPixel(0, 0, new Color(0.05f, 0.1f, 0.12f, 0.88f));
pauseOverlayTexture.Apply();
GUIStyle val = new GUIStyle(GUI.skin.box);
val.normal.background = pauseOverlayTexture;
val.border = new RectOffset(12, 12, 12, 12);
val.padding = new RectOffset(18, 18, 14, 14);
pauseOverlayBoxStyle = val;
GUIStyle val2 = new GUIStyle(GUI.skin.label)
{
alignment = (TextAnchor)4,
fontSize = Mathf.Clamp(Screen.height / 22, 28, 44),
fontStyle = (FontStyle)1
};
val2.normal.textColor = Color.white;
pauseOverlayTitleStyle = val2;
GUIStyle val3 = new GUIStyle(GUI.skin.label)
{
alignment = (TextAnchor)4,
fontSize = Mathf.Clamp(Screen.height / 42, 16, 24),
fontStyle = (FontStyle)1
};
val3.normal.textColor = new Color(0.82f, 0.95f, 1f, 1f);
pauseOverlayDetailStyle = val3;
}
}
private static void DestroyPauseOverlayStyles()
{
if ((Object)(object)pauseOverlayTexture != (Object)null)
{
Object.Destroy((Object)(object)pauseOverlayTexture);
pauseOverlayTexture = null;
}
pauseOverlayBoxStyle = null;
pauseOverlayTitleStyle = null;
pauseOverlayDetailStyle = null;
}
private static AheadOfBallMessage GetAheadOfBallMessage()
{
if (SingletonBehaviour<AheadOfBallMessage>.HasInstance)
{
return SingletonBehaviour<AheadOfBallMessage>.Instance;
}
return Object.FindFirstObjectByType<AheadOfBallMessage>((FindObjectsInactive)1);
}
private static bool GetAheadBannerVisible(AheadOfBallMessage banner)
{
object obj = AccessTools.Field(typeof(AheadOfBallMessage), "isVisible")?.GetValue(banner);
bool flag = default(bool);
int num;
if (obj is bool)
{
flag = (bool)obj;
num = 1;
}
else
{
num = 0;
}
return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
}
private static void FreezeRigidbodies()
{
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: 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_006a: Unknown result type (might be due to invalid IL or missing references)
frozenRigidbodies.Clear();
Rigidbody[] array = Object.FindObjectsByType<Rigidbody>((FindObjectsSortMode)0);
foreach (Rigidbody val in array)
{
if (!((Object)(object)val == (Object)null))
{
frozenRigidbodies.Add(new RigidbodySnapshot
{
Body = val,
IsKinematic = val.isKinematic,
UseGravity = val.useGravity,
DetectCollisions = val.detectCollisions,
LinearVelocity = val.linearVelocity,
AngularVelocity = val.angularVelocity
});
FreezeRigidbody(val);
}
}
}
private static void MaintainFrozenRigidbodies()
{
foreach (RigidbodySnapshot frozenRigidbody in frozenRigidbodies)
{
if ((Object)(object)frozenRigidbody.Body != (Object)null)
{
FreezeRigidbody(frozenRigidbody.Body);
}
}
}
private static void FreezeRigidbody(Rigidbody body)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
body.linearVelocity = Vector3.zero;
body.angularVelocity = Vector3.zero;
body.isKinematic = true;
}
private static void RestoreRigidbodies()
{
//IL_0053: 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)
foreach (RigidbodySnapshot frozenRigidbody in frozenRigidbodies)
{
Rigidbody body = frozenRigidbody.Body;
if (!((Object)(object)body == (Object)null))
{
body.useGravity = frozenRigidbody.UseGravity;
body.detectCollisions = frozenRigidbody.DetectCollisions;
body.isKinematic = frozenRigidbody.IsKinematic;
if (!body.isKinematic)
{
body.linearVelocity = frozenRigidbody.LinearVelocity;
body.angularVelocity = frozenRigidbody.AngularVelocity;
}
}
}
frozenRigidbodies.Clear();
}
private static void CancelPausedPlayerActions()
{
PlayerInput[] array = Object.FindObjectsByType<PlayerInput>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
ClearPausedInput(array[i]);
}
PlayerInfo[] array2 = Object.FindObjectsByType<PlayerInfo>((FindObjectsSortMode)0);
for (int i = 0; i < array2.Length; i++)
{
ClearPausedPlayerState(array2[i]);
}
SwingPowerBarUi.CancelSwingCharge();
}
private static void ClearPausedInput(PlayerInput input)
{
if (!((Object)(object)input == (Object)null))
{
playerInputHoldingAimSwingField?.SetValue(input, false);
playerInputHoldingChargeSwingField?.SetValue(input, false);
object? obj = playerInputPlayerInfoField?.GetValue(input);
ClearPausedPlayerState((PlayerInfo)((obj is PlayerInfo) ? obj : null));
}
}
private static void ClearPausedPlayerState(PlayerInfo player)
{
if (!((Object)(object)player == (Object)null))
{
player.SetIsAimingSwing(false);
player.SetIsAimingItem(false);
}
}
private static void ApplyPauseDances()
{
PlayerInfo[] array = Object.FindObjectsByType<PlayerInfo>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
ApplyPauseDance(array[i]);
}
}
private static void MaintainPauseDances()
{
PlayerInfo[] array = Object.FindObjectsByType<PlayerInfo>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
ApplyPauseDance(array[i]);
}
}
private static void ApplyPauseDance(PlayerInfo player)
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
if (CanPauseDance(player))
{
PlayerAnimatorIo animatorIo = player.AnimatorIo;
if (!pauseDanceOriginalValues.ContainsKey(animatorIo))
{
pauseDanceOriginalValues[animatorIo] = GetCurrentVictoryDanceValue(animatorIo);
}
animatorIo.SetVictoryDance(player.Cosmetics.victoryDance);
}
}
private static bool CanPauseDance(PlayerInfo player)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Invalid comparison between Unknown and I4
if ((Object)(object)player == (Object)null || (Object)(object)player.AnimatorIo == (Object)null || (Object)(object)player.Cosmetics == (Object)null || (Object)(object)player.AsGolfer == (Object)null)
{
return false;
}
return (int)player.AsGolfer.MatchResolution == 0;
}
private static int GetCurrentVictoryDanceValue(PlayerAnimatorIo animatorIo)
{
object? obj = animatorField?.GetValue(animatorIo);
Animator val = (Animator)((obj is Animator) ? obj : null);
if ((Object)(object)val == (Object)null)
{
return 0;
}
int num = ((victoryDanceHashField?.GetValue(null) is int num2 && num2 != 0) ? num2 : Animator.StringToHash("Victory dance"));
return val.GetInteger(num);
}
private static void RestorePauseDances()
{
foreach (KeyValuePair<PlayerAnimatorIo, int> pauseDanceOriginalValue in pauseDanceOriginalValues)
{
if ((Object)(object)pauseDanceOriginalValue.Key != (Object)null)
{
pauseDanceOriginalValue.Key.SetVictoryDance((VictoryDance)pauseDanceOriginalValue.Value);
}
}
pauseDanceOriginalValues.Clear();
}
private void AddPauseButton(PauseMenu pauseMenu)
{
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Expected O, but got Unknown
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Expected O, but got Unknown
//IL_0090: 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: Expected O, but got Unknown
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Expected O, but got Unknown
if ((Object)(object)pauseMenu == (Object)null || (Object)(object)pauseMenu.menuButtonContainer == (Object)null || (Object)(object)pauseButton != (Object)null)
{
return;
}
Button val = FindPauseButtonTemplate(pauseMenu);
if ((Object)(object)val == (Object)null)
{
((BaseUnityPlugin)this).Logger.LogWarning((object)"Could not find a pause menu button to clone for Host Pause.");
return;
}
pauseButton = CreateHostPauseMenuButton(val, "HostPauseButton", ((Component)val).transform.GetSiblingIndex() + 1);
pauseButton.onClick = new ButtonClickedEvent();
ButtonClickedEvent onClick = pauseButton.onClick;
object obj = <>O.<0>__TogglePauseFromPauseMenu;
if (obj == null)
{
UnityAction val2 = TogglePauseFromPauseMenu;
<>O.<0>__TogglePauseFromPauseMenu = val2;
obj = (object)val2;
}
((UnityEvent)onClick).AddListener((UnityAction)obj);
pauseButtonLabel = ((Component)pauseButton).GetComponentInChildren<TMP_Text>(true);
backToLobbyButton = CreateHostPauseMenuButton(val, "HostPauseBackToLobbyButton", ((Component)val).transform.GetSiblingIndex() + 2);
backToLobbyButton.onClick = new ButtonClickedEvent();
ButtonClickedEvent onClick2 = backToLobbyButton.onClick;
object obj2 = <>O.<1>__ReturnToLobbyFromPauseMenu;
if (obj2 == null)
{
UnityAction val3 = ReturnToLobbyFromPauseMenu;
<>O.<1>__ReturnToLobbyFromPauseMenu = val3;
obj2 = (object)val3;
}
((UnityEvent)onClick2).AddListener((UnityAction)obj2);
backToLobbyButtonLabel = ((Component)backToLobbyButton).GetComponentInChildren<TMP_Text>(true);
RefreshPauseButton();
RefreshPauseMenuButtonList(pauseMenu);
FitPauseMenuButtonStack(pauseMenu);
}
private static Button CreateHostPauseMenuButton(Button templateButton, string objectName, int siblingIndex)
{
GameObject val = Object.Instantiate<GameObject>(((Component)templateButton).gameObject, ((Component)templateButton).transform.parent);
((Object)val).name = objectName;
val.transform.SetSiblingIndex(siblingIndex);
LocalizeStringEvent[] componentsInChildren = val.GetComponentsInChildren<LocalizeStringEvent>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
((Behaviour)componentsInChildren[i]).enabled = false;
}
return val.GetComponent<Button>();
}
private static Button FindPauseButtonTemplate(PauseMenu pauseMenu)
{
Button[] componentsInChildren = pauseMenu.menuButtonContainer.GetComponentsInChildren<Button>(true);
Button[] array = componentsInChildren;
foreach (Button val in array)
{
TMP_Text componentInChildren = ((Component)val).GetComponentInChildren<TMP_Text>(true);
if ((Object)(object)componentInChildren != (Object)null && componentInChildren.text.Trim().Equals("Settings", StringComparison.OrdinalIgnoreCase))
{
return val;
}
}
int num = Array.IndexOf(componentsInChildren, pauseMenu.exitGameButton);
if (num > 0)
{
return componentsInChildren[num - 1];
}
if (!((Object)(object)pauseMenu.exitGameButton != (Object)null))
{
return pauseMenu.resumeButton;
}
return pauseMenu.exitGameButton;
}
private static void RefreshPauseMenuButtonList(PauseMenu pauseMenu)
{
Button[] componentsInChildren = pauseMenu.menuButtonContainer.GetComponentsInChildren<Button>(true);
AccessTools.Field(typeof(PauseMenu), "allButtons")?.SetValue(pauseMenu, componentsInChildren);
AccessTools.Method(typeof(PauseMenu), "UpdateButtonOffsets", (Type[])null, (Type[])null)?.Invoke(pauseMenu, null);
}
private static void FitPauseMenuButtonStack(PauseMenu pauseMenu)
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: 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_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
RectTransform component = pauseMenu.menuButtonContainer.GetComponent<RectTransform>();
if (!((Object)(object)component == (Object)null))
{
if (!pauseMenuStackAdjusted)
{
pauseMenuOriginalScale = ((Transform)component).localScale;
pauseMenuOriginalAnchoredPosition = component.anchoredPosition;
pauseMenuStackAdjusted = true;
}
((Transform)component).localScale = new Vector3(pauseMenuOriginalScale.x * 0.78f, pauseMenuOriginalScale.y * 0.78f, pauseMenuOriginalScale.z);
component.anchoredPosition = pauseMenuOriginalAnchoredPosition + new Vector2(0f, 58f);
}
}
private void RefreshPauseButton()
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Invalid comparison between Unknown and I4
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Invalid comparison between Unknown and I4
if (!((Object)(object)pauseButton == (Object)null))
{
bool active = NetworkServer.active;
((Selectable)pauseButton).interactable = active;
if ((Object)(object)pauseButtonLabel != (Object)null)
{
pauseButtonLabel.text = (active ? GetHostPauseButtonLabel() : "Host Pause Only");
}
if ((Object)(object)backToLobbyButton != (Object)null)
{
bool interactable = active && (int)CourseManager.MatchState >= 1 && (int)CourseManager.MatchState <= 6;
((Selectable)backToLobbyButton).interactable = interactable;
}
if ((Object)(object)backToLobbyButtonLabel != (Object)null)
{
backToLobbyButtonLabel.text = (active ? "Back to Lobby" : "Host Only");
}
}
}
private static string GetHostPauseButtonLabel()
{
if (ShouldBlockGameplay())
{
return "Resume Game";
}
return "Pause Game";
}
private static bool AllowPausedInputAction(PlayerInput input)
{
if (!ShouldBlockGameplay())
{
return true;
}
ClearPausedInput(input);
return false;
}
}
}
