using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("PassTheCurse")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.4.0")]
[assembly: AssemblyInformationalVersion("0.1.4")]
[assembly: AssemblyProduct("PassTheCurse")]
[assembly: AssemblyTitle("PassTheCurse")]
[assembly: AssemblyVersion("0.1.4.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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]
[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]
[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 PassTheCurse
{
internal enum CurseEffect
{
None,
RandomSlip,
BadStaminaRegen,
InvoluntaryJump,
CameraWobble,
FakeUi,
BackpackLeakage,
TripSneeze,
InvertedControls,
GripHiccup
}
internal sealed class CurseManager
{
private const string CursedActorKey = "PassTheCurse.CursedActor";
private const string CurseEffectKey = "PassTheCurse.CurseEffect";
private const string LastTransferKey = "PassTheCurse.LastTransferTime";
private static readonly MethodInfo? DropItemFromSlotMethod = AccessTools.Method(typeof(CharacterItems), "DropItemFromSlotRPC", (Type[])null, (Type[])null);
private readonly string[] fakeWarnings = new string[6] { "LOW STAMINA", "BACKPACK LEAK DETECTED", "GRIP FAILURE IMMINENT", "YOU DROPPED AN ITEM", "WRONG WAY", "CURSE LEVEL RISING" };
private int cachedCursedActor = -1;
private CurseEffect cachedCurseEffect;
private int previousLocalCursedActor = -1;
private CurseEffect previousLocalCurseEffect;
private int lastCharacterCount;
private float charactersAppearedAt = -1f;
private bool shouldAssignAtRunStart = true;
private float localLastTransferTime = -9999f;
private float nextSlipAt;
private float nextJumpAt;
private float nextFakeUiAt;
private float nextLeakAt;
private float nextTripSneezeAt;
private float nextGripHiccupAt;
private float nextCurseStatusAt;
private float cueUntil;
private string cueTitle = string.Empty;
private string cueSubtitle = string.Empty;
internal int CursedActor => cachedCursedActor;
internal CurseEffect ActiveEffect => cachedCurseEffect;
internal bool LocalPlayerIsCursed
{
get
{
Character localCharacter = Character.localCharacter;
if ((Object)(object)localCharacter != (Object)null && TryGetActorNumber(localCharacter, out var actorNumber))
{
return actorNumber == cachedCursedActor;
}
return false;
}
}
internal void Update()
{
if (!Plugin.ModEnabled.Value || !PhotonNetwork.InRoom)
{
ResetLocalState();
return;
}
RefreshCachedCursedActor();
HandleHostAssignmentAndTransfers();
HandleLocalCurseEffects();
}
internal void FixedUpdate()
{
}
internal void OnGUI()
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Expected O, but got Unknown
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012f: Expected O, but got Unknown
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
if (!(Time.time >= cueUntil) && !string.IsNullOrEmpty(cueTitle))
{
float num = Mathf.Clamp01((cueUntil - Time.time) / 0.8f);
Color color = GUI.color;
GUI.color = new Color(1f, 1f, 1f, num);
Rect val = default(Rect);
((Rect)(ref val))..ctor((float)Screen.width * 0.1f, (float)Screen.height * 0.18f, (float)Screen.width * 0.8f, 70f);
GUIStyle val2 = new GUIStyle(GUI.skin.label)
{
alignment = (TextAnchor)4,
fontSize = 34,
fontStyle = (FontStyle)1,
wordWrap = true
};
val2.normal.textColor = new Color(1f, 0.24f, 0.2f, num);
Rect val3 = default(Rect);
((Rect)(ref val3))..ctor((float)Screen.width * 0.1f, ((Rect)(ref val)).yMax - 6f, (float)Screen.width * 0.8f, 52f);
GUIStyle val4 = new GUIStyle(GUI.skin.label)
{
alignment = (TextAnchor)4,
fontSize = 19,
fontStyle = (FontStyle)1,
wordWrap = true
};
val4.normal.textColor = new Color(1f, 1f, 1f, num);
GUI.Label(val, cueTitle, val2);
GUI.Label(val3, cueSubtitle, val4);
GUI.color = color;
}
}
internal static bool IsCursed(Character character)
{
if (Plugin.Instance.Curse.TryGetActorNumber(character, out var actorNumber))
{
return actorNumber == Plugin.Instance.Curse.CursedActor;
}
return false;
}
internal static bool HasActiveEffect(Character character, CurseEffect effect)
{
if (IsCursed(character))
{
return Plugin.Instance.Curse.ActiveEffect == effect;
}
return false;
}
internal bool LocalPlayerHasEffect(CurseEffect effect)
{
if (LocalPlayerIsCursed)
{
return cachedCurseEffect == effect;
}
return false;
}
internal static bool TryGetCharacterActor(Character character, out int actorNumber)
{
return Plugin.Instance.Curse.TryGetActorNumber(character, out actorNumber);
}
private void RefreshCachedCursedActor()
{
Hashtable customProperties = ((RoomInfo)PhotonNetwork.CurrentRoom).CustomProperties;
if (((Dictionary<object, object>)(object)customProperties).ContainsKey((object)"PassTheCurse.CursedActor") && customProperties[(object)"PassTheCurse.CursedActor"] is int num)
{
cachedCursedActor = num;
}
if (((Dictionary<object, object>)(object)customProperties).ContainsKey((object)"PassTheCurse.CurseEffect") && customProperties[(object)"PassTheCurse.CurseEffect"] is int num2 && Enum.IsDefined(typeof(CurseEffect), num2))
{
cachedCurseEffect = (CurseEffect)num2;
}
if (((Dictionary<object, object>)(object)customProperties).ContainsKey((object)"PassTheCurse.LastTransferTime") && customProperties[(object)"PassTheCurse.LastTransferTime"] is float num3)
{
localLastTransferTime = num3;
}
}
private void HandleHostAssignmentAndTransfers()
{
//IL_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_0139: Unknown result type (might be due to invalid IL or missing references)
if (!PhotonNetwork.IsMasterClient)
{
return;
}
List<Character> validCharacters = GetValidCharacters();
int count = validCharacters.Count;
if (count == 0)
{
lastCharacterCount = 0;
charactersAppearedAt = -1f;
shouldAssignAtRunStart = true;
return;
}
if (lastCharacterCount == 0)
{
charactersAppearedAt = Time.time;
shouldAssignAtRunStart = true;
}
lastCharacterCount = count;
if (charactersAppearedAt >= 0f && Time.time - charactersAppearedAt < Plugin.StartDelay.Value)
{
return;
}
if (shouldAssignAtRunStart || cachedCursedActor < 0 || (Object)(object)FindCharacterByActor(cachedCursedActor, validCharacters) == (Object)null)
{
Character character = validCharacters[Random.Range(0, validCharacters.Count)];
if (TryGetActorNumber(character, out var actorNumber))
{
SetCursedActor(actorNumber, "initial");
}
}
else
{
if (Time.time - localLastTransferTime < Plugin.TransferCooldown.Value)
{
return;
}
Character val = FindCharacterByActor(cachedCursedActor, validCharacters);
if ((Object)(object)val == (Object)null)
{
return;
}
Vector3 val2 = SafeHipPosition(val);
float value = Plugin.TouchDistance.Value;
foreach (Character item in validCharacters)
{
if (item != val && TryGetActorNumber(item, out var actorNumber2) && Vector3.Distance(val2, SafeHipPosition(item)) <= value)
{
SetCursedActor(actorNumber2, "touch");
break;
}
}
}
}
private void HandleLocalCurseEffects()
{
Character localCharacter = Character.localCharacter;
if (!LocalPlayerIsCursed)
{
if (previousLocalCursedActor == PhotonNetwork.LocalPlayer.ActorNumber && (Object)(object)localCharacter?.refs.afflictions != (Object)null)
{
localCharacter.refs.afflictions.SetStatus((STATUSTYPE)5, 0f, false);
}
previousLocalCursedActor = cachedCursedActor;
return;
}
if (previousLocalCursedActor != cachedCursedActor || previousLocalCurseEffect != cachedCurseEffect)
{
ResetEffectTimers();
ShowCurseCue(cachedCurseEffect);
ApplyImmediateEffectCue(localCharacter, cachedCurseEffect);
}
previousLocalCursedActor = cachedCursedActor;
previousLocalCurseEffect = cachedCurseEffect;
if (!((Object)(object)localCharacter == (Object)null))
{
if (Plugin.ShowCurseOnStaminaBar.Value && Time.time >= nextCurseStatusAt && (Object)(object)localCharacter.refs.afflictions != (Object)null)
{
localCharacter.refs.afflictions.AddStatus((STATUSTYPE)5, 0.025f, false, true, false);
nextCurseStatusAt = Time.time + 6f;
}
else if (!Plugin.ShowCurseOnStaminaBar.Value && (Object)(object)localCharacter.refs.afflictions != (Object)null)
{
localCharacter.refs.afflictions.SetStatus((STATUSTYPE)5, 0f, false);
}
if (cachedCurseEffect == CurseEffect.RandomSlip && Plugin.EnableRandomSlip.Value && Time.time >= nextSlipAt)
{
ApplyRandomSlip(localCharacter);
nextSlipAt = Time.time + RandomRange(Plugin.SlipIntervalMin.Value, Plugin.SlipIntervalMax.Value);
}
if (cachedCurseEffect == CurseEffect.InvoluntaryJump && Plugin.EnableInvoluntaryJump.Value && Time.time >= nextJumpAt)
{
ApplyInvoluntaryJump(localCharacter);
nextJumpAt = Time.time + RandomRange(Plugin.JumpIntervalMin.Value, Plugin.JumpIntervalMax.Value);
}
if (cachedCurseEffect == CurseEffect.FakeUi && Plugin.EnableFakeUi.Value && Time.time >= nextFakeUiAt)
{
Notify(fakeWarnings[Random.Range(0, fakeWarnings.Length)]);
nextFakeUiAt = Time.time + RandomRange(Plugin.FakeUiIntervalMin.Value, Plugin.FakeUiIntervalMax.Value);
}
if (cachedCurseEffect == CurseEffect.BackpackLeakage && Plugin.EnableBackpackLeakage.Value && Time.time >= nextLeakAt)
{
TryLeakItem(localCharacter);
nextLeakAt = Time.time + RandomRange(Plugin.LeakIntervalMin.Value, Plugin.LeakIntervalMax.Value);
}
if (cachedCurseEffect == CurseEffect.TripSneeze && Plugin.EnableTripSneeze.Value && Time.time >= nextTripSneezeAt)
{
ApplyTripSneeze(localCharacter);
nextTripSneezeAt = Time.time + RandomRange(Plugin.TripSneezeIntervalMin.Value, Plugin.TripSneezeIntervalMax.Value);
}
if (cachedCurseEffect == CurseEffect.GripHiccup && Plugin.EnableGripHiccup.Value && Time.time >= nextGripHiccupAt)
{
ApplyGripHiccup(localCharacter);
nextGripHiccupAt = Time.time + RandomRange(Plugin.GripHiccupIntervalMin.Value, Plugin.GripHiccupIntervalMax.Value);
}
}
}
private void ApplyRandomSlip(Character local)
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: 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)
if ((Object)(object)local.refs.climbing != (Object)null)
{
float num = ((Random.value < 0.5f) ? (-1f) : 1f);
CharacterClimbing climbing = local.refs.climbing;
climbing.playerSlide += new Vector2(num * Plugin.SlipStrength.Value, 0f - Plugin.SlipStrength.Value);
}
Notify("Grip slipped.");
}
private void ApplyInvoluntaryJump(Character local)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: 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)
Vector3 insideUnitSphere = Random.insideUnitSphere;
insideUnitSphere.y = 0f;
Vector3 val = Vector3.up * Plugin.JumpForce.Value + ((Vector3)(ref insideUnitSphere)).normalized * (Plugin.JumpForce.Value * 0.18f);
if ((Object)(object)local.refs.hip != (Object)null)
{
local.refs.hip.AddForce(val, (ForceMode)1);
}
if ((Object)(object)local.refs.hip != (Object)null && (Object)(object)local.refs.hip.Rig != (Object)null)
{
local.refs.hip.Rig.AddForce(val, (ForceMode)1);
}
Notify("The curse jumped.");
}
private void TryLeakItem(Character local)
{
//IL_0089: 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_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: 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)
if (DropItemFromSlotMethod == null || (Object)(object)Player.localPlayer == (Object)null || (Object)(object)local.refs.items == (Object)null)
{
return;
}
List<ItemSlot> list = new List<ItemSlot>();
ItemSlot[] itemSlots = Player.localPlayer.itemSlots;
foreach (ItemSlot val in itemSlots)
{
if (val != null && !val.IsEmpty())
{
list.Add(val);
}
}
if (list.Count == 0)
{
return;
}
ItemSlot val2 = list[Random.Range(0, list.Count)];
Vector3 val3 = SafeHipPosition(local) + Vector3.up * 0.75f + Random.insideUnitSphere * 0.2f;
try
{
DropItemFromSlotMethod.Invoke(local.refs.items, new object[2] { val2.itemSlotID, val3 });
Notify("Something leaked from your pack.");
}
catch (Exception ex)
{
Plugin.Log.LogWarning((object)("Backpack leakage failed: " + ex.Message));
}
}
private void ApplyTripSneeze(Character local)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
Vector3 val = Random.insideUnitSphere;
val.y = 0f;
if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
{
val = local.data.lookDirection_Right;
}
((Vector3)(ref val)).Normalize();
Vector3 val2 = (val * 0.55f + Vector3.down * 0.25f + Vector3.up * 0.15f) * Plugin.TripSneezeForce.Value;
if ((Object)(object)local.refs.hip != (Object)null)
{
local.refs.hip.AddForce(val2, (ForceMode)1);
}
if ((Object)(object)local.refs.climbing != (Object)null)
{
CharacterClimbing climbing = local.refs.climbing;
climbing.playerSlide += new Vector2(val.x, -1f) * (Plugin.TripSneezeForce.Value / 220f);
}
local.data.slippy = Mathf.Max(local.data.slippy, Plugin.SlippyAmount.Value * 0.75f);
Notify("Trip sneeze.");
}
private void ApplyGripHiccup(Character local)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: 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_004b: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)local.refs.climbing == (Object)null) && local.data.isClimbing)
{
CharacterClimbing climbing = local.refs.climbing;
climbing.playerSlide += Vector2.down * Plugin.GripHiccupSlideStrength.Value;
local.refs.climbing.StopClimbing();
Notify("Grip hiccup.");
}
}
private void ResetEffectTimers()
{
float time = Time.time;
nextSlipAt = time + 2f;
nextJumpAt = time + 2.5f;
nextFakeUiAt = time + 2f;
nextLeakAt = time + 4f;
nextTripSneezeAt = time + 2.5f;
nextGripHiccupAt = time + 3f;
nextCurseStatusAt = time + 1f;
}
private void ApplyImmediateEffectCue(Character? local, CurseEffect effect)
{
Plugin.Log.LogInfo((object)$"Local player is cursed with {effect}.");
if (!((Object)(object)local == (Object)null))
{
switch (effect)
{
case CurseEffect.FakeUi:
Notify(fakeWarnings[Random.Range(0, fakeWarnings.Length)]);
break;
case CurseEffect.BackpackLeakage:
Notify("Your pack feels loose.");
break;
case CurseEffect.InvoluntaryJump:
Notify("Your legs twitch.");
break;
case CurseEffect.TripSneeze:
Notify("You feel a sneeze building.");
break;
case CurseEffect.InvertedControls:
Notify("Your controls feel backwards.");
break;
case CurseEffect.GripHiccup:
Notify("Your grip feels unreliable.");
break;
case CurseEffect.CameraWobble:
break;
}
}
}
private void ResetLocalState()
{
cachedCursedActor = -1;
cachedCurseEffect = CurseEffect.None;
previousLocalCursedActor = -1;
previousLocalCurseEffect = CurseEffect.None;
lastCharacterCount = 0;
charactersAppearedAt = -1f;
shouldAssignAtRunStart = true;
localLastTransferTime = -9999f;
cueUntil = 0f;
cueTitle = string.Empty;
cueSubtitle = string.Empty;
}
private void SetCursedActor(int actorNumber, string reason)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Expected O, but got Unknown
CurseEffect curseEffect = RollRandomEffect();
Hashtable val = new Hashtable
{
[(object)"PassTheCurse.CursedActor"] = actorNumber,
[(object)"PassTheCurse.CurseEffect"] = (int)curseEffect,
[(object)"PassTheCurse.LastTransferTime"] = Time.time
};
cachedCursedActor = actorNumber;
cachedCurseEffect = curseEffect;
shouldAssignAtRunStart = false;
localLastTransferTime = Time.time;
PhotonNetwork.CurrentRoom.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
Plugin.Log.LogInfo((object)$"Curse assigned to actor {actorNumber} ({reason}, {curseEffect}).");
}
private static CurseEffect RollRandomEffect()
{
List<CurseEffect> list = new List<CurseEffect>();
if (Plugin.EnableRandomSlip.Value)
{
list.Add(CurseEffect.RandomSlip);
}
if (Plugin.EnableBadStaminaRegen.Value)
{
list.Add(CurseEffect.BadStaminaRegen);
}
if (Plugin.EnableInvoluntaryJump.Value)
{
list.Add(CurseEffect.InvoluntaryJump);
}
if (Plugin.EnableCameraWobble.Value)
{
list.Add(CurseEffect.CameraWobble);
}
if (Plugin.EnableFakeUi.Value)
{
list.Add(CurseEffect.FakeUi);
}
if (Plugin.EnableBackpackLeakage.Value)
{
list.Add(CurseEffect.BackpackLeakage);
}
if (Plugin.EnableTripSneeze.Value)
{
list.Add(CurseEffect.TripSneeze);
}
if (Plugin.EnableInvertedControls.Value)
{
list.Add(CurseEffect.InvertedControls);
}
if (Plugin.EnableGripHiccup.Value)
{
list.Add(CurseEffect.GripHiccup);
}
if (list.Count != 0)
{
return list[Random.Range(0, list.Count)];
}
return CurseEffect.None;
}
private List<Character> GetValidCharacters()
{
List<Character> list = new List<Character>();
foreach (Character allCharacter in Character.AllCharacters)
{
if ((Object)(object)allCharacter != (Object)null && !allCharacter.isBot && !allCharacter.data.dead && !allCharacter.data.passedOut && !allCharacter.data.fullyPassedOut && TryGetActorNumber(allCharacter, out var _))
{
list.Add(allCharacter);
}
}
return list;
}
private Character? FindCharacterByActor(int actorNumber, List<Character> candidates)
{
foreach (Character candidate in candidates)
{
if (TryGetActorNumber(candidate, out var actorNumber2) && actorNumber2 == actorNumber)
{
return candidate;
}
}
return null;
}
private bool TryGetActorNumber(Character character, out int actorNumber)
{
actorNumber = -1;
PhotonView view = character.refs.view;
if ((Object)(object)view == (Object)null || view.Owner == null)
{
return false;
}
actorNumber = view.Owner.ActorNumber;
return actorNumber > 0;
}
private static Vector3 SafeHipPosition(Character character)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
try
{
return character.Center;
}
catch (Exception)
{
return ((Component)character).transform.position;
}
}
private static float RandomRange(float min, float max)
{
if (max < min)
{
float num = max;
max = min;
min = num;
}
return Random.Range(min, max);
}
private static void Notify(string text)
{
try
{
UI_Notifications val = Object.FindObjectOfType<UI_Notifications>();
if (val != null)
{
val.AddNotification(text);
}
}
catch (Exception ex)
{
Plugin.Log.LogDebug((object)("Failed to show curse notification: " + ex.Message));
}
}
private static void ShowCurseCue(CurseEffect effect)
{
string text = FormatEffectName(effect);
string text2 = "YOU ARE CURSED\n" + text.ToUpperInvariant();
string text3 = "You are cursed: " + text + ". Touch someone.";
Plugin.Instance.Curse.cueTitle = "YOU ARE CURSED";
Plugin.Instance.Curse.cueSubtitle = text + " - touch another player";
Plugin.Instance.Curse.cueUntil = Time.time + 4.5f;
try
{
if ((Object)(object)GUIManager.instance != (Object)null)
{
GUIManager.instance.SetHeroTitle(text2, (AudioClip)null);
return;
}
}
catch (Exception ex)
{
Plugin.Log.LogDebug((object)("Failed to show big curse cue: " + ex.Message));
}
Notify(text3);
}
private static string FormatEffectName(CurseEffect effect)
{
return effect switch
{
CurseEffect.RandomSlip => "Random Slip",
CurseEffect.BadStaminaRegen => "Bad Stamina Regen",
CurseEffect.InvoluntaryJump => "Involuntary Jump",
CurseEffect.CameraWobble => "Camera Wobble",
CurseEffect.FakeUi => "Fake UI",
CurseEffect.BackpackLeakage => "Backpack Leakage",
CurseEffect.TripSneeze => "Trip Sneeze",
CurseEffect.InvertedControls => "Inverted Controls",
CurseEffect.GripHiccup => "Grip Hiccup",
_ => "Unknown",
};
}
}
[HarmonyPatch(typeof(CharacterInput))]
internal static class CharacterInputPatches
{
[HarmonyPostfix]
[HarmonyPatch("Sample")]
private static void SamplePostfix(CharacterInput __instance)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
if (ShouldInvertControls())
{
__instance.movementInput *= -1f;
}
}
[HarmonyPostfix]
[HarmonyPatch("GetMovementInput")]
private static void GetMovementInputPostfix(ref Vector2 __result)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
if (ShouldInvertControls())
{
__result *= -1f;
}
}
private static bool ShouldInvertControls()
{
if (Plugin.ModEnabled.Value && Plugin.EnableInvertedControls.Value)
{
return Plugin.Instance.Curse.LocalPlayerHasEffect(CurseEffect.InvertedControls);
}
return false;
}
}
[HarmonyPatch(typeof(Character))]
internal static class CharacterPatches
{
[HarmonyPrefix]
[HarmonyPatch("AddStamina")]
private static void AddStaminaPrefix(Character __instance, ref float add)
{
if (Plugin.ModEnabled.Value && Plugin.EnableBadStaminaRegen.Value && add > 0f && CurseManager.HasActiveEffect(__instance, CurseEffect.BadStaminaRegen))
{
add *= Plugin.StaminaRegenMultiplier.Value;
}
}
}
[HarmonyPatch(typeof(MainCameraMovement))]
internal static class MainCameraMovementPatches
{
[HarmonyPostfix]
[HarmonyPatch("LateUpdate")]
private static void LateUpdatePostfix(MainCameraMovement __instance)
{
//IL_007b: 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_008c: Unknown result type (might be due to invalid IL or missing references)
if (Plugin.ModEnabled.Value && Plugin.EnableCameraWobble.Value && Plugin.Instance.Curse.LocalPlayerHasEffect(CurseEffect.CameraWobble))
{
float value = Plugin.CameraWobbleDegrees.Value;
if (!(value <= 0f))
{
float value2 = Plugin.CameraWobbleSpeed.Value;
float num = Mathf.Sin(Time.time * value2 * 1.17f) * value * 0.45f;
float num2 = Mathf.Sin(Time.time * value2) * value;
Transform transform = ((Component)__instance).transform;
transform.localRotation *= Quaternion.Euler(num, 0f, num2);
}
}
}
}
[BepInPlugin("edwar.peak.passthecurse", "Pass The Curse", "0.1.4")]
public sealed class Plugin : BaseUnityPlugin
{
public const string PluginGuid = "edwar.peak.passthecurse";
public const string PluginName = "Pass The Curse";
public const string PluginVersion = "0.1.4";
private Harmony? harmony;
internal static Plugin Instance { get; private set; }
internal static ManualLogSource Log { get; private set; }
internal static ConfigEntry<bool> ModEnabled { get; private set; }
internal static ConfigEntry<float> TouchDistance { get; private set; }
internal static ConfigEntry<float> TransferCooldown { get; private set; }
internal static ConfigEntry<float> StartDelay { get; private set; }
internal static ConfigEntry<bool> EnableRandomSlip { get; private set; }
internal static ConfigEntry<float> SlipIntervalMin { get; private set; }
internal static ConfigEntry<float> SlipIntervalMax { get; private set; }
internal static ConfigEntry<float> SlipStrength { get; private set; }
internal static ConfigEntry<float> SlippyAmount { get; private set; }
internal static ConfigEntry<bool> EnableBadStaminaRegen { get; private set; }
internal static ConfigEntry<float> StaminaRegenMultiplier { get; private set; }
internal static ConfigEntry<bool> EnableInvoluntaryJump { get; private set; }
internal static ConfigEntry<float> JumpIntervalMin { get; private set; }
internal static ConfigEntry<float> JumpIntervalMax { get; private set; }
internal static ConfigEntry<float> JumpForce { get; private set; }
internal static ConfigEntry<bool> EnableCameraWobble { get; private set; }
internal static ConfigEntry<float> CameraWobbleDegrees { get; private set; }
internal static ConfigEntry<float> CameraWobbleSpeed { get; private set; }
internal static ConfigEntry<bool> EnableFakeUi { get; private set; }
internal static ConfigEntry<float> FakeUiIntervalMin { get; private set; }
internal static ConfigEntry<float> FakeUiIntervalMax { get; private set; }
internal static ConfigEntry<bool> EnableBackpackLeakage { get; private set; }
internal static ConfigEntry<float> LeakIntervalMin { get; private set; }
internal static ConfigEntry<float> LeakIntervalMax { get; private set; }
internal static ConfigEntry<bool> ShowCurseOnStaminaBar { get; private set; }
internal static ConfigEntry<bool> EnableTripSneeze { get; private set; }
internal static ConfigEntry<float> TripSneezeIntervalMin { get; private set; }
internal static ConfigEntry<float> TripSneezeIntervalMax { get; private set; }
internal static ConfigEntry<float> TripSneezeForce { get; private set; }
internal static ConfigEntry<bool> EnableInvertedControls { get; private set; }
internal static ConfigEntry<bool> EnableGripHiccup { get; private set; }
internal static ConfigEntry<float> GripHiccupIntervalMin { get; private set; }
internal static ConfigEntry<float> GripHiccupIntervalMax { get; private set; }
internal static ConfigEntry<float> GripHiccupSlideStrength { get; private set; }
internal CurseManager Curse { get; private set; }
private void Awake()
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
Instance = this;
Log = ((BaseUnityPlugin)this).Logger;
BindConfig();
Curse = new CurseManager();
harmony = new Harmony("edwar.peak.passthecurse");
harmony.PatchAll();
Log.LogInfo((object)"Pass The Curse 0.1.4 loaded.");
}
private void Update()
{
Curse.Update();
}
private void FixedUpdate()
{
Curse.FixedUpdate();
}
private void OnGUI()
{
Curse.OnGUI();
}
private void OnDestroy()
{
Harmony? obj = harmony;
if (obj != null)
{
obj.UnpatchSelf();
}
}
private void BindConfig()
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00d2: Expected O, but got Unknown
//IL_0145: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Expected O, but got Unknown
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_018c: Expected O, but got Unknown
//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Expected O, but got Unknown
//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0206: Expected O, but got Unknown
//IL_0259: Unknown result type (might be due to invalid IL or missing references)
//IL_0263: Expected O, but got Unknown
//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
//IL_02c0: Expected O, but got Unknown
//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
//IL_02fd: Expected O, but got Unknown
//IL_0330: Unknown result type (might be due to invalid IL or missing references)
//IL_033a: Expected O, but got Unknown
//IL_038d: Unknown result type (might be due to invalid IL or missing references)
//IL_0397: Expected O, but got Unknown
//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
//IL_03d4: Expected O, but got Unknown
//IL_0427: Unknown result type (might be due to invalid IL or missing references)
//IL_0431: Expected O, but got Unknown
//IL_0464: Unknown result type (might be due to invalid IL or missing references)
//IL_046e: Expected O, but got Unknown
//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
//IL_04cb: Expected O, but got Unknown
//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0508: Expected O, but got Unknown
//IL_055b: Unknown result type (might be due to invalid IL or missing references)
//IL_0565: Expected O, but got Unknown
//IL_0598: Unknown result type (might be due to invalid IL or missing references)
//IL_05a2: Expected O, but got Unknown
//IL_05d5: Unknown result type (might be due to invalid IL or missing references)
//IL_05df: Expected O, but got Unknown
//IL_0652: Unknown result type (might be due to invalid IL or missing references)
//IL_065c: Expected O, but got Unknown
//IL_068f: Unknown result type (might be due to invalid IL or missing references)
//IL_0699: Expected O, but got Unknown
//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
//IL_06d6: Expected O, but got Unknown
ModEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enables cursed tag.");
TouchDistance = ((BaseUnityPlugin)this).Config.Bind<float>("General", "TouchDistance", 1.65f, new ConfigDescription("Distance between player hips that counts as touching.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 5f), Array.Empty<object>()));
TransferCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("General", "TransferCooldown", 4f, new ConfigDescription("Seconds before the curse can transfer again.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 30f), Array.Empty<object>()));
StartDelay = ((BaseUnityPlugin)this).Config.Bind<float>("General", "StartDelay", 5f, new ConfigDescription("Seconds after characters appear before the host assigns the first curse.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 60f), Array.Empty<object>()));
ShowCurseOnStaminaBar = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowCurseOnStaminaBar", false, "When true, also adds PEAK's built-in Curse status so it appears on the stamina bar.");
EnableRandomSlip = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.RandomSlip", "Enabled", true, "Makes the cursed player randomly slip while climbing.");
SlipIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.RandomSlip", "IntervalMin", 8f, new ConfigDescription("Minimum seconds between random slips.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
SlipIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.RandomSlip", "IntervalMax", 18f, new ConfigDescription("Maximum seconds between random slips.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
SlipStrength = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.RandomSlip", "SlideStrength", 1.6f, new ConfigDescription("How hard the climbing slide impulse is.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
SlippyAmount = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.RandomSlip", "SlippyAmount", 0.8f, new ConfigDescription("Temporary PEAK slippy value to apply.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
EnableBadStaminaRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.BadStaminaRegen", "Enabled", true, "Slows stamina regeneration for the cursed player.");
StaminaRegenMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.BadStaminaRegen", "Multiplier", 0.45f, new ConfigDescription("Positive stamina gains are multiplied by this while cursed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
EnableInvoluntaryJump = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.InvoluntaryJump", "Enabled", true, "Occasionally launches the cursed player upward.");
JumpIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.InvoluntaryJump", "IntervalMin", 12f, new ConfigDescription("Minimum seconds between involuntary jumps.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
JumpIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.InvoluntaryJump", "IntervalMax", 28f, new ConfigDescription("Maximum seconds between involuntary jumps.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
JumpForce = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.InvoluntaryJump", "Force", 420f, new ConfigDescription("Impulse force used for involuntary jumps.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1500f), Array.Empty<object>()));
EnableCameraWobble = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.CameraWobble", "Enabled", true, "Adds mild camera wobble while cursed.");
CameraWobbleDegrees = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.CameraWobble", "Degrees", 1.8f, new ConfigDescription("Camera wobble strength in degrees.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
CameraWobbleSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.CameraWobble", "Speed", 2.5f, new ConfigDescription("Camera wobble speed.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
EnableFakeUi = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.FakeUI", "Enabled", true, "Shows fake warning notifications to the cursed player.");
FakeUiIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.FakeUI", "IntervalMin", 6f, new ConfigDescription("Minimum seconds between fake warnings.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 180f), Array.Empty<object>()));
FakeUiIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.FakeUI", "IntervalMax", 14f, new ConfigDescription("Maximum seconds between fake warnings.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 180f), Array.Empty<object>()));
EnableBackpackLeakage = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.BackpackLeakage", "Enabled", true, "Occasionally drops an item from the cursed player's inventory.");
LeakIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.BackpackLeakage", "IntervalMin", 25f, new ConfigDescription("Minimum seconds between item leaks.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 240f), Array.Empty<object>()));
LeakIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.BackpackLeakage", "IntervalMax", 55f, new ConfigDescription("Maximum seconds between item leaks.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 240f), Array.Empty<object>()));
EnableTripSneeze = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.TripSneeze", "Enabled", true, "Occasionally makes the cursed player stumble with a sudden sneeze.");
TripSneezeIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.TripSneeze", "IntervalMin", 7f, new ConfigDescription("Minimum seconds between trip sneezes.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
TripSneezeIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.TripSneeze", "IntervalMax", 16f, new ConfigDescription("Maximum seconds between trip sneezes.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
TripSneezeForce = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.TripSneeze", "Force", 280f, new ConfigDescription("Impulse force used for trip sneezes.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1200f), Array.Empty<object>()));
EnableInvertedControls = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.InvertedControls", "Enabled", true, "Inverts movement controls while this curse is active.");
EnableGripHiccup = ((BaseUnityPlugin)this).Config.Bind<bool>("Effects.GripHiccup", "Enabled", true, "Occasionally interrupts the cursed player's climbing grip.");
GripHiccupIntervalMin = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.GripHiccup", "IntervalMin", 8f, new ConfigDescription("Minimum seconds between grip hiccups.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
GripHiccupIntervalMax = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.GripHiccup", "IntervalMax", 18f, new ConfigDescription("Maximum seconds between grip hiccups.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 120f), Array.Empty<object>()));
GripHiccupSlideStrength = ((BaseUnityPlugin)this).Config.Bind<float>("Effects.GripHiccup", "SlideStrength", 1.2f, new ConfigDescription("Downward slide impulse when grip hiccup triggers.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
}
}
}
