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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.Networking;
[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: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("RedLightGreenLight")]
[assembly: AssemblyTitle("RedLightGreenLight")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 Empress.CursedLights
{
[BepInPlugin("Empress.CursedLights", "Cursed Lights (Red Light, Green Light)", "1.5.0")]
public class CursedLightsPlugin : BaseUnityPlugin
{
private Harmony _harmony;
private GameObject _runnerGO;
internal static CursedLightsPlugin Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
private void Awake()
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
Instance = this;
_runnerGO = new GameObject("[CursedLightsRunner]");
((Object)_runnerGO).hideFlags = (HideFlags)53;
Object.DontDestroyOnLoad((Object)(object)_runnerGO);
_runnerGO.AddComponent<CursedRunner>();
_harmony = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
_harmony.PatchAll();
}
private void OnDestroy()
{
try
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
catch
{
}
if (Object.op_Implicit((Object)(object)_runnerGO))
{
Object.Destroy((Object)(object)_runnerGO);
}
}
}
internal static class LocalKillUtil
{
public static void TryKillLocal()
{
try
{
ChatManager val = ChatManager.instance ?? Object.FindObjectOfType<ChatManager>(true);
if ((Object)(object)val != (Object)null)
{
val.PossessSelfDestruction();
}
}
catch (Exception arg)
{
CursedLightsPlugin.Logger.LogWarning((object)$"CursedLights: local kill failed: {arg}");
}
}
}
internal class CursedRunner : MonoBehaviour
{
private enum NetPhase : byte
{
Green,
Red
}
private enum Phase
{
Idle,
WaitingForLevel,
Green,
Red
}
[CompilerGenerated]
private sealed class <>c__DisplayClass35_0
{
public string stem;
public CursedRunner <>4__this;
internal void <PreloadSfx>b__0(AudioClip clip)
{
if ((Object)(object)clip != (Object)null)
{
<>4__this._clips[stem] = clip;
}
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass37_0
{
public string stem;
internal IEnumerable<string> <TryLoadClipByStem>b__0(string r)
{
<>c__DisplayClass37_1 CS$<>8__locals0 = new <>c__DisplayClass37_1
{
r = r
};
return new string[2]
{
stem + ".ogg",
stem + ".wav"
}.Select((string candidate) => Path.Combine(CS$<>8__locals0.r, candidate));
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass37_1
{
public string r;
internal string <TryLoadClipByStem>b__1(string candidate)
{
return Path.Combine(r, candidate);
}
}
[CompilerGenerated]
private sealed class <LoadClip>d__38 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string path;
public Action<AudioClip> onReady;
public CursedRunner <>4__this;
private string <ext>5__1;
private AudioType <type>5__2;
private UnityWebRequest <req>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LoadClip>d__38(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<ext>5__1 = null;
<req>5__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//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)
//IL_0078: Invalid comparison between Unknown and I4
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
bool result;
try
{
switch (<>1__state)
{
default:
result = false;
break;
case 0:
<>1__state = -1;
<ext>5__1 = Path.GetExtension(path).ToLowerInvariant();
<type>5__2 = (AudioType)((<ext>5__1 == ".ogg") ? 14 : ((<ext>5__1 == ".wav") ? 20 : 0));
if ((int)<type>5__2 == 0)
{
onReady?.Invoke(null);
result = false;
break;
}
<req>5__3 = UnityWebRequestMultimedia.GetAudioClip("file://" + path, <type>5__2);
<>1__state = -3;
<>2__current = <req>5__3.SendWebRequest();
<>1__state = 1;
result = true;
break;
case 1:
<>1__state = -3;
if (<req>5__3.isNetworkError || <req>5__3.isHttpError)
{
onReady?.Invoke(null);
result = false;
<>m__Finally1();
}
else
{
onReady?.Invoke(DownloadHandlerAudioClip.GetContent(<req>5__3));
<>m__Finally1();
<req>5__3 = null;
result = false;
}
break;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
return result;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<req>5__3 != null)
{
((IDisposable)<req>5__3).Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <MasterConductor>d__26 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public CursedRunner <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MasterConductor>d__26(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
goto IL_0033;
case 1:
<>1__state = -1;
if (!<>4__this.LevelReady() || !PhotonNetwork.IsConnectedAndReady || !PhotonNetwork.InRoom)
{
return false;
}
<>4__this.BroadcastPhase(NetPhase.Red);
<>2__current = <>4__this.WaitSeconds(Random.Range(<>4__this._redMin, <>4__this._redMax), () => !<>4__this.LevelReady() || !PhotonNetwork.IsConnectedAndReady || !PhotonNetwork.InRoom);
<>1__state = 2;
return true;
case 2:
{
<>1__state = -1;
if (!<>4__this.LevelReady() || !PhotonNetwork.IsConnectedAndReady || !PhotonNetwork.InRoom)
{
break;
}
<>4__this.BroadcastPhase(NetPhase.Green);
goto IL_0033;
}
IL_0033:
<>2__current = <>4__this.WaitSeconds(Random.Range(<>4__this._greenMin, <>4__this._greenMax), () => !<>4__this.LevelReady() || !PhotonNetwork.IsConnectedAndReady || !PhotonNetwork.InRoom);
<>1__state = 1;
return true;
}
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 <PreloadSfx>d__35 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public CursedRunner <>4__this;
private string[] <>s__1;
private int <>s__2;
private <>c__DisplayClass35_0 <>8__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <PreloadSfx>d__35(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>s__1 = null;
<>8__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>s__1 = new string[2] { "Red", "Green" };
<>s__2 = 0;
break;
case 1:
<>1__state = -1;
<>8__3 = null;
<>s__2++;
break;
}
if (<>s__2 < <>s__1.Length)
{
<>8__3 = new <>c__DisplayClass35_0();
<>8__3.<>4__this = <>4__this;
<>8__3.stem = <>s__1[<>s__2];
<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.TryLoadClipByStem(<>8__3.stem, delegate(AudioClip clip)
{
if ((Object)(object)clip != (Object)null)
{
<>8__3.<>4__this._clips[<>8__3.stem] = clip;
}
}));
<>1__state = 1;
return true;
}
<>s__1 = 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 <StateMachine>d__25 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public CursedRunner <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <StateMachine>d__25(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0240: Unknown result type (might be due to invalid IL or missing references)
//IL_026c: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
case 2:
<>1__state = -1;
break;
}
if (PhotonNetwork.IsConnectedAndReady && PhotonNetwork.InRoom)
{
<>4__this.EnsurePhotonHook();
}
else
{
<>4__this.EnsurePhotonUnhook();
}
if (!<>4__this.LevelReady())
{
if (<>4__this._isRunning)
{
<>4__this._isRunning = false;
}
<>4__this._phase = Phase.WaitingForLevel;
<>2__current = null;
<>1__state = 1;
return true;
}
if (!<>4__this._isRunning)
{
<>4__this._isRunning = true;
<>4__this.EnsureSfxSource();
if (PhotonNetwork.IsMasterClient)
{
<>4__this.SetPhaseLocal(Phase.Green);
<>4__this.BroadcastPhase(NetPhase.Green);
((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.MasterConductor());
}
else if (<>4__this._haveNetPhase)
{
<>4__this.SetPhaseLocal((<>4__this._netPhase == NetPhase.Red) ? Phase.Red : Phase.Green);
}
else
{
<>4__this.TrySnapFromRoomProperty();
}
}
if (<>4__this._haveNetPhase && ((<>4__this._netPhase == NetPhase.Red && <>4__this._phase != Phase.Red) || (<>4__this._netPhase == NetPhase.Green && <>4__this._phase != Phase.Green)))
{
<>4__this.SetPhaseLocal((<>4__this._netPhase == NetPhase.Red) ? Phase.Red : Phase.Green);
}
<>4__this._reassertTimer -= Time.deltaTime;
if (<>4__this._reassertTimer <= 0f)
{
<>4__this._reassertTimer = 0.5f;
if (<>4__this._phase == Phase.Green)
{
<>4__this.ForceAllLights(Color.green, 1f);
}
else if (<>4__this._phase == Phase.Red)
{
<>4__this.ForceAllLights(Color.red, 1f);
}
}
if (<>4__this._phase == Phase.Red)
{
<>4__this.CheckForbiddenMovementAndExecute();
}
<>2__current = null;
<>1__state = 2;
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 <TryLoadClipByStem>d__37 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string stem;
public Action<AudioClip> onReady;
public CursedRunner <>4__this;
private <>c__DisplayClass37_0 <>8__1;
private string[] <roots>5__2;
private string <path>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <TryLoadClipByStem>d__37(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = null;
<roots>5__2 = null;
<path>5__3 = null;
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>8__1 = new <>c__DisplayClass37_0();
<>8__1.stem = stem;
<roots>5__2 = <>4__this.GetSearchRoots();
<path>5__3 = <roots>5__2.SelectMany(delegate(string r)
{
<>c__DisplayClass37_1 CS$<>8__locals0 = new <>c__DisplayClass37_1
{
r = r
};
return new string[2]
{
<>8__1.stem + ".ogg",
<>8__1.stem + ".wav"
}.Select((string candidate) => Path.Combine(CS$<>8__locals0.r, candidate));
}).FirstOrDefault(File.Exists);
if (string.IsNullOrEmpty(<path>5__3))
{
onReady?.Invoke(null);
return false;
}
<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.LoadClip(<path>5__3, onReady));
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
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 <WaitSeconds>d__33 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public float t;
public Func<bool> breakIf;
public CursedRunner <>4__this;
private float <timer>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitSeconds>d__33(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<timer>5__1 = t;
break;
case 1:
<>1__state = -1;
break;
}
if (<timer>5__1 > 0f)
{
if (breakIf != null && breakIf())
{
return false;
}
<timer>5__1 -= Time.deltaTime;
<>2__current = null;
<>1__state = 1;
return true;
}
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();
}
}
private readonly float _greenMin = 20f;
private readonly float _greenMax = 60f;
private readonly float _redMin = 10f;
private readonly float _redMax = 20f;
private readonly float _redGraceSeconds = 0.75f;
private readonly float _moveHoldThreshold = 0.08f;
private const byte EVT_PHASE = 99;
private const string ROOM_KEY_PHASE = "CLP";
private Phase _phase = Phase.Idle;
private NetPhase _netPhase = NetPhase.Green;
private bool _haveNetPhase;
private bool _isRunning;
private bool _firedKillThisRed;
private bool _photonHooked;
private float _reassertTimer;
private float _redEnteredAt;
private float _moveHoldAccum;
private AudioSource _sfx;
private readonly Dictionary<string, AudioClip> _clips = new Dictionary<string, AudioClip>(StringComparer.OrdinalIgnoreCase);
private void Start()
{
((MonoBehaviour)this).StartCoroutine(StateMachine());
((MonoBehaviour)this).StartCoroutine(PreloadSfx());
}
private void EnsurePhotonHook()
{
if (!_photonHooked && PhotonNetwork.IsConnectedAndReady && PhotonNetwork.InRoom)
{
PhotonNetwork.NetworkingClient.EventReceived += OnPhotonEvent;
_photonHooked = true;
TrySnapFromRoomProperty();
}
}
private void EnsurePhotonUnhook()
{
if (_photonHooked)
{
PhotonNetwork.NetworkingClient.EventReceived -= OnPhotonEvent;
_photonHooked = false;
}
}
private void TrySnapFromRoomProperty()
{
Room currentRoom = PhotonNetwork.CurrentRoom;
if (currentRoom == null || ((RoomInfo)currentRoom).CustomProperties == null || !((Dictionary<object, object>)(object)((RoomInfo)currentRoom).CustomProperties).TryGetValue((object)"CLP", out object value) || !(value is byte))
{
return;
}
byte netPhase = (byte)value;
if (true)
{
_netPhase = (NetPhase)netPhase;
_haveNetPhase = true;
if (LevelReady())
{
SetPhaseLocal((_netPhase == NetPhase.Red) ? Phase.Red : Phase.Green);
}
}
}
[IteratorStateMachine(typeof(<StateMachine>d__25))]
private IEnumerator StateMachine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <StateMachine>d__25(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<MasterConductor>d__26))]
private IEnumerator MasterConductor()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MasterConductor>d__26(0)
{
<>4__this = this
};
}
private void OnPhotonEvent(EventData e)
{
if (e.Code != 99 || !(e.CustomData is object[] array) || array.Length < 1)
{
return;
}
object obj = array[0];
byte netPhase = default(byte);
int num;
if (obj is byte)
{
netPhase = (byte)obj;
num = 1;
}
else
{
num = 0;
}
if (num != 0)
{
_netPhase = (NetPhase)netPhase;
_haveNetPhase = true;
if (LevelReady())
{
SetPhaseLocal((_netPhase == NetPhase.Red) ? Phase.Red : Phase.Green);
}
}
}
private void BroadcastPhase(NetPhase phase)
{
//IL_003c: 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_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Expected O, but got Unknown
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
//IL_0070: Expected O, but got Unknown
try
{
if (PhotonNetwork.IsConnectedAndReady && PhotonNetwork.InRoom)
{
SetPhaseLocal((phase == NetPhase.Red) ? Phase.Red : Phase.Green);
object[] array = new object[1] { (byte)phase };
RaiseEventOptions val = new RaiseEventOptions
{
Receivers = (ReceiverGroup)1
};
PhotonNetwork.RaiseEvent((byte)99, (object)array, val, SendOptions.SendReliable);
Hashtable val2 = new Hashtable();
((Dictionary<object, object>)val2).Add((object)"CLP", (object)(byte)phase);
Hashtable val3 = val2;
PhotonNetwork.CurrentRoom.SetCustomProperties(val3, (Hashtable)null, (WebFlags)null);
}
}
catch (Exception arg)
{
CursedLightsPlugin.Logger.LogWarning((object)$"CursedLights: BroadcastPhase failed: {arg}");
}
}
private void SetPhaseLocal(Phase p)
{
//IL_002f: 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)
_phase = p;
_reassertTimer = 0f;
switch (p)
{
case Phase.Green:
_firedKillThisRed = false;
_moveHoldAccum = 0f;
ForceAllLights(Color.green, 1f);
PlaySfx("Green");
break;
case Phase.Red:
_firedKillThisRed = false;
_moveHoldAccum = 0f;
_redEnteredAt = Time.time;
ForceAllLights(Color.red, 1f);
PlaySfx("Red");
break;
}
}
private bool LevelReady()
{
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Invalid comparison between Unknown and I4
try
{
if (!SemiFunc.RunIsLevel())
{
return false;
}
if (!PhotonNetwork.IsConnectedAndReady || !PhotonNetwork.InRoom)
{
return false;
}
if ((Object)(object)LevelGenerator.Instance == (Object)null || !LevelGenerator.Instance.Generated)
{
return false;
}
if ((Object)(object)GameDirector.instance == (Object)null)
{
return false;
}
if ((int)GameDirector.instance.currentState != 2)
{
return false;
}
PlayerController instance = PlayerController.instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance.playerAvatarScript == (Object)null || !instance.playerAvatarScript.isLocal)
{
return false;
}
return true;
}
catch
{
return false;
}
}
private void CheckForbiddenMovementAndExecute()
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
try
{
if (Time.time - _redEnteredAt < _redGraceSeconds)
{
return;
}
PlayerController instance = PlayerController.instance;
if ((Object)(object)instance == (Object)null || (Object)(object)instance.playerAvatarScript == (Object)null || !instance.playerAvatarScript.isLocal)
{
return;
}
Vector2 val = (((Object)(object)InputManager.instance != (Object)null) ? InputManager.instance.GetMovement() : Vector2.zero);
if (_phase != Phase.Red || _firedKillThisRed)
{
return;
}
if (((Vector2)(ref val)).sqrMagnitude > 0.0001f)
{
_moveHoldAccum += Time.deltaTime;
if (_moveHoldAccum >= _moveHoldThreshold)
{
_firedKillThisRed = true;
LocalKillUtil.TryKillLocal();
}
}
else
{
_moveHoldAccum = 0f;
}
}
catch (Exception arg)
{
CursedLightsPlugin.Logger.LogWarning((object)$"CursedLights: movement check failed: {arg}");
}
}
private void ForceAllLights(Color color, float emissionIntensity)
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
try
{
GameObject[] array = GameObject.FindGameObjectsWithTag("Prop Lights");
foreach (GameObject val in array)
{
if (Object.op_Implicit((Object)(object)val))
{
Light val2 = val.GetComponent<Light>() ?? val.GetComponentInChildren<Light>();
if (Object.op_Implicit((Object)(object)val2))
{
val2.color = color;
}
}
}
GameObject[] array2 = GameObject.FindGameObjectsWithTag("Prop Emission");
foreach (GameObject val3 in array2)
{
if (!Object.op_Implicit((Object)(object)val3))
{
continue;
}
Renderer component = val3.GetComponent<Renderer>();
if (Object.op_Implicit((Object)(object)component))
{
Material material = component.material;
if (!((Object)(object)material == (Object)null))
{
material.EnableKeyword("_EMISSION");
material.SetColor("_EmissionColor", new Color(color.r, color.g, color.b) * emissionIntensity);
}
}
}
}
catch (Exception arg)
{
CursedLightsPlugin.Logger.LogWarning((object)$"CursedLights: ForceAllLights failed: {arg}");
}
}
[IteratorStateMachine(typeof(<WaitSeconds>d__33))]
private IEnumerator WaitSeconds(float t, Func<bool> breakIf)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitSeconds>d__33(0)
{
<>4__this = this,
t = t,
breakIf = breakIf
};
}
private void EnsureSfxSource()
{
if (!((Object)(object)_sfx != (Object)null))
{
_sfx = ((Component)this).gameObject.AddComponent<AudioSource>();
_sfx.playOnAwake = false;
_sfx.loop = false;
_sfx.spatialBlend = 0f;
_sfx.volume = 0.3f;
}
}
[IteratorStateMachine(typeof(<PreloadSfx>d__35))]
private IEnumerator PreloadSfx()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <PreloadSfx>d__35(0)
{
<>4__this = this
};
}
private void PlaySfx(string stem)
{
try
{
EnsureSfxSource();
if (_clips.TryGetValue(stem, out AudioClip value) && (Object)(object)value != (Object)null)
{
_sfx.volume = 0.3f;
_sfx.PlayOneShot(value, 1f);
}
}
catch (Exception arg)
{
CursedLightsPlugin.Logger.LogWarning((object)$"CursedLights: PlaySfx('{stem}') failed: {arg}");
}
}
[IteratorStateMachine(typeof(<TryLoadClipByStem>d__37))]
private IEnumerator TryLoadClipByStem(string stem, Action<AudioClip> onReady)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <TryLoadClipByStem>d__37(0)
{
<>4__this = this,
stem = stem,
onReady = onReady
};
}
[IteratorStateMachine(typeof(<LoadClip>d__38))]
private IEnumerator LoadClip(string path, Action<AudioClip> onReady)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LoadClip>d__38(0)
{
<>4__this = this,
path = path,
onReady = onReady
};
}
private string[] GetSearchRoots()
{
string text = Path.GetDirectoryName(Paths.PluginPath) ?? Paths.PluginPath;
string directoryName = Path.GetDirectoryName(Chainloader.PluginInfos["Empress.CursedLights"].Instance.Info.Location);
return new string[2] { directoryName, text };
}
}
}
namespace RedLightGreenLight
{
[BepInPlugin("Omniscye.RedLightGreenLight", "RedLightGreenLight", "1.0")]
public class RedLightGreenLight : BaseUnityPlugin
{
internal static RedLightGreenLight Instance { get; private set; }
internal static ManualLogSource Logger => Instance._logger;
private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;
internal Harmony? Harmony { get; set; }
private void Awake()
{
Instance = this;
((Component)this).gameObject.transform.parent = null;
((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
Patch();
Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
internal void Patch()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0026: Expected O, but got Unknown
if (Harmony == null)
{
Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
Harmony val2 = val;
Harmony = val;
}
Harmony.PatchAll();
}
internal void Unpatch()
{
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
private void Update()
{
}
}
}
