using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalExtras.Patches;
using LethalExtras.UnlockableItems;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
[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("LethalExtras")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Extra stuff for Lethal Company")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0")]
[assembly: AssemblyProduct("LethalExtras")]
[assembly: AssemblyTitle("LethalExtras")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
static <Module>()
{
}
}
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 LethalExtras
{
public class Config
{
public bool blahajEnabled;
public bool redArgemiaEnabled;
public bool blueArgemiaEnabled;
public bool greenArgemiaEnabled;
public bool dingusEnabled;
public bool medstationEnabled;
public int medstationPrice;
public int medstationCharges;
public bool IsLoaded { get; private set; } = false;
public List<ConfigEntryBase> configEntries { get; private set; } = new List<ConfigEntryBase>();
public void Load()
{
blahajEnabled = AddBoolConfig("Scrap", "BlahajEnabled", defaultValues: true, "If enabled, adds blahaj to scrap pool.");
redArgemiaEnabled = AddBoolConfig("Scrap", "RedArgemiaEnabled", defaultValues: true, "If enabled, adds Red Argemia Plush to scrap pool.");
blueArgemiaEnabled = AddBoolConfig("Scrap", "BlueArgemiaEnabled", defaultValues: true, "If enabled, adds Blue Argemia Plush to scrap pool.");
greenArgemiaEnabled = AddBoolConfig("Scrap", "GreenArgemiaEnabled", defaultValues: true, "If enabled, adds Green Argemia Plush to scrap pool.");
dingusEnabled = AddBoolConfig("Scrap", "DingusEnabled", defaultValues: true, "If enabled, adds dingus to scrap pool.");
medstationEnabled = AddBoolConfig("Unlockables", "MedstationEnabled", defaultValues: true, "If enabled, adds the medstation unlockable.");
medstationPrice = AddIntConfig("Unlockables", "MedstationPrice", 600, "Sets the price of the medstation");
medstationCharges = AddIntConfig("Unlockables", "MedstationCharges", 200, "Sets the maximum healing capacity of the medstation");
IsLoaded = true;
}
private bool AddBoolConfig(string section, string key, bool defaultValues, string definition)
{
ConfigEntry<bool> val = Plugin.Instance.Config.Bind<bool>(section, key, defaultValues, definition);
configEntries.Add((ConfigEntryBase)(object)val);
return val.Value;
}
private int AddIntConfig(string section, string key, int defaultValue, string definition)
{
ConfigEntry<int> val = Plugin.Instance.Config.Bind<int>(section, key, defaultValue, definition);
configEntries.Add((ConfigEntryBase)(object)val);
return val.Value;
}
public void SyncConfig(string serialized)
{
}
public void SerializeConfig()
{
}
}
[BepInPlugin("joe1359.lethalextras", "LethalExtras", "1.0.4")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
public const string ModGUID = "lethalextras";
public const string ModName = "LethalExtras";
public const string ModVersion = "1.0.4";
public static AssetBundle MainAssets;
public static List<UnlockableItem> unlockables = new List<UnlockableItem>();
public static BaseUnityPlugin Instance { get; private set; }
public static Config ModConfig { get; private set; }
public static ManualLogSource logger { get; private set; }
private Plugin()
{
HarmonyPatcher.ApplyHarmonyPatches();
}
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = (BaseUnityPlugin)(object)this;
}
PatchNetcode();
if (ModConfig == null)
{
ModConfig = new Config();
ModConfig.Load();
}
logger = Logger.CreateLogSource("lethalextras");
logger.LogInfo((object)"Plugin LethalExtras is loaded!");
MainAssets = AssetBundle.LoadFromFile(Assembly.GetExecutingAssembly().Location.Replace("LethalExtras.dll", "lethalextras"));
InitializeScrap();
InitializeUnlockables();
}
public void InitializeScrap()
{
InitializeScrapItem("Assets/LethalExtras/scrap/blahaj/blahaj.asset", 5, (LevelTypes)510, ModConfig.blahajEnabled);
InitializeScrapItem("Assets/LethalExtras/scrap/ArgemiaPlush/RedArgemiaPlush.asset", 20, (LevelTypes)510, ModConfig.redArgemiaEnabled);
InitializeScrapItem("Assets/LethalExtras/scrap/ArgemiaPlush/BlueArgemiaPlush.asset", 10, (LevelTypes)44, ModConfig.blueArgemiaEnabled);
InitializeScrapItem("Assets/LethalExtras/scrap/ArgemiaPlush/GreenArgemiaPlush.asset", 2, (LevelTypes)448, ModConfig.greenArgemiaEnabled);
InitializeScrapItem("Assets/LethalExtras/scrap/maxwell/dingus.asset", 4, (LevelTypes)510, ModConfig.dingusEnabled);
}
public void InitializeUnlockables()
{
AddUnlockableItem("Medstation", "Assets/LethalExtras/buyable/placeable/medstation/MedstationContainer.prefab", LethalExtras.UnlockableItems.UnlockableItems.UnlockableTypes.Placeable, ModConfig.medstationEnabled, ModConfig.medstationPrice);
}
private UnlockableItem AddUnlockableItem(string unlockableName, string asset, LethalExtras.UnlockableItems.UnlockableItems.UnlockableTypes unlockableType, bool enabled = true, int price = 0)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected O, but got Unknown
GameObject val = LoadPrefabFromAsset(asset);
if ((Object)(object)val == (Object)null)
{
return null;
}
if (!enabled)
{
return null;
}
UnlockableItem val2 = new UnlockableItem();
val2.unlockableName = unlockableName;
val2.prefabObject = val;
val2.unlockableType = (int)unlockableType;
val2.alwaysInStock = true;
val2.IsPlaceable = true;
Unlockables.RegisterUnlockable(val2, (StoreType)1, (TerminalNode)null, (TerminalNode)null, (TerminalNode)null, price);
logger.LogInfo((object)("Loading unlockable: " + unlockableName));
return val2;
}
private GameObject LoadPrefabFromAsset(string asset)
{
if ((Object)(object)MainAssets == (Object)null)
{
return null;
}
GameObject val = MainAssets.LoadAsset<GameObject>(asset);
if ((Object)(object)val == (Object)null)
{
return null;
}
NetworkPrefabs.RegisterNetworkPrefab(val);
return val;
}
private Item LoadItemFromAsset(string asset)
{
if ((Object)(object)MainAssets == (Object)null)
{
return null;
}
Item val = MainAssets.LoadAsset<Item>(asset);
if ((Object)(object)val == (Object)null)
{
return null;
}
NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
return val;
}
private Item CreateItemVariant(Item item, string name, int value, string mesh = null, string material = null)
{
if ((Object)(object)item == (Object)null)
{
return null;
}
Item val = Object.Instantiate<Item>(item);
val.itemName = name;
val.creditsWorth = value;
if (mesh != null)
{
MeshFilter component = val.spawnPrefab.GetComponent<MeshFilter>();
Mesh[] meshVariants = val.meshVariants;
foreach (Mesh val2 in meshVariants)
{
if (((Object)val2).name == mesh)
{
component.mesh = val2;
break;
}
}
}
if (material != null)
{
MeshRenderer component2 = val.spawnPrefab.GetComponent<MeshRenderer>();
Material[] materialVariants = val.materialVariants;
foreach (Material val3 in materialVariants)
{
if (((Object)val3).name == material)
{
((Renderer)component2).material = val3;
break;
}
}
}
NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
return val;
}
private void RegisterScrapItem(Item item, int rarity, LevelTypes levelTypes)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)item == (Object)null))
{
Items.RegisterScrap(item, rarity, levelTypes);
logger.LogInfo((object)("Adding scrap item variant: " + ((Object)item).name));
}
}
private Item InitializeScrapItem(string asset, int rarity, LevelTypes levelTypes, bool enabled = true)
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)MainAssets == (Object)null)
{
return null;
}
Item val = LoadItemFromAsset(asset);
logger.LogInfo((object)("Loading item: " + val.itemName));
if (!enabled)
{
return null;
}
Items.RegisterScrap(val, rarity, levelTypes);
logger.LogInfo((object)("Adding to scrap pool: " + val.itemName));
return val;
}
private Item RegisterShopItem(Item item, TerminalNode buyNode1 = null, TerminalNode buyNode2 = null, TerminalNode itemInfo = null, int price = 0)
{
if ((Object)(object)item == (Object)null)
{
return null;
}
Items.RegisterShopItem(item, price);
logger.LogInfo((object)("Adding shop item: " + item.itemName));
return item;
}
private Item InitializeShopItem(string asset, TerminalNode buyNode1 = null, TerminalNode buyNode2 = null, TerminalNode itemInfo = null, int price = 0)
{
if ((Object)(object)MainAssets == (Object)null)
{
return null;
}
Item val = LoadItemFromAsset(asset);
Items.RegisterShopItem(val, price);
logger.LogInfo((object)("Adding shop item: " + asset));
return val;
}
private void PatchNetcode()
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "LethalExtras";
public const string PLUGIN_NAME = "LethalExtras";
public const string PLUGIN_VERSION = "0.1.0";
}
}
namespace LethalExtras.UnlockableItems
{
public class Medstation : NetworkBehaviour
{
private NetworkVariable<int> maxCharges = new NetworkVariable<int>(Plugin.ModConfig.medstationCharges, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
private NetworkVariable<int> charges = new NetworkVariable<int>(Plugin.ModConfig.medstationCharges, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
public Transform healthCylinderTransform;
public InteractTrigger medstationTrigger;
public AudioClip medstationStartSFX;
public AudioClip medstationInProgressSFX;
public AudioClip medstationEndSFX;
public AudioSource medstationAudio;
private int unlockableId;
private string dataKey;
private MedstationState medstationState = MedstationState.WAITING;
private void Awake()
{
if (!((Object)(object)this == (Object)null))
{
}
}
public override void OnNetworkSpawn()
{
((NetworkVariableBase)maxCharges).Initialize((NetworkBehaviour)(object)this);
((NetworkVariableBase)charges).Initialize((NetworkBehaviour)(object)this);
dataKey = "LethalExtrasData_Unlockables_MedstationCharges";
if (ES3.KeyExists(dataKey, GameNetworkManager.Instance.currentSaveFileName))
{
charges.Value = ES3.Load<int>(dataKey, GameNetworkManager.Instance.currentSaveFileName, charges.Value);
}
}
private void Update()
{
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)this == (Object)null)
{
return;
}
if (medstationTrigger.interactable)
{
float num = (float)charges.Value / (float)maxCharges.Value;
int num2 = (int)(num * 100f);
medstationTrigger.holdTip = $"[Charges: {num2}%]";
healthCylinderTransform.localScale = new Vector3(1f, num, 1f);
}
if (charges.Value > 0)
{
medstationTrigger.interactable = true;
if (medstationTrigger.isBeingHeldByPlayer)
{
medstationState = MedstationState.HEALING;
}
else
{
medstationState = MedstationState.WAITING;
}
}
else
{
medstationTrigger.disabledHoverTip = "[No charges remaining]";
charges.Value = 0;
}
}
private void OnDisable()
{
}
public void PressMedstationOnLocalClient()
{
//IL_0004: 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)
PressMedstationServerRpc();
}
[ServerRpc(RequireOwnership = false)]
public void PressMedstationServerRpc(ServerRpcParams serverRpcParams = default(ServerRpcParams))
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: 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_00df: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1486470394u, serverRpcParams, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendServerRpc(ref val, 1486470394u, serverRpcParams, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
{
NetworkManager networkManager2 = ((NetworkBehaviour)this).NetworkManager;
if (!((Object)(object)networkManager2 == (Object)null) && networkManager2.IsListening)
{
ulong senderClientId = serverRpcParams.Receive.SenderClientId;
HealPlayerServer(senderClientId);
HealPlayerClientRpc(senderClientId);
}
}
}
[ClientRpc]
public void HealPlayerClientRpc(ulong clientId)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2759607538u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, clientId);
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2759607538u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost) || !((NetworkBehaviour)this).IsClient)
{
return;
}
int num = 5;
PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
if (localPlayerController.actualClientId == clientId && localPlayerController.health != 100)
{
if (charges.Value <= num && charges.Value > 0)
{
num = charges.Value;
}
num = Math.Min(num, 100 - localPlayerController.health);
localPlayerController.health += num;
if (localPlayerController.health == 100)
{
localPlayerController.MakeCriticallyInjured(false);
}
HUDManager.Instance.UpdateHealthUI(localPlayerController.health, true);
}
}
private void HealPlayerServer(ulong clientId)
{
if (!((NetworkBehaviour)this).IsHost)
{
return;
}
int num = 5;
PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
foreach (PlayerControllerB val in allPlayerScripts)
{
if (val.actualClientId != clientId || val.health == 100)
{
continue;
}
if (val.health != 100)
{
if (charges.Value <= num && charges.Value > 0)
{
num = charges.Value;
}
num = Math.Min(num, 100 - val.health);
val.health += num;
val.MakeCriticallyInjured(false);
NetworkVariable<int> obj = charges;
obj.Value -= num;
ES3.Save<int>(dataKey, charges.Value, GameNetworkManager.Instance.currentSaveFileName);
}
break;
}
}
private void PressButtonEffects()
{
if (medstationState == MedstationState.WAITING)
{
medstationAudio.PlayOneShot(medstationStartSFX);
}
else if (medstationState == MedstationState.HEALING)
{
medstationAudio.PlayOneShot(medstationInProgressSFX);
}
}
public void LoadCharges()
{
if (((NetworkBehaviour)this).IsHost)
{
dataKey = "LethalExtrasData_Unlockables_MedstationCharges";
if (ES3.KeyExists(dataKey, GameNetworkManager.Instance.currentSaveFileName))
{
charges.Value = ES3.Load<int>(dataKey, GameNetworkManager.Instance.currentSaveFileName, charges.Value);
}
}
}
public void SetCharges(int charges)
{
if (((NetworkBehaviour)this).IsHost)
{
Plugin.logger.LogInfo((object)$"before - {this.charges.Value}");
if (charges > maxCharges.Value)
{
charges = maxCharges.Value;
}
this.charges.Value = charges;
Plugin.logger.LogInfo((object)$"after - {this.charges.Value}");
}
}
private bool CanUseMedstation()
{
return false;
}
protected override void __initializeVariables()
{
if (maxCharges == null)
{
throw new Exception("Medstation.maxCharges cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)maxCharges).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)maxCharges, "maxCharges");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)maxCharges);
if (charges == null)
{
throw new Exception("Medstation.charges cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)charges).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)charges, "charges");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)charges);
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_Medstation()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(1486470394u, new RpcReceiveHandler(__rpc_handler_1486470394));
NetworkManager.__rpc_func_table.Add(2759607538u, new RpcReceiveHandler(__rpc_handler_2759607538));
}
private static void __rpc_handler_1486470394(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_0029: 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_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ServerRpcParams server = rpcParams.Server;
target.__rpc_exec_stage = (__RpcExecStage)1;
((Medstation)(object)target).PressMedstationServerRpc(server);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_2759607538(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ulong clientId = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
target.__rpc_exec_stage = (__RpcExecStage)2;
((Medstation)(object)target).HealPlayerClientRpc(clientId);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "Medstation";
}
}
public enum MedstationState
{
WAITING,
HEALING
}
public class UnlockableItems
{
public enum UnlockableTypes
{
Suit,
Placeable
}
}
}
namespace LethalExtras.Patches
{
public class HarmonyPatcher
{
private static Harmony instance;
public const string InstanceId = "LethalExtras";
public static bool IsPatched { get; private set; }
internal static void ApplyHarmonyPatches()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
if (!IsPatched)
{
if (instance == null)
{
instance = new Harmony("LethalExtras");
}
instance.PatchAll(Assembly.GetExecutingAssembly());
IsPatched = true;
}
}
internal static void RemoveHarmonyPatches()
{
if (instance != null && IsPatched)
{
instance.UnpatchSelf();
IsPatched = false;
}
}
}
[HarmonyPatch(typeof(RoundManager))]
internal class RoundManagerPatch
{
[HarmonyPatch("GeneratedFloorPostProcessing")]
[HarmonyPrefix]
private static void GeneratedFloorPostProcessingPatch(ref RoundManager __instance)
{
if (!((Object)(object)__instance == (Object)null) && ((NetworkBehaviour)__instance).IsHost)
{
string text = "LethalExtrasData_Unlockables_MedstationCharges";
if (ES3.KeyExists(text, GameNetworkManager.Instance.currentSaveFileName))
{
ES3.Save<int>(text, Plugin.ModConfig.medstationCharges, GameNetworkManager.Instance.currentSaveFileName);
}
Medstation[] array = Object.FindObjectsOfType<Medstation>();
Medstation[] array2 = array;
foreach (Medstation medstation in array2)
{
medstation.LoadCharges();
}
}
}
}
}
