using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DunGen.Graph;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Rendering.HighDefinition;
using com.github.zehsteam.RemoveInteriorFog.Dependencies.LethalConfigMod;
using com.github.zehsteam.RemoveInteriorFog.Extensions;
using com.github.zehsteam.RemoveInteriorFog.Helpers;
using com.github.zehsteam.RemoveInteriorFog.Managers;
using com.github.zehsteam.RemoveInteriorFog.Patches;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Zehs")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2026 Zehs")]
[assembly: AssemblyDescription("Removes interior fog. Configurable!")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+49dd0ec8dac2a5cba51494cfbfadafd770db5039")]
[assembly: AssemblyProduct("RemoveInteriorFog")]
[assembly: AssemblyTitle("com.github.zehsteam.RemoveInteriorFog")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
[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 com.github.zehsteam.RemoveInteriorFog
{
internal static class Logger
{
public static ManualLogSource ManualLogSource { get; private set; }
public static bool IsExtendedLoggingEnabled => ConfigManager.Misc_ExtendedLogging?.Value ?? false;
public static void Initialize(ManualLogSource manualLogSource)
{
ManualLogSource = manualLogSource;
}
public static void LogDebug(object data)
{
Log((LogLevel)32, data);
}
public static void LogInfo(object data, bool extended = false)
{
Log((LogLevel)16, data, extended);
}
public static void LogMessage(object data, bool extended = false)
{
Log((LogLevel)8, data, extended);
}
public static void LogWarning(object data, bool extended = false)
{
Log((LogLevel)4, data, extended);
}
public static void LogError(object data, bool extended = false)
{
Log((LogLevel)2, data, extended);
}
public static void LogFatal(object data, bool extended = false)
{
Log((LogLevel)1, data, extended);
}
public static void Log(LogLevel logLevel, object data, bool extended = false)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if (!extended || IsExtendedLoggingEnabled)
{
ManualLogSource manualLogSource = ManualLogSource;
if (manualLogSource != null)
{
manualLogSource.Log(logLevel, data);
}
}
}
}
[BepInPlugin("com.github.zehsteam.RemoveInteriorFog", "RemoveInteriorFog", "1.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class Plugin : BaseUnityPlugin
{
private readonly Harmony _harmony = new Harmony("com.github.zehsteam.RemoveInteriorFog");
internal static Plugin Instance { get; private set; }
private void Awake()
{
Instance = this;
Logger.Initialize(Logger.CreateLogSource("com.github.zehsteam.RemoveInteriorFog"));
Logger.LogInfo("RemoveInteriorFog has awoken!");
_harmony.PatchAll(typeof(RoundManager_Patches));
ConfigManager.Initialize(((BaseUnityPlugin)this).Config);
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "com.github.zehsteam.RemoveInteriorFog";
public const string PLUGIN_NAME = "RemoveInteriorFog";
public const string PLUGIN_VERSION = "1.1.0";
}
}
namespace com.github.zehsteam.RemoveInteriorFog.Patches
{
[HarmonyPatch(typeof(RoundManager))]
internal static class RoundManager_Patches
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void Start_Patch()
{
string allMoonNames = LevelHelper.GetAllMoonNames();
ConfigManager.Values_AllMoonNames.Value = allMoonNames;
Logger.LogMessage("All available moon names for config: " + allMoonNames);
string allInteriorNames = LevelHelper.GetAllInteriorNames();
ConfigManager.Values_AllInteriorNames.Value = allInteriorNames;
Logger.LogMessage("All available interior names for config: " + allInteriorNames);
}
[HarmonyPatch("RefreshEnemiesList")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void RefreshEnemiesList_Patch()
{
FogHelper.DisableEventFogUsingConfig();
}
[HarmonyPatch("FinishGeneratingLevel")]
[HarmonyPostfix]
[HarmonyPriority(0)]
private static void FinishGeneratingLevel_Patch()
{
FogHelper.DisableOtherFogUsingConfig();
}
}
}
namespace com.github.zehsteam.RemoveInteriorFog.MonoBehaviours
{
internal class CoroutineRunner : MonoBehaviour
{
public static CoroutineRunner Instance { get; private set; }
public static CoroutineRunner Spawn()
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
if ((Object)(object)Instance != (Object)null)
{
return Instance;
}
GameObject val = new GameObject("RemoveInteriorFog CoroutineRunner", new Type[1] { typeof(CoroutineRunner) })
{
hideFlags = (HideFlags)61
};
Object.DontDestroyOnLoad((Object)(object)val);
return val.GetComponent<CoroutineRunner>();
}
private void Awake()
{
if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
else
{
Instance = this;
}
}
public static Coroutine Start(IEnumerator routine)
{
if ((Object)(object)Instance == (Object)null)
{
CoroutineRunner coroutineRunner = Spawn();
return ((coroutineRunner != null) ? ((MonoBehaviour)coroutineRunner).StartCoroutine(routine) : null) ?? null;
}
CoroutineRunner instance = Instance;
return ((instance != null) ? ((MonoBehaviour)instance).StartCoroutine(routine) : null) ?? null;
}
public static void Stop(IEnumerator routine)
{
CoroutineRunner instance = Instance;
if (instance != null)
{
((MonoBehaviour)instance).StopCoroutine(routine);
}
}
public static void Stop(Coroutine routine)
{
CoroutineRunner instance = Instance;
if (instance != null)
{
((MonoBehaviour)instance).StopCoroutine(routine);
}
}
}
}
namespace com.github.zehsteam.RemoveInteriorFog.Managers
{
internal static class ConfigManager
{
public static ConfigFile ConfigFile { get; private set; }
public static ConfigEntry<bool> Misc_ExtendedLogging { get; private set; }
public static ConfigEntry<bool> Fog_RemoveEventFog { get; private set; }
public static ConfigEntry<bool> Fog_RemoveOtherFog { get; private set; }
public static ConfigEntry<string> Fog_OtherFogMoonWhitelist { get; private set; }
public static ConfigEntry<string> Fog_OtherFogInteriorWhitelist { get; private set; }
public static string[] Fog_OtherFogMoonWhitelist_Array => Fog_OtherFogMoonWhitelist.Value.ToCollection<string>().ToArray();
public static string[] Fog_OtherFogInteriorWhitelist_Array => Fog_OtherFogInteriorWhitelist.Value.ToCollection<string>().ToArray();
public static ConfigEntry<string> Values_AllMoonNames { get; private set; }
public static ConfigEntry<string> Values_AllInteriorNames { get; private set; }
public static void Initialize(ConfigFile configFile)
{
ConfigFile = configFile;
BindConfigs();
}
private static void BindConfigs()
{
ConfigHelper.SkipAutoGen();
Misc_ExtendedLogging = ConfigHelper.Bind("Misc", "ExtendedLogging", defaultValue: false, "Enable extended logging.");
Fog_RemoveEventFog = ConfigHelper.Bind("Fog", "RemoveEventFog", defaultValue: true, "If enabled, the rare vanilla thick interior fog that was added in v67 will be disabled.");
Fog_RemoveOtherFog = ConfigHelper.Bind("Fog", "RemoveOtherFog", defaultValue: false, "If enabled, other interior fog will be disabled.");
Fog_OtherFogMoonWhitelist = ConfigHelper.Bind("Fog", "OtherFogMoonWhitelist", "Example Moon, Second Moon", "List of moon names to not disable other interior fog on. Comma-separated list. Use the AllMoonNames config setting for a list of all available moon names.");
Fog_OtherFogInteriorWhitelist = ConfigHelper.Bind("Fog", "OtherFogInteriorWhitelist", "Example Interior, Second Interior", "List of interior names to not disable other interior fog on. Comma-separated list. Use the AllInteriorNames config setting for a list of all available interior names.");
ConfigHelper.AddButton("Fog", "Event Fog", "Remove", "Will disable the rare vanilla thick interior fog that was added in v67 for the current moon.", FogHelper.DisableEventFog);
ConfigHelper.AddButton("Fog", "Other Fog", "Remove", "Will disable other interior fog for the current moon.", FogHelper.DisableOtherFog);
Values_AllMoonNames = ConfigHelper.Bind("Values", "AllMoonNames", "", "These are all of the available moon names. Values will generate after loading into the ship.");
Values_AllInteriorNames = ConfigHelper.Bind("Values", "AllInteriorNames", "", "These are all of the available interior names. Values will generate after loading into the ship.");
}
}
}
namespace com.github.zehsteam.RemoveInteriorFog.Helpers
{
internal static class ConfigHelper
{
public static void SkipAutoGen()
{
if (LethalConfigProxy.IsInstalled)
{
LethalConfigProxy.SkipAutoGen();
}
}
public static void AddButton(string section, string name, string buttonText, string description, Action callback)
{
if (LethalConfigProxy.IsInstalled)
{
LethalConfigProxy.AddButton(section, name, buttonText, description, callback);
}
}
public static ConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description, bool requiresRestart = false, AcceptableValueBase acceptableValues = null, Action<T> settingChanged = null, ConfigFile configFile = null)
{
if (configFile == null)
{
configFile = ConfigManager.ConfigFile;
}
ConfigEntry<T> configEntry = configFile.Bind(section, key, defaultValue, description, acceptableValues);
if (settingChanged != null)
{
configEntry.SettingChanged += delegate
{
settingChanged?.Invoke(configEntry.Value);
};
}
if (LethalConfigProxy.IsInstalled)
{
LethalConfigProxy.AddConfig<T>(configEntry, requiresRestart);
}
return configEntry;
}
}
internal static class FogHelper
{
public static void DisableEventFogUsingConfig()
{
if (ConfigManager.Fog_RemoveEventFog.Value)
{
DisableEventFog();
}
}
public static void DisableEventFog()
{
LocalVolumetricFog eventFog = GetEventFog();
if (!((Object)(object)eventFog == (Object)null))
{
bool activeSelf = ((Component)eventFog).gameObject.activeSelf;
((Behaviour)eventFog).enabled = false;
((Component)eventFog).gameObject.SetActive(false);
if (activeSelf)
{
Logger.LogInfo("Disabled event fog.");
}
else
{
Logger.LogInfo("Event fog was not enabled.", extended: true);
}
}
}
public static void DisableOtherFogUsingConfig()
{
if (!ConfigManager.Fog_RemoveOtherFog.Value)
{
return;
}
string currentMoonName = LevelHelper.GetCurrentMoonName();
string[] fog_OtherFogMoonWhitelist_Array = ConfigManager.Fog_OtherFogMoonWhitelist_Array;
if (!fog_OtherFogMoonWhitelist_Array.Contains<string>(currentMoonName, StringComparer.OrdinalIgnoreCase))
{
string currentInteriorName = LevelHelper.GetCurrentInteriorName();
string[] fog_OtherFogInteriorWhitelist_Array = ConfigManager.Fog_OtherFogInteriorWhitelist_Array;
if (!fog_OtherFogInteriorWhitelist_Array.Contains<string>(currentInteriorName, StringComparer.OrdinalIgnoreCase))
{
DisableOtherFog();
}
}
}
public static void DisableOtherFog()
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: 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)
GameObject dungeonRoot = GetDungeonRoot();
if ((Object)(object)dungeonRoot == (Object)null)
{
Logger.LogError("Failed to disable other fog. Dungeon root was not found.");
return;
}
LocalVolumetricFog[] componentsInChildren = dungeonRoot.GetComponentsInChildren<LocalVolumetricFog>(true);
LocalVolumetricFog[] array = componentsInChildren;
foreach (LocalVolumetricFog localVolumetricFog in array)
{
DisableLocalVolumetricFog(localVolumetricFog);
}
Vector3 position = dungeonRoot.transform.position;
LocalVolumetricFog[] array2 = Object.FindObjectsByType<LocalVolumetricFog>((FindObjectsSortMode)0);
LocalVolumetricFog[] array3 = array2;
foreach (LocalVolumetricFog val in array3)
{
if (!componentsInChildren.Contains(val))
{
Vector3 bottomPosition = val.GetBottomPosition();
if (bottomPosition.y < position.y)
{
DisableLocalVolumetricFog(val);
}
}
}
}
private static void DisableLocalVolumetricFog(LocalVolumetricFog localVolumetricFog)
{
if ((Object)(object)localVolumetricFog == (Object)null)
{
return;
}
GameObject gameObject = ((Component)localVolumetricFog).gameObject;
LocalVolumetricFog eventFog = GetEventFog();
if ((Object)(object)gameObject == (Object)(object)((eventFog != null) ? ((Component)eventFog).gameObject : null))
{
return;
}
bool enabled = ((Behaviour)localVolumetricFog).enabled;
bool activeSelf = ((Component)localVolumetricFog).gameObject.activeSelf;
string name = ((Object)localVolumetricFog).name;
if (!enabled && !activeSelf)
{
Logger.LogInfo("Fog \"" + name + "\" is already disabled. Path: \"" + ((Component)localVolumetricFog).transform.GetHierarchyPath() + "\"", extended: true);
return;
}
((Behaviour)localVolumetricFog).enabled = false;
((Component)localVolumetricFog).gameObject.SetActive(false);
Logger.LogInfo("Disabled fog \"" + name + "\". Path: \"" + ((Component)localVolumetricFog).transform.GetHierarchyPath() + "\"");
if (!Logger.IsExtendedLoggingEnabled)
{
return;
}
if (enabled && activeSelf)
{
Logger.LogInfo("Disabled LocalVolumetricFog script and GameObject.", extended: true);
return;
}
if (enabled)
{
Logger.LogInfo("Disabled LocalVolumetricFog script.", extended: true);
}
else
{
Logger.LogInfo("LocalVolumetricFog script was already disabled.", extended: true);
}
if (activeSelf)
{
Logger.LogInfo("Disabled LocalVolumetricFog GameObject.", extended: true);
}
else
{
Logger.LogInfo("LocalVolumetricFog GameObject was already disabled.", extended: true);
}
}
private static LocalVolumetricFog GetEventFog()
{
return RoundManager.Instance?.indoorFog;
}
private static GameObject GetDungeonRoot()
{
return RoundManager.Instance?.dungeonGenerator?.Root;
}
}
internal static class LevelHelper
{
private static readonly Dictionary<string, string> _dungeonFlowToReadableNames;
static LevelHelper()
{
_dungeonFlowToReadableNames = new Dictionary<string, string>();
_dungeonFlowToReadableNames.TryAdd("Level1Flow", "Facility");
_dungeonFlowToReadableNames.TryAdd("Level2Flow", "Mansion");
_dungeonFlowToReadableNames.TryAdd("Level3Flow", "Mineshaft");
}
public static string GetAllMoonNames()
{
if ((Object)(object)StartOfRound.Instance == (Object)null)
{
return string.Empty;
}
SelectableLevel[] source = StartOfRound.Instance.levels.Where((SelectableLevel x) => !x.lockedForDemo).ToArray();
string[] value = source.Select((SelectableLevel x) => x.PlanetName).ToArray();
return string.Join(", ", value);
}
public static string GetAllInteriorNames()
{
if ((Object)(object)RoundManager.Instance == (Object)null)
{
return string.Empty;
}
IndoorMapType[] dungeonFlowTypes = RoundManager.Instance.dungeonFlowTypes;
if (dungeonFlowTypes == null || dungeonFlowTypes.Length == 0)
{
return string.Empty;
}
string[] array = dungeonFlowTypes.Select((IndoorMapType x) => GetInteriorName(x.dungeonFlow)).ToArray();
if (array.Length == 0)
{
return string.Empty;
}
return string.Join(", ", array.Distinct());
}
public static string GetCurrentMoonName()
{
return StartOfRound.Instance?.currentLevel?.PlanetName;
}
public static string GetCurrentInteriorName()
{
return GetInteriorName(GetCurrentDungeonFlow());
}
public static string GetInteriorName(DungeonFlow dungeonFlow)
{
if ((Object)(object)dungeonFlow == (Object)null)
{
return "DungeonFlow is null";
}
foreach (KeyValuePair<string, string> dungeonFlowToReadableName in _dungeonFlowToReadableNames)
{
if (((Object)dungeonFlow).name.StartsWith(dungeonFlowToReadableName.Key, StringComparison.OrdinalIgnoreCase))
{
return dungeonFlowToReadableName.Value;
}
}
return ((Object)dungeonFlow).name;
}
private static DungeonFlow GetCurrentDungeonFlow()
{
if ((Object)(object)RoundManager.Instance == (Object)null)
{
return null;
}
return RoundManager.Instance.dungeonFlowTypes[RoundManager.Instance.currentDungeonType].dungeonFlow;
}
}
internal static class NetworkUtils
{
private static readonly FieldInfo _rpcExecStageField = AccessTools.Field(typeof(NetworkBehaviour), "__rpc_exec_stage");
public static bool IsConnected
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return false;
}
return singleton.IsConnectedClient;
}
}
public static bool IsServer
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return false;
}
return singleton.IsServer;
}
}
public static ulong LocalClientId
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
if (singleton == null)
{
return 0uL;
}
return singleton.LocalClientId;
}
}
public static int ConnectedPlayerCount => GameNetworkManager.Instance?.connectedPlayers ?? 0;
public static bool IsLocalClientId(ulong clientId)
{
return clientId == LocalClientId;
}
public static bool HasClient(ulong clientId)
{
if ((Object)(object)NetworkManager.Singleton == (Object)null)
{
return false;
}
return NetworkManager.Singleton.ConnectedClients.ContainsKey(clientId);
}
public static bool IsNetworkPrefab(GameObject prefab)
{
if ((Object)(object)prefab == (Object)null)
{
return false;
}
if ((Object)(object)NetworkManager.Singleton == (Object)null)
{
return false;
}
IReadOnlyList<NetworkPrefab> prefabs = NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs;
return prefabs.Any((NetworkPrefab x) => (Object)(object)x.Prefab == (Object)(object)prefab);
}
public static void NetcodePatcherAwake()
{
try
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
IEnumerable<Type> loadableTypes = executingAssembly.GetLoadableTypes();
foreach (Type item in loadableTypes)
{
MethodInfo[] methods = item.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array = methods;
foreach (MethodInfo methodInfo in array)
{
try
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
try
{
methodInfo.Invoke(null, null);
}
catch (TargetInvocationException ex)
{
Logger.LogWarning("[NetworkUtils] Failed to invoke method " + methodInfo.Name + ": " + ex.Message);
}
}
}
catch (Exception ex2)
{
Logger.LogWarning("[NetworkUtils] Error processing method " + methodInfo.Name + " in type " + item.Name + ": " + ex2.Message);
}
}
}
}
catch (Exception ex3)
{
Logger.LogError("[NetworkUtils] Failed to run NetcodePatcherAwake: " + ex3.Message);
}
}
public static bool IsExecutingRPCMethod(NetworkBehaviour networkBehaviour)
{
if ((Object)(object)networkBehaviour == (Object)null)
{
return false;
}
NetworkManager networkManager = networkBehaviour.NetworkManager;
if ((Object)(object)networkManager == (Object)null || !networkManager.IsListening)
{
return false;
}
if (_rpcExecStageField == null)
{
Logger.LogError("[NetworkUtils] IsExecutingRPCMethod: Failed to find \"__rpc_exec_stage\" field.");
return false;
}
object value = _rpcExecStageField.GetValue(networkBehaviour);
int num = (int)value;
if (num != 0)
{
return num == 1;
}
return true;
}
}
internal static class PlayerUtils
{
public static PlayerControllerB LocalPlayerScript => GameNetworkManager.Instance?.localPlayerController ?? null;
public static PlayerControllerB[] AllPlayerScripts => StartOfRound.Instance?.allPlayerScripts ?? Array.Empty<PlayerControllerB>();
public static PlayerControllerB[] ConnectedPlayerScripts => AllPlayerScripts.Where(IsConnected).ToArray();
public static PlayerControllerB[] AlivePlayerScripts => ConnectedPlayerScripts.Where((PlayerControllerB x) => !x.isPlayerDead).ToArray();
public static PlayerControllerB[] DeadPlayerScripts => ConnectedPlayerScripts.Where((PlayerControllerB x) => x.isPlayerDead).ToArray();
public static bool TryGetLocalPlayerScript(out PlayerControllerB playerScript)
{
playerScript = LocalPlayerScript;
return (Object)(object)playerScript != (Object)null;
}
public static bool IsLocalPlayer(PlayerControllerB playerScript)
{
if ((Object)(object)playerScript == (Object)null)
{
return false;
}
return (Object)(object)playerScript == (Object)(object)LocalPlayerScript;
}
public static bool IsConnected(PlayerControllerB playerScript)
{
if ((Object)(object)playerScript == (Object)null)
{
return false;
}
if (!playerScript.isPlayerControlled)
{
return playerScript.isPlayerDead;
}
return true;
}
public static PlayerControllerB GetPlayerScriptByClientId(ulong clientId)
{
return ((IEnumerable<PlayerControllerB>)ConnectedPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB playerScript) => playerScript.actualClientId == clientId));
}
public static bool TryGetPlayerScriptByClientId(ulong clientId, out PlayerControllerB playerScript)
{
playerScript = GetPlayerScriptByClientId(clientId);
return (Object)(object)playerScript != (Object)null;
}
public static PlayerControllerB GetPlayerScriptByPlayerId(int playerId)
{
if (playerId < 0 || playerId > ConnectedPlayerScripts.Length - 1)
{
return null;
}
return ConnectedPlayerScripts[playerId];
}
public static bool TryGetPlayerScriptByPlayerId(int playerId, out PlayerControllerB playerScript)
{
playerScript = GetPlayerScriptByPlayerId(playerId);
return (Object)(object)playerScript != (Object)null;
}
public static PlayerControllerB GetPlayerScriptByUsername(string username)
{
PlayerControllerB[] source = ConnectedPlayerScripts.OrderBy((PlayerControllerB x) => x.playerUsername.Length).ToArray();
PlayerControllerB val = ((IEnumerable<PlayerControllerB>)source).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB x) => x.playerUsername.Equals(username, StringComparison.OrdinalIgnoreCase)));
if (val == null)
{
val = ((IEnumerable<PlayerControllerB>)source).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB x) => x.playerUsername.StartsWith(username, StringComparison.OrdinalIgnoreCase)));
}
if (val == null)
{
val = ((IEnumerable<PlayerControllerB>)source).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB x) => x.playerUsername.Contains(username, StringComparison.OrdinalIgnoreCase)));
}
return val;
}
public static bool TryGetPlayerScriptByUsername(string username, out PlayerControllerB playerScript)
{
playerScript = GetPlayerScriptByUsername(username);
return (Object)(object)playerScript != (Object)null;
}
public static PlayerControllerB GetRandomPlayerScript(PlayerControllerB[] playerScripts, bool excludeLocal = false)
{
if (playerScripts == null || playerScripts.Length == 0)
{
return null;
}
PlayerControllerB[] array = playerScripts.Where((PlayerControllerB playerScript) => !excludeLocal || !IsLocalPlayer(playerScript)).ToArray();
if (array.Length == 0)
{
return null;
}
return array[Random.Range(0, array.Length)];
}
public static bool TryGetRandomPlayerScript(PlayerControllerB[] playerScripts, out PlayerControllerB playerScript, bool excludeLocal = false)
{
playerScript = GetRandomPlayerScript(playerScripts, excludeLocal);
return (Object)(object)playerScript != (Object)null;
}
}
internal static class Utils
{
public static string GetPluginDirectoryPath()
{
return Path.GetDirectoryName(((BaseUnityPlugin)Plugin.Instance).Info.Location);
}
public static string GetConfigDirectoryPath()
{
return Paths.ConfigPath;
}
public static string GetPluginPersistentDataPath()
{
return Path.Combine(Application.persistentDataPath, "RemoveInteriorFog");
}
public static ConfigFile CreateConfigFile(BaseUnityPlugin plugin, string path, string name = null, bool saveOnInit = false)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
BepInPlugin metadata = MetadataHelper.GetMetadata((object)plugin);
if (name == null)
{
name = metadata.GUID;
}
name += ".cfg";
return new ConfigFile(Path.Combine(path, name), saveOnInit, metadata);
}
public static ConfigFile CreateLocalConfigFile(BaseUnityPlugin plugin, string name = null, bool saveOnInit = false)
{
return CreateConfigFile(plugin, GetConfigDirectoryPath(), name, saveOnInit);
}
public static ConfigFile CreateGlobalConfigFile(BaseUnityPlugin plugin, string name = null, bool saveOnInit = false)
{
string pluginPersistentDataPath = GetPluginPersistentDataPath();
if (name == null)
{
name = "global";
}
return CreateConfigFile(plugin, pluginPersistentDataPath, name, saveOnInit);
}
public static bool RollPercentChance(float percent)
{
if (percent <= 0f)
{
return false;
}
if (percent >= 100f)
{
return true;
}
return Random.value * 100f <= percent;
}
}
}
namespace com.github.zehsteam.RemoveInteriorFog.Extensions
{
internal static class AssemblyExtensions
{
public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly)
{
if (assembly == null)
{
return Array.Empty<Type>();
}
try
{
return assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
return ex.Types.Where((Type type) => type != null);
}
}
}
internal static class CollectionExtensions
{
public static IEnumerable<T> ToCollection<T>(this string s, string separator = ",")
{
if (string.IsNullOrEmpty(s))
{
return Array.Empty<T>();
}
T result;
return from x in s.Split(separator, StringSplitOptions.RemoveEmptyEntries)
where !string.IsNullOrWhiteSpace(x)
select x.Trim() into x
select (!x.TryConvertTo<T>(out result)) ? default(T) : result into x
where x != null
select x;
}
public static string AsString<T>(this IEnumerable<T> value, string separator = ", ")
{
if (value == null || !value.Any())
{
return string.Empty;
}
return string.Join(separator, from x in value
where x != null && !string.IsNullOrWhiteSpace(x.ToString())
select x.ToString().Trim());
}
}
internal static class ConfigFileExtensions
{
public static ConfigEntry<T> Bind<T>(this ConfigFile configFile, string section, string key, T defaultValue, string description, AcceptableValueBase acceptableValues)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
if (acceptableValues == null)
{
return configFile.Bind<T>(section, key, defaultValue, description);
}
return configFile.Bind<T>(section, key, defaultValue, new ConfigDescription(description, acceptableValues, Array.Empty<object>()));
}
}
internal static class LocalVolumetricFogExtensions
{
public static Vector3 GetBottomPosition(this LocalVolumetricFog localVolumetricFog)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)localVolumetricFog == (Object)null)
{
return Vector3.zero;
}
Vector3 position = ((Component)localVolumetricFog).transform.position;
position.y -= localVolumetricFog.parameters.size.y / 2f;
return position;
}
}
internal static class StringExtensions
{
public static bool IsHexColor(this string value)
{
return Regex.IsMatch(value, "^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$");
}
public static T ConvertTo<T>(this string s)
{
Type typeFromHandle = typeof(T);
if ((object)typeFromHandle != null)
{
Type type = typeFromHandle;
object obj;
if (type == typeof(int) && int.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
{
obj = result;
}
else
{
Type type2 = typeFromHandle;
if (type2 == typeof(float) && float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
{
obj = result2;
}
else
{
Type type3 = typeFromHandle;
if (type3 == typeof(double) && double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
{
obj = result3;
}
else
{
Type type4 = typeFromHandle;
if (type4 == typeof(bool) && bool.TryParse(s, out var result4))
{
obj = result4;
}
else
{
Type type5 = typeFromHandle;
if (type5 == typeof(string))
{
obj = s;
}
else
{
Type type6 = typeFromHandle;
if (!type6.IsEnum || !Enum.TryParse(type6, s, ignoreCase: true, out object result5))
{
goto IL_0121;
}
obj = result5;
}
}
}
}
}
object obj2 = obj;
return (T)obj2;
}
goto IL_0121;
IL_0121:
throw new NotSupportedException($"Unsupported value type: {typeof(T)}");
}
public static bool TryConvertTo<T>(this string s, out T result)
{
try
{
result = s.ConvertTo<T>();
return true;
}
catch
{
result = default(T);
return false;
}
}
}
internal static class TransformExtensions
{
public static string GetHierarchyPath(this Transform transform)
{
if ((Object)(object)transform == (Object)null)
{
return string.Empty;
}
string text = ((Object)transform).name;
Transform val = transform;
while ((Object)(object)val.parent != (Object)null)
{
val = val.parent;
text = ((Object)val).name + "/" + text;
}
return text;
}
}
}
namespace com.github.zehsteam.RemoveInteriorFog.Dependencies.LethalConfigMod
{
internal static class LethalConfigProxy
{
public const string PLUGIN_GUID = "ainavt.lc.lethalconfig";
public static bool IsInstalled => Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig");
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static void SkipAutoGen()
{
LethalConfigManager.SkipAutoGen();
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static object AddConfig<T>(ConfigEntry<T> configEntry, bool requiresRestart = false)
{
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Expected O, but got Unknown
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Expected O, but got Unknown
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Expected O, but got Unknown
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Expected O, but got Unknown
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Expected O, but got Unknown
if (typeof(T).IsEnum)
{
MethodInfo methodInfo = AccessTools.Method(typeof(LethalConfigProxy), "AddEnumDropdown", (Type[])null, (Type[])null);
MethodInfo methodInfo2 = methodInfo.MakeGenericMethod(typeof(T));
object? obj = methodInfo2.Invoke(null, new object[2] { configEntry, requiresRestart });
return (obj is BaseConfigItem) ? obj : null;
}
AcceptableValueBase acceptableValues = ((ConfigEntryBase)configEntry).Description.AcceptableValues;
if (acceptableValues != null)
{
if (acceptableValues is AcceptableValueRange<float> || acceptableValues is AcceptableValueRange<int>)
{
return AddConfigSlider<T>(configEntry, requiresRestart);
}
if (acceptableValues is AcceptableValueList<string>)
{
return AddConfigDropdown<T>(configEntry, requiresRestart);
}
}
if (configEntry is ConfigEntry<string> val && IsConfigEntryForHexColor(val))
{
return AddConfigItem((BaseConfigItem)new HexColorInputFieldConfigItem(val, requiresRestart));
}
if (!(configEntry is ConfigEntry<int> val2))
{
if (!(configEntry is ConfigEntry<float> val3))
{
if (!(configEntry is ConfigEntry<bool> val4))
{
if (configEntry is ConfigEntry<string> val5)
{
return AddConfigItem((BaseConfigItem)new TextInputFieldConfigItem(val5, requiresRestart));
}
throw new NotSupportedException($"Unsupported type: {typeof(T)}");
}
return AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(val4, requiresRestart));
}
return AddConfigItem((BaseConfigItem)new FloatInputFieldConfigItem(val3, requiresRestart));
}
return AddConfigItem((BaseConfigItem)new IntInputFieldConfigItem(val2, requiresRestart));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static object AddButton(string section, string name, string buttonText, string description, Action callback)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
BaseConfigItem configItem = (BaseConfigItem)new GenericButtonConfigItem(section, name, description, buttonText, (GenericButtonHandler)delegate
{
callback?.Invoke();
});
return AddConfigItem(configItem);
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddConfigSlider<T>(ConfigEntry<T> configEntry, bool requiresRestart = false)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Expected O, but got Unknown
if (!(configEntry is ConfigEntry<float> val))
{
if (configEntry is ConfigEntry<int> val2)
{
return AddConfigItem((BaseConfigItem)new IntSliderConfigItem(val2, requiresRestart));
}
throw new NotSupportedException($"Slider not supported for type: {typeof(T)}");
}
return AddConfigItem((BaseConfigItem)new FloatSliderConfigItem(val, requiresRestart));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddConfigDropdown<T>(ConfigEntry<T> configEntry, bool requiresRestart = false)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
if (configEntry is ConfigEntry<string> val)
{
return AddConfigItem((BaseConfigItem)new TextDropDownConfigItem(val, requiresRestart));
}
throw new NotSupportedException($"Dropdown not supported for type: {typeof(T)}");
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddEnumDropdown<T>(ConfigEntry<T> configEntry, bool requiresRestart = false) where T : Enum
{
return AddConfigItem((BaseConfigItem)(object)new EnumDropDownConfigItem<T>(configEntry, requiresRestart));
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static bool IsConfigEntryForHexColor(ConfigEntry<string> configEntry)
{
if (!(((ConfigEntryBase)configEntry).DefaultValue is string value))
{
return false;
}
return value.IsHexColor();
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddConfigItem(BaseConfigItem configItem)
{
LethalConfigManager.AddConfigItem(configItem);
return configItem;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
