using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using PxntxrezStudio.RepoFlashlightRework;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("FlashlightRework")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("FlashlightRework")]
[assembly: AssemblyTitle("FlashlightRework")]
[assembly: AssemblyVersion("1.0.0.0")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
[BepInPlugin("PxntxrezStudio.RepoFlashlightRework", "REPO Flashlight Rework", "2.0.0")]
public class FlashlightReworkPlugin : BaseUnityPlugin
{
private Harmony _harmony;
private void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
FlashlightConfig.Init(((BaseUnityPlugin)this).Config);
_harmony = new Harmony("PxntxrezStudio.RepoFlashlightRework");
_harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
}
}
public static class Patch_FlashlightController_Start
{
[HarmonyPatch(typeof(FlashlightController), "Start")]
public static class Patch
{
public static void Postfix(FlashlightController __instance)
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
PlayerAvatar playerAvatar = __instance.PlayerAvatar;
if (getIsLocal.Invoke(playerAvatar))
{
if (!originalColors.ContainsKey(__instance))
{
originalColors[__instance] = __instance.spotlight.color;
}
TryStartFlicker(__instance);
}
}
}
[CompilerGenerated]
private sealed class <FlickerCoroutine>d__6 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public FlashlightController flashlight;
private float <detectionRadius>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <FlickerCoroutine>d__6(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_018d: Expected O, but got Unknown
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_0141: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Expected O, but got Unknown
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Expected O, but got Unknown
Collider[] array;
bool flag;
Collider[] array2;
float num2;
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<detectionRadius>5__2 = FlashlightConfig.FlickerDetectionRadius.Value;
goto IL_003a;
case 1:
<>1__state = -1;
goto IL_003a;
case 2:
<>1__state = -1;
goto IL_003a;
case 3:
{
<>1__state = -1;
SetFlickerState(flashlight, enabled: true);
float num = Random.Range(FlashlightConfig.FlickerIntervalMin.Value, FlashlightConfig.FlickerIntervalMax.Value);
<>2__current = (object)new WaitForSeconds(num);
<>1__state = 4;
return true;
}
case 4:
{
<>1__state = -1;
goto IL_003a;
}
IL_003a:
if (!FlashlightConfig.EnableFlicker.Value || !flashlight.LightActive)
{
SetFlickerState(flashlight, flashlight.LightActive);
<>2__current = (object)new WaitForSeconds(0.2f);
<>1__state = 1;
return true;
}
array = Physics.OverlapSphere(((Component)flashlight).transform.position, <detectionRadius>5__2);
flag = false;
array2 = array;
for (int i = 0; i < array2.Length; i++)
{
if ((Object)(object)((Component)array2[i]).GetComponentInParent<EnemyChecklist>() != (Object)null)
{
flag = true;
break;
}
}
if (!flag)
{
if (!((Behaviour)flashlight.spotlight).enabled)
{
SetFlickerState(flashlight, enabled: true);
}
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 2;
return true;
}
SetFlickerState(flashlight, enabled: false);
num2 = Random.Range(FlashlightConfig.FlickerDurationMin.Value, FlashlightConfig.FlickerDurationMax.Value);
<>2__current = (object)new WaitForSeconds(num2);
<>1__state = 3;
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();
}
}
private static readonly FieldRef<PlayerAvatar, bool> getIsLocal = AccessTools.FieldRefAccess<PlayerAvatar, bool>("isLocal");
public static readonly Dictionary<FlashlightController, Color> originalColors = new Dictionary<FlashlightController, Color>();
private static readonly Dictionary<FlashlightController, Coroutine> activeFlickers = new Dictionary<FlashlightController, Coroutine>();
public static void TryStartFlicker(FlashlightController flashlight)
{
if (!FlashlightConfig.EnableFlicker.Value)
{
StopFlicker(flashlight);
}
else if (!activeFlickers.ContainsKey(flashlight))
{
Coroutine value = ((MonoBehaviour)flashlight).StartCoroutine(FlickerCoroutine(flashlight));
activeFlickers[flashlight] = value;
}
}
public static void StopFlicker(FlashlightController flashlight)
{
if (activeFlickers.TryGetValue(flashlight, out var value))
{
((MonoBehaviour)flashlight).StopCoroutine(value);
activeFlickers.Remove(flashlight);
}
if (!flashlight.LightActive)
{
((Behaviour)flashlight.spotlight).enabled = false;
flashlight.halo.enabled = false;
}
else
{
((Behaviour)flashlight.spotlight).enabled = true;
flashlight.halo.enabled = true;
}
}
[IteratorStateMachine(typeof(<FlickerCoroutine>d__6))]
public static IEnumerator FlickerCoroutine(FlashlightController flashlight)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <FlickerCoroutine>d__6(0)
{
flashlight = flashlight
};
}
private static void SetFlickerState(FlashlightController flashlight, bool enabled)
{
((Behaviour)flashlight.spotlight).enabled = enabled;
flashlight.halo.enabled = enabled;
PlayerAvatar playerAvatar = flashlight.PlayerAvatar;
if (!((Object)(object)playerAvatar == (Object)null) && !((Object)(object)playerAvatar.photonView == (Object)null) && playerAvatar.photonView.IsMine)
{
if ((Object)(object)((Component)playerAvatar).GetComponent<FlashlightRPCHandler>() == (Object)null)
{
Debug.LogWarning((object)"FlashlightRPCHandler not found! Adding it now...");
((Component)playerAvatar).gameObject.AddComponent<FlashlightRPCHandler>();
}
playerAvatar.photonView.RPC("RPC_FlashlightFlicker", (RpcTarget)1, new object[1] { enabled });
}
}
public static void OnFlickerSettingChanged()
{
FlashlightController[] array = Object.FindObjectsOfType<FlashlightController>();
foreach (FlashlightController val in array)
{
PlayerAvatar playerAvatar = val.PlayerAvatar;
if (getIsLocal.Invoke(playerAvatar))
{
if (FlashlightConfig.EnableFlicker.Value)
{
TryStartFlicker(val);
}
else
{
StopFlicker(val);
}
}
}
}
}
[HarmonyPatch(typeof(FlashlightController), "Update")]
internal static class Patch_FlashlightController_Update
{
private static readonly FieldInfo fiCurrentState = AccessTools.Field(typeof(FlashlightController), "currentState");
private static readonly FieldInfo fiStateTimer = AccessTools.Field(typeof(FlashlightController), "stateTimer");
private static readonly FieldInfo fiIntroRotLerp = AccessTools.Field(typeof(FlashlightController), "introRotLerp");
private static readonly FieldInfo fiIntroYLerp = AccessTools.Field(typeof(FlashlightController), "introYLerp");
private static readonly FieldInfo fiActive = AccessTools.Field(typeof(FlashlightController), "active");
private static readonly FieldRef<PlayerAvatar, bool> getIsLocal = AccessTools.FieldRefAccess<PlayerAvatar, bool>("isLocal");
private static readonly FieldRef<PlayerAvatar, bool> getIsDisabled = AccessTools.FieldRefAccess<PlayerAvatar, bool>("isDisabled");
private static readonly FieldInfo fiClick = AccessTools.Field(typeof(FlashlightController), "click");
private static readonly Dictionary<FlashlightController, float> lastToggle = new Dictionary<FlashlightController, float>();
private static readonly Dictionary<FlashlightController, bool> autoStarted = new Dictionary<FlashlightController, bool>();
private static readonly Dictionary<FlashlightController, Color> syncedColors = new Dictionary<FlashlightController, Color>();
private const float toggleCooldown = 1.3f;
private static bool Prefix(FlashlightController __instance)
{
//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Invalid comparison between Unknown and I4
//IL_0284: Unknown result type (might be due to invalid IL or missing references)
//IL_028b: 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)
PlayerAvatar playerAvatar = __instance.PlayerAvatar;
if (getIsDisabled.Invoke(playerAvatar))
{
if (fiCurrentState.GetValue(__instance).ToString() != "Hidden")
{
fiCurrentState.SetValue(__instance, Enum.Parse(fiCurrentState.FieldType, "Hidden"));
((Renderer)__instance.mesh).enabled = false;
((Behaviour)__instance.spotlight).enabled = false;
__instance.halo.enabled = false;
__instance.LightActive = false;
AccessTools.Field(typeof(FlashlightController), "hiddenScale").SetValue(__instance, 0f);
}
return false;
}
if (getIsLocal.Invoke(playerAvatar))
{
if (!autoStarted.ContainsKey(__instance) && (int)GameDirector.instance.currentState >= 2)
{
autoStarted[__instance] = true;
SyncFlashlightState(__instance, turnOn: true);
}
float value;
bool flag = !lastToggle.TryGetValue(__instance, out value) || Time.time - value >= 1.3f;
if (Input.GetKeyDown(FlashlightConfig.GetKeyCode()) && flag)
{
lastToggle[__instance] = Time.time;
bool turnOn = !__instance.LightActive;
SyncFlashlightState(__instance, turnOn);
}
switch (fiCurrentState.GetValue(__instance).ToString())
{
case "Intro":
case "LightOn":
case "Idle":
fiActive.SetValue(__instance, true);
break;
}
ProcessFlashlightStates(__instance);
UpdateFlashlightScale(__instance, playerAvatar);
if (getIsLocal.Invoke(playerAvatar))
{
UpdateFlashlightColorLocal(__instance);
}
else
{
UpdateFlashlightColorSynced(__instance);
}
UpdateClickAnimation(__instance);
return false;
}
if (!getIsLocal.Invoke(playerAvatar))
{
((Component)__instance).transform.position = __instance.FollowTransformClient.position;
((Component)__instance).transform.rotation = __instance.FollowTransformClient.rotation;
((Component)__instance).transform.localScale = __instance.FollowTransformClient.localScale;
switch (fiCurrentState.GetValue(__instance).ToString())
{
case "Intro":
case "LightOn":
case "Idle":
fiActive.SetValue(__instance, true);
break;
}
ProcessFlashlightStates(__instance);
float num = (float)AccessTools.Field(typeof(FlashlightController), "hiddenScale").GetValue(__instance);
((Component)__instance).transform.localScale = __instance.FollowTransformClient.localScale * num;
UpdateClickAnimation(__instance);
UpdateFlashlightColorSynced(__instance);
return false;
}
return true;
}
private static void UpdateFlashlightScale(FlashlightController flashlight, PlayerAvatar avatar)
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: 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)
float num = (float)AccessTools.Field(typeof(FlashlightController), "hiddenScale").GetValue(flashlight);
if (!getIsLocal.Invoke(avatar))
{
((Component)flashlight).transform.position = flashlight.FollowTransformClient.position;
((Component)flashlight).transform.rotation = flashlight.FollowTransformClient.rotation;
((Component)flashlight).transform.localScale = flashlight.FollowTransformClient.localScale * num;
}
else
{
((Component)flashlight).transform.localScale = Vector3.one * num;
}
}
private static void ProcessFlashlightStates(FlashlightController flashlight)
{
switch (fiCurrentState.GetValue(flashlight).ToString())
{
case "Intro":
CallMethod(flashlight, "Intro");
break;
case "LightOn":
CallMethod(flashlight, "LightOn");
break;
case "Idle":
CustomIdle(flashlight);
break;
case "LightOff":
CallMethod(flashlight, "LightOff");
break;
case "Outro":
CallMethod(flashlight, "Outro");
break;
case "Hidden":
CustomHidden(flashlight);
break;
}
}
private static void CustomIdle(FlashlightController flashlight)
{
}
private static void CustomHidden(FlashlightController flashlight)
{
}
private static void CallMethod(FlashlightController flashlight, string methodName)
{
MethodInfo methodInfo = AccessTools.Method(typeof(FlashlightController), methodName, (Type[])null, (Type[])null);
if (methodInfo != null)
{
methodInfo.Invoke(flashlight, null);
}
}
private static void UpdateClickAnimation(FlashlightController flashlight)
{
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Expected O, but got Unknown
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
FieldInfo fieldInfo = AccessTools.Field(typeof(FlashlightController), "clickLerp");
FieldInfo fieldInfo2 = AccessTools.Field(typeof(FlashlightController), "clickSpeed");
FieldInfo fieldInfo3 = AccessTools.Field(typeof(FlashlightController), "clickStrength");
FieldInfo fieldInfo4 = AccessTools.Field(typeof(FlashlightController), "clickCurve");
FieldInfo fieldInfo5 = AccessTools.Field(typeof(FlashlightController), "clickTransform");
if ((bool)fiClick.GetValue(flashlight))
{
float num = (float)fieldInfo.GetValue(flashlight);
float num2 = (float)fieldInfo2.GetValue(flashlight);
float num3 = (float)fieldInfo3.GetValue(flashlight);
AnimationCurve val = (AnimationCurve)fieldInfo4.GetValue(flashlight);
Transform val2 = (Transform)fieldInfo5.GetValue(flashlight);
float num4 = Mathf.LerpUnclamped(0f, num3, val.Evaluate(num));
val2.localRotation = Quaternion.Euler(0f, 0f - num4, 0f);
num += num2 * Time.deltaTime;
num = Mathf.Clamp01(num);
fieldInfo.SetValue(flashlight, num);
if (num == 1f)
{
fieldInfo.SetValue(flashlight, 0f);
fiClick.SetValue(flashlight, false);
}
}
}
private static void UpdateFlashlightColorLocal(FlashlightController flashlight)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: 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_0040: 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_004c: 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_0057: 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_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
if (!flashlight.LightActive)
{
return;
}
Color val;
if (FlashlightConfig.UseCustomRGB.Value)
{
val = FlashlightConfig.GetColor();
}
else
{
if (!Patch_FlashlightController_Start.originalColors.TryGetValue(flashlight, out var value))
{
return;
}
val = value;
}
if (!syncedColors.TryGetValue(flashlight, out var value2) || Vector3.Distance(new Vector3(val.r, val.g, val.b), new Vector3(value2.r, value2.g, value2.b)) > 0.01f)
{
syncedColors[flashlight] = val;
SyncFlashlightColor(flashlight, val);
}
}
private static void UpdateFlashlightColorSynced(FlashlightController flashlight)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
if (flashlight.LightActive && syncedColors.TryGetValue(flashlight, out var value))
{
ApplyFlashlightColor(flashlight, value);
}
}
private static void SyncFlashlightState(FlashlightController flashlight, bool turnOn)
{
PlayerAvatar playerAvatar = flashlight.PlayerAvatar;
if ((Object)(object)playerAvatar == (Object)null || (Object)(object)playerAvatar.photonView == (Object)null)
{
ApplyFlashlightToggle(flashlight, turnOn);
}
else if (playerAvatar.photonView.IsMine)
{
playerAvatar.photonView.RPC("RPC_FlashlightToggle", (RpcTarget)0, new object[1] { turnOn });
}
else
{
ApplyFlashlightToggle(flashlight, turnOn);
}
}
public static void ApplyFlashlightToggle(FlashlightController flashlight, bool turnOn)
{
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
if (turnOn && !flashlight.LightActive)
{
fiCurrentState.SetValue(flashlight, Enum.Parse(fiCurrentState.FieldType, "Intro"));
fiStateTimer.SetValue(flashlight, 1f);
fiIntroRotLerp.SetValue(flashlight, 0f);
fiIntroYLerp.SetValue(flashlight, 0f);
fiClick.SetValue(flashlight, true);
}
else if (!turnOn && flashlight.LightActive)
{
fiCurrentState.SetValue(flashlight, Enum.Parse(fiCurrentState.FieldType, "LightOff"));
fiStateTimer.SetValue(flashlight, 0.25f);
fiClick.SetValue(flashlight, true);
flashlight.lightOffAudio.Play(((Component)flashlight).transform.position, 1f, 1f, 1f, 1f);
}
}
private static void SyncFlashlightColor(FlashlightController flashlight, Color color)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: 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)
PlayerAvatar playerAvatar = flashlight.PlayerAvatar;
if ((Object)(object)playerAvatar == (Object)null || (Object)(object)playerAvatar.photonView == (Object)null)
{
ApplyFlashlightColor(flashlight, color);
}
else if (playerAvatar.photonView.IsMine)
{
playerAvatar.photonView.RPC("RPC_FlashlightColor", (RpcTarget)0, new object[3] { color.r, color.g, color.b });
}
else
{
ApplyFlashlightColor(flashlight, color);
}
}
public static void ApplyFlashlightColor(FlashlightController flashlight, Color color)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
flashlight.spotlight.color = color;
if ((Object)(object)flashlight.halo == (Object)null)
{
return;
}
Behaviour halo = flashlight.halo;
Light val = (Light)(object)((halo is Light) ? halo : null);
if ((Object)(object)val != (Object)null)
{
val.color = color;
return;
}
GameObject gameObject = ((Component)flashlight.halo).gameObject;
if ((Object)(object)gameObject != (Object)null)
{
val = gameObject.GetComponent<Light>();
if ((Object)(object)val != (Object)null)
{
val.color = color;
}
}
}
public static void SetSyncedColor(FlashlightController flashlight, Color color)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
syncedColors[flashlight] = color;
}
}
namespace PxntxrezStudio.RepoFlashlightRework
{
public static class FlashlightConfig
{
public static ConfigEntry<int> LightColorRed;
public static ConfigEntry<int> LightColorGreen;
public static ConfigEntry<int> LightColorBlue;
public static ConfigEntry<bool> UseCustomRGB;
public static ConfigEntry<string> FlashlightToggleKey;
public static ConfigEntry<bool> EnableFlicker;
public static ConfigEntry<float> FlickerDetectionRadius;
public static ConfigEntry<float> FlickerDurationMin;
public static ConfigEntry<float> FlickerDurationMax;
public static ConfigEntry<float> FlickerIntervalMin;
public static ConfigEntry<float> FlickerIntervalMax;
private static ConfigFile config;
public static void Init(ConfigFile cfg)
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Expected O, but got Unknown
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Expected O, but got Unknown
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_0198: Expected O, but got Unknown
//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Expected O, but got Unknown
//IL_0219: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: Expected O, but got Unknown
//IL_0251: Unknown result type (might be due to invalid IL or missing references)
//IL_025b: Expected O, but got Unknown
//IL_0289: Unknown result type (might be due to invalid IL or missing references)
//IL_0293: Expected O, but got Unknown
//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
//IL_02cb: Expected O, but got Unknown
config = cfg;
UseCustomRGB = cfg.Bind<bool>("Light Color", "Use Custom RGB Color", false, "Enable or disable RGB color override");
LightColorRed = cfg.Bind<int>("Light Color", "Red", 255, new ConfigDescription("Light Color Red", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
LightColorGreen = cfg.Bind<int>("Light Color", "Green", 255, new ConfigDescription("Light Color Green", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
LightColorBlue = cfg.Bind<int>("Light Color", "Blue", 255, new ConfigDescription("Light Color Blue", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 255), Array.Empty<object>()));
FlashlightToggleKey = cfg.Bind<string>("Controls", "Toggle Key", "F", new ConfigDescription("Flashlight toggle key", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[20]
{
"F", "R", "T", "Y", "U", "I", "O", "P", "G", "H",
"J", "K", "L", "Z", "X", "C", "V", "B", "N", "M"
}), Array.Empty<object>()));
EnableFlicker = cfg.Bind<bool>("Flicker Settings", "Enable Flicker", true, "Enable flickering when enemy is nearby");
FlickerDetectionRadius = cfg.Bind<float>("Flicker Settings", "Detection Radius", 30f, new ConfigDescription("Radius in meters to detect enemies (default: 30)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 100f), Array.Empty<object>()));
FlickerDurationMin = cfg.Bind<float>("Flicker Settings", "Flicker Duration Min", 0.1f, new ConfigDescription("Minimum time flashlight stays OFF during flicker (seconds)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 50f), Array.Empty<object>()));
FlickerDurationMax = cfg.Bind<float>("Flicker Settings", "Flicker Duration Max", 0.5f, new ConfigDescription("Maximum time flashlight stays OFF during flicker (seconds)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 50f), Array.Empty<object>()));
FlickerIntervalMin = cfg.Bind<float>("Flicker Settings", "Flicker Interval Min", 1f, new ConfigDescription("Minimum time between flickers (seconds)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 100f), Array.Empty<object>()));
FlickerIntervalMax = cfg.Bind<float>("Flicker Settings", "Flicker Interval Max", 15f, new ConfigDescription("Maximum time between flickers (seconds)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 100f), Array.Empty<object>()));
cfg.SettingChanged += OnConfigChanged;
}
private static void OnConfigChanged(object sender, SettingChangedEventArgs e)
{
if (e.ChangedSetting.Definition.Key == "Enable Flicker")
{
Patch_FlashlightController_Start.OnFlickerSettingChanged();
}
}
public static KeyCode GetKeyCode()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
if (Enum.TryParse<KeyCode>(FlashlightToggleKey.Value.ToUpper(), out KeyCode result))
{
return result;
}
return (KeyCode)102;
}
public static Color GetColor()
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
return new Color((float)LightColorRed.Value / 255f, (float)LightColorGreen.Value / 255f, (float)LightColorBlue.Value / 255f);
}
}
public class FlashlightRPCHandler : MonoBehaviour
{
private PlayerAvatar playerAvatar;
private FlashlightController flashlight;
private void Awake()
{
playerAvatar = ((Component)this).GetComponent<PlayerAvatar>();
if ((Object)(object)playerAvatar != (Object)null)
{
flashlight = playerAvatar.flashlightController;
}
}
[PunRPC]
public void RPC_FlashlightToggle(bool turnOn)
{
if ((Object)(object)flashlight == (Object)null)
{
if ((Object)(object)playerAvatar != (Object)null)
{
flashlight = playerAvatar.flashlightController;
}
if ((Object)(object)flashlight == (Object)null)
{
return;
}
}
Patch_FlashlightController_Update.ApplyFlashlightToggle(flashlight, turnOn);
}
[PunRPC]
public void RPC_FlashlightColor(float r, float g, float b)
{
//IL_004c: 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)
if ((Object)(object)flashlight == (Object)null)
{
if ((Object)(object)playerAvatar != (Object)null)
{
flashlight = playerAvatar.flashlightController;
}
if ((Object)(object)flashlight == (Object)null)
{
return;
}
}
Color color = default(Color);
((Color)(ref color))..ctor(r, g, b);
Patch_FlashlightController_Update.SetSyncedColor(flashlight, color);
Patch_FlashlightController_Update.ApplyFlashlightColor(flashlight, color);
}
[PunRPC]
public void RPC_FlashlightFlicker(bool enabled)
{
if ((Object)(object)flashlight == (Object)null)
{
if ((Object)(object)playerAvatar != (Object)null)
{
flashlight = playerAvatar.flashlightController;
}
if ((Object)(object)flashlight == (Object)null)
{
return;
}
}
((Behaviour)flashlight.spotlight).enabled = enabled;
flashlight.halo.enabled = enabled;
}
}
[HarmonyPatch(typeof(PlayerAvatar), "Awake")]
public static class Patch_PlayerAvatar_AddRPCHandler
{
private static void Postfix(PlayerAvatar __instance)
{
if ((Object)(object)((Component)__instance).GetComponent<FlashlightRPCHandler>() == (Object)null)
{
((Component)__instance).gameObject.AddComponent<FlashlightRPCHandler>();
PhotonView photonView = __instance.photonView;
Debug.Log((object)$"FlashlightRPCHandler added! (ViewID: {((photonView != null) ? new int?(photonView.ViewID) : null)})");
}
}
}
}
