using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Json;
using System.Text.Json.Serialization;
using AK;
using Agents;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Hook;
using CellMenu;
using DropServer;
using DropServer.BoosterImplants;
using DropServer.VanityItems;
using GTFO.API;
using GTFO.API.Utilities;
using GameData;
using GameEvent;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppInterop.Runtime.Runtime;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Threading.Tasks;
using LevelGeneration;
using Localization;
using MTFO.Managers;
using Microsoft.CodeAnalysis;
using Oxygen.Components;
using Oxygen.Config;
using Oxygen.Utils;
using Oxygen.Utils.PartialData;
using Player;
using SNetwork;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Oxygen")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Oxygen")]
[assembly: AssemblyTitle("Oxygen")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace Oxygen
{
[BepInPlugin("Inas.Oxygen", "Oxygen", "1.2.1")]
[BepInProcess("GTFO.exe")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BasePlugin
{
[CompilerGenerated]
private static class <>O
{
public static Action <0>__Setup;
public static Action <1>__OnBuildDone;
public static Action <2>__OnLevelCleanup;
public static Action <3>__Setup;
public static Action <4>__OnLevelCleanup;
public static Action <5>__OnBuildStart;
public static Action <6>__OnLevelCleanup;
public static LiveEditEventHandler <7>__Listener_FileChanged1;
}
public const string MODNAME = "Oxygen";
public const string AUTHOR = "Inas";
public const string GUID = "Inas.Oxygen";
public const string VERSION = "1.2.1";
public static readonly string OXYGEN_CONFIG_PATH = Path.Combine(ConfigManager.CustomPath, "Oxygen");
public static Dictionary<uint, OxygenBlock> lookup = new Dictionary<uint, OxygenBlock>();
private static LiveEditListener listener = null;
public override void Load()
{
//IL_013a: Unknown result type (might be due to invalid IL or missing references)
//IL_0228: Unknown result type (might be due to invalid IL or missing references)
//IL_022d: Unknown result type (might be due to invalid IL or missing references)
//IL_0233: Expected O, but got Unknown
if (!Directory.Exists(OXYGEN_CONFIG_PATH))
{
Directory.CreateDirectory(OXYGEN_CONFIG_PATH);
StreamWriter streamWriter = File.CreateText(Path.Combine(OXYGEN_CONFIG_PATH, "Template.json"));
streamWriter.WriteLine(ConfigManager.Serialize(new OxygenConfig()));
streamWriter.Flush();
streamWriter.Close();
}
ClassInjector.RegisterTypeInIl2Cpp<AirManager>();
LevelAPI.OnBuildStart += AirManager.Setup;
LevelAPI.OnBuildDone += AirManager.OnBuildDone;
LevelAPI.OnLevelCleanup += AirManager.OnLevelCleanup;
ClassInjector.RegisterTypeInIl2Cpp<AirBar>();
LevelAPI.OnBuildStart += AirBar.Setup;
LevelAPI.OnLevelCleanup += AirBar.OnLevelCleanup;
ClassInjector.RegisterTypeInIl2Cpp<AirPlane>();
LevelAPI.OnBuildStart += AirPlane.OnBuildStart;
LevelAPI.OnLevelCleanup += AirPlane.OnLevelCleanup;
new Harmony("Inas.Oxygen").PatchAll();
foreach (string item in Directory.EnumerateFiles(OXYGEN_CONFIG_PATH, "*.json", SearchOption.AllDirectories))
{
ConfigManager.Load<OxygenConfig>(item, out var config);
foreach (OxygenBlock block in config.Blocks)
{
foreach (uint fogSetting in block.FogSettings)
{
if (!lookup.ContainsKey(fogSetting))
{
lookup.Add(fogSetting, block);
}
}
}
}
listener = LiveEdit.CreateListener(OXYGEN_CONFIG_PATH, "*.json", true);
LiveEditListener obj = listener;
object obj2 = <>O.<7>__Listener_FileChanged1;
if (obj2 == null)
{
LiveEditEventHandler val = Listener_FileChanged1;
<>O.<7>__Listener_FileChanged1 = val;
obj2 = (object)val;
}
obj.FileChanged += (LiveEditEventHandler)obj2;
}
private static void Listener_FileChanged1(LiveEditEventArgs e)
{
Log.Warning("LiveEdit File Changed: " + e.FullPath + ".");
LiveEdit.TryReadFileContent(e.FullPath, (Action<string>)delegate(string content)
{
foreach (OxygenBlock block in ConfigManager.Deserialize<OxygenConfig>(content).Blocks)
{
foreach (uint fogSetting in block.FogSettings)
{
if (lookup.ContainsKey(fogSetting))
{
lookup.Remove(fogSetting);
}
lookup.Add(fogSetting, block);
Log.Warning($"Replaced OxygenConfig for FogSetting: {fogSetting}.");
}
}
if (GameStateManager.IsInExpedition)
{
AirManager.Current.UpdateAirConfig(AirManager.Current.FogSetting(), LiveEditForceUpdate: true);
}
});
}
}
}
namespace Oxygen.Utils
{
internal static class Extension
{
public static T Instantiate<T>(this GameObject gameObject, string name) where T : Component
{
GameObject obj = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent, false);
((Object)obj).name = name;
return obj.GetComponent<T>();
}
}
internal class LocalizedTextConverter : JsonConverter<LocalizedText>
{
public override bool HandleNull => false;
public override LocalizedText Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_002c: 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_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Expected O, but got Unknown
switch (reader.TokenType)
{
case JsonTokenType.String:
{
string @string = reader.GetString();
return new LocalizedText
{
Id = 0u,
UntranslatedText = @string
};
}
case JsonTokenType.Number:
return new LocalizedText
{
Id = reader.GetUInt32(),
UntranslatedText = null
};
default:
throw new JsonException($"LocalizedTextJson type: {reader.TokenType} is not implemented!");
}
}
public override void Write(Utf8JsonWriter writer, LocalizedText value, JsonSerializerOptions options)
{
JsonSerializer.Serialize<LocalizedText>(writer, value, options);
}
}
internal static class Log
{
private static ManualLogSource source;
static Log()
{
source = Logger.CreateLogSource("Oxygen");
}
public static void Debug(object msg)
{
source.LogDebug(msg);
}
public static void Error(object msg)
{
source.LogError(msg);
}
public static void Fatal(object msg)
{
source.LogFatal(msg);
}
public static void Info(object msg)
{
source.LogInfo(msg);
}
public static void Message(object msg)
{
source.LogMessage(msg);
}
public static void Warning(object msg)
{
source.LogWarning(msg);
}
}
}
namespace Oxygen.Utils.PartialData
{
public static class MTFOPartialDataUtil
{
public const string PLUGIN_GUID = "MTFO.Extension.PartialBlocks";
public static JsonConverter PersistentIDConverter { get; private set; }
public static JsonConverter LocalizedTextConverter { get; private set; }
public static bool IsLoaded { get; private set; }
public static bool Initialized { get; private set; }
public static string PartialDataPath { get; private set; }
public static string ConfigPath { get; private set; }
static MTFOPartialDataUtil()
{
PersistentIDConverter = null;
LocalizedTextConverter = null;
IsLoaded = false;
Initialized = false;
PartialDataPath = string.Empty;
ConfigPath = string.Empty;
if (!((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue("MTFO.Extension.PartialBlocks", out var value))
{
return;
}
try
{
Assembly obj = ((value == null) ? null : value.Instance?.GetType()?.Assembly) ?? null;
if ((object)obj == null)
{
throw new Exception("Assembly is Missing!");
}
Type[] types = obj.GetTypes();
Type type = types.First((Type t) => t.Name == "PersistentIDConverter");
if ((object)type == null)
{
throw new Exception("Unable to Find PersistentIDConverter Class");
}
Type type2 = types.First((Type t) => t.Name == "LocalizedTextConverter");
if ((object)type2 == null)
{
throw new Exception("Unable to Find LocalizedTextConverter Class");
}
Type obj2 = types.First((Type t) => t.Name == "PartialDataManager") ?? throw new Exception("Unable to Find PartialDataManager Class");
PropertyInfo property = obj2.GetProperty("Initialized", BindingFlags.Static | BindingFlags.Public);
PropertyInfo property2 = obj2.GetProperty("PartialDataPath", BindingFlags.Static | BindingFlags.Public);
PropertyInfo? property3 = obj2.GetProperty("ConfigPath", BindingFlags.Static | BindingFlags.Public);
if ((object)property == null)
{
throw new Exception("Unable to Find Property: Initialized");
}
if ((object)property2 == null)
{
throw new Exception("Unable to Find Property: PartialDataPath");
}
if ((object)property3 == null)
{
throw new Exception("Unable to Find Field: ConfigPath");
}
Initialized = (bool)property.GetValue(null);
PartialDataPath = (string)property2.GetValue(null);
ConfigPath = (string)property3.GetValue(null);
PersistentIDConverter = (JsonConverter)Activator.CreateInstance(type);
LocalizedTextConverter = (JsonConverter)Activator.CreateInstance(type2);
IsLoaded = true;
}
catch (Exception value2)
{
Log.Error($"Exception thrown while reading data from MTFO_Extension_PartialData:\n{value2}");
}
}
}
public static class MTFOUtil
{
public const string PLUGIN_GUID = "com.dak.MTFO";
public const BindingFlags PUBLIC_STATIC = BindingFlags.Static | BindingFlags.Public;
public static string GameDataPath { get; private set; }
public static string CustomPath { get; private set; }
public static bool HasCustomContent { get; private set; }
public static bool IsLoaded { get; private set; }
static MTFOUtil()
{
GameDataPath = string.Empty;
CustomPath = string.Empty;
HasCustomContent = false;
IsLoaded = false;
if (!((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue("com.dak.MTFO", out var value))
{
return;
}
try
{
Assembly obj = ((value == null) ? null : value.Instance?.GetType()?.Assembly) ?? null;
if ((object)obj == null)
{
throw new Exception("Assembly is Missing!");
}
Type obj2 = obj.GetTypes().First((Type t) => t.Name == "ConfigManager") ?? throw new Exception("Unable to Find ConfigManager Class");
FieldInfo field = obj2.GetField("GameDataPath", BindingFlags.Static | BindingFlags.Public);
FieldInfo field2 = obj2.GetField("CustomPath", BindingFlags.Static | BindingFlags.Public);
FieldInfo? field3 = obj2.GetField("HasCustomContent", BindingFlags.Static | BindingFlags.Public);
if ((object)field == null)
{
throw new Exception("Unable to Find Field: GameDataPath");
}
if ((object)field2 == null)
{
throw new Exception("Unable to Find Field: CustomPath");
}
if ((object)field3 == null)
{
throw new Exception("Unable to Find Field: HasCustomContent");
}
GameDataPath = (string)field.GetValue(null);
CustomPath = (string)field2.GetValue(null);
HasCustomContent = (bool)field3.GetValue(null);
IsLoaded = true;
}
catch (Exception value2)
{
Log.Error($"Exception thrown while reading path from DataDumper (MTFO): \n{value2}");
}
}
}
}
namespace Oxygen.Patches
{
[HarmonyPatch]
internal class Patches_Dam_PlayerDamageLocal
{
[HarmonyPrefix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveNoAirDamage")]
public static bool Pre_ReceiveNoAirDamage(Dam_PlayerDamageLocal __instance, pMiniDamageData data)
{
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
float num = ((UFloat16)(ref data.damage)).Get(((Dam_SyncedDamageBase)__instance).HealthMax);
((Dam_PlayerDamageBase)__instance).m_nextRegen = Clock.Time + ((Dam_PlayerDamageBase)__instance).Owner.PlayerData.healthRegenStartDelayAfterDamage;
if (((Agent)((Dam_PlayerDamageBase)__instance).Owner).IsLocallyOwned)
{
DramaManager.CurrentState.OnLocalDamage(num);
GameEventManager.PostEvent((eGameEvent)13, ((Dam_PlayerDamageBase)__instance).Owner, num, "", (Dictionary<string, string>)null);
}
else
{
DramaManager.CurrentState.OnTeammatesDamage(num);
}
if (((Dam_PlayerDamageBase)__instance).IgnoreAllDamage)
{
return false;
}
if (SNet.IsMaster && !((Dam_SyncedDamageBase)__instance).RegisterDamage(num))
{
((Dam_SyncedDamageBase)__instance).SendSetHealth(((Dam_SyncedDamageBase)__instance).Health);
}
__instance.Hitreact(((UFloat16)(ref data.damage)).Get(((Dam_SyncedDamageBase)__instance).HealthMax), Vector3.zero, true, false, false);
return false;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveBulletDamage")]
public static void Post_ReceiveBulletDamage()
{
AirManager.Current.ResetHealthToRegen();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveMeleeDamage")]
public static void Post_ReceiveMeleeDamage()
{
AirManager.Current.ResetHealthToRegen();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveFireDamage")]
public static void Post_ReceiveFireDamage()
{
AirManager.Current.ResetHealthToRegen();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveShooterProjectileDamage")]
public static void Post_ReceiveShooterProjectileDamage()
{
AirManager.Current.ResetHealthToRegen();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveTentacleAttackDamage")]
public static void Post_ReceiveTentacleAttackDamage()
{
AirManager.Current.ResetHealthToRegen();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceivePushDamage")]
public static void Post_ReceivePushDamage()
{
AirManager.Current.ResetHealthToRegen();
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Dam_PlayerDamageLocal), "ReceiveSetDead")]
public static void Post_ReceiveSetDead()
{
AirManager.Current.ResetHealthToRegen();
}
}
[HarmonyPatch(typeof(EnvironmentStateManager), "UpdateFog")]
internal class EnvironmentStateManager_UpdateFog
{
public static void Prefix(EnvironmentStateManager __instance)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)AirManager.Current == (Object)null)
{
return;
}
FogState val = ((Il2CppArrayBase<FogState>)(object)__instance.m_stateReplicator.State.FogStates)[__instance.m_latestKnownLocalDimensionCreationIndex];
if (val.FogDataID != 0)
{
AirManager.Current.UpdateAirConfig(val.FogDataID);
if (!AirManager.Current.HasAirConfig())
{
AirManager.Current.StopInfectionLoop();
}
}
}
}
[HarmonyPatch(typeof(FogRepeller_Sphere), "StartRepelling")]
internal class FogRepeller_Sphere_StartRepelling
{
public static void Postfix(ref FogRepeller_Sphere __instance)
{
if (__instance.m_infectionShield != null)
{
EffectVolumeManager.UnregisterVolume((EffectVolume)(object)__instance.m_infectionShield);
((EffectVolume)__instance.m_infectionShield).contents = (eEffectVolumeContents)0;
EffectVolumeManager.RegisterVolume((EffectVolume)(object)__instance.m_infectionShield);
}
}
}
[HarmonyPatch(typeof(LocalPlayerAgentSettings), "UpdateBlendTowardsTargetFogSetting")]
internal class LocalPlayerAgentSettings_UpdateBlendTowardsTargetFogSetting
{
public static void Postfix(LocalPlayerAgentSettings __instance, float amount)
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
if (!AirManager.Current.HasAirConfig())
{
AirPlane.Current.Unregister();
}
else
{
if (__instance.m_targetFogSettings == null || !SNet.LocalPlayer.HasPlayerAgent)
{
return;
}
PlayerAgent localPlayerAgent = PlayerManager.GetLocalPlayerAgent();
if ((Object)(object)localPlayerAgent.FPSCamera == (Object)null)
{
return;
}
AirPlane current = AirPlane.Current;
if (!((Object)(object)current == (Object)null) && RundownManager.ExpeditionIsStarted)
{
float num = 0f;
Dimension val = default(Dimension);
if (Dimension.GetDimension(((Agent)localPlayerAgent).DimensionIndex, ref val))
{
num = val.GroundY;
}
PreLitVolume prelitVolume = localPlayerAgent.FPSCamera.PrelitVolume;
((EffectVolume)current.airPlane).invert = (double)prelitVolume.m_densityHeightMaxBoost > (double)prelitVolume.m_fogDensity;
((EffectVolume)current.airPlane).contents = (eEffectVolumeContents)1;
((EffectVolume)current.airPlane).modification = (eEffectVolumeModification)0;
((EffectVolume)current.airPlane).modificationScale = AirManager.Current.AirLoss();
current.airPlane.lowestAltitude = prelitVolume.m_densityHeightAltitude + num;
current.airPlane.highestAltitude = prelitVolume.m_densityHeightAltitude + prelitVolume.m_densityHeightRange + num;
AirPlane.Current.Register();
}
}
}
}
[HarmonyPatch(typeof(PlayerAgent), "ReceiveModification")]
internal class PlayerAgent_ReceiveModification
{
public static void Prefix(PlayerAgent __instance, ref EV_ModificationData data)
{
if (AirManager.Current.HasAirConfig())
{
if ((double)data.health != 0.0)
{
AirManager.Current.RemoveAir(data.health);
}
else
{
AirManager.Current.AddAir();
}
data.health = 0f;
}
}
}
}
namespace Oxygen.Config
{
public class ConfigManager
{
private static readonly JsonSerializerOptions s_SerializerOptions;
public static T Deserialize<T>(string json)
{
return JsonSerializer.Deserialize<T>(json, s_SerializerOptions);
}
public static string Serialize<T>(T value)
{
return JsonSerializer.Serialize(value, s_SerializerOptions);
}
static ConfigManager()
{
s_SerializerOptions = new JsonSerializerOptions
{
AllowTrailingCommas = true,
ReadCommentHandling = JsonCommentHandling.Skip,
PropertyNameCaseInsensitive = true,
WriteIndented = true
};
s_SerializerOptions.Converters.Add(new JsonStringEnumConverter());
if (MTFOPartialDataUtil.IsLoaded && MTFOPartialDataUtil.Initialized)
{
s_SerializerOptions.Converters.Add(MTFOPartialDataUtil.PersistentIDConverter);
s_SerializerOptions.Converters.Add(MTFOPartialDataUtil.LocalizedTextConverter);
Log.Message("PartialData Support Found!");
}
else
{
s_SerializerOptions.Converters.Add(new LocalizedTextConverter());
}
}
public static void Load<T>(string file, out T config) where T : new()
{
if (file.Length < ".json".Length)
{
config = default(T);
return;
}
if (file.Substring(file.Length - ".json".Length) != ".json")
{
file += ".json";
}
file = File.ReadAllText(Path.Combine(ConfigManager.CustomPath, "Oxygen", file));
config = Deserialize<T>(file);
}
}
public class AirText
{
public float x { get; set; }
public float y { get; set; }
public LocalizedText Text { get; set; }
}
public class OxygenConfig
{
public List<OxygenBlock> Blocks { get; set; } = new List<OxygenBlock>
{
new OxygenBlock()
};
}
public class OxygenBlock
{
public float AirLoss { get; set; }
public float AirGain { get; set; } = 1f;
public float DamageTime { get; set; } = 1f;
public float DamageAmount { get; set; }
public bool ShatterGlass { get; set; }
public float ShatterAmount { get; set; }
public float DamageThreshold { get; set; } = 0.1f;
public bool AlwaysDisplayAirBar { get; set; }
public float HealthRegenProportion { get; set; } = 1f;
public float TimeToStartHealthRegen { get; set; } = 3f;
public float TimeToCompleteHealthRegen { get; set; } = 5f;
public AirText AirText { get; set; }
public List<uint> FogSettings { get; set; } = new List<uint> { 0u };
}
}
namespace Oxygen.Components
{
public class AirBar : MonoBehaviour
{
public static AirBar Current;
private TextMeshPro m_airText;
private TextMeshPro m_airTextLocalization;
private float m_airTextX;
private float m_airTextY;
private float m_airTextZ;
private RectTransform m_air1;
private RectTransform m_air2;
private SpriteRenderer m_airBar1;
private SpriteRenderer m_airBar2;
private float m_airWidth = 100f;
private float m_barHeightMin = 3f;
private float m_barHeightMax = 9f;
private Color m_airLow = new Color(0f, 0.5f, 0.5f);
private Color m_airHigh = new Color(0f, 0.3f, 0.8f);
public AirBar(IntPtr value)
: base(value)
{
}//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
public static void Setup()
{
if ((Object)(object)Current == (Object)null)
{
Current = ((Component)GuiManager.Current.m_playerLayer.m_playerStatus).gameObject.AddComponent<AirBar>();
Current.Init();
}
}
private void Init()
{
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_0270: Unknown result type (might be due to invalid IL or missing references)
//IL_027a: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)m_airText == (Object)null)
{
m_airText = ((Component)GuiManager.Current.m_playerLayer.m_playerStatus.m_healthText).gameObject.Instantiate<TextMeshPro>("AirText");
TextMeshPro airText = m_airText;
((TMP_Text)airText).fontSize = ((TMP_Text)airText).fontSize / 1.25f;
m_airText.transform.Translate(0f, -30f, 0f);
}
if ((Object)(object)m_airTextLocalization == (Object)null)
{
m_airTextLocalization = ((Component)GuiManager.Current.m_playerLayer.m_playerStatus.m_pulseText).gameObject.Instantiate<TextMeshPro>("AirText Localization");
((Behaviour)m_airTextLocalization).enabled = true;
m_airTextLocalization.transform.Translate(300f - m_airWidth, -45f, 0f);
m_airTextX = m_airTextLocalization.transform.position.x;
m_airTextY = m_airTextLocalization.transform.position.y;
m_airTextZ = m_airTextLocalization.transform.position.z;
}
if ((Object)(object)m_air1 == (Object)null)
{
m_air1 = ((Component)((Component)GuiManager.Current.m_playerLayer.m_playerStatus.m_health1).gameObject.transform.parent).gameObject.Instantiate<RectTransform>("AirFill Right");
((Component)m_air1).transform.Translate(0f, -30f, 0f);
SpriteRenderer component = ((Component)((Transform)m_air1).GetChild(0)).GetComponent<SpriteRenderer>();
component.size = new Vector2(m_airWidth, component.size.y);
m_airBar1 = ((Component)((Transform)m_air1).GetChild(1)).GetComponent<SpriteRenderer>();
((Renderer)((Component)((Transform)m_air1).GetChild(2)).GetComponent<SpriteRenderer>()).enabled = false;
}
if ((Object)(object)m_air2 == (Object)null)
{
m_air2 = ((Component)((Component)GuiManager.Current.m_playerLayer.m_playerStatus.m_health2).gameObject.transform.parent).gameObject.Instantiate<RectTransform>("AirFill Left");
((Component)m_air2).transform.Translate(0f, 30f, 0f);
SpriteRenderer component2 = ((Component)((Transform)m_air2).GetChild(0)).GetComponent<SpriteRenderer>();
component2.size = new Vector2(m_airWidth, component2.size.y);
m_airBar2 = ((Component)((Transform)m_air2).GetChild(1)).GetComponent<SpriteRenderer>();
((Renderer)((Component)((Transform)m_air2).GetChild(2)).GetComponent<SpriteRenderer>()).enabled = false;
}
UpdateAirBar(1f);
SetVisible(vis: false);
}
public void UpdateAirBar(float air)
{
SetAirPercentageText(air);
SetAirBar(m_airBar1, air);
SetAirBar(m_airBar2, air);
}
private void SetAirBar(SpriteRenderer bar, float val)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: 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)
bar.size = new Vector2(val * m_airWidth, Mathf.Lerp(m_barHeightMin, m_barHeightMax, val));
bar.color = Color.Lerp(m_airLow, m_airHigh, val);
}
private void SetAirPercentageText(float val)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
Color color = Color.Lerp(m_airLow, m_airHigh, val);
((TMP_Text)m_airText).text = "O<size=75%>2</size>";
((Graphic)m_airText).color = color;
((TMP_Text)m_airText).ForceMeshUpdate(true, false);
((Graphic)m_airTextLocalization).color = color;
((TMP_Text)m_airTextLocalization).ForceMeshUpdate(true, false);
}
public void UpdateAirText(OxygenBlock config)
{
//IL_007d: 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)
if (config != null)
{
string text = LocalizedText.op_Implicit(config.AirText.Text);
float x = config.AirText.x;
float y = config.AirText.y;
((TMP_Text)m_airTextLocalization).text = text;
((TMP_Text)m_airTextLocalization).ForceMeshUpdate(true, false);
CoroutineManager.BlinkIn(((Component)m_airTextLocalization).gameObject, 0f);
m_airTextLocalization.transform.SetPositionAndRotation(new Vector3(m_airTextX + x, m_airTextY + y, m_airTextZ), m_airTextLocalization.transform.rotation);
}
}
public void SetVisible(bool vis)
{
((Component)m_airText).gameObject.SetActive(vis);
((Component)m_airTextLocalization).gameObject.SetActive(vis);
((Component)m_air1).gameObject.SetActive(vis);
((Component)m_air2).gameObject.SetActive(vis);
}
public static void OnLevelCleanup()
{
if (!((Object)(object)Current == (Object)null))
{
Current.SetVisible(vis: false);
}
}
}
public class AirManager : MonoBehaviour
{
public static AirManager Current;
public PlayerAgent m_playerAgent;
private HUDGlassShatter m_hudGlass;
private Dam_PlayerDamageBase Damage;
public OxygenBlock config;
private uint fogSetting;
private FogSettingsDataBlock fogSettingDB;
private float airAmount = 1f;
private float damageTick;
private float glassShatterAmount;
private bool m_isInInfectionLoop;
private bool isRegeningHealth;
private float healthToRegen;
private float healthRegenTick;
private float tickUntilHealthRegenHealthStart;
private readonly float regenHealthTickInterval = 0.25f;
private float healthRegenAmountPerInterval;
internal bool PlayerShouldCough;
private readonly float CoughPerLoss = 0.1f;
private float CoughLoss;
public AirManager(IntPtr value)
: base(value)
{
}
public static void Setup()
{
if ((Object)(object)Current == (Object)null)
{
Current = ((Component)PlayerManager.Current.m_localPlayerAgentInLevel).gameObject.AddComponent<AirManager>();
}
}
public static void OnBuildDone()
{
if (!((Object)(object)Current == (Object)null))
{
Current.m_playerAgent = PlayerManager.GetLocalPlayerAgent();
Current.m_hudGlass = ((Component)Current.m_playerAgent.FPSCamera).GetComponent<HUDGlassShatter>();
Current.Damage = ((Component)Current.m_playerAgent).gameObject.GetComponent<Dam_PlayerDamageBase>();
Current.UpdateAirConfig(RundownManager.ActiveExpedition.Expedition.FogSettings);
AirBar.Current.UpdateAirText(Current.config);
}
}
public static void OnLevelCleanup()
{
if (!((Object)(object)Current == (Object)null))
{
if (Current.m_isInInfectionLoop)
{
Current.StopInfectionLoop();
}
Current.config = null;
Current.fogSetting = 0u;
Current.fogSettingDB = null;
Current.airAmount = 0f;
Current.damageTick = 0f;
Current.glassShatterAmount = 0f;
Current.healthToRegen = 0f;
Current.m_playerAgent = null;
Current.m_hudGlass = null;
Current.Damage = null;
}
}
private void Update()
{
if (!RundownManager.ExpeditionIsStarted)
{
return;
}
if (!HasAirConfig())
{
AirBar.Current.SetVisible(vis: false);
return;
}
if (airAmount == 1f)
{
if (config.AlwaysDisplayAirBar)
{
AirBar.Current.SetVisible(vis: true);
}
else
{
AirBar.Current.SetVisible(vis: false);
}
}
else
{
AirBar.Current.SetVisible(vis: true);
}
if (airAmount <= config.DamageThreshold)
{
damageTick += Time.deltaTime;
if (damageTick > config.DamageTime && ((Dam_SyncedDamageBase)Damage).Health > 0f && ((Agent)m_playerAgent).Alive)
{
AirDamage();
}
isRegeningHealth = false;
}
else if (healthToRegen > 0f)
{
tickUntilHealthRegenHealthStart += Time.deltaTime;
if (tickUntilHealthRegenHealthStart > config.TimeToStartHealthRegen)
{
if (healthRegenAmountPerInterval == 0f)
{
healthRegenAmountPerInterval = healthToRegen * (regenHealthTickInterval / config.TimeToCompleteHealthRegen);
}
RegenHealth();
if (!isRegeningHealth)
{
Damage.m_nextRegen = Clock.Time + config.TimeToStartHealthRegen + config.TimeToCompleteHealthRegen;
isRegeningHealth = true;
}
}
}
else
{
isRegeningHealth = false;
}
}
public void AddAir()
{
if (HasAirConfig())
{
float airGain = config.AirGain;
airAmount = Mathf.Clamp01(airAmount + airGain);
AirBar.Current.UpdateAirBar(airAmount);
if (fogSettingDB.Infection <= 0f && m_isInInfectionLoop)
{
StopInfectionLoop();
}
}
}
public void RemoveAir(float amount)
{
if (HasAirConfig())
{
amount = config.AirLoss;
airAmount = Mathf.Clamp01(airAmount - amount);
AirBar.Current.UpdateAirBar(airAmount);
if (fogSettingDB.Infection <= 0f && amount > 0f)
{
StartInfectionLoop();
}
}
}
public void AirDamage()
{
float health = ((Dam_SyncedDamageBase)Damage).Health;
float num = config.DamageAmount;
if (num > health)
{
num = ((health > 0f) ? (health - 0.001f) : 0f);
}
((Dam_SyncedDamageBase)Damage).NoAirDamage(num);
if (config.ShatterGlass)
{
glassShatterAmount += config.ShatterAmount;
m_hudGlass.SetGlassShatterProgression(glassShatterAmount);
}
damageTick = 0f;
tickUntilHealthRegenHealthStart = 0f;
healthRegenAmountPerInterval = 0f;
healthToRegen += num * config.HealthRegenProportion;
CoughLoss += num;
if (CoughLoss > CoughPerLoss)
{
PlayerShouldCough = true;
CoughLoss = 0f;
}
}
public void RegenHealth()
{
if (healthToRegen <= 0f)
{
return;
}
tickUntilHealthRegenHealthStart = config.TimeToStartHealthRegen;
healthRegenTick += Time.deltaTime;
if (healthRegenTick > regenHealthTickInterval)
{
float num = healthRegenAmountPerInterval;
if (num >= healthToRegen)
{
num = healthToRegen;
healthToRegen = 0f;
tickUntilHealthRegenHealthStart = 0f;
healthRegenAmountPerInterval = 0f;
isRegeningHealth = false;
}
else
{
healthToRegen -= num;
}
((Dam_SyncedDamageBase)Damage).AddHealth(num, (Agent)(object)m_playerAgent);
healthRegenTick = 0f;
}
}
public void UpdateAirConfig(uint fogsetting, bool LiveEditForceUpdate = false)
{
if (fogsetting != 0 && (fogsetting != fogSetting || LiveEditForceUpdate))
{
if (Plugin.lookup.ContainsKey(fogsetting))
{
config = Plugin.lookup[fogsetting];
}
else if (Plugin.lookup.ContainsKey(0u))
{
config = Plugin.lookup[0u];
}
else
{
config = null;
airAmount = 1f;
}
fogSetting = fogsetting;
fogSettingDB = GameDataBlockBase<FogSettingsDataBlock>.GetBlock(fogsetting);
if (GameStateManager.IsInExpedition)
{
AirBar.Current.UpdateAirText(config);
}
}
}
public void ResetHealthToRegen()
{
healthRegenTick = 0f;
healthToRegen = 0f;
tickUntilHealthRegenHealthStart = 0f;
}
public float AirLoss()
{
if (config != null)
{
return config.AirLoss;
}
return 0f;
}
public bool AlwaysDisplayAirBar()
{
if (config != null)
{
return config.AlwaysDisplayAirBar;
}
return false;
}
public uint FogSetting()
{
return fogSetting;
}
public float HealthToRegen()
{
return healthToRegen;
}
public string AirText()
{
return LocalizedText.op_Implicit((config == null) ? null : config.AirText.Text);
}
public float AirTextX()
{
if (config != null)
{
return config.AirText.x;
}
return 0f;
}
public float AirTextY()
{
if (config != null)
{
return config.AirText.y;
}
return 0f;
}
public bool HasAirConfig()
{
return config != null;
}
public void StartInfectionLoop()
{
if (!m_isInInfectionLoop)
{
m_playerAgent.Sound.Post(EVENTS.INFECTION_EFFECT_LOOP_START, true);
m_isInInfectionLoop = true;
}
}
public void StopInfectionLoop()
{
if (m_isInInfectionLoop)
{
if ((Object)(object)m_playerAgent != (Object)null && m_playerAgent.Sound != null)
{
m_playerAgent.Sound.Post(EVENTS.INFECTION_EFFECT_LOOP_STOP, true);
}
m_isInInfectionLoop = false;
}
}
}
public class AirPlane : MonoBehaviour
{
public static AirPlane Current;
public EV_Plane airPlane;
private bool isAirPlaneRegistered;
public AirPlane(IntPtr value)
: base(value)
{
}
public static void OnBuildStart()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
if ((Object)(object)Current == (Object)null)
{
Current = ((Component)LocalPlayerAgentSettings.Current).gameObject.AddComponent<AirPlane>();
}
Current.airPlane = new EV_Plane();
uint num = RundownManager.ActiveExpedition.Expedition.FogSettings;
if (num == 0)
{
num = 21u;
}
OxygenBlock oxygenBlock = (Plugin.lookup.ContainsKey(num) ? Plugin.lookup[num] : ((!Plugin.lookup.ContainsKey(0u)) ? null : Plugin.lookup[0u]));
FogSettingsDataBlock block = GameDataBlockBase<FogSettingsDataBlock>.GetBlock(num);
((EffectVolume)Current.airPlane).invert = block.DensityHeightMaxBoost > block.FogDensity;
((EffectVolume)Current.airPlane).contents = (eEffectVolumeContents)1;
((EffectVolume)Current.airPlane).modification = (eEffectVolumeModification)0;
Current.airPlane.lowestAltitude = block.DensityHeightAltitude;
Current.airPlane.highestAltitude = block.DensityHeightAltitude + block.DensityHeightRange;
if (oxygenBlock != null)
{
((EffectVolume)Current.airPlane).modificationScale = oxygenBlock.AirLoss;
Current.Register();
}
}
public static void OnLevelCleanup()
{
if (!((Object)(object)Current == (Object)null))
{
Current.Unregister();
Current.isAirPlaneRegistered = false;
Current.airPlane = null;
}
}
public void Register()
{
if (airPlane != null && !isAirPlaneRegistered)
{
EffectVolumeManager.RegisterVolume((EffectVolume)(object)airPlane);
isAirPlaneRegistered = true;
}
}
public void Unregister()
{
if (airPlane != null && isAirPlaneRegistered)
{
EffectVolumeManager.UnregisterVolume((EffectVolume)(object)airPlane);
isAirPlaneRegistered = false;
}
}
}
}
namespace Oxygen.Utils.SU
{
internal class InventoryPatches
{
public unsafe delegate void UpdateItems(IntPtr _this, IntPtr data, Il2CppMethodInfo* methodInfo);
[HarmonyPatch(typeof(DropServerClientAPIViaPlayFab), "GetInventoryPlayerDataAsync")]
public static class DropServerClientAPI_GetInventoryPlayerDataAsync_Patch
{
public static bool Prefix(GetInventoryPlayerDataRequest request, ref Task<GetInventoryPlayerDataResult> __result)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Expected O, but got Unknown
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
VanityItemPlayerData val = new VanityItemPlayerData(ClassInjector.DerivedConstructorPointer<VanityItemPlayerData>());
val.Items = new Il2CppReferenceArray<VanityItem>(0L);
BoosterImplantPlayerData val2 = new BoosterImplantPlayerData(ClassInjector.DerivedConstructorPointer<BoosterImplantPlayerData>());
val2.Advanced = EmptyCat();
val2.Basic = EmptyCat();
val2.Specialized = EmptyCat();
GetInventoryPlayerDataResult val3 = new GetInventoryPlayerDataResult(ClassInjector.DerivedConstructorPointer<GetInventoryPlayerDataResult>())
{
Boosters = val2,
VanityItems = val
};
__result = Task.FromResult<GetInventoryPlayerDataResult>(val3);
return false;
}
}
internal List<INativeDetour> _detours = new List<INativeDetour>();
private UpdateItems _patchMethod;
private UpdateItems _originalUpdateItems;
internal unsafe void ApplyNative()
{
_patchMethod = UpdateItemsPatch;
_detours.Add(INativeDetour.CreateAndApply<UpdateItems>((IntPtr)(nint)Il2CppAPI.GetIl2CppMethod<VanityItemInventory>("UpdateItems", typeof(void).FullName, false, new string[1] { typeof(VanityItemPlayerData).FullName }), _patchMethod, ref _originalUpdateItems));
}
public unsafe void UpdateItemsPatch(IntPtr _this, IntPtr data, Il2CppMethodInfo* methodInfo)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Expected O, but got Unknown
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Expected O, but got Unknown
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
_originalUpdateItems(_this, data, methodInfo);
VanityItemInventory val = new VanityItemInventory(_this);
if (val.m_backednItems == null)
{
val.m_backednItems = new List<VanityItem>(0);
}
foreach (VanityItemsTemplateDataBlock allBlock in GameDataBlockBase<VanityItemsTemplateDataBlock>.GetAllBlocks())
{
VanityItem val2 = new VanityItem(ClassInjector.DerivedConstructorPointer<VanityItem>());
val2.publicName = allBlock.publicName;
val2.type = allBlock.type;
val2.prefab = allBlock.prefab;
val2.flags = (VanityItemFlags)3;
val2.id = ((GameDataBlockBase<VanityItemsTemplateDataBlock>)(object)allBlock).persistentID;
val.m_backednItems.Add(val2);
}
}
private static Category EmptyCat()
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
return new Category(ClassInjector.DerivedConstructorPointer<Category>())
{
Inventory = new Il2CppReferenceArray<BoosterImplantInventoryItem>(0L)
};
}
}
internal static class LobbyPatches
{
[HarmonyPatch(typeof(CM_PlayerLobbyBar), "SetupFromPage")]
public static class CM_PlayerLobbyBar_SetupFromPage_Patch
{
public static void Postfix(CM_PlayerLobbyBar __instance)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
__instance.m_boosterImplantAlign.position = new Vector3(10000f, 0f, 0f);
}
}
}
[BepInPlugin("sameutils", "SamUtils", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BasePlugin
{
public const string PLUGIN_GUID = "sameutils";
public const string PLUGIN_NAME = "SamUtils";
public const string PLUGIN_VERSION = "1.0.0";
private static Plugin _instance;
private readonly Harmony _harmony = new Harmony("sameutils");
private static InventoryPatches _patches;
private static bool _initialLoad = true;
public override void Load()
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected O, but got Unknown
_instance = this;
if (_initialLoad)
{
_harmony.Patch((MethodBase)typeof(GameDataInit).GetMethod("Initialize"), (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin).GetMethod("OnAfterGameDataInit")), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_initialLoad = false;
return;
}
_patches = new InventoryPatches();
_patches.ApplyNative();
_harmony.PatchAll(typeof(LobbyPatches.CM_PlayerLobbyBar_SetupFromPage_Patch));
_harmony.PatchAll(typeof(InventoryPatches.DropServerClientAPI_GetInventoryPlayerDataAsync_Patch));
}
public static void OnAfterGameDataInit()
{
if (!((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.Any((KeyValuePair<string, PluginInfo> p) => p.Value.Metadata.GUID == "samutils"))
{
((BasePlugin)_instance).Load();
}
}
internal static void LogMsg(string v)
{
((BasePlugin)_instance).Log.LogMessage((object)v);
}
}
}