using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using OneForAll.Heal.Patches;
using OneForAll.Horn.Coroutines;
using OneForAll.Horn.Manager;
using OneForAll.MiniMap.Component;
using OneForAll.MiniMap.Patches;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("OneForAllDEV")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("OneForAllDEV")]
[assembly: AssemblyTitle("OneForAllDEV")]
[assembly: AssemblyVersion("1.0.0.0")]
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 Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace OneForAll.Skip
{
[BepInPlugin("FraZy.OneForAll.Skip", "OneForAll.Skip", "1.0.3")]
public class Plugin : BaseUnityPlugin
{
private Harmony _harmony;
private static Plugin instance;
private void Awake()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
instance = this;
_harmony = new Harmony("FraZy.OneForAll.Skip");
_harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"OneForAll.Skip loaded");
}
public static void Log(string message)
{
((BaseUnityPlugin)instance).Logger.LogInfo((object)message);
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "FraZy.OneForAll.Skip";
public const string PLUGIN_NAME = "OneForAll.Skip";
public const string PLUGIN_VERSION = "1.0.3";
}
}
namespace OneForAll.Skip.Patches
{
[HarmonyPatch]
internal class SkipToMultiplayerMenuPatcher
{
private static bool skippedPreInitScene;
private static bool skippedInitScene;
[HarmonyPatch(typeof(PreInitSceneScript), "Awake")]
[HarmonyPrefix]
public static bool InitializeGameManager()
{
if (skippedPreInitScene)
{
return true;
}
skippedPreInitScene = true;
Plugin.Log("Loading GameManager in InitScene.");
SceneManager.LoadScene("InitScene");
return false;
}
[HarmonyPatch(typeof(InitializeGame), "Start")]
[HarmonyPrefix]
public static bool LoadMultiplayerMenuScene()
{
if (skippedInitScene)
{
return true;
}
skippedInitScene = true;
Plugin.Log("Skipping to Multiplayer MainMenu scene.");
SceneManager.LoadScene("MainMenu");
return false;
}
}
}
namespace OneForAll.Restart
{
[BepInPlugin("FraZy-OneForAll.Restart", "OneForAll.Restart", "1.0.3")]
public class Plugin : BaseUnityPlugin
{
public static bool verifying;
private ConfigEntry<bool> overrideConfirmation;
public static bool bypassConfirm;
private Harmony harmony;
private static MethodInfo chat;
private void Awake()
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
overrideConfirmation = ((BaseUnityPlugin)this).Config.Bind<bool>("Config", "Override Confirmation", true, "Ignore the confirmation step of restarting.");
bypassConfirm = overrideConfirmation.Value;
harmony = new Harmony("FraZy-OneForAll.Restart");
harmony.PatchAll();
chat = AccessTools.Method(typeof(HUDManager), "AddChatMessage", (Type[])null, (Type[])null);
((BaseUnityPlugin)this).Logger.LogInfo((object)"OneForAll.Restart loaded!");
}
public static void SendChatMessage(string message)
{
chat?.Invoke(HUDManager.Instance, new object[2] { message, "" });
HUDManager.Instance.lastChatMessage = "";
}
public static void ConfirmRestart()
{
verifying = true;
SendChatMessage("Are you sure? Type CONFIRM or DENY.");
}
public static void AcceptRestart(StartOfRound manager)
{
SendChatMessage("Restarting Soon...Please Wait...");
verifying = false;
int[] array = new int[4]
{
manager.gameStats.daysSpent,
manager.gameStats.scrapValueCollected,
manager.gameStats.deaths,
manager.gameStats.allStepsTaken
};
manager.FirePlayersAfterDeadlineClientRpc(array, false);
}
public static void DeclineRestart()
{
SendChatMessage("Restart aborted. You Scared?");
verifying = false;
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "OneForAll.Restart";
public const string PLUGIN_NAME = "OneForAll.Restart";
public const string PLUGIN_VERSION = "1.0.3";
}
}
namespace OneForAll.Restart.Patches
{
[HarmonyPatch(typeof(HUDManager), "SubmitChat_performed")]
public class SubmitChat
{
private static bool Prefix(HUDManager __instance, ref CallbackContext context)
{
if (!((CallbackContext)(ref context)).performed || string.IsNullOrEmpty(__instance.chatTextField.text))
{
return true;
}
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if ((Object)(object)localPlayerController == (Object)null)
{
return true;
}
StartOfRound playersManager = localPlayerController.playersManager;
if ((Object)(object)playersManager == (Object)null)
{
return true;
}
string text = __instance.chatTextField.text;
if (Plugin.verifying)
{
if (text.ToLower() == "confirm")
{
ResetTextbox(__instance, localPlayerController);
if (!localPlayerController.isInHangarShipRoom || !playersManager.inShipPhase || playersManager.travellingToNewLevel)
{
Plugin.SendChatMessage("nice try! you can't restart session on a planet, please ship back to orbit.");
return false;
}
Plugin.AcceptRestart(playersManager);
return false;
}
if (text.ToLower() == "deny")
{
return true;
}
ResetTextbox(__instance, localPlayerController);
Plugin.DeclineRestart();
return false;
}
if (text == "!restart")
{
return true;
}
ResetTextbox(__instance, localPlayerController);
if (!GameNetworkManager.Instance.isHostingGame)
{
Plugin.SendChatMessage("quiting already? ask the host to restart lobby. type /restart or !restart");
return false;
}
if (!localPlayerController.isInHangarShipRoom || !playersManager.inShipPhase || playersManager.travellingToNewLevel)
{
Plugin.SendChatMessage("Cannot restart, ship must be in orbit.");
return false;
}
if (Plugin.bypassConfirm)
{
Plugin.AcceptRestart(playersManager);
}
else
{
Plugin.ConfirmRestart();
}
return false;
}
private static void ResetTextbox(HUDManager manager, PlayerControllerB local)
{
local.isTypingChat = false;
manager.chatTextField.text = "";
EventSystem.current.SetSelectedGameObject((GameObject)null);
manager.PingHUDElement(manager.Chat, 2f, 1f, 0.2f);
((Behaviour)manager.typingIndicator).enabled = false;
}
}
}
namespace OneForAll.Remover
{
[HarmonyPatch(typeof(HUDManager), "DisplayTip")]
public static class DisplayTipPatch
{
public static bool Prefix(HUDManager __instance, string headerText, string bodyText, bool isWarning = false, bool useSave = false, string prefsKey = "LC_Tip1")
{
if (headerText.StartsWith("Mod List"))
{
return false;
}
return true;
}
}
public static class PluginInfo
{
private const string GUID = "FraZy.OneForAll.Remover";
private const string NAME = "OneForAll.Remover";
private const string VERSION = "1.0.3";
}
}
namespace OneForAll.Remover.Patches
{
internal class Patches
{
private static ManualLogSource Logger { get; set; }
public static void Init(ManualLogSource logger)
{
Logger = logger;
}
}
}
namespace OneForAll.MiniMap
{
public class HostSettingsToSync
{
public bool ShowLoots { get; set; }
public bool ShowEnemies { get; set; }
public bool ShowLivePlayers { get; set; }
public bool ShowDeadPlayers { get; set; }
public bool ShowRadarBoosters { get; set; }
public bool ShowTerminalCodes { get; set; }
public HostSettingsToSync()
{
ShowLoots = true;
ShowEnemies = true;
ShowLivePlayers = true;
ShowDeadPlayers = true;
ShowRadarBoosters = true;
ShowTerminalCodes = true;
}
public void Sync()
{
MinimapMod.minimapGUI.showLoots = ShowLoots;
MinimapMod.minimapGUI.showEnemies = ShowEnemies;
MinimapMod.minimapGUI.showLivePlayers = ShowLivePlayers;
MinimapMod.minimapGUI.showDeadPlayers = ShowDeadPlayers;
MinimapMod.minimapGUI.showRadarBoosters = ShowRadarBoosters;
MinimapMod.minimapGUI.showTerminalCodes = ShowTerminalCodes;
}
public bool IsSync()
{
return MinimapMod.minimapGUI.showLoots == ShowLoots && MinimapMod.minimapGUI.showEnemies == ShowEnemies && MinimapMod.minimapGUI.showLivePlayers == ShowLivePlayers && MinimapMod.minimapGUI.showDeadPlayers == ShowDeadPlayers && MinimapMod.minimapGUI.showRadarBoosters == ShowRadarBoosters && MinimapMod.minimapGUI.showTerminalCodes == ShowTerminalCodes;
}
public static HostSettingsToSync Parse(string data)
{
if (string.IsNullOrEmpty(data))
{
return null;
}
string[] array = data.Split(';');
if (array.Length != 6)
{
return null;
}
HostSettingsToSync hostSettingsToSync = new HostSettingsToSync();
HashSet<string> hashSet = new HashSet<string> { "loots", "enemies", "livePlayers", "deadPlayers", "radarBoosters", "terminalCodes" };
string[] array2 = array;
foreach (string text in array2)
{
char[] separator = new char[1] { '=' };
string[] array3 = text.Split(separator);
if (array3.Length != 2)
{
return null;
}
string text2 = array3[0].Trim();
string text3 = array3[1].Trim();
if (!hashSet.Remove(text2))
{
return null;
}
string text4 = text3;
string text5 = text4;
bool flag;
if (!(text5 == "show"))
{
if (!(text5 == "hide"))
{
return null;
}
flag = false;
}
else
{
flag = true;
}
switch (text2)
{
case "loots":
hostSettingsToSync.ShowLoots = flag;
break;
case "enemies":
hostSettingsToSync.ShowEnemies = flag;
break;
case "livePlayers":
hostSettingsToSync.ShowLivePlayers = flag;
break;
case "deadPlayers":
hostSettingsToSync.ShowDeadPlayers = flag;
break;
case "radarBoosters":
hostSettingsToSync.ShowRadarBoosters = flag;
break;
case "terminalCodes":
hostSettingsToSync.ShowTerminalCodes = flag;
break;
default:
return null;
}
}
return (hashSet.Count > 0) ? null : hostSettingsToSync;
}
}
public class HotkeyManager
{
public ModHotkey[] AllHotkeys;
public HotkeyManager(int numberOfHotkeys)
{
AllHotkeys = new ModHotkey[numberOfHotkeys];
}
public bool AnyHotkeyIsSettingKey()
{
ModHotkey[] allHotkeys = AllHotkeys;
foreach (ModHotkey modHotkey in allHotkeys)
{
if (modHotkey.IsSettingKey)
{
return true;
}
}
return false;
}
private static MouseAndKeyboard ConvertToExtendedKey(Key key)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
foreach (MouseAndKeyboard value in Enum.GetValues(typeof(MouseAndKeyboard)))
{
if (Enum.GetName(typeof(Key), key) == Enum.GetName(typeof(MouseAndKeyboard), value))
{
return value;
}
}
return MouseAndKeyboard.None;
}
public bool SetHotKey(Key key)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return SetHotKey(ConvertToExtendedKey(key));
}
public bool SetHotKey(MouseAndKeyboard key)
{
ModHotkey[] allHotkeys = AllHotkeys;
foreach (ModHotkey modHotkey in allHotkeys)
{
if (modHotkey.IsSettingKey)
{
modHotkey.Key = key;
ResetIsSettingKey();
return true;
}
}
return false;
}
public void ResetIsSettingKey()
{
ModHotkey[] allHotkeys = AllHotkeys;
foreach (ModHotkey modHotkey in allHotkeys)
{
modHotkey.IsSettingKey = false;
}
}
public void ResetSettingKey()
{
ModHotkey[] allHotkeys = AllHotkeys;
foreach (ModHotkey modHotkey in allHotkeys)
{
modHotkey.IsSettingKey = false;
}
}
public void ResetToDefaultKey()
{
ModHotkey[] allHotkeys = AllHotkeys;
foreach (ModHotkey modHotkey in allHotkeys)
{
modHotkey.Key = modHotkey.DefaultKey;
}
}
public void Update()
{
ModHotkey[] allHotkeys = AllHotkeys;
foreach (ModHotkey modHotkey in allHotkeys)
{
modHotkey.Update();
}
}
}
[BepInPlugin("FraZy.OneForAll.MiniMap", "OneForAll.MiniMap", "1.0.3")]
public class MinimapMod : BaseUnityPlugin
{
public const string modGUID = "FraZy.OneForAll.MiniMap";
public const string modName = "OneForAll.MiniMap";
public const string modVersion = "1.0.3";
public static MouseAndKeyboard defaultGuiKey = MouseAndKeyboard.F1;
public static MouseAndKeyboard defaultToggleMinimapKey = MouseAndKeyboard.F2;
public static MouseAndKeyboard defaultToggleOverrideKey = MouseAndKeyboard.F3;
public static MouseAndKeyboard defaultSwitchTargetKey = MouseAndKeyboard.F4;
public const int defaultMinimapSize = 129;
public const float defaultXoffset = -6.944445f;
public const float defaultYoffset = -6.944445f;
public const float defaultMapZoom = 19.7f;
public const float defaultBrightness = 0f;
private static ConfigEntry<MouseAndKeyboard> guiKeyConfig;
private static ConfigEntry<MouseAndKeyboard> toggleMinimapKeyConfig;
private static ConfigEntry<MouseAndKeyboard> toggleOverrideKeyConfig;
private static ConfigEntry<MouseAndKeyboard> switchTargetKeyConfig;
private static ConfigEntry<bool> enableMinimapConfig;
private static ConfigEntry<bool> autoRotateConfig;
private static ConfigEntry<int> minimapSizeConfig;
private static ConfigEntry<float> minimapXPosConfig;
private static ConfigEntry<float> minimapYPosConfig;
private static ConfigEntry<float> minimapZoomConfig;
private static ConfigEntry<float> brightnessConfig;
private static ConfigEntry<bool> showLootsConfig;
private static ConfigEntry<bool> showEnemiesConfig;
private static ConfigEntry<bool> showLivePlayersConfig;
private static ConfigEntry<bool> showDeadPlayersConfig;
private static ConfigEntry<bool> showRadarBoostersConfig;
private static ConfigEntry<bool> showTerminalCodesConfig;
private static ConfigEntry<bool> showShipArrowConfig;
private static ConfigEntry<bool> freezePlayerIndexConfig;
public static MinimapMod Instance;
public static ManualLogSource mls;
private readonly Harmony harmony = new Harmony("FraZy.OneForAll.MiniMap");
public static MinimapGUI minimapGUI;
private void Awake()
{
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Expected O, but got Unknown
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("FraZy.OneForAll.Minimap");
mls.LogInfo((object)"Minimap 1.0.3 loaded!");
VersionChecker.GetLatestVersionAsync();
harmony.PatchAll(typeof(ManualCameraRendererPatch));
harmony.PatchAll(typeof(QuickMenuManagerPatch));
harmony.PatchAll(typeof(ShipTeleporterPatch));
harmony.PatchAll(typeof(GrabbableObjectPatch));
harmony.PatchAll(typeof(TerminalAccessibleObjectPatch));
harmony.PatchAll(typeof(EnemyAIPatch));
harmony.PatchAll(typeof(OneForAll.MiniMap.Patches.PlayerControllerBPatch));
harmony.PatchAll(typeof(RadarBoosterItemPatch));
harmony.PatchAll(typeof(HUDManagerPatch));
harmony.PatchAll(typeof(TimeOfDayPatch));
harmony.PatchAll(typeof(DeadBodyInfoPatch));
GameObject val = new GameObject("MinimapGUI");
Object.DontDestroyOnLoad((Object)(object)val);
((Object)val).hideFlags = (HideFlags)61;
val.AddComponent<MinimapGUI>();
minimapGUI = (MinimapGUI)(object)val.GetComponent("MinimapGUI");
SetBindings();
SyncGUIFromConfigs();
}
private void SetBindings()
{
guiKeyConfig = ((BaseUnityPlugin)this).Config.Bind<MouseAndKeyboard>("Hotkeys", "Open Mod Menu", defaultGuiKey, "Hotkey to open the Minimap mod menu");
toggleMinimapKeyConfig = ((BaseUnityPlugin)this).Config.Bind<MouseAndKeyboard>("Hotkeys", "Toggle Minimap", defaultToggleMinimapKey, "Hotkey to toggle the visibility of your Minimap");
toggleOverrideKeyConfig = ((BaseUnityPlugin)this).Config.Bind<MouseAndKeyboard>("Hotkeys", "Toggle Override Ship", defaultToggleOverrideKey, "Hotkey to toggle the override ship controls");
switchTargetKeyConfig = ((BaseUnityPlugin)this).Config.Bind<MouseAndKeyboard>("Hotkeys", "Switch Minimap Focus", defaultSwitchTargetKey, "Hotkey to switch the Minimap focus");
enableMinimapConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Basic Settings", "Enable Minimap", true, "Toggles visibility of your Minimap");
autoRotateConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Basic Settings", "Auto Rotate", true, "Auto-rotate the Map based on where you are facing");
minimapSizeConfig = ((BaseUnityPlugin)this).Config.Bind<int>("Basic Settings", "Minimap Size", 129, "Adjusts the size of your Minimap");
minimapXPosConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Basic Settings", "X Offset", -6.944445f, "Shifts the Minimap position horizontally");
minimapYPosConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Basic Settings", "Y Offset", -6.944445f, "Shifts the Minimap position vertically");
minimapZoomConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Basic Settings", "Map Zoom", 19.7f, "Adjust the Map zoom level");
brightnessConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Basic Settings", "Brightness", 0f, "Adjust the brightness level");
showLootsConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Minimap Icons", "Show Loots", true, "Toggles visibility of loots (small triangles) on your Minimap");
showEnemiesConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Minimap Icons", "Show Enemies", true, "Toggles visibility of enemies (red circles) on your Minimap");
showLivePlayersConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Minimap Icons", "Show Live Players", true, "Toggles visibility of live players (cyan circles) on your Minimap");
showDeadPlayersConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Minimap Icons", "Show Dead Players", true, "Toggles visibility of dead players (greyed-out cyan circles) on your Minimap");
showRadarBoostersConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Minimap Icons", "Show Radar Boosters", true, "Toggles visibility of radar boosters (blue circles) on your Minimap");
showTerminalCodesConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Minimap Icons", "Show Terminal Codes", true, "Toggles visibility of terminal codes on your Minimap");
showShipArrowConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Minimap Icons", "Show Ship Arrow", true, "Toggles visibility of the arrow pointing to the Ship");
freezePlayerIndexConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("Advance Settings", "Override Ship Controls", false, "Disables the ability to change the Minimap focus through the ship control panel, allowing Minimap focus changes only through the mod menu");
}
public void SyncGUIFromConfigs()
{
minimapGUI.guiKey.Key = guiKeyConfig.Value;
minimapGUI.toggleMinimapKey.Key = toggleMinimapKeyConfig.Value;
minimapGUI.toggleOverrideKey.Key = toggleOverrideKeyConfig.Value;
minimapGUI.switchTargetKey.Key = switchTargetKeyConfig.Value;
minimapGUI.enableMinimap = enableMinimapConfig.Value;
minimapGUI.autoRotate = autoRotateConfig.Value;
minimapGUI.minimapSize = minimapSizeConfig.Value;
minimapGUI.minimapXPos = minimapXPosConfig.Value;
minimapGUI.minimapYPos = minimapYPosConfig.Value;
minimapGUI.minimapZoom = minimapZoomConfig.Value;
minimapGUI.brightness = brightnessConfig.Value;
minimapGUI.showLoots = showLootsConfig.Value;
minimapGUI.showEnemies = showEnemiesConfig.Value;
minimapGUI.showLivePlayers = showLivePlayersConfig.Value;
minimapGUI.showDeadPlayers = showDeadPlayersConfig.Value;
minimapGUI.showRadarBoosters = showRadarBoostersConfig.Value;
minimapGUI.showTerminalCodes = showTerminalCodesConfig.Value;
minimapGUI.showShipArrow = showShipArrowConfig.Value;
minimapGUI.freezePlayerIndex = freezePlayerIndexConfig.Value;
}
public void SyncConfigFromGUI()
{
guiKeyConfig.Value = minimapGUI.guiKey.Key;
toggleMinimapKeyConfig.Value = minimapGUI.toggleMinimapKey.Key;
toggleOverrideKeyConfig.Value = minimapGUI.toggleOverrideKey.Key;
switchTargetKeyConfig.Value = minimapGUI.switchTargetKey.Key;
enableMinimapConfig.Value = minimapGUI.enableMinimap;
autoRotateConfig.Value = minimapGUI.autoRotate;
minimapSizeConfig.Value = minimapGUI.minimapSize;
minimapXPosConfig.Value = minimapGUI.minimapXPos;
minimapYPosConfig.Value = minimapGUI.minimapYPos;
minimapZoomConfig.Value = minimapGUI.minimapZoom;
brightnessConfig.Value = minimapGUI.brightness;
showLootsConfig.Value = minimapGUI.showLoots;
showEnemiesConfig.Value = minimapGUI.showEnemies;
showLivePlayersConfig.Value = minimapGUI.showLivePlayers;
showDeadPlayersConfig.Value = minimapGUI.showDeadPlayers;
showRadarBoostersConfig.Value = minimapGUI.showRadarBoosters;
showTerminalCodesConfig.Value = minimapGUI.showTerminalCodes;
showShipArrowConfig.Value = minimapGUI.showShipArrow;
freezePlayerIndexConfig.Value = minimapGUI.freezePlayerIndex;
}
}
public class ModHotkey
{
public MouseAndKeyboard DefaultKey { get; set; }
public MouseAndKeyboard Key { get; set; }
public bool KeyWasDown { get; set; }
public bool IsSettingKey { get; set; }
public Action OnKey { get; set; }
public ModHotkey(MouseAndKeyboard defaultKey, Action onKey)
{
DefaultKey = defaultKey;
Key = defaultKey;
KeyWasDown = false;
IsSettingKey = false;
OnKey = onKey;
}
public void Update()
{
Mouse current = Mouse.current;
Keyboard current2 = Keyboard.current;
if (current != null && current2 != null)
{
ButtonControl val = (ButtonControl)(Key switch
{
MouseAndKeyboard.MouseBack => current.backButton,
MouseAndKeyboard.MouseForward => current.forwardButton,
MouseAndKeyboard.MouseRight => current.rightButton,
MouseAndKeyboard.MouseMiddle => current.middleButton,
MouseAndKeyboard.MouseLeft => current.leftButton,
_ => current2[(Key)Key],
});
if (val.wasPressedThisFrame && !KeyWasDown && !IsSettingKey)
{
KeyWasDown = true;
}
if (val.wasReleasedThisFrame && KeyWasDown)
{
KeyWasDown = false;
OnKey?.Invoke();
}
}
}
}
public class ModUser
{
public string Version { get; set; }
public bool Comply { get; set; }
public ModUser(string version = null, bool comply = false)
{
Version = version;
Comply = comply;
}
}
public enum MouseAndKeyboard
{
MouseBack = -5,
MouseForward = -4,
MouseRight = -3,
MouseMiddle = -2,
MouseLeft = -1,
None = 0,
Space = 1,
Enter = 2,
Tab = 3,
Backquote = 4,
Quote = 5,
Semicolon = 6,
Comma = 7,
Period = 8,
Slash = 9,
Backslash = 10,
LeftBracket = 11,
RightBracket = 12,
Minus = 13,
Equals = 14,
A = 15,
B = 16,
C = 17,
D = 18,
E = 19,
F = 20,
G = 21,
H = 22,
I = 23,
J = 24,
K = 25,
L = 26,
M = 27,
N = 28,
O = 29,
P = 30,
Q = 31,
R = 32,
S = 33,
T = 34,
U = 35,
V = 36,
W = 37,
X = 38,
Y = 39,
Z = 40,
Digit1 = 41,
Digit2 = 42,
Digit3 = 43,
Digit4 = 44,
Digit5 = 45,
Digit6 = 46,
Digit7 = 47,
Digit8 = 48,
Digit9 = 49,
Digit0 = 50,
LeftShift = 51,
RightShift = 52,
LeftAlt = 53,
AltGr = 54,
RightAlt = 54,
LeftCtrl = 55,
RightCtrl = 56,
LeftApple = 57,
LeftCommand = 57,
LeftMeta = 57,
LeftWindows = 57,
RightApple = 58,
RightCommand = 58,
RightMeta = 58,
RightWindows = 58,
ContextMenu = 59,
Escape = 60,
LeftArrow = 61,
RightArrow = 62,
UpArrow = 63,
DownArrow = 64,
Backspace = 65,
PageDown = 66,
PageUp = 67,
Home = 68,
End = 69,
Insert = 70,
Delete = 71,
CapsLock = 72,
NumLock = 73,
PrintScreen = 74,
ScrollLock = 75,
Pause = 76,
NumpadEnter = 77,
NumpadDivide = 78,
NumpadMultiply = 79,
NumpadPlus = 80,
NumpadMinus = 81,
NumpadPeriod = 82,
NumpadEquals = 83,
Numpad0 = 84,
Numpad1 = 85,
Numpad2 = 86,
Numpad3 = 87,
Numpad4 = 88,
Numpad5 = 89,
Numpad6 = 90,
Numpad7 = 91,
Numpad8 = 92,
Numpad9 = 93,
F1 = 94,
F2 = 95,
F3 = 96,
F4 = 97,
F5 = 98,
F6 = 99,
F7 = 100,
F8 = 101,
F9 = 102,
F10 = 103,
F11 = 104,
F12 = 105,
OEM1 = 106,
OEM2 = 107,
OEM3 = 108,
OEM4 = 109,
OEM5 = 110,
IMESelected = 111
}
public enum SettingAsHostAction
{
DontSync,
SyncIcons
}
public enum SyncSettingsAction
{
AlwaysAsk,
Allow,
Deny
}
public class VersionChecker
{
public static string latestVersion;
private static async Task<bool> GetVersionFromUrlAsync(string url)
{
using HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("User-Agent", BuildUserAgentString());
try
{
latestVersion = ParseTagNameFromJson(await client.GetStringAsync(url));
return true;
}
catch (Exception ex2)
{
Exception ex = ex2;
MinimapMod.mls.LogError((object)("Failed to get the latest version from " + url + " for Minimap Mod. Error: " + ex.Message));
return false;
}
}
public static async Task GetLatestVersionAsync()
{
string mainUrl = "https://thunderstore.io/c/lethal-company/p/FraZy/OneForAll/versions/";
string fallbackUrl = "https://api.github.com/repos/FraZy";
if (!(await GetVersionFromUrlAsync(mainUrl)) && await GetVersionFromUrlAsync(fallbackUrl))
{
}
}
private static string ParseTagNameFromJson(string jsonString)
{
string text = "\"tag_name\":\"";
int num = jsonString.IndexOf(text);
if (num != -1)
{
int num2 = num + text.Length;
int num3 = jsonString.IndexOf("\"", num2);
if (num3 != -1)
{
return LStrip(jsonString.Substring(num2, num3 - num2), 'v');
}
}
return null;
}
private static string LStrip(string input, char charToStrip)
{
int i;
for (i = 0; i < input.Length && input[i] == charToStrip; i++)
{
}
return input.Substring(i);
}
private static string BuildUserAgentString()
{
return "OneForAll/1.0.2 (" + GetOperatingSystemInfo() + "; " + (Environment.Is64BitOperatingSystem ? "x64" : "x86") + ")";
}
private static string GetOperatingSystemInfo()
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
return $"Windows NT {Environment.OSVersion.Version}";
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
return $"Mac OS X {Environment.OSVersion.Version}";
}
return RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? $"Linux {Environment.OSVersion.Version}" : $"Unknown OS {Environment.OSVersion.Version}";
}
}
}
namespace OneForAll.MiniMap.Component
{
public class MinimapGUI : MonoBehaviour
{
private const int GUI_WIDTH = 500;
private const int GUI_HEIGHT = 650;
private const int ITEMWIDTH = 300;
public ModHotkey guiKey = new ModHotkey(MinimapMod.defaultGuiKey, null);
public ModHotkey toggleMinimapKey = new ModHotkey(MinimapMod.defaultToggleMinimapKey, null);
public ModHotkey toggleOverrideKey = new ModHotkey(MinimapMod.defaultToggleOverrideKey, null);
public ModHotkey switchTargetKey = new ModHotkey(MinimapMod.defaultSwitchTargetKey, null);
public HotkeyManager hotkeyManager = new HotkeyManager(4);
public bool enableMinimap;
public bool autoRotate;
public int minimapSize;
public float minimapXPos;
public float minimapYPos;
public float minimapZoom;
public float brightness;
public bool showLoots;
public bool showEnemies;
public bool showLivePlayers;
public bool showDeadPlayers;
public bool showRadarBoosters;
public bool showTerminalCodes;
public bool showShipArrow;
public bool freezePlayerIndex;
private string[] navbarStr = new string[4] { "Minimap", "Icons", "Select Target", "Keybinds" };
private readonly KeyboardShortcut escapeKey = new KeyboardShortcut((KeyCode)27, Array.Empty<KeyCode>());
private int navbarIndex = 0;
public bool isGUIOpen = false;
private bool escKeyWasDown = false;
public int playerIndex = 0;
public int realPlayerIndex = 0;
private bool lockPrefix = false;
private string prefix = "MONITORING";
private CursorLockMode lastCursorState = Cursor.lockState;
private Vector2 scrollPos = Vector2.zero;
private int validTargetCount = 0;
public IDictionary<PlayerControllerB, ModUser> modUsers;
private GUIStyle menuStyle;
private GUIStyle buttonStyle;
private GUIStyle labelStyle;
private GUIStyle midLabelStyle;
private GUIStyle tinyLabelStyle;
private GUIStyle toggleStyle;
private GUIStyle midToggleStyle;
private void Awake()
{
MinimapMod.mls.LogInfo((object)"MinimapGUI loaded.");
modUsers = new Dictionary<PlayerControllerB, ModUser>();
guiKey.OnKey = ToggleGUI;
toggleMinimapKey.OnKey = delegate
{
enableMinimap = !enableMinimap;
};
toggleOverrideKey.OnKey = delegate
{
freezePlayerIndex = !freezePlayerIndex;
};
switchTargetKey.OnKey = SwitchTarget;
hotkeyManager.AllHotkeys[0] = guiKey;
hotkeyManager.AllHotkeys[1] = toggleMinimapKey;
hotkeyManager.AllHotkeys[2] = toggleOverrideKey;
hotkeyManager.AllHotkeys[3] = switchTargetKey;
}
private Texture2D MakeTex(int width, int height, Color col)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
Color[] array = (Color[])(object)new Color[width * height];
for (int i = 0; i < array.Length; i++)
{
array[i] = col;
}
Texture2D val = new Texture2D(width, height);
val.SetPixels(array);
val.Apply();
return val;
}
public string GetPlayerNameAtIndex(int index)
{
if ((Object)(object)StartOfRound.Instance == (Object)null)
{
return "n/a";
}
List<TransformAndName> radarTargets = StartOfRound.Instance.mapScreen.radarTargets;
return (index < 0 || index >= radarTargets.Count) ? "n/a" : radarTargets[index].name;
}
public void SetMinimapTarget(int targetTransformIndex)
{
playerIndex = targetTransformIndex;
StartOfRound.Instance.mapScreen.targetTransformIndex = playerIndex;
StartOfRound.Instance.mapScreen.targetedPlayer = ((Component)StartOfRound.Instance.mapScreen.radarTargets[playerIndex].transform).gameObject.GetComponent<PlayerControllerB>();
((TMP_Text)StartOfRound.Instance.mapScreenPlayerName).text = prefix + ": " + StartOfRound.Instance.mapScreen.radarTargets[playerIndex].name;
}
private void IntitializeMenu()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Expected O, but got Unknown
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Expected O, but got Unknown
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Expected O, but got Unknown
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Expected O, but got Unknown
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_01be: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
//IL_0239: Unknown result type (might be due to invalid IL or missing references)
//IL_0266: Unknown result type (might be due to invalid IL or missing references)
//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
if (menuStyle == null)
{
menuStyle = new GUIStyle(GUI.skin.box);
buttonStyle = new GUIStyle(GUI.skin.button);
labelStyle = new GUIStyle(GUI.skin.label);
midLabelStyle = new GUIStyle(GUI.skin.label);
tinyLabelStyle = new GUIStyle(GUI.skin.label);
toggleStyle = new GUIStyle(GUI.skin.toggle);
midToggleStyle = new GUIStyle(GUI.skin.toggle);
menuStyle.normal.textColor = Color.white;
menuStyle.normal.background = MakeTex(2, 2, new Color(0.19f, 0.2f, 0.22f, 0.9f));
menuStyle.fontSize = 20;
((Object)menuStyle.normal.background).hideFlags = (HideFlags)61;
buttonStyle.normal.textColor = Color.white;
buttonStyle.fontSize = 18;
labelStyle.normal.textColor = Color.white;
labelStyle.normal.background = MakeTex(2, 2, new Color(0.19f, 0.2f, 0.22f, 0f));
labelStyle.fontSize = 18;
labelStyle.alignment = (TextAnchor)4;
((Object)labelStyle.normal.background).hideFlags = (HideFlags)61;
midLabelStyle.normal.textColor = Color.white;
midLabelStyle.normal.background = MakeTex(2, 2, new Color(0.19f, 0.2f, 0.22f, 0f));
midLabelStyle.fontSize = 14;
midLabelStyle.alignment = (TextAnchor)4;
((Object)midLabelStyle.normal.background).hideFlags = (HideFlags)61;
tinyLabelStyle.normal.textColor = Color.white;
tinyLabelStyle.normal.background = MakeTex(2, 2, new Color(0.19f, 0.2f, 0.22f, 0f));
tinyLabelStyle.fontSize = 11;
tinyLabelStyle.alignment = (TextAnchor)4;
((Object)tinyLabelStyle.normal.background).hideFlags = (HideFlags)61;
toggleStyle.normal.textColor = Color.white;
toggleStyle.fontSize = 18;
midToggleStyle.normal.textColor = Color.white;
midToggleStyle.fontSize = 14;
}
}
public int CalculateValidTargetIndex(int setRadarTargetIndex)
{
List<TransformAndName> radarTargets = StartOfRound.Instance.mapScreen.radarTargets;
if (radarTargets.Count <= setRadarTargetIndex)
{
setRadarTargetIndex = radarTargets.Count - 1;
}
for (int i = 0; i < radarTargets.Count; i++)
{
if (radarTargets[setRadarTargetIndex] == null)
{
setRadarTargetIndex = (setRadarTargetIndex + 1) % radarTargets.Count;
continue;
}
PlayerControllerB component = ((Component)radarTargets[setRadarTargetIndex].transform).gameObject.GetComponent<PlayerControllerB>();
if ((Object)(object)component != (Object)null && !component.isPlayerControlled && !component.isPlayerDead)
{
setRadarTargetIndex = (setRadarTargetIndex + 1) % radarTargets.Count;
continue;
}
break;
}
return setRadarTargetIndex;
}
public void SwitchTarget()
{
List<TransformAndName> list = (((Object)(object)StartOfRound.Instance != (Object)null) ? StartOfRound.Instance.mapScreen.radarTargets : new List<TransformAndName>());
if (freezePlayerIndex && list.Count >= 1)
{
SetMinimapTarget(CalculateValidTargetIndex((playerIndex + 1) % list.Count));
}
}
private void ToggleGUI()
{
//IL_0042: 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)
if (!isGUIOpen)
{
isGUIOpen = true;
Cursor.visible = true;
lastCursorState = Cursor.lockState;
Cursor.lockState = (CursorLockMode)2;
}
else
{
isGUIOpen = false;
Cursor.visible = false;
Cursor.lockState = lastCursorState;
}
}
public void Update()
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: 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)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
hotkeyManager.Update();
KeyboardShortcut val = escapeKey;
if (((KeyboardShortcut)(ref val)).IsDown())
{
escKeyWasDown = true;
if (isGUIOpen)
{
if (hotkeyManager.AnyHotkeyIsSettingKey())
{
Cursor.lockState = (CursorLockMode)2;
}
else
{
isGUIOpen = false;
Cursor.visible = false;
}
}
}
val = escapeKey;
if (((KeyboardShortcut)(ref val)).IsUp() && escKeyWasDown)
{
escKeyWasDown = false;
}
if (freezePlayerIndex != lockPrefix && (Object)(object)StartOfRound.Instance != (Object)null)
{
lockPrefix = freezePlayerIndex;
prefix = (freezePlayerIndex ? "LOCKED" : "MONITORING");
((TMP_Text)StartOfRound.Instance.mapScreenPlayerName).text = prefix + ": " + StartOfRound.Instance.mapScreen.radarTargets[playerIndex].name;
}
if (!freezePlayerIndex && playerIndex != realPlayerIndex)
{
realPlayerIndex = CalculateValidTargetIndex(realPlayerIndex);
SetMinimapTarget(realPlayerIndex);
}
}
private static MouseAndKeyboard MouseWasPressedThisFrame()
{
Mouse current = Mouse.current;
if (current == null || current.leftButton.wasPressedThisFrame)
{
return MouseAndKeyboard.None;
}
if (current.middleButton.wasPressedThisFrame)
{
return MouseAndKeyboard.MouseMiddle;
}
if (current.rightButton.wasPressedThisFrame)
{
return MouseAndKeyboard.MouseRight;
}
if (current.forwardButton.wasPressedThisFrame)
{
return MouseAndKeyboard.MouseForward;
}
return current.backButton.wasPressedThisFrame ? MouseAndKeyboard.MouseBack : MouseAndKeyboard.None;
}
public void OnGUI()
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
//IL_021c: Unknown result type (might be due to invalid IL or missing references)
//IL_024d: Unknown result type (might be due to invalid IL or missing references)
//IL_0286: Unknown result type (might be due to invalid IL or missing references)
//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
//IL_0321: Unknown result type (might be due to invalid IL or missing references)
//IL_035a: Unknown result type (might be due to invalid IL or missing references)
//IL_038c: Unknown result type (might be due to invalid IL or missing references)
//IL_0474: Unknown result type (might be due to invalid IL or missing references)
//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
//IL_04da: Unknown result type (might be due to invalid IL or missing references)
//IL_050d: Unknown result type (might be due to invalid IL or missing references)
//IL_0540: Unknown result type (might be due to invalid IL or missing references)
//IL_0573: Unknown result type (might be due to invalid IL or missing references)
//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
//IL_0401: Unknown result type (might be due to invalid IL or missing references)
//IL_0602: Unknown result type (might be due to invalid IL or missing references)
//IL_063c: Unknown result type (might be due to invalid IL or missing references)
//IL_07b7: Unknown result type (might be due to invalid IL or missing references)
//IL_0435: Unknown result type (might be due to invalid IL or missing references)
//IL_0686: Unknown result type (might be due to invalid IL or missing references)
//IL_068c: Unknown result type (might be due to invalid IL or missing references)
//IL_06aa: Unknown result type (might be due to invalid IL or missing references)
//IL_06af: Unknown result type (might be due to invalid IL or missing references)
//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
//IL_0828: Unknown result type (might be due to invalid IL or missing references)
//IL_0716: Unknown result type (might be due to invalid IL or missing references)
//IL_0899: Unknown result type (might be due to invalid IL or missing references)
//IL_090a: Unknown result type (might be due to invalid IL or missing references)
//IL_094b: Unknown result type (might be due to invalid IL or missing references)
//IL_09e6: Unknown result type (might be due to invalid IL or missing references)
//IL_09eb: Unknown result type (might be due to invalid IL or missing references)
//IL_09ef: Unknown result type (might be due to invalid IL or missing references)
//IL_09f4: Unknown result type (might be due to invalid IL or missing references)
//IL_0a13: Unknown result type (might be due to invalid IL or missing references)
if (menuStyle == null)
{
IntitializeMenu();
}
if (!isGUIOpen)
{
return;
}
float num = Screen.width / 2 - 250;
float num2 = Screen.height / 2 - 325;
float num3 = num + 100f;
GUI.Box(new Rect(num, num2, 500f, 650f), "\nOneForAll Map\n", menuStyle);
GUI.Label(new Rect(num3, num2 + 60f, 300f, 30f), "v1.0.3\t\t\tby FraZy", tinyLabelStyle);
navbarIndex = GUI.Toolbar(new Rect(num, num2 - 30f, 500f, 30f), navbarIndex, navbarStr, buttonStyle);
float num4 = num2 + 20f;
switch (navbarIndex)
{
case 0:
enableMinimap = GUI.Toggle(new Rect(num3, num4 + 90f, 300f, 30f), enableMinimap, "Toggle Minimap", toggleStyle);
autoRotate = GUI.Toggle(new Rect(num3, num4 + 130f, 300f, 30f), autoRotate, "Auto Rotate Map", toggleStyle);
GUI.Label(new Rect(num3, num4 + 170f, 300f, 30f), $"Minimap Size: {minimapSize}", labelStyle);
minimapSize = (int)GUI.HorizontalSlider(new Rect(num3, num4 + 200f, 300f, 30f), (float)minimapSize, 0f, 1000f);
GUI.Label(new Rect(num3, num4 + 220f, 300f, 30f), $"X Position Offset: {minimapXPos}", labelStyle);
minimapXPos = GUI.HorizontalSlider(new Rect(num3, num4 + 250f, 300f, 30f), minimapXPos, -1000f, 1000f);
GUI.Label(new Rect(num3, num4 + 270f, 300f, 30f), $"Y Position Offset: {minimapYPos}", labelStyle);
minimapYPos = GUI.HorizontalSlider(new Rect(num3, num4 + 300f, 300f, 30f), minimapYPos, -1000f, 1000f);
GUI.Label(new Rect(num3, num4 + 320f, 300f, 30f), $"Map Zoom: {minimapZoom}", labelStyle);
minimapZoom = GUI.HorizontalSlider(new Rect(num3, num4 + 350f, 300f, 30f), minimapZoom, 0f, 80f);
GUI.Label(new Rect(num3, num4 + 370f, 300f, 30f), $"Extra Brightness: {brightness}", labelStyle);
brightness = GUI.HorizontalSlider(new Rect(num3, num4 + 400f, 300f, 30f), brightness, 0f, 50f);
if (LeftClickButton(new Rect(num3, num4 + 440f, 300f, 30f), "Reset to Default Size"))
{
minimapSize = 200;
}
if (LeftClickButton(new Rect(num3, num4 + 480f, 300f, 30f), "Reset to Default Position"))
{
minimapXPos = 0f;
minimapYPos = 0f;
}
if (LeftClickButton(new Rect(num3, num4 + 520f, 300f, 30f), "Reset to Default Zoom"))
{
minimapZoom = 19.7f;
}
if (LeftClickButton(new Rect(num3, num4 + 560f, 300f, 30f), "Reset to Default Brightness"))
{
brightness = 0f;
}
break;
case 1:
showLoots = GUI.Toggle(new Rect(num3, num4 + 90f, 300f, 30f), showLoots, "Show Loots", toggleStyle);
showEnemies = GUI.Toggle(new Rect(num3, num4 + 130f, 300f, 30f), showEnemies, "Show Enemies", toggleStyle);
showLivePlayers = GUI.Toggle(new Rect(num3, num4 + 170f, 300f, 30f), showLivePlayers, "Show Live Players", toggleStyle);
showDeadPlayers = GUI.Toggle(new Rect(num3, num4 + 210f, 300f, 30f), showDeadPlayers, "Show Dead Players", toggleStyle);
showRadarBoosters = GUI.Toggle(new Rect(num3, num4 + 250f, 300f, 30f), showRadarBoosters, "Show Radar Boosters", toggleStyle);
showTerminalCodes = GUI.Toggle(new Rect(num3, num4 + 290f, 300f, 30f), showTerminalCodes, "Show Terminal Codes", toggleStyle);
showShipArrow = GUI.Toggle(new Rect(num3, num4 + 330f, 300f, 30f), showShipArrow, "Show Ship Arrow", toggleStyle);
break;
case 2:
{
List<TransformAndName> list = (((Object)(object)StartOfRound.Instance != (Object)null) ? StartOfRound.Instance.mapScreen.radarTargets : new List<TransformAndName>());
GUI.Label(new Rect(num3, num4 + 90f, 300f, 30f), "Selected Target: " + GetPlayerNameAtIndex(playerIndex), labelStyle);
freezePlayerIndex = GUI.Toggle(new Rect(num3, num4 + 140f, 300f, 30f), freezePlayerIndex, "Override Ship Controls", toggleStyle);
int num5 = 0;
if (freezePlayerIndex)
{
float num6 = num4 + 180f;
scrollPos = GUI.BeginScrollView(new Rect(num3, num6, 300f, 400f), scrollPos, new Rect(0f, 0f, 280f, (float)(40 * validTargetCount)));
for (int i = 0; i < list.Count; i++)
{
PlayerControllerB component = ((Component)list[i].transform).gameObject.GetComponent<PlayerControllerB>();
if (!((Object)(object)component != (Object)null) || component.isPlayerControlled || component.isPlayerDead)
{
if (LeftClickButton(new Rect(0f, (float)(40 * num5), 270f, 30f), list[i].name))
{
SetMinimapTarget(i);
}
num5++;
}
}
GUI.EndScrollView();
}
validTargetCount = num5;
break;
}
case 3:
{
string text = (guiKey.IsSettingKey ? "Press a Key..." : $"Open Mod Menu: {guiKey.Key}");
if (LeftClickButton(new Rect(num3, num4 + 90f, 300f, 30f), text))
{
hotkeyManager.ResetSettingKey();
guiKey.IsSettingKey = true;
}
string text2 = (toggleMinimapKey.IsSettingKey ? "Press a Key..." : $"Toggle Minimap: {toggleMinimapKey.Key}");
if (LeftClickButton(new Rect(num3, num4 + 130f, 300f, 30f), text2))
{
hotkeyManager.ResetSettingKey();
toggleMinimapKey.IsSettingKey = true;
}
string text3 = (toggleOverrideKey.IsSettingKey ? "Press a Key..." : $"Override Ship Controls: {toggleOverrideKey.Key}");
if (LeftClickButton(new Rect(num3, num4 + 170f, 300f, 30f), text3))
{
hotkeyManager.ResetSettingKey();
toggleOverrideKey.IsSettingKey = true;
}
string text4 = (switchTargetKey.IsSettingKey ? "Press a Key..." : $"Switch Minimap Target: {switchTargetKey.Key}");
if (LeftClickButton(new Rect(num3, num4 + 210f, 300f, 30f), text4))
{
hotkeyManager.ResetSettingKey();
switchTargetKey.IsSettingKey = true;
}
if (LeftClickButton(new Rect(num3, num4 + 280f, 300f, 30f), "Reset to Default Keybinds"))
{
hotkeyManager.ResetToDefaultKey();
}
if (!hotkeyManager.AnyHotkeyIsSettingKey())
{
break;
}
MouseAndKeyboard mouseAndKeyboard = MouseWasPressedThisFrame();
if (mouseAndKeyboard != 0)
{
hotkeyManager.SetHotKey(mouseAndKeyboard);
}
else if (((ButtonControl)Keyboard.current.escapeKey).wasPressedThisFrame)
{
hotkeyManager.ResetIsSettingKey();
}
else
{
if (!((ButtonControl)Keyboard.current.anyKey).wasPressedThisFrame)
{
break;
}
Enumerator<KeyControl> enumerator = Keyboard.current.allKeys.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
KeyControl current = enumerator.Current;
if (((ButtonControl)current).wasPressedThisFrame && hotkeyManager.SetHotKey(current.keyCode))
{
break;
}
}
}
finally
{
((IDisposable)enumerator).Dispose();
}
}
break;
}
}
MinimapMod.Instance.SyncConfigFromGUI();
}
private bool LeftClickButton(Rect rect, string text, GUIStyle style = null)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: 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)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected I4, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: 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: Invalid comparison between Unknown and I4
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
GUIContent val = new GUIContent(text);
if (style == null)
{
style = GUI.skin.button;
}
Event current = Event.current;
int controlID = GUIUtility.GetControlID((FocusType)2);
EventType type = current.type;
EventType val2 = type;
switch ((int)val2)
{
default:
if ((int)val2 == 7)
{
style.Draw(rect, val, controlID);
}
break;
case 0:
if (GUIUtility.hotControl == 0 && ((Rect)(ref rect)).Contains(current.mousePosition) && current.button == 0)
{
GUIUtility.hotControl = controlID;
current.Use();
}
break;
case 1:
if (GUIUtility.hotControl == controlID && ((Rect)(ref rect)).Contains(current.mousePosition) && current.button == 0)
{
GUIUtility.hotControl = 0;
current.Use();
return true;
}
break;
case 3:
if (GUIUtility.hotControl == controlID)
{
current.Use();
}
break;
case 2:
break;
}
return false;
}
}
}
namespace OneForAll.MiniMap.Patches
{
[HarmonyPatch(typeof(DeadBodyInfo))]
internal class DeadBodyInfoPatch
{
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void MapCameraAlwaysEnabledPatch(ref Transform ___radarDot)
{
if (MinimapMod.minimapGUI.showDeadPlayers != ((Component)___radarDot).gameObject.activeSelf)
{
((Component)___radarDot).gameObject.SetActive(MinimapMod.minimapGUI.showDeadPlayers);
}
}
}
[HarmonyPatch(typeof(EnemyAI))]
internal class EnemyAIPatch
{
private static GameObject FindMapDot(GameObject enemyObject, bool isModel = false)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
foreach (Transform item in enemyObject.transform)
{
Transform val = item;
if (((Object)val).name.StartsWith("MapDot"))
{
return ((Component)val).gameObject;
}
if (!isModel && (((Object)val).name.EndsWith("Model") || ((Object)val).name.EndsWith("ModelContainer")))
{
GameObject val2 = FindMapDot(((Component)val).gameObject, isModel = true);
if ((Object)(object)val2 != (Object)null)
{
return val2;
}
}
}
return null;
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void EnemyVisibilityOnMapPatch(EnemyAI __instance)
{
if ((Object)(object)__instance != (Object)null && (Object)(object)((Component)__instance).gameObject != (Object)null)
{
GameObject val = FindMapDot(((Component)__instance).gameObject);
if ((Object)(object)val != (Object)null && MinimapMod.minimapGUI.showEnemies != val.activeSelf)
{
val.SetActive(MinimapMod.minimapGUI.showEnemies);
}
}
}
}
[HarmonyPatch(typeof(GrabbableObject))]
internal class GrabbableObjectPatch
{
private static bool showTerminalCodes = MinimapMod.minimapGUI.showTerminalCodes;
[HarmonyPatch("LateUpdate")]
[HarmonyPostfix]
private static void LootVisibilityOnMapPatch(GrabbableObject __instance)
{
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Expected O, but got Unknown
if ((Object)(object)__instance != (Object)null && (Object)(object)__instance.radarIcon != (Object)null && (Object)(object)((Component)__instance.radarIcon).gameObject != (Object)null && MinimapMod.minimapGUI.showLoots != ((Component)__instance.radarIcon).gameObject.activeSelf)
{
((Component)__instance.radarIcon).gameObject.SetActive(MinimapMod.minimapGUI.showLoots);
}
if (showTerminalCodes != MinimapMod.minimapGUI.showTerminalCodes)
{
showTerminalCodes = MinimapMod.minimapGUI.showTerminalCodes;
TerminalAccessibleObject[] array = Object.FindObjectsOfType<TerminalAccessibleObject>();
FieldInfo fieldInfo = AccessTools.Field(typeof(TerminalAccessibleObject), "mapRadarText");
for (int i = 0; i < array.Length; i++)
{
TextMeshProUGUI val = (TextMeshProUGUI)fieldInfo.GetValue(array[i]);
((Component)val).gameObject.SetActive(MinimapMod.minimapGUI.showTerminalCodes);
}
}
}
}
[HarmonyPatch(typeof(HUDManager))]
internal class HUDManagerPatch
{
public static readonly string prefix = "<color=#00ffffff>[Minimap]</color> ";
public static readonly string prefixForBroadcast = "FraZy.OneForAll.Minimap";
private static readonly Regex parserRegex = new Regex("\\A<size=0>" + Regex.Escape(prefixForBroadcast) + "/([ -~]+)/([ -~]+)/([ -~]+)</size>\\z", RegexOptions.Compiled);
private static IDictionary<string, string> myBroadcasts = new Dictionary<string, string>();
private static string lastMessage = "";
public static void SendClientMessage(string message)
{
HUDManager.Instance.AddTextToChatOnServer(prefix + message, -1);
}
[HarmonyPatch("AddTextMessageServerRpc")]
[HarmonyPrefix]
private static bool DontSendMinimapMessagesPatch(string chatMessage)
{
return !chatMessage.StartsWith(prefix);
}
public static void SendMinimapBroadcast(string signature, string data = "null")
{
int num = (int)GameNetworkManager.Instance.localPlayerController.playerClientId;
if (!myBroadcasts.ContainsKey(signature))
{
myBroadcasts.Add(signature, data);
}
else
{
myBroadcasts[signature] = data;
}
HUDManager.Instance.AddTextToChatOnServer($"<size=0>{prefixForBroadcast}/{num}/{signature}/{data}</size>", -1);
}
}
[HarmonyPatch(typeof(ManualCameraRenderer))]
internal class ManualCameraRendererPatch
{
private static Vector3 defaultEulerAngles = new Vector3(90f, 315f, 0f);
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void MapCameraAlwaysEnabledPatch(ref Camera ___mapCamera, ref PlayerControllerB ___targetedPlayer, ref Light ___mapCameraLight, ref Transform ___shipArrowPointer, ref GameObject ___shipArrowUI)
{
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Unknown result type (might be due to invalid IL or missing references)
//IL_021e: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_027d: Unknown result type (might be due to invalid IL or missing references)
//IL_0290: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)___mapCamera != (Object)null)
{
((Behaviour)___mapCamera).enabled = true;
if (___mapCamera.orthographicSize != MinimapMod.minimapGUI.minimapZoom)
{
___mapCamera.orthographicSize = MinimapMod.minimapGUI.minimapZoom;
}
if (MinimapMod.minimapGUI.autoRotate && (Object)(object)___targetedPlayer != (Object)null)
{
((Component)___mapCamera).transform.eulerAngles = new Vector3(defaultEulerAngles.x, ((Component)___targetedPlayer).transform.eulerAngles.y, defaultEulerAngles.z);
}
else if (((Component)___mapCamera).transform.eulerAngles != defaultEulerAngles)
{
((Component)___mapCamera).transform.eulerAngles = defaultEulerAngles;
}
TerminalAccessibleObject[] array = Object.FindObjectsOfType<TerminalAccessibleObject>();
foreach (TerminalAccessibleObject val in array)
{
FieldInfo field = ((object)val).GetType().GetField("mapRadarText", BindingFlags.Instance | BindingFlags.NonPublic);
if (field != null)
{
((TMP_Text)field.GetValue(val)).transform.eulerAngles = new Vector3(defaultEulerAngles.x, ((Component)___mapCamera).transform.eulerAngles.y, defaultEulerAngles.z);
}
}
}
if ((Object)(object)___mapCameraLight != (Object)null && (Object)(object)___targetedPlayer != (Object)null)
{
((Behaviour)___mapCameraLight).enabled = ___targetedPlayer.isInsideFactory;
if ((Object)(object)GameNetworkManager.Instance != (Object)null && (Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
{
___mapCameraLight.cullingMask = ~GameNetworkManager.Instance.localPlayerController.gameplayCamera.cullingMask;
}
}
if (!((Object)(object)___shipArrowPointer != (Object)null) || !((Object)(object)___shipArrowUI != (Object)null) || !((Object)(object)___targetedPlayer != (Object)null))
{
return;
}
if (MinimapMod.minimapGUI.showShipArrow && !___targetedPlayer.isInsideFactory && (double)Vector3.Distance(((Component)___targetedPlayer).transform.position, ((Component)StartOfRound.Instance.elevatorTransform).transform.position) > 16.0)
{
if ((Object)(object)StartOfRound.Instance != (Object)null)
{
___shipArrowPointer.LookAt(StartOfRound.Instance.elevatorTransform);
}
int num = (MinimapMod.minimapGUI.autoRotate ? 45 : 0);
___shipArrowPointer.eulerAngles = new Vector3(0f, ___shipArrowPointer.eulerAngles.y + (float)num, 0f);
___shipArrowUI.SetActive(true);
}
else
{
___shipArrowUI.SetActive(false);
}
}
[HarmonyPatch("updateMapTarget")]
[HarmonyPrefix]
private static bool RadarMapSwitchTargetPatch(int setRadarTargetIndex, ref int ___targetTransformIndex, ref IEnumerator __result)
{
MinimapMod.minimapGUI.realPlayerIndex = setRadarTargetIndex;
if (MinimapMod.minimapGUI.freezePlayerIndex)
{
MinimapMod.minimapGUI.SetMinimapTarget(MinimapMod.minimapGUI.playerIndex);
__result = DoNothingCoroutine();
return false;
}
MinimapMod.minimapGUI.playerIndex = ___targetTransformIndex;
return true;
}
private static IEnumerator DoNothingCoroutine()
{
yield break;
}
[HarmonyPatch("RemoveTargetFromRadar")]
[HarmonyPostfix]
private static void RemoveTargetFromMapPatch()
{
if (MinimapMod.minimapGUI.freezePlayerIndex)
{
MinimapMod.minimapGUI.SwitchTarget();
}
}
[HarmonyPatch("SwitchRadarTargetForward")]
[HarmonyPrefix]
private static bool DontSwitchTargetForwardPatch()
{
return !MinimapMod.minimapGUI.freezePlayerIndex;
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
internal class PlayerControllerBPatch
{
private const int padding = -5;
private static GameObject minimapObj;
private static RawImage minimap;
private static RectTransform tooltips;
private static Vector2 tooltipsOriginalPos;
private static GameObject minimapLightObj;
public static Light minimapLight;
[HarmonyPatch("ConnectClientToPlayerObject")]
[HarmonyPostfix]
private static void DisplayMinimapPatch()
{
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Expected O, but got Unknown
//IL_00be: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_0291: Unknown result type (might be due to invalid IL or missing references)
//IL_0296: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
//IL_0184: Expected O, but got Unknown
//IL_019d: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
string text = null;
if (VersionChecker.latestVersion == null)
{
text = "<color=red>Failed to check for latest version</color>";
}
else if (new Version("1.0.3") < new Version(VersionChecker.latestVersion))
{
text = "<color=white>There is a new version available: </color><color=green>" + VersionChecker.latestVersion + "</color>";
}
if (text != null)
{
HUDManagerPatch.SendClientMessage(text);
}
int minimapSize = MinimapMod.minimapGUI.minimapSize;
if ((Object)(object)minimap == (Object)null || (Object)(object)minimapObj == (Object)null)
{
minimapObj = new GameObject("Minimap");
minimap = minimapObj.AddComponent<RawImage>();
((Graphic)minimap).rectTransform.anchorMin = new Vector2(1f, 1f);
((Graphic)minimap).rectTransform.anchorMax = new Vector2(1f, 1f);
((Graphic)minimap).rectTransform.pivot = new Vector2(1f, 1f);
((Graphic)minimap).rectTransform.sizeDelta = new Vector2((float)minimapSize, (float)minimapSize);
((Graphic)minimap).rectTransform.anchoredPosition = new Vector2(MinimapMod.minimapGUI.minimapXPos, MinimapMod.minimapGUI.minimapYPos - 5f);
}
if ((Object)(object)minimapLight == (Object)null || (Object)(object)minimapLightObj == (Object)null)
{
minimapLightObj = new GameObject("MinimapLight");
minimapLightObj.transform.position = new Vector3(0f, 100f, 0f);
minimapLightObj.transform.rotation = Quaternion.Euler(90f, 0f, 0f);
minimapLight = minimapLightObj.AddComponent<Light>();
minimapLight.type = (LightType)1;
minimapLight.range = 100f;
minimapLight.color = Color.white;
minimapLight.colorTemperature = 6500f;
minimapLight.intensity = 0f;
minimapLight.cullingMask = 0;
}
minimap.texture = (Texture)(object)StartOfRound.Instance.mapScreen.cam.targetTexture;
((Component)minimap).transform.SetParent(((Component)HUDManager.Instance.playerScreenTexture).transform, false);
tooltips = ((Component)HUDManager.Instance.Tooltips.canvasGroup).gameObject.GetComponent<RectTransform>();
Vector2 val = tooltipsOriginalPos;
bool flag = false;
RectTransform obj = tooltips;
obj.anchoredPosition -= new Vector2(0f, (float)minimapSize);
HUDManagerPatch.SendMinimapBroadcast("VersionReq");
HUDManagerPatch.SendMinimapBroadcast("VersionResp", "1.0.3");
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void UpdateMinimapPatch(PlayerControllerB __instance)
{
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
if (MinimapMod.minimapGUI.showLivePlayers != ((Component)__instance.mapRadarDotAnimator).gameObject.activeSelf)
{
((Component)__instance.mapRadarDotAnimator).gameObject.SetActive(MinimapMod.minimapGUI.showLivePlayers);
}
if ((Object)(object)minimap != (Object)null)
{
if (MinimapMod.minimapGUI.enableMinimap != ((Component)minimap).gameObject.activeSelf)
{
((Component)minimap).gameObject.SetActive(MinimapMod.minimapGUI.enableMinimap);
if (MinimapMod.minimapGUI.enableMinimap)
{
RectTransform obj = tooltips;
obj.anchoredPosition -= new Vector2(0f, (float)MinimapMod.minimapGUI.minimapSize);
}
else
{
tooltips.anchoredPosition = tooltipsOriginalPos;
}
}
if ((float)MinimapMod.minimapGUI.minimapSize != ((Graphic)minimap).rectTransform.sizeDelta.y)
{
int minimapSize = MinimapMod.minimapGUI.minimapSize;
((Graphic)minimap).rectTransform.sizeDelta = new Vector2((float)minimapSize, (float)minimapSize);
tooltips.anchoredPosition = tooltipsOriginalPos - new Vector2(0f, (float)minimapSize);
}
if (MinimapMod.minimapGUI.minimapXPos != ((Graphic)minimap).rectTransform.anchoredPosition.x || MinimapMod.minimapGUI.minimapYPos != ((Graphic)minimap).rectTransform.anchoredPosition.y)
{
((Graphic)minimap).rectTransform.anchoredPosition = new Vector2(MinimapMod.minimapGUI.minimapXPos, MinimapMod.minimapGUI.minimapYPos - 5f);
}
}
if ((Object)(object)minimapLight != (Object)null)
{
if (minimapLight.cullingMask == 0 && (Object)(object)GameNetworkManager.Instance != (Object)null && (Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
{
minimapLight.cullingMask = ~GameNetworkManager.Instance.localPlayerController.gameplayCamera.cullingMask;
}
minimapLight.intensity = MinimapMod.minimapGUI.brightness;
}
}
}
[HarmonyPatch(typeof(QuickMenuManager))]
internal class QuickMenuManagerPatch
{
private static bool isRealMenuOpen;
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void FreezeWhenOpenedGUIPatch(ref bool ___isMenuOpen)
{
bool flag = MinimapMod.minimapGUI.isGUIOpen || isRealMenuOpen;
if (___isMenuOpen != flag)
{
___isMenuOpen = flag;
}
}
[HarmonyPatch("OpenQuickMenu")]
[HarmonyPostfix]
private static void OpenQuickMenuPatch()
{
isRealMenuOpen = true;
}
[HarmonyPatch("CloseQuickMenu")]
[HarmonyPostfix]
private static void CloseQuickMenuPatch()
{
isRealMenuOpen = false;
}
}
[HarmonyPatch(typeof(RadarBoosterItem))]
internal class RadarBoosterItemPatch
{
[HarmonyPatch("Update")]
[HarmonyPostfix]
private static void RadarBoosterVisibilityPatch(RadarBoosterItem __instance)
{
if (MinimapMod.minimapGUI.showRadarBoosters != __instance.radarDot.activeSelf)
{
__instance.radarDot.SetActive(MinimapMod.minimapGUI.showRadarBoosters);
}
}
}
[HarmonyPatch(typeof(ShipTeleporter))]
internal class ShipTeleporterPatch
{
private static PlayerControllerB playerToBeamUp;
[HarmonyPatch("beamUpPlayer")]
[HarmonyPrefix]
private static void BeforeTeleportPatch()
{
int realPlayerIndex = MinimapMod.minimapGUI.realPlayerIndex;
if (StartOfRound.Instance.mapScreen.targetTransformIndex != realPlayerIndex)
{
playerToBeamUp = ((Component)StartOfRound.Instance.mapScreen.radarTargets[MinimapMod.minimapGUI.CalculateValidTargetIndex(realPlayerIndex)].transform).gameObject.GetComponent<PlayerControllerB>();
StartOfRound.Instance.mapScreen.targetedPlayer = playerToBeamUp;
}
}
[HarmonyPatch("SetPlayerTeleporterId")]
[HarmonyPrefix]
private static void DuringTeleportPatch()
{
if ((Object)(object)playerToBeamUp != (Object)null)
{
playerToBeamUp = null;
MinimapMod.minimapGUI.SetMinimapTarget(MinimapMod.minimapGUI.playerIndex);
}
}
}
[HarmonyPatch(typeof(TerminalAccessibleObject))]
internal class TerminalAccessibleObjectPatch
{
[HarmonyPatch("InitializeValues")]
[HarmonyPostfix]
private static void TerminalCodeVisibilityPatch(ref TextMeshProUGUI ___mapRadarText)
{
((Component)___mapRadarText).gameObject.SetActive(MinimapMod.minimapGUI.showTerminalCodes);
}
}
[HarmonyPatch(typeof(TimeOfDay))]
internal class TimeOfDayPatch
{
[HarmonyPatch("SetInsideLightingDimness")]
[HarmonyPostfix]
private static void MinimapBrightnessPatch()
{
if ((Object)(object)TimeOfDay.Instance.sunDirect != (Object)null)
{
((Behaviour)TimeOfDay.Instance.sunDirect).enabled = true;
}
}
}
}
namespace OneForAll.Horn
{
[BepInPlugin("FraZy.OneForAll.Horn", "OneForAll.Horn", "1.0.3")]
public class Plugin : BaseUnityPlugin
{
private const string GUID = "FraZy.OneForAll.Horn";
private const string NAME = "OneForAll.Horn";
private const string VERSION = "1.0.3";
private readonly Harmony harmony = new Harmony("FraZy.OneForAll.Horn");
public static Plugin Instance;
public static ManualLogSource mls;
private void Awake()
{
mls = Logger.CreateLogSource("FraZy.OneForAll.Horn");
Instance = this;
harmony.PatchAll();
mls.LogInfo((object)"OneForAll.Horn has been Patched");
}
}
}
namespace OneForAll.Horn.Patches
{
[HarmonyPatch]
internal class ShipAlarmCordPatch
{
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void LoadAudio()
{
HornManager.Load();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(ShipAlarmCord), "Start")]
private static void ChangeShipAlarmCordSFX(ShipAlarmCord __instance)
{
if (HornManager.Loaded)
{
HornManager.ChangeClip(__instance);
return;
}
HornManager.OnLoaded += delegate
{
HornManager.ChangeClip(__instance);
};
}
[HarmonyPrefix]
[HarmonyPatch(typeof(ShipAlarmCord), "StopHorn")]
private static void ActuallyStopHorn(ShipAlarmCord __instance)
{
__instance.cordAudio.Stop();
HornManager.NextClip(__instance);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(ShipAlarmCord), "HoldCordDown")]
private static void LoopNewHornSFX(ShipAlarmCord __instance)
{
if (!__instance.cordAudio.isPlaying)
{
__instance.cordAudio.PlayOneShot(__instance.cordPullSFX);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(ShipAlarmCord), "PullCordClientRpc")]
private static void LoopNewHornSFXClient(ShipAlarmCord __instance)
{
if (!__instance.cordAudio.isPlaying)
{
__instance.cordAudio.PlayOneShot(__instance.cordPullSFX);
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(ShipAlarmCord), "StopPullingCordClientRpc")]
private static void ActuallyStopHornClient(ShipAlarmCord __instance)
{
__instance.cordAudio.Stop();
HornManager.NextClip(__instance);
}
}
}
namespace OneForAll.Horn.Manager
{
internal static class HornManager
{
public static List<AudioClip> clips = new List<AudioClip>();
public static bool Loaded;
public static int clipIndex = 0;
private static bool canSwitch = true;
public static event Action OnLoaded;
public static void Load()
{
string path = Path.Combine(Paths.PluginPath, "Audio");
if (!Directory.Exists(path))
{
return;
}
string[] files = Directory.GetFiles(path);
if (files.Length < 1)
{
Plugin.mls.LogInfo((object)"No Horn Audio Found!");
return;
}
List<Coroutine> list = new List<Coroutine>();
string[] array = files;
string[] array2 = array;
foreach (string filePath in array2)
{
Coroutine item = CorStarter.StartCoroutine(LoadAudioClip(filePath));
list.Add(item);
}
CorStarter.StartCoroutine(WaitForAllClips(list));
}
private static IEnumerator WaitForAllClips(List<Coroutine> coroutines)
{
foreach (Coroutine coroutine in coroutines)
{
yield return coroutine;
}
Loaded = true;
HornManager.OnLoaded?.Invoke();
}
private static IEnumerator LoadAudioClip(string filePath)
{
Plugin.mls.LogInfo((object)("Loading " + filePath + "!"));
AudioType audioType = GetAudioType(filePath);
if ((int)audioType == 0)
{
Plugin.mls.LogError((object)("Failed to load AudioClip from " + filePath + "\nUnsupported file extension!"));
yield break;
}
UnityWebRequest loader = UnityWebRequestMultimedia.GetAudioClip(filePath, GetAudioType(filePath));
loader.SendWebRequest();
while (!loader.isDone)
{
yield return null;
}
if (loader.error != null)
{
Plugin.mls.LogError((object)("Error loading clip from path: " + filePath + "\n" + loader.error));
Plugin.mls.LogError((object)loader.error);
yield break;
}
AudioClip dlClip = DownloadHandlerAudioClip.GetContent(loader);
if (Object.op_Implicit((Object)(object)dlClip) && (int)dlClip.loadState == 2)
{
Plugin.mls.LogInfo((object)("Loaded " + filePath));
((Object)dlClip).name = Path.GetFileName(filePath);
clips.Add(dlClip);
Plugin.mls.LogInfo((object)$"Clips loaded: {clips.Count()}");
}
else
{
Plugin.mls.LogError((object)("Failed to load clip at: " + filePath + "\nThis might be due to an mismatch between the audio codec and the file extension!"));
}
}
public static void ChangeClip(ShipAlarmCord __instance)
{
__instance.cordPullSFX = clips[0];
__instance.hornClose.clip = null;
__instance.hornFar.clip = null;
__instance.cordAudio.maxDistance = 155f;
}
public static void NextClip(ShipAlarmCord __instance)
{
if (canSwitch)
{
clipIndex++;
if (clipIndex >= clips.Count)
{
clipIndex = 0;
}
__instance.cordPullSFX = clips[clipIndex];
Plugin.mls.LogInfo((object)$"Switched Clip to index {clipIndex}");
canSwitch = false;
CorStarter.StartCoroutine(WaitToSwitch());
}
}
private static IEnumerator WaitToSwitch()
{
yield return (object)new WaitForSeconds(0.25f);
canSwitch = true;
}
private static AudioType GetAudioType(string path)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: 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)
//IL_0046: 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)
string text = Path.GetExtension(path).ToLower();
switch (text)
{
case ".wav":
return (AudioType)20;
case ".ogg":
return (AudioType)14;
case ".mp3":
return (AudioType)13;
default:
Plugin.mls.LogError((object)("Unsupported extension type: " + text));
return (AudioType)0;
}
}
}
}
namespace OneForAll.Horn.Coroutines
{
public class CorStarter : MonoBehaviour
{
private static CorStarter Instance;
public static Coroutine StartCoroutine(IEnumerator routine)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Instance == (Object)null)
{
Instance = new GameObject("Shared Coroutine Starter").AddComponent<CorStarter>();
Object.DontDestroyOnLoad((Object)(object)Instance);
}
return ((MonoBehaviour)Instance).StartCoroutine(routine);
}
}
}
namespace OneForAll.Heal
{
[BepInPlugin("FraZy.OneForAll.Heal", "OneForAll.Heal", "1.0.3")]
public class Heal : BaseUnityPlugin
{
private const string modGUID = "FraZy.OneForAll.Heal";
private const string modName = "OneForAll.Heal";
private const string modVersion = "1.0.3";
private readonly Harmony harmony = new Harmony("OneForAll.Heal");
private ConfigEntry<bool> configInfiniteFuel;
public static bool InfiniteFuel;
private ConfigEntry<bool> configShowBatteryIcon;
public static bool ShowBatteryIcon;
private static Heal Instance;
internal ManualLogSource mls;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("OneForAll.Heal");
mls.LogInfo((object)"OneForAll.Heal loaded");
harmony.PatchAll(typeof(Heal));
harmony.PatchAll(typeof(OneForAll.Heal.Patches.PlayerControllerBPatch));
configInfiniteFuel = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Infinite TZP", true, "Prevent TZP from ever running out.");
InfiniteFuel = configInfiniteFuel.Value;
configShowBatteryIcon = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Battery Icon", true, "Show a battery icon with the current TZP Fuel");
ShowBatteryIcon = configShowBatteryIcon.Value;
}
}
}
namespace OneForAll.Heal.Patches
{
[HarmonyPatch(typeof(PlayerControllerB))]
[HarmonyPatch(typeof(TetraChemicalItem))]
internal class PlayerControllerBPatch : GrabbableObject
{
[HarmonyPatch(typeof(TetraChemicalItem), "Update")]
[HarmonyPrefix]
private static void PatchBattery(ref Item ___itemProperties, ref Battery ___insertedBattery, ref float ___fuel)
{
___itemProperties.requiresBattery = false;
___insertedBattery.charge = ___fuel;
___insertedBattery.empty = false;
}
[HarmonyPatch(typeof(TetraChemicalItem), "Update")]
[HarmonyPostfix]
public static void healtzp(ref bool ___emittingGas, ref bool ___isHeld, PlayerControllerB __instance, ref float ___fuel, ref Item ___itemProperties, ref Battery ___insertedBattery)
{
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
if (Heal.InfiniteFuel && (int)((double)___fuel * 1000.0) % 1000 < 500)
{
___fuel = 3f;
}
else if (Heal.ShowBatteryIcon)
{
___itemProperties.requiresBattery = true;
___insertedBattery.charge = ___fuel;
___insertedBattery.empty = false;
}
if (!(___emittingGas & ___isHeld) || !((NetworkBehaviour)__instance).IsOwner)
{
return;
}
int num = (int)((double)___fuel * 1000.0) % 1000;
GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation = true;
if (((NetworkBehaviour)__instance).IsOwner && num % 30 == 0 && GameNetworkManager.Instance.localPlayerController.health < 100)
{
HUDManager.Instance.DisplayStatusEffect("Healing ... " + (GameNetworkManager.Instance.localPlayerController.health + 1) + "%");
GameNetworkManager.Instance.localPlayerController.DamagePlayer(-2, false, true, (CauseOfDeath)0, 0, false, default(Vector3));
if (GameNetworkManager.Instance.localPlayerController.health >= 10 && GameNetworkManager.Instance.localPlayerController.criticallyInjured)
{
GameNetworkManager.Instance.localPlayerController.MakeCriticallyInjured(false);
}
HUDManager.Instance.HUDAnimator.ResetTrigger("SmallHit");
}
if (GameNetworkManager.Instance.localPlayerController.health >= 99)
{
HUDManager.Instance.DisplayStatusEffect("Healthy.\nGet to work!");
HUDManager.Instance.statusEffectAnimator.SetTrigger("IndicateStatus");
}
GameNetworkManager.Instance.localPlayerController.inSpecialInteractAnimation = false;
}
}
}