using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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 ConfigSpace;
using Curse;
using Gui;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using WeForgotBingBong;
using Zorro.Core;
[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("WeForgotBingBong")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+b8b5abac810e691fc39b15a3c6c57d351cd7fbd4")]
[assembly: AssemblyProduct("WeForgotBingBong")]
[assembly: AssemblyTitle("WeForgotBingBong")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace Gui
{
public class UIManager : MonoBehaviour
{
[CompilerGenerated]
private sealed class <TryFindFontUntilSuccess>d__14 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public UIManager <>4__this;
private TMP_FontAsset <newFont>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TryFindFontUntilSuccess>d__14(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<newFont>5__1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
<newFont>5__1 = null;
break;
}
<newFont>5__1 = <>4__this.CacheGameFont();
if ((Object)(object)<newFont>5__1 != (Object)null)
{
if ((Object)(object)<newFont>5__1 != (Object)(object)gameFont)
{
gameFont = <newFont>5__1;
<>4__this.ApplyFontToAllTexts();
Debug.Log((object)("[WeForgotBingBong] Apply game font: " + ((Object)gameFont).name));
}
return false;
}
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static UIManager instance;
private bool isHeld;
private float distance;
private bool hasValidData = false;
private string currentCurseType = "None";
private float curseTimer = 0f;
private bool isInvincible = false;
private float invincibleTimer = 0f;
private Canvas canvas = null;
private TextMeshProUGUI statusTextTMP = null;
private TextMeshProUGUI timerTextTMP = null;
private TextMeshProUGUI distanceTextTMP = null;
private static TMP_FontAsset? gameFont;
private void Awake()
{
if ((Object)(object)instance == (Object)null)
{
instance = this;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
CreateUI();
((MonoBehaviour)this).StartCoroutine(TryFindFontUntilSuccess());
}
else
{
Object.Destroy((Object)(object)((Component)this).gameObject);
}
}
[IteratorStateMachine(typeof(<TryFindFontUntilSuccess>d__14))]
private IEnumerator TryFindFontUntilSuccess()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TryFindFontUntilSuccess>d__14(0)
{
<>4__this = this
};
}
private TMP_FontAsset? CacheGameFont()
{
TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
if (array.Length == 0)
{
return null;
}
return ((IEnumerable<TMP_FontAsset>)array).FirstOrDefault((Func<TMP_FontAsset, bool>)((TMP_FontAsset f) => ((Object)f).name.Contains("DarumaDropOne-Regular", StringComparison.OrdinalIgnoreCase)));
}
private void ApplyFontToAllTexts()
{
if (!((Object)(object)gameFont == (Object)null))
{
TMP_Text[] array = Resources.FindObjectsOfTypeAll<TMP_Text>();
foreach (TMP_Text val in array)
{
val.font = gameFont;
val.fontMaterial = ((TMP_Asset)gameFont).material;
}
}
}
private void CreateUI()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject("UIManagerCanvas");
val.transform.SetParent(((Component)this).transform);
canvas = val.AddComponent<Canvas>();
canvas.renderMode = (RenderMode)0;
canvas.pixelPerfect = true;
CanvasScaler val2 = val.AddComponent<CanvasScaler>();
val2.uiScaleMode = (ScaleMode)1;
val2.referenceResolution = new Vector2(1920f, 1080f);
val.AddComponent<GraphicRaycaster>();
statusTextTMP = CreateTMPText("StatusText", new Vector2(0f, 20f), 22, (TextAlignmentOptions)514);
timerTextTMP = CreateTMPText("TimerText", new Vector2(0f, 50f), 28, (TextAlignmentOptions)514);
distanceTextTMP = CreateTMPText("DistanceText", new Vector2(0f, 70f), 18, (TextAlignmentOptions)514);
}
private TextMeshProUGUI CreateTMPText(string name, Vector2 anchoredPos, int fontSize, TextAlignmentOptions align)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name);
val.transform.SetParent(((Component)canvas).transform, false);
TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
((TMP_Text)val2).text = "";
((TMP_Text)val2).fontSize = fontSize;
((TMP_Text)val2).alignment = align;
((Graphic)val2).color = Color.white;
if ((Object)(object)gameFont != (Object)null)
{
((TMP_Text)val2).font = gameFont;
((TMP_Text)val2).fontMaterial = ((TMP_Asset)gameFont).material;
}
RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
rectTransform.anchorMin = new Vector2(0.5f, 0f);
rectTransform.anchorMax = new Vector2(0.5f, 0f);
rectTransform.pivot = new Vector2(0.5f, 0f);
rectTransform.anchoredPosition = anchoredPos;
rectTransform.sizeDelta = new Vector2(800f, 50f);
return val2;
}
public void SetBingBongStatus(bool held, float dist)
{
isHeld = held;
distance = Mathf.Max(0f, dist);
hasValidData = true;
UpdateUI();
}
public void SetCurseInfo(string curseType, float timer)
{
currentCurseType = curseType;
curseTimer = timer;
UpdateUI();
}
public void SetInvincibilityInfo(bool active, float remainingTime)
{
isInvincible = active;
invincibleTimer = remainingTime;
UpdateUI();
}
private void UpdateUI()
{
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_015e: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Unknown result type (might be due to invalid IL or missing references)
if (!hasValidData)
{
return;
}
if (isHeld)
{
((TMP_Text)statusTextTMP).text = "<color=#5CB338>BingBong is being carried</color>";
}
else
{
((TMP_Text)statusTextTMP).text = "<color=#FB4141>BingBong has been forgotten</color>";
}
if (isInvincible)
{
if (invincibleTimer > 3f)
{
((Graphic)timerTextTMP).color = Color.gray;
}
else if (invincibleTimer > 1f)
{
((Graphic)timerTextTMP).color = new Color(0.93f, 0.91f, 0.32f);
}
else
{
((Graphic)timerTextTMP).color = new Color(0.98f, 0.26f, 0.25f);
}
((TMP_Text)timerTextTMP).text = $"Invincible {invincibleTimer:F1}s";
((TMP_Text)distanceTextTMP).text = ((distance > 0f) ? $"({distance:F1}m Away from BingBong)" : "");
}
else if (!isHeld)
{
float num = Mathf.Max(0f, curseTimer);
if (num > 3f)
{
((Graphic)timerTextTMP).color = Color.gray;
}
else if (num > 1f)
{
((Graphic)timerTextTMP).color = new Color(0.93f, 0.91f, 0.32f);
}
else
{
((Graphic)timerTextTMP).color = new Color(0.98f, 0.26f, 0.25f);
}
((TMP_Text)timerTextTMP).text = $"Curse in {num:F1}s";
((TMP_Text)distanceTextTMP).text = ((distance > 0f) ? $"({distance:F1}m Away from BingBong)" : "");
}
else
{
((TMP_Text)timerTextTMP).text = "";
((TMP_Text)distanceTextTMP).text = "";
}
}
}
}
namespace Curse
{
public class BingBongCurseLogic : MonoBehaviour
{
private ushort bingBongItemID;
private float timer = 0f;
private readonly Dictionary<Player, float> playerPickupTime = new Dictionary<Player, float>();
private Player[] cachedPlayers = Array.Empty<Player>();
private float lastPlayerUpdateTime = 0f;
private const float PLAYER_UPDATE_INTERVAL = 1f;
private bool lastCurseState = false;
private Item[] cachedBingBongs = (Item[])(object)new Item[0];
private float lastBingBongUpdateTime = 0f;
private const float BINGBONG_UPDATE_INTERVAL = 2f;
private readonly Dictionary<Player, List<MonoBehaviour>> activeCurses = new Dictionary<Player, List<MonoBehaviour>>();
public void Setup(ushort itemID, float interval, bool displayUI)
{
bingBongItemID = itemID;
}
private void Update()
{
//IL_0270: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Unknown result type (might be due to invalid IL or missing references)
//IL_0340: Unknown result type (might be due to invalid IL or missing references)
//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
//IL_0345: Unknown result type (might be due to invalid IL or missing references)
//IL_0371: Unknown result type (might be due to invalid IL or missing references)
//IL_0377: Invalid comparison between Unknown and I4
//IL_0313: Unknown result type (might be due to invalid IL or missing references)
//IL_037b: Unknown result type (might be due to invalid IL or missing references)
//IL_0381: Invalid comparison between Unknown and I4
//IL_0337: Unknown result type (might be due to invalid IL or missing references)
//IL_032e: Unknown result type (might be due to invalid IL or missing references)
//IL_038e: Unknown result type (might be due to invalid IL or missing references)
//IL_0397: Unknown result type (might be due to invalid IL or missing references)
if (LoadingScreenHandler.loading)
{
return;
}
if (Time.time - lastPlayerUpdateTime >= 1f)
{
cachedPlayers = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
lastPlayerUpdateTime = Time.time;
}
if (cachedPlayers.Length == 0)
{
return;
}
if (Time.time - lastBingBongUpdateTime >= 2f)
{
List<Item> list = new List<Item>();
Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
foreach (Item val in array)
{
if ((Object)(object)val != (Object)null && (val.itemID == bingBongItemID || ((Object)val).name.Contains("BingBong")) && (Object)(object)((Component)val).transform.root == (Object)(object)((Component)val).transform)
{
list.Add(val);
}
}
cachedBingBongs = list.ToArray();
lastBingBongUpdateTime = Time.time;
}
bool flag = false;
Player val2 = null;
List<string> list2 = new List<string>();
Player[] array2 = cachedPlayers;
foreach (Player val3 in array2)
{
if (!((Object)(object)val3 == (Object)null))
{
if (Plugin.CheckIfPlayerHasBingBong(val3, bingBongItemID))
{
flag = true;
string item = ((Object)val3).name ?? "Unknown Player";
list2.Add(item);
}
if (((MonoBehaviourPun)val3).photonView.IsMine)
{
val2 = val3;
}
}
}
bool flag2 = (Object)(object)RunManager.Instance != (Object)null && RunManager.Instance.timeSinceRunStarted < ConfigClass.invincibilityPeriod.Value;
float remainingTime = 0f;
if (flag2 && (Object)(object)RunManager.Instance != (Object)null)
{
remainingTime = ConfigClass.invincibilityPeriod.Value - RunManager.Instance.timeSinceRunStarted;
}
if (ConfigClass.showUI.Value && (Object)(object)val2 != (Object)null)
{
Vector3 val4;
if ((Object)(object)val2.character != (Object)null && (Object)(object)val2.character.refs.head != (Object)null)
{
val4 = ((Component)val2.character.refs.head).transform.position;
}
else
{
Character character = val2.character;
Vector3? obj;
if (character == null)
{
obj = null;
}
else
{
CharacterRefs refs = character.refs;
if (refs == null)
{
obj = null;
}
else
{
Bodypart head = refs.head;
if (head == null)
{
obj = null;
}
else
{
Transform transform = ((Component)head).transform;
obj = ((transform != null) ? new Vector3?(transform.position) : null);
}
}
}
Vector3? val5 = obj;
? val6;
if (!val5.HasValue)
{
Character character2 = val2.character;
Vector3? obj2;
if (character2 == null)
{
obj2 = null;
}
else
{
Transform transform2 = ((Component)character2).transform;
obj2 = ((transform2 != null) ? new Vector3?(transform2.position) : null);
}
val6 = ((??)obj2) ?? ((Component)val2).transform.position;
}
else
{
val6 = val5.GetValueOrDefault();
}
val4 = (Vector3)val6;
}
float num = float.MaxValue;
Item[] array3 = cachedBingBongs;
foreach (Item val7 in array3)
{
if (!((Object)(object)val7 == (Object)null) && (int)val7.itemState != 1 && (int)val7.itemState != 2)
{
float num2 = Vector3.Distance(val4, ((Component)val7).transform.position);
if (num2 < num)
{
num = num2;
}
}
}
if (num == float.MaxValue)
{
num = -1f;
}
UIManager.instance?.SetBingBongStatus(flag, num);
if (flag2)
{
UIManager.instance?.SetInvincibilityInfo(active: true, remainingTime);
UIManager.instance?.SetCurseInfo("", 0f);
}
else
{
UIManager.instance?.SetInvincibilityInfo(active: false, 0f);
if (!flag)
{
float num3 = Mathf.Max(0f, ConfigClass.curseInterval.Value - timer);
UIManager.instance?.SetCurseInfo(GetCurrentCurseTypeDisplay(), num3);
}
else
{
UIManager.instance?.SetCurseInfo("", 0f);
}
}
}
if (!flag2 && !flag)
{
timer += Time.deltaTime;
if (timer >= ConfigClass.curseInterval.Value)
{
int num4 = 0;
Player[] array4 = cachedPlayers;
foreach (Player val8 in array4)
{
if ((Object)(object)val8 != (Object)null)
{
ApplyCurse(val8);
num4++;
}
}
timer = 0f;
}
}
if (lastCurseState != flag)
{
lastCurseState = flag;
}
}
private void ApplyCurse(Player player)
{
string playerName = ((Object)player).name ?? "Unknown Player";
if (!activeCurses.ContainsKey(player))
{
activeCurses[player] = new List<MonoBehaviour>();
}
ApplyCurseAlternative(player, playerName);
}
private void ApplyCurseAlternative(Player player, string playerName)
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: 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)
try
{
if (!((Object)(object)player.character != (Object)null) || player.character.refs == null || !((Object)(object)player.character.refs.afflictions != (Object)null))
{
return;
}
List<STATUSTYPE> availableCurseTypes = GetAvailableCurseTypes();
if (availableCurseTypes.Count == 0)
{
return;
}
List<STATUSTYPE> list = SelectCurses(availableCurseTypes);
foreach (STATUSTYPE item in list)
{
ApplySpecificCurse(player, playerName, item);
}
}
catch (Exception)
{
}
}
private List<STATUSTYPE> GetAvailableCurseTypes()
{
List<STATUSTYPE> list = new List<STATUSTYPE>();
if (ConfigClass.enablePoison.Value)
{
list.Add((STATUSTYPE)3);
}
if (ConfigClass.enableInjury.Value)
{
list.Add((STATUSTYPE)0);
}
if (ConfigClass.enableHunger.Value)
{
list.Add((STATUSTYPE)1);
}
if (ConfigClass.enableDrowsy.Value)
{
list.Add((STATUSTYPE)6);
}
if (ConfigClass.enableCurse.Value)
{
list.Add((STATUSTYPE)5);
}
if (ConfigClass.enableCold.Value)
{
list.Add((STATUSTYPE)2);
}
if (ConfigClass.enableHot.Value)
{
list.Add((STATUSTYPE)8);
}
return list;
}
private List<STATUSTYPE> SelectCurses(List<STATUSTYPE> availableCurses)
{
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: 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_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_0199: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
List<STATUSTYPE> list = new List<STATUSTYPE>();
if (ConfigClass.debugMode.Value)
{
Plugin.Logger.LogInfo((object)("[SelectCurses] Available curses: " + string.Join(", ", availableCurses)));
Plugin.Logger.LogInfo((object)$"[SelectCurses] Selection mode: {ConfigClass.curseSelectionMode.Value}");
Plugin.Logger.LogInfo((object)("[SelectCurses] Single curse type setting: " + ConfigClass.singleCurseType.Value));
}
switch (ConfigClass.curseSelectionMode.Value)
{
case Plugin.CurseSelectionMode.Single:
{
STATUSTYPE curseTypeFromString = GetCurseTypeFromString(ConfigClass.singleCurseType.Value);
if (availableCurses.Contains(curseTypeFromString))
{
list.Add(curseTypeFromString);
if (ConfigClass.debugMode.Value)
{
Plugin.Logger.LogInfo((object)$"[SelectCurses] Selected single curse: {curseTypeFromString}");
}
}
else if (availableCurses.Count > 0)
{
list.Add(availableCurses[0]);
if (ConfigClass.debugMode.Value)
{
Plugin.Logger.LogInfo((object)$"[SelectCurses] Single curse not available, fallback to: {availableCurses[0]}");
}
}
break;
}
case Plugin.CurseSelectionMode.Random:
if (availableCurses.Count > 0)
{
int num = Random.Range(0, availableCurses.Count);
list.Add(availableCurses[num]);
if (ConfigClass.debugMode.Value)
{
Plugin.Logger.LogInfo((object)$"[SelectCurses] Random selection: {availableCurses[num]} (index {num} of {availableCurses.Count})");
}
}
break;
case Plugin.CurseSelectionMode.Multiple:
list.AddRange(availableCurses);
if (ConfigClass.debugMode.Value)
{
Plugin.Logger.LogInfo((object)("[SelectCurses] Multiple curses selected: " + string.Join(", ", list)));
}
break;
}
if (ConfigClass.debugMode.Value)
{
Plugin.Logger.LogInfo((object)("[SelectCurses] Final selected curses: " + string.Join(", ", list)));
}
return list;
}
private STATUSTYPE GetCurseTypeFromString(string curseTypeString)
{
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0102: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
string text = curseTypeString.ToLower();
if (1 == 0)
{
}
STATUSTYPE result = (STATUSTYPE)(text switch
{
"poison" => 3,
"injury" => 0,
"hunger" => 1,
"drowsy" => 6,
"curse" => 5,
"cold" => 2,
"hot" => 8,
_ => 3,
});
if (1 == 0)
{
}
return result;
}
private void ApplySpecificCurse(Player player, string playerName, STATUSTYPE curseType)
{
//IL_0002: 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_0022: Unknown result type (might be due to invalid IL or missing references)
float finalIntensityForCurseType = GetFinalIntensityForCurseType(curseType);
if (ConfigClass.debugMode.Value)
{
Plugin.Logger.LogInfo((object)$"[ApplySpecificCurse] Applying {curseType} to {playerName} with intensity {finalIntensityForCurseType}");
}
player.character.refs.afflictions.AddStatus(curseType, finalIntensityForCurseType, false);
}
private float GetFinalIntensityForCurseType(STATUSTYPE curseType)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected I4, but got Unknown
if (1 == 0)
{
}
float result = (int)curseType switch
{
3 => ConfigClass.poisonIntensity.Value,
0 => ConfigClass.injuryIntensity.Value,
1 => ConfigClass.hungerIntensity.Value,
6 => ConfigClass.drowsyIntensity.Value,
5 => ConfigClass.curseStatusIntensity.Value,
2 => ConfigClass.coldIntensity.Value,
8 => ConfigClass.hotIntensity.Value,
_ => 0.1f,
};
if (1 == 0)
{
}
return result;
}
private string GetCurrentCurseTypeDisplay()
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
List<STATUSTYPE> availableCurseTypes = GetAvailableCurseTypes();
if (availableCurseTypes.Count == 0)
{
return "No Curse";
}
return ConfigClass.curseSelectionMode.Value switch
{
Plugin.CurseSelectionMode.Single => GetCurseTypeDisplayName(GetCurseTypeFromString(ConfigClass.singleCurseType.Value)),
Plugin.CurseSelectionMode.Random => "Random Curse",
Plugin.CurseSelectionMode.Multiple => "Multiple Curse",
_ => "Unknown Mode",
};
}
private string GetCurseTypeDisplayName(STATUSTYPE curseType)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected I4, but got Unknown
if (1 == 0)
{
}
string result = (int)curseType switch
{
3 => "Poison",
0 => "Injury",
1 => "Hunger",
6 => "Drowsy",
5 => "Curse",
2 => "Cold",
8 => "Hot",
_ => "Unknown",
};
if (1 == 0)
{
}
return result;
}
}
}
namespace WeForgotBingBong
{
[BepInPlugin("com.yeci.weforgotbingbong", "WeForgotBingBong!", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
public enum CurseSelectionMode
{
Single,
Random,
Multiple
}
[CompilerGenerated]
private sealed class <InitializeBingBongLogic>d__13 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Plugin <>4__this;
private ItemDatabase <db>5__1;
private bool <foundBingBong>5__2;
private Dictionary<ushort, Item>.Enumerator <>s__3;
private KeyValuePair<ushort, Item> <kv>5__4;
private BingBongCurseLogic <curseLogic>5__5;
private BingBongCurseLogic <curseLogic>5__6;
private GameObject <uiManagerGO>5__7;
private UIManager <uiManager>5__8;
private Player[] <players>5__9;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InitializeBingBongLogic>d__13(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<db>5__1 = null;
<>s__3 = default(Dictionary<ushort, Item>.Enumerator);
<kv>5__4 = default(KeyValuePair<ushort, Item>);
<curseLogic>5__5 = null;
<curseLogic>5__6 = null;
<uiManagerGO>5__7 = null;
<uiManager>5__8 = null;
<players>5__9 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_0198: Unknown result type (might be due to invalid IL or missing references)
//IL_01a2: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<db>5__1 = SingletonAsset<ItemDatabase>.Instance;
if ((Object)(object)<db>5__1 == (Object)null)
{
return false;
}
<foundBingBong>5__2 = false;
<>s__3 = <db>5__1.itemLookup.GetEnumerator();
try
{
while (<>s__3.MoveNext())
{
<kv>5__4 = <>s__3.Current;
if (((Object)<kv>5__4.Value).name == "BingBong")
{
<>4__this.bingBong = ((Component)<kv>5__4.Value).gameObject;
<>4__this.bingBongItemID = <kv>5__4.Value.itemID;
<foundBingBong>5__2 = true;
<curseLogic>5__5 = <>4__this.bingBong.AddComponent<BingBongCurseLogic>();
<curseLogic>5__5.Setup(<>4__this.bingBongItemID, ConfigClass.curseInterval.Value, ConfigClass.showUI.Value);
break;
}
<kv>5__4 = default(KeyValuePair<ushort, Item>);
}
}
finally
{
((IDisposable)<>s__3).Dispose();
}
<>s__3 = default(Dictionary<ushort, Item>.Enumerator);
if (<foundBingBong>5__2)
{
if (ConfigClass.showUI.Value)
{
<uiManagerGO>5__7 = new GameObject("BingBongUIManager");
<uiManager>5__8 = <uiManagerGO>5__7.AddComponent<UIManager>();
<uiManagerGO>5__7 = null;
<uiManager>5__8 = null;
}
<curseLogic>5__6 = <>4__this.bingBong.GetComponent<BingBongCurseLogic>();
if ((Object)(object)<curseLogic>5__6 != (Object)null)
{
<players>5__9 = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
<players>5__9 = null;
}
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.StartLocalPlayerSetup());
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.MonitorPlayerInventoryChanges());
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.MonitorItemStateChanges());
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.MonitorPlayerJoins());
<curseLogic>5__6 = null;
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <MonitorItemStateChanges>d__14 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Plugin <>4__this;
private Item[] <allItems>5__1;
private Item[] <>s__2;
private int <>s__3;
private Item <item>5__4;
private Player <player>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MonitorItemStateChanges>d__14(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<allItems>5__1 = null;
<>s__2 = null;
<item>5__4 = null;
<player>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Invalid comparison between Unknown and I4
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
<allItems>5__1 = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
<>s__2 = <allItems>5__1;
for (<>s__3 = 0; <>s__3 < <>s__2.Length; <>s__3++)
{
<item>5__4 = <>s__2[<>s__3];
if ((<item>5__4.itemID == <>4__this.bingBongItemID || ((Object)<item>5__4).name.Contains("BingBong")) && (int)<item>5__4.itemState == 1)
{
<player>5__5 = ((Component)<item>5__4).GetComponentInParent<Player>();
if ((Object)(object)<player>5__5 != (Object)null)
{
}
<player>5__5 = null;
}
<item>5__4 = null;
}
<>s__2 = null;
<allItems>5__1 = null;
break;
}
<>2__current = (object)new WaitForSeconds(3f);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <MonitorPlayerInventoryChanges>d__15 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Plugin <>4__this;
private Player[] <players>5__1;
private Player[] <>s__2;
private int <>s__3;
private Player <player>5__4;
private bool <currentlyHolding>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MonitorPlayerInventoryChanges>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<players>5__1 = null;
<>s__2 = null;
<player>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
<players>5__1 = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
<>s__2 = <players>5__1;
for (<>s__3 = 0; <>s__3 < <>s__2.Length; <>s__3++)
{
<player>5__4 = <>s__2[<>s__3];
if (((MonoBehaviourPun)<player>5__4).photonView.IsMine)
{
<currentlyHolding>5__5 = CheckIfPlayerHasBingBong(<player>5__4, <>4__this.bingBongItemID);
if (!<currentlyHolding>5__5)
{
}
}
<player>5__4 = null;
}
<>s__2 = null;
<players>5__1 = null;
break;
}
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <MonitorPlayerJoins>d__16 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Plugin <>4__this;
private HashSet<Player> <trackedPlayers>5__1;
private Player[] <players>5__2;
private Player[] <>s__3;
private int <>s__4;
private Player <player>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MonitorPlayerJoins>d__16(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<trackedPlayers>5__1 = null;
<players>5__2 = null;
<>s__3 = null;
<player>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<trackedPlayers>5__1 = new HashSet<Player>();
break;
case 1:
<>1__state = -1;
<players>5__2 = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
<>s__3 = <players>5__2;
for (<>s__4 = 0; <>s__4 < <>s__3.Length; <>s__4++)
{
<player>5__5 = <>s__3[<>s__4];
if ((Object)(object)<player>5__5 != (Object)null && (Object)(object)((MonoBehaviourPun)<player>5__5).photonView != (Object)null && !<trackedPlayers>5__1.Contains(<player>5__5))
{
<trackedPlayers>5__1.Add(<player>5__5);
if (ConfigClass.debugMode.Value)
{
Logger.LogInfo((object)("New player detected: " + ((Object)<player>5__5).name));
}
}
<player>5__5 = null;
}
<>s__3 = null;
<trackedPlayers>5__1.RemoveWhere((Player p) => (Object)(object)p == (Object)null);
<players>5__2 = null;
break;
}
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <StartLocalPlayerSetup>d__17 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Plugin <>4__this;
private Player[] <players>5__1;
private Player <localPlayer>5__2;
private Player[] <>s__3;
private int <>s__4;
private Player <player>5__5;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <StartLocalPlayerSetup>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<players>5__1 = null;
<localPlayer>5__2 = null;
<>s__3 = null;
<player>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<players>5__1 = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
<localPlayer>5__2 = null;
<>s__3 = <players>5__1;
for (<>s__4 = 0; <>s__4 < <>s__3.Length; <>s__4++)
{
<player>5__5 = <>s__3[<>s__4];
if ((Object)(object)<player>5__5 != (Object)null && (Object)(object)((MonoBehaviourPun)<player>5__5).photonView != (Object)null && ((MonoBehaviourPun)<player>5__5).photonView.IsMine)
{
<localPlayer>5__2 = <player>5__5;
break;
}
<player>5__5 = null;
}
<>s__3 = null;
if ((Object)(object)<localPlayer>5__2 != (Object)null && ConfigClass.debugMode.Value)
{
Logger.LogInfo((object)("Local player ready: " + ((Object)<localPlayer>5__2).name));
}
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static ManualLogSource Logger;
private bool alreadyLoaded = false;
private GameObject bingBong = null;
private ushort bingBongItemID;
private static GameObject? uiManagerGO;
public static Plugin Instance { get; private set; }
private void Awake()
{
Instance = this;
Logger = ((BaseUnityPlugin)this).Logger;
SceneManager.sceneLoaded += OnSceneLoaded;
ConfigClass.InitConfig(((BaseUnityPlugin)this).Config);
}
private void OnSceneLoaded(Scene scene, LoadSceneMode _)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
if (!alreadyLoaded)
{
alreadyLoaded = true;
((MonoBehaviour)this).StartCoroutine(InitializeBingBongLogic());
}
if (ConfigClass.showUI.Value)
{
if ((Object)(object)uiManagerGO == (Object)null)
{
uiManagerGO = new GameObject("BingBongUIManager");
uiManagerGO.AddComponent<UIManager>();
}
}
else if ((Object)(object)uiManagerGO != (Object)null)
{
Object.Destroy((Object)(object)uiManagerGO);
uiManagerGO = null;
}
}
private void OnDestroy()
{
if ((Object)(object)uiManagerGO != (Object)null)
{
Object.Destroy((Object)(object)uiManagerGO);
uiManagerGO = null;
}
}
[IteratorStateMachine(typeof(<InitializeBingBongLogic>d__13))]
private IEnumerator InitializeBingBongLogic()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InitializeBingBongLogic>d__13(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<MonitorItemStateChanges>d__14))]
private IEnumerator MonitorItemStateChanges()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MonitorItemStateChanges>d__14(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<MonitorPlayerInventoryChanges>d__15))]
private IEnumerator MonitorPlayerInventoryChanges()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MonitorPlayerInventoryChanges>d__15(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<MonitorPlayerJoins>d__16))]
private IEnumerator MonitorPlayerJoins()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MonitorPlayerJoins>d__16(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<StartLocalPlayerSetup>d__17))]
private IEnumerator StartLocalPlayerSetup()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <StartLocalPlayerSetup>d__17(0)
{
<>4__this = this
};
}
public static bool CheckIfPlayerHasBingBong(Player player, ushort bingBongItemID)
{
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)player == (Object)null || player.itemSlots == null)
{
return false;
}
for (int i = 0; i < player.itemSlots.Length; i++)
{
ItemSlot val = player.itemSlots[i];
if (!val.IsEmpty() && (Object)(object)val.prefab != (Object)null && (val.prefab.itemID == bingBongItemID || ((Object)val.prefab).name.Contains("BingBong")))
{
return true;
}
}
if (ConfigClass.countTempSlotAsCarrying.Value && !player.tempFullSlot.IsEmpty() && (Object)(object)player.tempFullSlot.prefab != (Object)null && (player.tempFullSlot.prefab.itemID == bingBongItemID || ((Object)player.tempFullSlot.prefab).name.Contains("BingBong")))
{
return true;
}
if (ConfigClass.countBackpackAsCarrying.Value && player.backpackSlot.hasBackpack && !((ItemSlot)player.backpackSlot).IsEmpty())
{
BackpackReference fromEquippedBackpack = BackpackReference.GetFromEquippedBackpack(player.character);
BackpackData data = ((BackpackReference)(ref fromEquippedBackpack)).GetData();
if (data != null)
{
ItemSlot[] itemSlots = data.itemSlots;
foreach (ItemSlot val2 in itemSlots)
{
if (!val2.IsEmpty() && (Object)(object)val2.prefab != (Object)null && (val2.prefab.itemID == bingBongItemID || ((Object)val2.prefab).name.Contains("BingBong")))
{
Logger.LogInfo((object)("[BackpackCheck] Found BingBong inside backpack of " + ((Object)player).name));
return true;
}
}
}
}
return false;
}
}
}
namespace ConfigSpace
{
public class ConfigClass
{
public static ConfigEntry<float> curseInterval;
public static ConfigEntry<float> invincibilityPeriod;
public static ConfigEntry<bool> showUI;
public static ConfigEntry<bool> debugMode;
public static ConfigEntry<Plugin.CurseSelectionMode> curseSelectionMode;
public static ConfigEntry<string> singleCurseType;
public static ConfigEntry<bool> enablePoison;
public static ConfigEntry<bool> enableInjury;
public static ConfigEntry<bool> enableHunger;
public static ConfigEntry<bool> enableDrowsy;
public static ConfigEntry<bool> enableCurse;
public static ConfigEntry<bool> enableCold;
public static ConfigEntry<bool> enableHot;
public static ConfigEntry<bool> countBackpackAsCarrying;
public static ConfigEntry<bool> countTempSlotAsCarrying;
public static ConfigEntry<float> poisonIntensity;
public static ConfigEntry<float> injuryIntensity;
public static ConfigEntry<float> hungerIntensity;
public static ConfigEntry<float> drowsyIntensity;
public static ConfigEntry<float> curseStatusIntensity;
public static ConfigEntry<float> coldIntensity;
public static ConfigEntry<float> hotIntensity;
public static void InitConfig(ConfigFile config)
{
curseInterval = config.Bind<float>("General", "CurseInterval", 5f, "Interval in seconds between curse applications (Min: 0.01, Max: 60.0)");
invincibilityPeriod = config.Bind<float>("General", "InvincibilityPeriod", 20f, "Duration in seconds for invincibility after curse application (Min: 0.0, Max: 60.0)");
showUI = config.Bind<bool>("UI", "ShowBingBongUI", true, "Whether to display BingBong status on screen");
debugMode = config.Bind<bool>("Debug", "EnableDebugMode", false, "Enable debug mode for detailed logging");
curseSelectionMode = config.Bind<Plugin.CurseSelectionMode>("CurseType", "SelectionMode", Plugin.CurseSelectionMode.Single, "Curse selection mode: Single(one type), Random(random selection), Multiple(multiple curses)");
singleCurseType = config.Bind<string>("CurseType", "SingleCurseType", "Poison", "Single curse type (effective when SelectionMode is set to Single)");
enablePoison = config.Bind<bool>("CurseType", "EnablePoison", true, "Enable poison curse");
enableInjury = config.Bind<bool>("CurseType", "EnableInjury", true, "Enable injury curse");
enableHunger = config.Bind<bool>("CurseType", "EnableHunger", true, "Enable hunger curse");
enableDrowsy = config.Bind<bool>("CurseType", "EnableDrowsy", true, "Enable drowsy curse");
enableCurse = config.Bind<bool>("CurseType", "EnableCurse", false, "Enable curse status");
enableCold = config.Bind<bool>("CurseType", "EnableCold", true, "Enable cold curse");
enableHot = config.Bind<bool>("CurseType", "EnableHot", true, "Enable hot curse");
countBackpackAsCarrying = config.Bind<bool>("CarryingDetection", "CountBackpackAsCarrying", true, "Whether BingBong in backpack counts as carrying (prevents curses)");
countTempSlotAsCarrying = config.Bind<bool>("CarryingDetection", "CountTempSlotAsCarrying", true, "Whether BingBong in temporary item slot counts as carrying");
poisonIntensity = config.Bind<float>("CurseIntensity", "PoisonIntensity", 0.1f, "Final poison curse intensity (0.01-10.0)");
injuryIntensity = config.Bind<float>("CurseIntensity", "InjuryIntensity", 0.1f, "Final injury curse intensity (0.01-10.0)");
hungerIntensity = config.Bind<float>("CurseIntensity", "HungerIntensity", 0.1f, "Final hunger curse intensity (0.01-10.0)");
drowsyIntensity = config.Bind<float>("CurseIntensity", "DrowsyIntensity", 0.1f, "Final drowsy curse intensity (0.01-10.0)");
curseStatusIntensity = config.Bind<float>("CurseIntensity", "CurseStatusIntensity", 0.1f, "Final curse status intensity (0.01-10.0)");
coldIntensity = config.Bind<float>("CurseIntensity", "ColdIntensity", 0.1f, "Final cold curse intensity (0.01-10.0)");
hotIntensity = config.Bind<float>("CurseIntensity", "HotIntensity", 0.1f, "Final hot curse intensity (0.01-10.0)");
SetupConfigConstraints();
}
private static void SetupConfigConstraints()
{
curseInterval.SettingChanged += delegate
{
if (curseInterval.Value < 0.01f)
{
curseInterval.Value = 0.01f;
}
if (curseInterval.Value > 60f)
{
curseInterval.Value = 60f;
}
};
invincibilityPeriod.SettingChanged += delegate
{
if (invincibilityPeriod.Value < 0f)
{
invincibilityPeriod.Value = 0f;
}
if (invincibilityPeriod.Value > 60f)
{
invincibilityPeriod.Value = 60f;
}
};
poisonIntensity.SettingChanged += delegate
{
if (poisonIntensity.Value < 0.01f)
{
poisonIntensity.Value = 0.01f;
}
if (poisonIntensity.Value > 10f)
{
poisonIntensity.Value = 10f;
}
};
injuryIntensity.SettingChanged += delegate
{
if (injuryIntensity.Value < 0.01f)
{
injuryIntensity.Value = 0.01f;
}
if (injuryIntensity.Value > 10f)
{
injuryIntensity.Value = 10f;
}
};
hungerIntensity.SettingChanged += delegate
{
if (hungerIntensity.Value < 0.01f)
{
hungerIntensity.Value = 0.01f;
}
if (hungerIntensity.Value > 10f)
{
hungerIntensity.Value = 10f;
}
};
drowsyIntensity.SettingChanged += delegate
{
if (drowsyIntensity.Value < 0.01f)
{
drowsyIntensity.Value = 0.01f;
}
if (drowsyIntensity.Value > 10f)
{
drowsyIntensity.Value = 10f;
}
};
curseStatusIntensity.SettingChanged += delegate
{
if (curseStatusIntensity.Value < 0.01f)
{
curseStatusIntensity.Value = 0.01f;
}
if (curseStatusIntensity.Value > 10f)
{
curseStatusIntensity.Value = 10f;
}
};
coldIntensity.SettingChanged += delegate
{
if (coldIntensity.Value < 0.01f)
{
coldIntensity.Value = 0.01f;
}
if (coldIntensity.Value > 10f)
{
coldIntensity.Value = 10f;
}
};
hotIntensity.SettingChanged += delegate
{
if (hotIntensity.Value < 0.01f)
{
hotIntensity.Value = 0.01f;
}
if (hotIntensity.Value > 10f)
{
hotIntensity.Value = 10f;
}
};
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
