using System;
using System.Collections;
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.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dawn;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.UI;
using com.github.zehsteam.FapEnergy.Dependencies;
using com.github.zehsteam.FapEnergy.Extensions;
using com.github.zehsteam.FapEnergy.Helpers;
using com.github.zehsteam.FapEnergy.Managers;
using com.github.zehsteam.FapEnergy.NetcodePatcher;
using com.github.zehsteam.FapEnergy.Objects;
using com.github.zehsteam.FapEnergy.Patches;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[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("Debug")]
[assembly: AssemblyCopyright("Copyright © 2026 Zehs")]
[assembly: AssemblyDescription("Marketed as “fuel for maximum performance,” FAP keeps things vague, which is probably for the best. Need to power through work? FAP. Suddenly deep-cleaning your house at midnight? FAP. Considering texting your ex? Maybe put the can down first.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+0d95f599460d6e2e8c4441ac18668d82f556df9e")]
[assembly: AssemblyProduct("FapEnergy")]
[assembly: AssemblyTitle("com.github.zehsteam.FapEnergy")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
int ICollection.Count => _items.Count;
bool ICollection.IsSynchronized => false;
object ICollection.SyncRoot => this;
object IList.this[int index]
{
get
{
return _items[index];
}
set
{
throw new NotSupportedException();
}
}
bool IList.IsFixedSize => true;
bool IList.IsReadOnly => true;
int IReadOnlyCollection<T>.Count => _items.Count;
T IReadOnlyList<T>.this[int index] => _items[index];
int ICollection<T>.Count => _items.Count;
bool ICollection<T>.IsReadOnly => true;
T IList<T>.this[int index]
{
get
{
return _items[index];
}
set
{
throw new NotSupportedException();
}
}
public <>z__ReadOnlyList(List<T> items)
{
_items = items;
}
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable)_items).GetEnumerator();
}
void ICollection.CopyTo(Array array, int index)
{
((ICollection)_items).CopyTo(array, index);
}
int IList.Add(object value)
{
throw new NotSupportedException();
}
void IList.Clear()
{
throw new NotSupportedException();
}
bool IList.Contains(object value)
{
return ((IList)_items).Contains(value);
}
int IList.IndexOf(object value)
{
return ((IList)_items).IndexOf(value);
}
void IList.Insert(int index, object value)
{
throw new NotSupportedException();
}
void IList.Remove(object value)
{
throw new NotSupportedException();
}
void IList.RemoveAt(int index)
{
throw new NotSupportedException();
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
return ((IEnumerable<T>)_items).GetEnumerator();
}
void ICollection<T>.Add(T item)
{
throw new NotSupportedException();
}
void ICollection<T>.Clear()
{
throw new NotSupportedException();
}
bool ICollection<T>.Contains(T item)
{
return _items.Contains(item);
}
void ICollection<T>.CopyTo(T[] array, int arrayIndex)
{
_items.CopyTo(array, arrayIndex);
}
bool ICollection<T>.Remove(T item)
{
throw new NotSupportedException();
}
int IList<T>.IndexOf(T item)
{
return _items.IndexOf(item);
}
void IList<T>.Insert(int index, T item)
{
throw new NotSupportedException();
}
void IList<T>.RemoveAt(int index)
{
throw new NotSupportedException();
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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.FapEnergy
{
internal static class Assets
{
public static readonly string AssetBundleFileName = "fapenergy_assets";
public static AssetBundle AssetBundle { get; private set; }
public static bool IsLoaded { get; private set; }
public static Item FapEnergyDrink { get; private set; }
public static void Load()
{
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string text = Path.Combine(directoryName, AssetBundleFileName);
if (!File.Exists(text))
{
Logger.LogFatal("Failed to load assets. AssetBundle file could not be found at path \"" + text + "\". Make sure the \"" + AssetBundleFileName + "\" file is in the same folder as the mod's DLL file.");
}
else
{
AssetBundle = AssetBundle.LoadFromFile(text);
if ((Object)(object)AssetBundle == (Object)null)
{
Logger.LogFatal("Failed to load assets. AssetBundle is null.");
return;
}
OnAssetBundleLoaded(AssetBundle);
IsLoaded = true;
}
}
private static void OnAssetBundleLoaded(AssetBundle assetBundle)
{
FapEnergyDrink = LoadAsset<Item>("FapEnergyDrink", assetBundle);
}
private static T LoadAsset<T>(string name, AssetBundle assetBundle) where T : Object
{
if (string.IsNullOrWhiteSpace(name))
{
Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" from AssetBundle. Name is null or whitespace.");
return default(T);
}
if ((Object)(object)assetBundle == (Object)null)
{
Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" with name \"" + name + "\" from AssetBundle. AssetBundle is null.");
return default(T);
}
T val = assetBundle.LoadAsset<T>(name);
if ((Object)(object)val == (Object)null)
{
Logger.LogError("Failed to load asset of type \"" + typeof(T).Name + "\" with name \"" + name + "\" from AssetBundle. No asset found with that type and name.");
return default(T);
}
return val;
}
private static bool TryLoadAsset<T>(string name, AssetBundle assetBundle, out T asset) where T : Object
{
asset = LoadAsset<T>(name, assetBundle);
return (Object)(object)asset != (Object)null;
}
}
public static class FapEnergyKeys
{
public static readonly NamespacedKey<DawnItemInfo> FapEnergyDrink = NamespacedKey<DawnItemInfo>.From("fap_energy", "fap_energy_drink");
}
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_0020: 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.FapEnergy", "FapEnergy", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class Plugin : BaseUnityPlugin
{
private readonly Harmony _harmony = new Harmony("com.github.zehsteam.FapEnergy");
internal static Plugin Instance { get; private set; }
private void Awake()
{
Instance = this;
Logger.Initialize(Logger.CreateLogSource("com.github.zehsteam.FapEnergy"));
Logger.LogInfo("FapEnergy has awoken!");
_harmony.PatchAll(typeof(StartOfRound_Patches));
_harmony.PatchAll(typeof(PlayerControllerB_Patches));
Assets.Load();
if (Assets.IsLoaded)
{
ConfigManager.Initialize(((BaseUnityPlugin)this).Config);
PlayerControllerB_Patches.Initialize();
RegisterItems();
NetworkUtils.NetcodePatcherAwake();
}
}
private void RegisterItems()
{
int spawnWeight = ConfigManager.FapEnergyDrink_SpawnWeight.Value;
DawnLib.DefineItem(FapEnergyKeys.FapEnergyDrink, Assets.FapEnergyDrink, (Action<ItemInfoBuilder>)delegate(ItemInfoBuilder builder)
{
builder.DefineScrap((Action<ScrapBuilder>)delegate(ScrapBuilder scrapBuilder)
{
scrapBuilder.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightTableBuilder)
{
weightTableBuilder.SetGlobalWeight(spawnWeight);
});
});
});
DawnLib.RegisterNetworkPrefab(Assets.FapEnergyDrink.spawnPrefab);
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "com.github.zehsteam.FapEnergy";
public const string PLUGIN_NAME = "FapEnergy";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace com.github.zehsteam.FapEnergy.Patches
{
[HarmonyPatch(typeof(PlayerControllerB))]
internal static class PlayerControllerB_Patches
{
private static Color? _defaultSprintMeterUIColor;
public static bool StaminaUIEffectsEnabled => ConfigManager.FapEnergyDrink_StaminaUIEffectsEnabled.Value;
public static void Initialize()
{
FapEnergyStaminaEffect.OnStateChanged = (Action<FapEnergyStaminaEffect.States>)Delegate.Combine(FapEnergyStaminaEffect.OnStateChanged, new Action<FapEnergyStaminaEffect.States>(OnStaminaEffectStateChanged));
Application.quitting += delegate
{
FapEnergyStaminaEffect.OnStateChanged = (Action<FapEnergyStaminaEffect.States>)Delegate.Remove(FapEnergyStaminaEffect.OnStateChanged, new Action<FapEnergyStaminaEffect.States>(OnStaminaEffectStateChanged));
};
}
[HarmonyPatch("LateUpdate")]
[HarmonyPostfix]
private static void LateUpdate_Patch(PlayerControllerB __instance)
{
if (!PlayerUtils.IsLocalPlayer(__instance))
{
return;
}
FapEnergyStaminaEffect.Tick();
if (FapEnergyStaminaEffect.State == FapEnergyStaminaEffect.States.InfiniteStamina)
{
__instance.sprintMeter = 1f;
}
if (FapEnergyStaminaEffect.State == FapEnergyStaminaEffect.States.StaminaDrained)
{
__instance.sprintMeter = 0f;
if (StaminaUIEffectsEnabled)
{
float value = 1f - FapEnergyStaminaEffect.StateProgress;
SetSprintMeterUIFillAmount(__instance.sprintMeterUI, value);
}
}
}
private static void OnStaminaEffectStateChanged(FapEnergyStaminaEffect.States state)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB localPlayerScript = PlayerUtils.LocalPlayerScript;
if ((Object)(object)localPlayerScript == (Object)null)
{
return;
}
if (!_defaultSprintMeterUIColor.HasValue && FapEnergyStaminaEffect.PreviousState == FapEnergyStaminaEffect.States.None)
{
_defaultSprintMeterUIColor = ((Graphic)localPlayerScript.sprintMeterUI).color;
}
if (StaminaUIEffectsEnabled)
{
if (1 == 0)
{
}
Color val = (Color)(state switch
{
FapEnergyStaminaEffect.States.InfiniteStamina => Color32.op_Implicit(new Color32((byte)151, (byte)187, (byte)36, byte.MaxValue)),
FapEnergyStaminaEffect.States.StaminaDrained => Color32.op_Implicit(new Color32(byte.MaxValue, (byte)0, (byte)0, byte.MaxValue)),
_ => ((??)_defaultSprintMeterUIColor) ?? Color32.op_Implicit(new Color32(byte.MaxValue, (byte)118, (byte)0, byte.MaxValue)),
});
if (1 == 0)
{
}
Color color = val;
((Graphic)localPlayerScript.sprintMeterUI).color = color;
}
}
private static void SetSprintMeterUIFillAmount(Image image, float value)
{
if (!((Object)(object)image == (Object)null))
{
image.fillAmount = Utils.Remap(value, 0f, 1f, 0.29767f, 0.911f);
}
}
}
[HarmonyPatch(typeof(StartOfRound))]
internal static class StartOfRound_Patches
{
[HarmonyPatch("Start")]
[HarmonyPostfix]
private static void Start_Patch()
{
ItemHelper.OnLobbyLoaded();
}
[HarmonyPatch("EndOfGame")]
[HarmonyPostfix]
private static void EndOfGame_Patch()
{
FapEnergyStaminaEffect.Reset();
}
[HarmonyPatch("OnLocalDisconnect")]
[HarmonyPostfix]
private static void OnLocalDisconnect_Patch()
{
FapEnergyStaminaEffect.Reset();
}
}
}
namespace com.github.zehsteam.FapEnergy.MonoBehaviours
{
public abstract class AdvancedGrabbableObject : GrabbableObject
{
public int UniqueId { get; private set; }
public string SaveKey => $"{((object)this).GetType().Name}_{UniqueId}";
public virtual void Awake()
{
if (NetworkUtils.IsServer)
{
UniqueId = Random.Range(0, 1000000);
}
}
public override void OnNetworkSpawn()
{
((NetworkBehaviour)this).OnNetworkSpawn();
if (NetworkUtils.IsServer)
{
NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnected_Server;
}
}
public override void OnNetworkDespawn()
{
((NetworkBehaviour)this).OnNetworkDespawn();
if (NetworkUtils.IsServer)
{
NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnected_Server;
}
}
protected virtual void OnClientConnected_Server(ulong clientId)
{
}
public override int GetItemDataToSave()
{
return UniqueId;
}
public override void LoadItemSaveData(int saveData)
{
((GrabbableObject)this).LoadItemSaveData(saveData);
UniqueId = saveData;
}
protected override void __initializeVariables()
{
((GrabbableObject)this).__initializeVariables();
}
protected override void __initializeRpcs()
{
((GrabbableObject)this).__initializeRpcs();
}
protected internal override string __getTypeName()
{
return "AdvancedGrabbableObject";
}
}
public class AdvancedNoisemakerProp : AdvancedGrabbableObject
{
[Space(20f)]
[Header("Advanced Noisemaker Prop")]
[Space(5f)]
public AudioSourceGroup NoiseAudio;
public WeightedList<AudioClip> NoiseSFX;
[Space(10f)]
public float MinVolume = 1f;
public float MaxVolume = 1f;
public float MinPitch = 1f;
public float MaxPitch = 1f;
[Space(10f)]
public bool UseDynamicCooldown;
[Space(10f)]
public bool IsEnemyAudible = true;
public float EnemyAudibleNoiseRange = 65f;
public override void ItemActivate(bool used, bool buttonDown = true)
{
if (NoiseSFX != null && NoiseSFX.Count != 0 && NoiseSFX.TryGetRandomIndex(out var index))
{
PlaySound(index);
}
}
public void PlaySound(int index)
{
if (NoiseSFX.IsValidIndex(index))
{
PlaySound_Rpc(index);
PlaySound_Local(index);
}
}
[Rpc(/*Could not decode attribute arguments.*/)]
protected void PlaySound_Rpc(int index)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Invalid comparison between Unknown and I4
//IL_0043: 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_005f: 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_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1)
{
RpcAttributeParams val = new RpcAttributeParams
{
RequireOwnership = false
};
RpcParams val2 = default(RpcParams);
FastBufferWriter val3 = ((NetworkBehaviour)this).__beginSendRpc(3275817297u, val2, val, (SendTo)5, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val3, index);
((NetworkBehaviour)this).__endSendRpc(ref val3, 3275817297u, val2, val, (SendTo)5, (RpcDelivery)0);
}
if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1)
{
((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
PlaySound_Local(index);
}
}
}
public void PlaySound_Local(int index)
{
if (NoiseSFX.TryGet(index, out var value))
{
PlaySound_Local(value);
OnPlayedSoundFromIndex(index);
}
}
public float PlaySound_Local(AudioClip clip)
{
if ((Object)(object)clip == (Object)null)
{
return 0f;
}
if (UseDynamicCooldown)
{
((GrabbableObject)this).currentUseCooldown = clip.length;
}
NoiseAudio.Stop();
float num = Random.Range(MinVolume, MaxVolume);
float pitch = Random.Range(MinPitch, MaxPitch);
NoiseAudio.Volume = num;
NoiseAudio.Pitch = pitch;
NoiseAudio.PlayOneShot(clip);
WalkieTalkie.TransmitOneShotAudio(NoiseAudio.Main, clip, num);
if (IsEnemyAudible)
{
((GrabbableObject)(object)this).MakeEnemyAudibleNoise(EnemyAudibleNoiseRange, num, MinVolume);
}
return clip.length;
}
protected virtual void OnPlayedSoundFromIndex(int index)
{
}
protected override void __initializeVariables()
{
base.__initializeVariables();
}
protected override void __initializeRpcs()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
((NetworkBehaviour)this).__registerRpc(3275817297u, new RpcReceiveHandler(__rpc_handler_3275817297), "PlaySound_Rpc");
base.__initializeRpcs();
}
private static void __rpc_handler_3275817297(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)
{
int index = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref index);
target.__rpc_exec_stage = (__RpcExecStage)1;
((AdvancedNoisemakerProp)(object)target).PlaySound_Rpc(index);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "AdvancedNoisemakerProp";
}
}
public class FapEnergyDrink : AdvancedNoisemakerProp
{
private static readonly List<FapEnergyDrink> _instances = new List<FapEnergyDrink>();
[Space(20f)]
[Header("Fap Energy Drink")]
[Space(5f)]
public AudioSourceGroup RandomMusicAudio;
public AudioClip[] RandomMusic = Array.Empty<AudioClip>();
[HideInInspector]
public NetworkVariable<bool> UsedInfiniteStamina = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)1);
private float _randomMusicTimer;
public bool InfiniteStaminaEffectEnabled => ConfigManager.FapEnergyDrink_InfiniteStaminaEffectEnabled.Value;
public bool RandomMusicEnabled => ConfigManager.FapEnergyDrink_RandomMusicEnabled.Value;
public float RandomMusicChance => ConfigManager.FapEnergyDrink_RandomMusicChance.Value;
public float RandomMusicRollChanceCooldown => ConfigManager.FapEnergyDrink_RandomMusicRollChanceCooldown.Value;
public float RandomMusicSuccessMinCooldown => ConfigManager.FapEnergyDrink_RandomMusicSuccessMinCooldown.Value;
public float RandomMusicSuccessMaxCooldown => ConfigManager.FapEnergyDrink_RandomMusicSuccessMaxCooldown.Value;
public float RandomMusicSuccessCooldown => Random.Range(RandomMusicSuccessMinCooldown, RandomMusicSuccessMaxCooldown);
public bool RandomMusicOnlyAllowSingleInstance => ConfigManager.FapEnergyDrink_RandomMusicOnlyAllowSingleInstance.Value;
public override void Awake()
{
base.Awake();
_randomMusicTimer = RandomMusicRollChanceCooldown;
}
private void OnEnable()
{
if (!_instances.Contains(this))
{
_instances.Add(this);
}
}
private void OnDisable()
{
_instances.Remove(this);
}
public override void Update()
{
((GrabbableObject)this).Update();
RandomMusicTick_Server();
}
private void RandomMusicTick_Server()
{
if (!NetworkUtils.IsServer || !RandomMusicEnabled || RandomMusicAudio.IsPlaying || (RandomMusicOnlyAllowSingleInstance && IsAnyInstancePlayingRandomMusic()) || ((GrabbableObject)this).isHeld || !((GrabbableObject)this).isInFactory || ((GrabbableObject)this).isInShipRoom || ((GrabbableObject)this).isInElevator)
{
return;
}
if (_randomMusicTimer <= 0f)
{
if (Utils.RollPercentChance(RandomMusicChance))
{
PlayRandomMusic();
_randomMusicTimer = RandomMusicSuccessCooldown;
}
else
{
_randomMusicTimer = RandomMusicRollChanceCooldown;
}
}
else
{
_randomMusicTimer -= Time.deltaTime;
}
}
private bool IsAnyInstancePlayingRandomMusic()
{
return _instances.Any((FapEnergyDrink x) => x.RandomMusicAudio.IsPlaying);
}
private void PlayRandomMusic()
{
//IL_0014: 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)
int index = Random.Range(0, RandomMusic.Length);
PlayRandomMusic_Rpc(index);
}
[Rpc(/*Could not decode attribute arguments.*/)]
private void PlayRandomMusic_Rpc(int index, RpcParams rpcParams = default(RpcParams))
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Invalid comparison between Unknown and I4
//IL_0043: 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_005f: 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_0072: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1)
{
RpcAttributeParams val = new RpcAttributeParams
{
RequireOwnership = false
};
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1625127774u, rpcParams, val, (SendTo)6, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, index);
((NetworkBehaviour)this).__endSendRpc(ref val2, 1625127774u, rpcParams, val, (SendTo)6, (RpcDelivery)0);
}
if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1)
{
((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
ulong senderClientId = rpcParams.Receive.SenderClientId;
if (index >= 0 && index < RandomMusic.Length)
{
AudioClip clip = RandomMusic[index];
RandomMusicAudio.Play(clip);
}
}
}
[Rpc(/*Could not decode attribute arguments.*/)]
private void StopRandomMusic_Rpc()
{
//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_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1)
{
RpcAttributeParams val = default(RpcAttributeParams);
RpcParams val2 = default(RpcParams);
FastBufferWriter val3 = ((NetworkBehaviour)this).__beginSendRpc(50365314u, val2, val, (SendTo)6, (RpcDelivery)0);
((NetworkBehaviour)this).__endSendRpc(ref val3, 50365314u, val2, val, (SendTo)6, (RpcDelivery)0);
}
if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1)
{
((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
RandomMusicAudio.Stop();
}
}
}
public override void GrabItem()
{
((GrabbableObject)this).GrabItem();
if (((NetworkBehaviour)this).IsOwner)
{
StopRandomMusic_Rpc();
}
}
public override void SetControlTipsForItem()
{
string[] array = ((!UsedInfiniteStamina.Value) ? new string[1] { "Drink : [LMB]".RichColor("#97bb24") } : new string[1] { "Interact : [LMB]" });
HUDManager.Instance.ChangeControlTipMultiple(array, true, ((GrabbableObject)this).itemProperties);
}
public override void LoadItemSaveData(int saveData)
{
base.LoadItemSaveData(saveData);
UsedInfiniteStamina.Value = GameSaveFileHelper.Load(base.SaveKey + "_UsedInfiniteStamina", defaultValue: false);
}
public override int GetItemDataToSave()
{
GameSaveFileHelper.Save(base.SaveKey + "_UsedInfiniteStamina", UsedInfiniteStamina.Value);
return base.GetItemDataToSave();
}
public override void ItemActivate(bool used, bool buttonDown = true)
{
base.ItemActivate(used, buttonDown);
if (!StartOfRound.Instance.inShipPhase && !StartOfRound.Instance.shipIsLeaving)
{
TryUseInfiniteStamina();
}
}
private void TryUseInfiniteStamina()
{
if (InfiniteStaminaEffectEnabled && FapEnergyStaminaEffect.State != FapEnergyStaminaEffect.States.InfiniteStamina && !UsedInfiniteStamina.Value)
{
UsedInfiniteStamina.Value = true;
FapEnergyStaminaEffect.Apply();
((GrabbableObject)this).SetControlTipsForItem();
}
}
private void ApplyConfigSettings()
{
}
public static void OnConfigSettingsChanged()
{
foreach (FapEnergyDrink instance in _instances)
{
instance.ApplyConfigSettings();
}
}
protected override void __initializeVariables()
{
if (UsedInfiniteStamina == null)
{
throw new Exception("FapEnergyDrink.UsedInfiniteStamina cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)UsedInfiniteStamina).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)UsedInfiniteStamina, "UsedInfiniteStamina");
((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)UsedInfiniteStamina);
base.__initializeVariables();
}
protected override void __initializeRpcs()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
((NetworkBehaviour)this).__registerRpc(1625127774u, new RpcReceiveHandler(__rpc_handler_1625127774), "PlayRandomMusic_Rpc");
((NetworkBehaviour)this).__registerRpc(50365314u, new RpcReceiveHandler(__rpc_handler_50365314), "StopRandomMusic_Rpc");
base.__initializeRpcs();
}
private static void __rpc_handler_1625127774(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: 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_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_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
int index = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref index);
RpcParams ext = rpcParams.Ext;
target.__rpc_exec_stage = (__RpcExecStage)1;
((FapEnergyDrink)(object)target).PlayRandomMusic_Rpc(index, ext);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
private static void __rpc_handler_50365314(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
target.__rpc_exec_stage = (__RpcExecStage)1;
((FapEnergyDrink)(object)target).StopRandomMusic_Rpc();
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "FapEnergyDrink";
}
}
}
namespace com.github.zehsteam.FapEnergy.Objects
{
internal static class FapEnergyStaminaEffect
{
public enum States
{
None,
InfiniteStamina,
StaminaDrained
}
public static Action<States> OnStateChanged;
private static float _timeSinceStartedState;
public static States State { get; private set; }
public static States PreviousState { get; private set; }
public static float ElapsedStateTime => Time.realtimeSinceStartup - _timeSinceStartedState;
public static float StateProgress { get; private set; }
public static void Apply()
{
SetState(States.InfiniteStamina);
}
public static void Reset()
{
SetState(States.None);
}
private static void SetState(States state)
{
PreviousState = State;
State = state;
StateProgress = 0f;
OnStateChanged?.Invoke(state);
_timeSinceStartedState = Time.realtimeSinceStartup;
}
public static void Tick()
{
switch (State)
{
case States.None:
break;
case States.InfiniteStamina:
InfiniteStamina_Tick();
break;
case States.StaminaDrained:
StaminaDrained_Tick();
break;
}
}
private static void InfiniteStamina_Tick()
{
float value = ConfigManager.FapEnergyDrink_InfiniteStaminaDuration.Value;
StateProgress = ElapsedStateTime / value;
if (ElapsedStateTime > value)
{
SetState(States.StaminaDrained);
}
}
private static void StaminaDrained_Tick()
{
float value = ConfigManager.FapEnergyDrink_StaminaDrainedDuration.Value;
StateProgress = ElapsedStateTime / value;
if (ElapsedStateTime > value)
{
Reset();
}
}
}
[Serializable]
public class AudioSourceGroup
{
public AudioSource Main;
public AudioSource Far;
public bool IsPlaying => Main.isPlaying;
public float Volume
{
get
{
return Main.volume;
}
set
{
Main.volume = value;
AudioSource far = Far;
if (far != null)
{
far.volume = value;
}
}
}
public float Pitch
{
get
{
return Main.pitch;
}
set
{
Main.pitch = value;
AudioSource far = Far;
if (far != null)
{
far.pitch = value;
}
}
}
public AudioClip Clip
{
get
{
return Main.clip;
}
set
{
Main.clip = value;
AudioSource far = Far;
if (far != null)
{
far.clip = value;
}
}
}
public void Play()
{
Main.Play();
AudioSource far = Far;
if (far != null)
{
far.Play();
}
}
public void Play(AudioClip clip)
{
if (IsPlaying)
{
Stop();
}
Clip = clip;
Play();
}
public void Stop()
{
Main.Stop();
AudioSource far = Far;
if (far != null)
{
far.Stop();
}
}
public void PlayOneShot(AudioClip clip)
{
PlayOneShot(clip, Volume);
}
public float PlayOneShot(AudioClip clip, float volumeScale)
{
if ((Object)(object)clip == (Object)null)
{
return 0f;
}
Main.PlayOneShot(clip, volumeScale);
AudioSource far = Far;
if (far != null)
{
far.PlayOneShot(clip, volumeScale);
}
return clip.length;
}
}
[Serializable]
public class WeightedList<T>
{
public List<WeightedItem<T>> List = new List<WeightedItem<T>>();
public IReadOnlyList<WeightedItem<T>> ValidList
{
get
{
List<WeightedItem<T>> list = new List<WeightedItem<T>>();
list.AddRange(List.Where((WeightedItem<T> x) => x.Weight > 0));
return new <>z__ReadOnlyList<WeightedItem<T>>(list);
}
}
public int Count => ValidList.Count;
public int GetRandomIndex()
{
if (List == null || List.Count == 0 || ValidList.Count == 0)
{
return -1;
}
return Utils.GetRandomIndexFromWeightList(ValidList.Select((WeightedItem<T> x) => x.Weight).ToList());
}
public bool TryGetRandomIndex(out int index)
{
index = GetRandomIndex();
return IsValidIndex(index);
}
public T GetRandom()
{
if (!TryGetRandom(out var value))
{
return default(T);
}
return value;
}
public bool TryGetRandom(out T value)
{
if (!TryGetRandomIndex(out var index))
{
value = default(T);
return false;
}
value = ValidList[index].Value;
return true;
}
public bool TryGet(int index, out T value)
{
if (!IsValidIndex(index))
{
value = default(T);
return false;
}
value = ValidList[index].Value;
return true;
}
public bool IsValidIndex(int index)
{
return index >= 0 && index < ValidList.Count;
}
}
[Serializable]
public class WeightedItem<T>
{
public T Value;
public int Weight;
public WeightedItem(T value, int weight)
{
Value = value;
Weight = weight;
}
}
}
namespace com.github.zehsteam.FapEnergy.Managers
{
internal static class ConfigManager
{
public static ConfigFile ConfigFile { get; private set; }
public static ConfigEntry<bool> Misc_ExtendedLogging { get; private set; }
public static ConfigEntry<int> FapEnergyDrink_SpawnWeight { get; private set; }
public static ConfigEntry<bool> FapEnergyDrink_InfiniteStaminaEffectEnabled { get; private set; }
public static ConfigEntry<float> FapEnergyDrink_InfiniteStaminaDuration { get; private set; }
public static ConfigEntry<float> FapEnergyDrink_StaminaDrainedDuration { get; private set; }
public static ConfigEntry<bool> FapEnergyDrink_StaminaUIEffectsEnabled { get; private set; }
public static ConfigEntry<bool> FapEnergyDrink_RandomMusicEnabled { get; private set; }
public static ConfigEntry<float> FapEnergyDrink_RandomMusicChance { get; private set; }
public static ConfigEntry<float> FapEnergyDrink_RandomMusicRollChanceCooldown { get; private set; }
public static ConfigEntry<float> FapEnergyDrink_RandomMusicSuccessMinCooldown { get; private set; }
public static ConfigEntry<float> FapEnergyDrink_RandomMusicSuccessMaxCooldown { get; private set; }
public static ConfigEntry<bool> FapEnergyDrink_RandomMusicOnlyAllowSingleInstance { 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.");
FapEnergyDrink_SpawnWeight = ConfigHelper.Bind("Fap Energy Drink", "SpawnWeight", 20, "How likely this item will spawn.");
FapEnergyDrink_SpawnWeight.SettingChanged += delegate
{
ItemHelper.UpdateScrapRarity(Assets.FapEnergyDrink, FapEnergyDrink_SpawnWeight.Value);
};
FapEnergyDrink_InfiniteStaminaEffectEnabled = ConfigHelper.Bind("Fap Energy Drink", "InfiniteStaminaEnabled", defaultValue: true, "If enabled, using this item will temporary give you inifinte stamina.");
FapEnergyDrink_InfiniteStaminaDuration = ConfigHelper.Bind("Fap Energy Drink", "InfiniteStaminaDuration", 30f, "The duration in seconds you will have infinite stamina for.");
FapEnergyDrink_StaminaDrainedDuration = ConfigHelper.Bind("Fap Energy Drink", "StaminaDrainedDuration", 10f, "The duration in seconds your stamina will be completely drained for after having infinite stamina.");
FapEnergyDrink_StaminaUIEffectsEnabled = ConfigHelper.Bind("Fap Energy Drink", "StaminaUIEffectsEnabled", defaultValue: true, "If enabled, infinite/drained stamina will change the stamina UI.");
FapEnergyDrink_RandomMusicEnabled = ConfigHelper.Bind("Fap Energy Drink", "RandomMusicEnabled", defaultValue: true, "If enabled, this item will have a chance to randomly play music while inside the facility.");
FapEnergyDrink_RandomMusicChance = ConfigHelper.Bind("Fap Energy Drink", "RandomMusicChance", 10f, "The percent chance for random music to start playing.");
FapEnergyDrink_RandomMusicRollChanceCooldown = ConfigHelper.Bind("Fap Energy Drink", "RandomMusicRollChanceCooldown", 15f, "The cooldown in seconds between each time RandomMusicChance is rolled.");
FapEnergyDrink_RandomMusicSuccessMinCooldown = ConfigHelper.Bind("Fap Energy Drink", "RandomMusicSuccessMinCooldown", 30f, "The minimum cooldown in seconds after random music successfully plays.");
FapEnergyDrink_RandomMusicSuccessMaxCooldown = ConfigHelper.Bind("Fap Energy Drink", "RandomMusicSuccessMaxCooldown", 60f, "The maximum cooldown in seconds after random music successfully plays.");
FapEnergyDrink_RandomMusicOnlyAllowSingleInstance = ConfigHelper.Bind("Fap Energy Drink", "RandomMusicOnlyAllowSingleInstance", defaultValue: false, "If enabled, will only allow a single item instance to play random music at a time.");
}
}
}
namespace com.github.zehsteam.FapEnergy.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 GameSaveFileHelper
{
private static string GetCurrentSaveFilePath()
{
if ((Object)(object)GameNetworkManager.Instance == (Object)null)
{
Logger.LogWarning("GameSaveFileHelper: GetCurrentSaveFilePath() GameNetworkManager instance is null. Returning an empty string.");
return string.Empty;
}
return GameNetworkManager.Instance.currentSaveFileName;
}
public static bool KeyExists(string key)
{
if (!NetworkUtils.IsServer)
{
return false;
}
return ES3.KeyExists(key, GetCurrentSaveFilePath());
}
public static T Load<T>(string key, T defaultValue = default(T))
{
if (!NetworkUtils.IsServer)
{
return defaultValue;
}
if (TryLoad<T>(key, out var value))
{
return value;
}
return defaultValue;
}
public static bool TryLoad<T>(string key, out T value)
{
if (!NetworkUtils.IsServer)
{
value = default(T);
return false;
}
value = ES3.Load<T>(key, GetCurrentSaveFilePath());
return value != null;
}
public static bool Save<T>(string key, T value)
{
if (!NetworkUtils.IsServer)
{
return false;
}
ES3.Save<T>(key, value, GetCurrentSaveFilePath());
return true;
}
}
internal static class ItemHelper
{
private static readonly Dictionary<Item, int> _spawnWeightsToUpdate = new Dictionary<Item, int>();
public static void UpdateScrapRarity(Item item, int rarity)
{
if ((Object)(object)item == (Object)null)
{
Logger.LogError("[ItemHelper] Failed to update scrap item rarity. Item is null.");
return;
}
if ((Object)(object)StartOfRound.Instance == (Object)null)
{
Logger.LogWarning("[ItemHelper] Failed to update scrap item rarity. StartOfRound instance is null.");
_spawnWeightsToUpdate[item] = rarity;
return;
}
SelectableLevel[] levels = StartOfRound.Instance.levels;
foreach (SelectableLevel val in levels)
{
foreach (SpawnableItemWithRarity item2 in val.spawnableScrap)
{
if (!((Object)(object)item2.spawnableItem != (Object)(object)item))
{
item2.rarity = rarity;
Logger.LogInfo(string.Format("[{0}] Updated \"{1}\" scrap item rarity to {2} on \"{3}\".", "ItemHelper", item.itemName, rarity, val.PlanetName));
}
}
}
}
public static void OnLobbyLoaded()
{
if (_spawnWeightsToUpdate.Count == 0)
{
return;
}
foreach (KeyValuePair<Item, int> item in _spawnWeightsToUpdate)
{
UpdateScrapRarity(item.Key, item.Value);
}
_spawnWeightsToUpdate.Clear();
}
}
internal static class NetworkUtils
{
public static bool IsConnected
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
return singleton != null && singleton.IsConnectedClient;
}
}
public static bool IsServer
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
return singleton != null && singleton.IsServer;
}
}
public static ulong LocalClientId
{
get
{
NetworkManager singleton = NetworkManager.Singleton;
return (singleton != null) ? singleton.LocalClientId : 0;
}
}
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)
{
IReadOnlyList<NetworkPrefab> prefabs = NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs;
return prefabs.Any((NetworkPrefab x) => (Object)(object)x.Prefab == (Object)(object)prefab);
}
public static bool AddNetworkPrefab(GameObject prefab)
{
if ((Object)(object)prefab == (Object)null)
{
Logger.LogError("Failed to register network prefab. GameObject is null.");
return false;
}
if ((Object)(object)NetworkManager.Singleton == (Object)null)
{
Logger.LogError("Failed to register network prefab. NetworkManager Singleton is null.");
return false;
}
NetworkManager.Singleton.AddNetworkPrefab(prefab);
Logger.LogInfo("Registered \"" + ((Object)prefab).name + "\" network prefab.");
return true;
}
public static void NetcodePatcherAwake()
{
try
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
Type[] types = executingAssembly.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)
{
try
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
try
{
methodInfo.Invoke(null, null);
}
catch (TargetInvocationException ex)
{
Logger.LogWarning("Failed to invoke method " + methodInfo.Name + ": " + ex.Message);
}
}
}
catch (Exception ex2)
{
Logger.LogWarning("Error processing method " + methodInfo.Name + " in type " + type.Name + ": " + ex2.Message);
}
}
}
}
catch (Exception ex3)
{
Logger.LogError("An error occurred in NetcodePatcherAwake: " + ex3.Message);
}
}
}
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 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;
}
return playerScript.isPlayerControlled || playerScript.isPlayerDead;
}
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 val = null;
PlayerControllerB[] source = ConnectedPlayerScripts.OrderByDescending((PlayerControllerB x) => x.playerUsername.Length).ToArray();
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 bool RollPercentChance(float percent)
{
if (percent <= 0f)
{
return false;
}
if (percent >= 100f)
{
return true;
}
return Random.value * 100f <= percent;
}
public static int GetRandomIndexFromWeightList(List<int> weightList)
{
List<(int, int)> list = new List<(int, int)>();
for (int i = 0; i < weightList.Count; i++)
{
int num = weightList[i];
if (num > 0)
{
list.Add((i, num));
}
}
int num2 = 0;
foreach (var item4 in list)
{
int item = item4.Item2;
num2 += item;
}
if (num2 == 0)
{
return -1;
}
int num3 = Random.Range(0, num2);
int num4 = 0;
foreach (var item5 in list)
{
int item2 = item5.Item1;
int item3 = item5.Item2;
num4 += item3;
if (num3 < num4)
{
return item2;
}
}
throw new InvalidOperationException("Weights are not properly specified.");
}
public static float Remap(float value, float fromMin, float fromMax, float toMin, float toMax)
{
return Mathf.Lerp(toMin, toMax, Mathf.InverseLerp(fromMin, fromMax, value));
}
}
}
namespace com.github.zehsteam.FapEnergy.Extensions
{
internal static class ConfigFileExtensions
{
public static ConfigEntry<T> Bind<T>(this ConfigFile configFile, string section, string key, T defaultValue, string description, AcceptableValueBase acceptableValues)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: 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 GrabbableObjectExtensions
{
public static void MakeEnemyAudibleNoise(this GrabbableObject grabbableObject, float noiseRange, float noiseLoudness, float minNoiseLoudness)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)grabbableObject == (Object)null))
{
bool flag = grabbableObject.isInElevator && StartOfRound.Instance.hangarDoorsClosed;
RoundManager.Instance.PlayAudibleNoise(((Component)grabbableObject).transform.position, noiseRange, noiseLoudness, 0, flag, 0);
if (minNoiseLoudness >= 0.6f && (Object)(object)grabbableObject.playerHeldBy != (Object)null)
{
grabbableObject.playerHeldBy.timeSinceMakingLoudNoise = 0f;
}
}
}
}
internal static class StringExtensions
{
public static bool IsHexColor(this string s)
{
return Regex.IsMatch(s, "^#?([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$");
}
public static string RichColor(this string s, string colorHex)
{
if (string.IsNullOrWhiteSpace(colorHex))
{
colorHex = "#FFFFFF";
}
return "<color=" + colorHex + ">" + s + "</color>";
}
}
}
namespace com.github.zehsteam.FapEnergy.Dependencies
{
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_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: Expected O, but got Unknown
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Expected O, but got Unknown
//IL_0148: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Expected O, but got Unknown
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Expected O, but got Unknown
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_0178: 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 (1 == 0)
{
}
BaseConfigItem result;
if (!(configEntry is ConfigEntry<int> val2))
{
if (!(configEntry is ConfigEntry<float> val3))
{
if (!(configEntry is ConfigEntry<bool> val4))
{
if (!(configEntry is ConfigEntry<string> val5))
{
throw new NotSupportedException($"Unsupported type: {typeof(T)}");
}
result = AddConfigItem((BaseConfigItem)new TextInputFieldConfigItem(val5, requiresRestart));
}
else
{
result = AddConfigItem((BaseConfigItem)new BoolCheckBoxConfigItem(val4, requiresRestart));
}
}
else
{
result = AddConfigItem((BaseConfigItem)new FloatInputFieldConfigItem(val3, requiresRestart));
}
}
else
{
result = AddConfigItem((BaseConfigItem)new IntInputFieldConfigItem(val2, requiresRestart));
}
if (1 == 0)
{
}
return result;
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static object AddButton(string section, string name, string buttonText, string description, Action callback)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
if (1 == 0)
{
}
BaseConfigItem result;
if (!(configEntry is ConfigEntry<float> val))
{
if (!(configEntry is ConfigEntry<int> val2))
{
throw new NotSupportedException($"Slider not supported for type: {typeof(T)}");
}
result = AddConfigItem((BaseConfigItem)new IntSliderConfigItem(val2, requiresRestart));
}
else
{
result = AddConfigItem((BaseConfigItem)new FloatSliderConfigItem(val, requiresRestart));
}
if (1 == 0)
{
}
return result;
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
private static BaseConfigItem AddConfigDropdown<T>(ConfigEntry<T> configEntry, bool requiresRestart = false)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
if (1 == 0)
{
}
if (configEntry is ConfigEntry<string> val)
{
BaseConfigItem result = AddConfigItem((BaseConfigItem)new TextDropDownConfigItem(val, requiresRestart));
if (1 == 0)
{
}
return result;
}
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 s))
{
return false;
}
return s.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)
{
}
}
}
namespace __GEN
{
internal class NetworkVariableSerializationHelper
{
[RuntimeInitializeOnLoadMethod]
internal static void InitializeSerialization()
{
NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<bool>();
NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<bool>();
}
}
}
namespace com.github.zehsteam.FapEnergy.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
