using System;
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]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.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.1")]
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;
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;
nextLobbyPollTime = 0f;
pendingRemotePause = false;
ForceLocalResume();
}
}
[HarmonyPatch(typeof(PlayerMovement), "Update")]
private static class PlayerMovementUpdatePatch
{
private static bool Prefix()
{
return !isPaused;
}
}
[HarmonyPatch(typeof(PlayerMovement), "FixedUpdate")]
private static class PlayerMovementFixedUpdatePatch
{
private static bool Prefix()
{
return !isPaused;
}
}
[HarmonyPatch(typeof(GolfBall), "UpdatePhysics")]
private static class GolfBallUpdatePhysicsPatch
{
private static bool Prefix()
{
return !isPaused;
}
}
[CompilerGenerated]
private static class <>O
{
public static UnityAction <0>__TogglePauseFromPauseMenu;
}
private const string PluginGuid = "codex.superbattlegolf.hostpause";
private const string PluginName = "Host Pause";
private const string PluginVersion = "0.2.1";
private const string LobbyPauseStateKey = "codex_hostpause_state";
private const string LobbyPauseVersionKey = "codex_hostpause_version";
private static HostPausePlugin instance;
private static bool isPaused;
private static string lastObservedLobbyPauseVersion = string.Empty;
private static float nextLobbyPollTime;
private static bool pendingRemotePause;
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 Harmony harmony;
private Button pauseButton;
private TMP_Text pauseButtonLabel;
private void Awake()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
instance = this;
harmony = new Harmony("codex.superbattlegolf.hostpause");
harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"Host Pause 0.2.1 loaded.");
}
private void OnDestroy()
{
ForceLocalResume();
Harmony obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
if (instance == this)
{
instance = null;
}
}
private void Update()
{
if (isPaused)
{
if (!CanApplyPauseState())
{
ForceLocalResume();
return;
}
MaintainFrozenRigidbodies();
ShowPauseBanner();
}
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 || !CanApplyPauseState() || Time.unscaledTime < nextLobbyPollTime)
{
return;
}
nextLobbyPollTime = Time.unscaledTime + 0.5f;
Lobby val = default(Lobby);
if (BNetworkManager.TryGetSteamLobby(ref val))
{
string data = ((Lobby)(ref val)).GetData("codex_hostpause_version");
if (!string.IsNullOrEmpty(data) && !(data == lastObservedLobbyPauseVersion))
{
lastObservedLobbyPauseVersion = data;
ApplyRemotePause(((Lobby)(ref val)).GetData("codex_hostpause_state") == "1");
}
}
}
private static void TogglePauseFromPauseMenu()
{
if (!NetworkServer.active)
{
return;
}
bool flag = !isPaused;
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.");
}
}
else
{
PauseMenu.Unpause();
ApplyPauseLocal(flag);
PublishSteamLobbyPauseState(flag);
}
}
private static void PublishSteamLobbyPauseState(bool paused)
{
Lobby val = default(Lobby);
if (NetworkServer.active && BNetworkManager.TryGetSteamLobby(ref val))
{
((Lobby)(ref val)).SetData("codex_hostpause_state", paused ? "1" : "0");
((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 (!isPaused)
{
FreezeRigidbodies();
ShowPauseBanner();
}
isPaused = true;
}
else
{
pendingRemotePause = false;
isPaused = false;
RestoreRigidbodies();
RestorePauseBanner();
}
instance?.RefreshPauseButton();
}
private static void ApplyRemotePause(bool paused)
{
if (!paused)
{
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()
{
isPaused = false;
RestoreRigidbodies();
RestorePauseBanner();
instance?.RefreshPauseButton();
}
private static bool CanApplyPauseState()
{
//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_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Invalid comparison between Unknown and I4
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Invalid comparison between Unknown and I4
if (!NetworkServer.active && (!NetworkClient.active || NetworkClient.connection == null || !((NetworkConnection)NetworkClient.connection).isAuthenticated))
{
return false;
}
if (!SingletonBehaviour<PauseMenu>.HasInstance)
{
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 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 void AddPauseButton(PauseMenu pauseMenu)
{
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Expected O, but got Unknown
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: 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;
}
GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent);
((Object)val2).name = "HostPauseButton";
val2.transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex() + 1);
LocalizeStringEvent[] componentsInChildren = val2.GetComponentsInChildren<LocalizeStringEvent>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
((Behaviour)componentsInChildren[i]).enabled = false;
}
pauseButton = val2.GetComponent<Button>();
pauseButton.onClick = new ButtonClickedEvent();
ButtonClickedEvent onClick = pauseButton.onClick;
object obj = <>O.<0>__TogglePauseFromPauseMenu;
if (obj == null)
{
UnityAction val3 = TogglePauseFromPauseMenu;
<>O.<0>__TogglePauseFromPauseMenu = val3;
obj = (object)val3;
}
((UnityEvent)onClick).AddListener((UnityAction)obj);
pauseButtonLabel = val2.GetComponentInChildren<TMP_Text>(true);
RefreshPauseButton();
RefreshPauseMenuButtonList(pauseMenu);
FitPauseMenuButtonStack(pauseMenu);
}
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.88f, pauseMenuOriginalScale.y * 0.88f, pauseMenuOriginalScale.z);
component.anchoredPosition = pauseMenuOriginalAnchoredPosition + new Vector2(0f, 26f);
}
}
private void RefreshPauseButton()
{
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");
}
}
}
private static string GetHostPauseButtonLabel()
{
if (isPaused)
{
return "Resume Game";
}
return "Pause Game";
}
}
}
