using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ColourfulFlashlights;
using ColourfulFlashlights.NetcodePatcher;
using ColourfulFlashlights.Properties;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ColourfulFlashlights")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("4.0.1.0")]
[assembly: AssemblyInformationalVersion("4.0.1+76b75d314d4b952dfc60ed937fdd93bfe94b11c9")]
[assembly: AssemblyProduct("ColourfulFlashlights")]
[assembly: AssemblyTitle("ColourfulFlashlights")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
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;
}
}
}
public enum FlashlightMode
{
Fixed,
Cycle,
SmoothCycle,
Random,
Health,
Rainbow
}
public class FlashlightState
{
public FlashlightMode Mode = FlashlightMode.Fixed;
public List<Color> Colors = new List<Color>();
public int Speed = 10;
}
namespace ColourfulFlashlights
{
public class ConfigHandler
{
public ConfigFile configFile;
public ConfigEntry<bool> syncOthers;
public ConfigEntry<bool> syncOwn;
public ConfigEntry<bool> syncCyclicFX;
public void Init()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
Directory.CreateDirectory(Path.GetDirectoryName(Plugin.configPath));
configFile = new ConfigFile(Plugin.configPath, true);
syncOthers = configFile.Bind<bool>("Multiplayer", "Sync Others", true, "If true, you will see other player's flashlight settings. If false, all other players flashlights will be default (white).");
syncOwn = configFile.Bind<bool>("Multiplayer", "Sync Own", true, "If true, other players will see your custom flashlight settings. If false, your flashlight will appear default (white) to other players.");
syncCyclicFX = configFile.Bind<bool>("Multiplayer", "Sync Cyclic Effects", true, "If true, cyclic effects you or others create, such as potential fast flashing or strobing, will sync. If false, only fixed colours will sync.");
}
}
public class FlashlightData
{
public FlashlightItem Flashlight;
public FlashlightMode Mode;
public List<Color> Colors;
public int Speed;
private Color currentColour;
private float currentHue;
private float cycleTime = 0f;
private int cycleIndex = 0;
public float EffectSpeed => 0.25f * Mathf.Pow((float)Speed / 20f, 2.5f);
public FlashlightData(FlashlightItem flashlight, List<Color> colors, FlashlightMode mode, int speed = 10)
{
Flashlight = flashlight;
Mode = mode;
Colors = colors.ToList();
Speed = speed;
if (mode == FlashlightMode.Health && ((GrabbableObject)flashlight).isHeld)
{
Plugin.playerMaxHealth = Math.Max(((GrabbableObject)flashlight).playerHeldBy.health, 100);
}
}
public bool IsEqual(FlashlightData other)
{
return Mode == other.Mode && Speed == other.Speed && Colors.SequenceEqual(other.Colors);
}
public void Update(float deltaTime)
{
if (((GrabbableObject)Flashlight).isBeingUsed)
{
if (Flashlight == null)
{
Plugin.flashlightHandler.RemoveFlashlight(Flashlight);
}
switch (Mode)
{
case FlashlightMode.Fixed:
case FlashlightMode.Random:
Fixed();
break;
case FlashlightMode.Rainbow:
Rainbow(deltaTime);
break;
case FlashlightMode.Cycle:
Cycle(deltaTime, smooth: false);
break;
case FlashlightMode.SmoothCycle:
Cycle(deltaTime, smooth: true);
break;
case FlashlightMode.Health:
Health();
break;
}
}
}
private void Fixed()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
currentColour = Colors.First();
SetColour();
}
private void Cycle(float deltaTime, bool smooth)
{
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: 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_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
cycleTime += deltaTime * (EffectSpeed * 4f);
int index = (cycleIndex + 1) % Colors.Count;
if (smooth)
{
currentColour = Color.Lerp(Colors[cycleIndex], Colors[index], cycleTime);
}
else
{
currentColour = Colors[cycleIndex];
}
if (cycleTime >= 1f)
{
cycleTime = 0f;
cycleIndex = index;
}
SetColour();
}
private void Rainbow(float deltaTime)
{
//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)
currentHue += deltaTime * EffectSpeed;
currentHue = Mathf.Repeat(currentHue, 1f);
currentColour = Color.HSVToRGB(currentHue, 1f, 1f);
SetColour();
}
private void Health()
{
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: 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)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
if (((GrabbableObject)Flashlight).isHeld)
{
if (((GrabbableObject)Flashlight).playerHeldBy.health > Plugin.playerMaxHealth)
{
Plugin.playerMaxHealth = ((GrabbableObject)Flashlight).playerHeldBy.health;
}
float num = Mathf.InverseLerp(0.1f, 1f, (float)((GrabbableObject)Flashlight).playerHeldBy.health / (float)Plugin.playerMaxHealth);
currentColour = Color.Lerp(Colors[1], Colors[0], num);
SetColour();
}
}
private void SetColour()
{
//IL_000d: 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_0050: Unknown result type (might be due to invalid IL or missing references)
Flashlight.flashlightBulb.color = currentColour;
Flashlight.flashlightBulbGlow.color = currentColour;
if (((GrabbableObject)Flashlight).isHeld)
{
((GrabbableObject)Flashlight).playerHeldBy.helmetLight.color = currentColour;
}
}
}
public class FlashlightHandler
{
public Dictionary<FlashlightItem, FlashlightData> Flashlights = new Dictionary<FlashlightItem, FlashlightData>();
public void SetFlashlight(FlashlightData data)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
if (data.Mode != FlashlightMode.Random && data.Colors.Count == 0)
{
data.Colors.Add(Color.white);
}
if (Flashlights.ContainsKey(data.Flashlight))
{
Flashlights.Remove(data.Flashlight);
Flashlights.Add(data.Flashlight, data);
Plugin.mls.LogDebug((object)"Updated flashlight data");
}
else
{
Flashlights.Add(data.Flashlight, data);
Plugin.mls.LogDebug((object)"Added new flashlight data");
}
}
public void RemoveFlashlight(FlashlightItem flashlight)
{
Flashlights.Remove(flashlight);
}
public void CFUpdate(float deltaTime)
{
foreach (FlashlightData value in Flashlights.Values)
{
value.Update(deltaTime);
}
}
}
public static class Assets
{
public static AssetBundle MainAssetBundle;
public static void PopulateAssets()
{
if ((Object)(object)MainAssetBundle == (Object)null)
{
MainAssetBundle = AssetBundle.LoadFromMemory(Resources.cfasset);
}
}
}
public static class Helpers
{
private static readonly Regex HexRegex = new Regex("^#([0-9A-Fa-f]{6})$", RegexOptions.Compiled);
private static readonly Random rand = new Random();
public static Dictionary<string, string> colourDict = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "White", "#FFFFFF" },
{ "Blue", "#0000FF" },
{ "Red", "#FF0000" },
{ "Green", "#2FDE2F" },
{ "Yellow", "#FFFF00" },
{ "Pink", "#FC96FF" },
{ "Orange", "#FF7B00" },
{ "Purple", "#7E00F5" }
};
public static Color? HexStringToColor(string hex)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
Color value = default(Color);
if (GetValidHexCode(hex, out hex) && ColorUtility.TryParseHtmlString(hex, ref value))
{
return value;
}
return null;
}
public static List<Color> HexListToColors(List<string> data)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
List<Color> list = new List<Color>();
foreach (string datum in data)
{
if (list.Count >= 10)
{
break;
}
if (!GetValidHexCode(datum, out var code))
{
continue;
}
Color? val = HexStringToColor(code);
if (val.HasValue)
{
Color valueOrDefault = val.GetValueOrDefault();
if (true)
{
list.Add(valueOrDefault);
}
}
}
return list;
}
public static List<string> ColorsToHexList(List<Color> data)
{
//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)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
List<string> list = new List<string>();
foreach (Color datum in data)
{
list.Add(ColorToHexString(datum));
}
return list;
}
public static string ColorToHexString(Color colour)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
string text = ColorUtility.ToHtmlStringRGB(colour);
return "#" + text;
}
public static string ColorsToHexString(List<Color> colours)
{
return string.Join(",", colours.Select((Color c) => ColorToHexString(c)));
}
public static Color? NameToColor(string name)
{
if (colourDict.TryGetValue(name.Trim(), out var value))
{
return HexStringToColor(value);
}
return null;
}
public static int GetSpeedFromArgs(string[] args)
{
int result;
if (args.Length > 2)
{
return int.TryParse(args[2], out result) ? Math.Clamp(result, 1, 20) : Plugin.activeState.Speed;
}
return Plugin.activeState.Speed;
}
public static bool IsValidHexCode(string hex)
{
if (!hex.StartsWith("#"))
{
hex = "#" + hex;
}
return HexRegex.IsMatch(hex);
}
public static bool GetValidHexCode(string hex, out string code)
{
code = "";
if (Utility.IsNullOrWhiteSpace(hex))
{
return false;
}
code = hex.Trim();
if (!code.StartsWith("#"))
{
code = "#" + code;
}
return HexRegex.IsMatch(code);
}
public static Color GetUniqueRandomColor(List<Color> colours, int prevIndex, out int index)
{
//IL_0035: 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_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: 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_007b: Unknown result type (might be due to invalid IL or missing references)
index = -1;
if (colours == null || colours.Count == 0)
{
return Random.ColorHSV(0f, 1f, 0.5f, 1f, 0.5f, 1f);
}
if (colours.Count == 1)
{
return colours[0];
}
int num;
do
{
num = rand.Next(colours.Count);
}
while (num == prevIndex);
index = num;
return colours[num];
}
public static string GetStateText(FlashlightState state, string name = "")
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
FlashlightMode mode = state.Mode;
bool flag = ((mode == FlashlightMode.Fixed || (uint)(mode - 3) <= 1u) ? true : false);
bool flag2 = flag;
string text = "Colour: " + ColorToHexString(state.Colors[0]);
if (state.Mode == FlashlightMode.Random)
{
text = ((state.Colors.Count <= 1) ? "Colour: Random!" : $"Colour count: {state.Colors.Count}");
}
else if (state.Mode == FlashlightMode.Health)
{
text = "Colours: [100% HP] " + ColorToHexString(state.Colors[0]) + " | [0% HP] " + ColorToHexString(state.Colors[1]);
}
else if (state.Mode == FlashlightMode.Rainbow)
{
text = "Colours: Rainbow!";
}
else if (state.Colors.Count > 1)
{
text = $"Colour count: {state.Colors.Count}";
}
return ((name.Length < 1) ? "" : ("Preset name: " + name + "\n")) + $"Mode: {state.Mode} [{(int)state.Mode}]\n" + "Speed: " + (flag2 ? "N/A" : $"{state.Speed}") + "\n" + text;
}
public static void UpdateState(List<Color> colours, FlashlightMode mode, int speed)
{
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB val = ((IEnumerable<PlayerControllerB>)RoundManager.Instance.playersManager.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB p) => p.playerClientId == Plugin.playerId));
if ((Object)(object)val != (Object)null)
{
if (mode == FlashlightMode.Random)
{
Plugin.randomColours = colours;
colours = new List<Color>(1) { GetUniqueRandomColor(colours, -1, out var index) };
Plugin.prevRandIndex = index;
}
else
{
Plugin.randomColours = new List<Color>();
Plugin.prevRandIndex = -1;
}
string text = ColorsToHexString(colours);
Plugin.activeState = new FlashlightState
{
Colors = colours,
Mode = mode,
Speed = speed
};
SaveHandler.SaveData();
if (!Plugin.config.syncOwn.Value || !Plugin.config.syncCyclicFX.Value)
{
text = "#FFFFFF";
mode = FlashlightMode.Fixed;
}
CFNetwork.Instance.SetPlayerColourServerRpc(Plugin.playerId, mode, FixedString128Bytes.op_Implicit(text), speed);
}
else
{
Plugin.mls.LogDebug((object)"Player was null?");
}
}
}
public struct CFPlayerData : INetworkSerializable, IEquatable<CFPlayerData>
{
public ulong ClientId;
public FlashlightMode Mode;
public FixedString128Bytes Colors;
public int Speed;
public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
//IL_000b: 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_0022: 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_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
((BufferSerializer<ulong>*)(&serializer))->SerializeValue<ulong>(ref ClientId, default(ForPrimitives));
((BufferSerializer<FlashlightMode>*)(&serializer))->SerializeValue<FlashlightMode>(ref Mode, default(ForEnums));
((BufferSerializer<FixedString128Bytes>*)(&serializer))->SerializeValue<FixedString128Bytes>(ref Colors, default(ForFixedStrings));
((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref Speed, default(ForPrimitives));
}
public bool Equals(CFPlayerData other)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
return ClientId == other.ClientId && Mode == other.Mode && Speed == other.Speed && ((FixedString128Bytes)(ref Colors)).Equals(other.Colors);
}
public readonly List<Color> GetColors()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: 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)
List<Color> list = new List<Color>();
FixedString128Bytes colors = Colors;
string[] array = ((object)(FixedString128Bytes)(ref colors)).ToString().Split(',', StringSplitOptions.RemoveEmptyEntries);
string[] array2 = array;
Color item = default(Color);
foreach (string text in array2)
{
if (ColorUtility.TryParseHtmlString(text, ref item))
{
list.Add(item);
}
}
return list;
}
public override int GetHashCode()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
return HashCode.Combine<ulong, FlashlightMode, FixedString128Bytes, int>(ClientId, Mode, Colors, Speed);
}
}
public class CFNetwork : NetworkBehaviour
{
public NetworkList<CFPlayerData> PlayerData;
public static CFNetwork Instance { get; private set; }
private void Awake()
{
Instance = this;
PlayerData = new NetworkList<CFPlayerData>();
}
public override void OnNetworkSpawn()
{
((NetworkBehaviour)this).OnNetworkSpawn();
PlayerData.OnListChanged += OnListChanged;
Plugin.mls.LogInfo((object)"Network ready!");
}
public override void OnNetworkDespawn()
{
((NetworkBehaviour)this).OnNetworkDespawn();
PlayerData.OnListChanged -= OnListChanged;
Plugin.mls.LogInfo((object)"Network closed!");
}
private void OnListChanged(NetworkListEvent<CFPlayerData> e)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
ApplyFlashlightColour(e.Value);
}
public CFPlayerData? GetPlayerData(ulong clientId)
{
foreach (CFPlayerData playerDatum in PlayerData)
{
if (playerDatum.ClientId == clientId)
{
return playerDatum;
}
}
return null;
}
private void ApplyFlashlightColour(CFPlayerData data)
{
PlayerControllerB val = ((IEnumerable<PlayerControllerB>)RoundManager.Instance.playersManager.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB p) => p.playerClientId == data.ClientId));
if (!((Object)(object)val != (Object)null))
{
return;
}
IEnumerable<FlashlightItem> enumerable = val.ItemSlots.OfType<FlashlightItem>();
foreach (FlashlightItem item in enumerable)
{
FlashlightData flashlight = new FlashlightData(item, data.GetColors(), data.Mode, data.Speed);
Plugin.flashlightHandler.SetFlashlight(flashlight);
}
}
[ServerRpc(RequireOwnership = false)]
public void SetPlayerColourServerRpc(ulong clientId, FlashlightMode mode, FixedString128Bytes colors, int speed)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0154: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
{
ServerRpcParams val = default(ServerRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(558749639u, val, (RpcDelivery)0);
BytePacker.WriteValueBitPacked(val2, clientId);
((FastBufferWriter)(ref val2)).WriteValueSafe<FlashlightMode>(ref mode, default(ForEnums));
((FastBufferWriter)(ref val2)).WriteValueSafe<FixedString128Bytes>(ref colors, default(ForFixedStrings));
BytePacker.WriteValueBitPacked(val2, speed);
((NetworkBehaviour)this).__endSendServerRpc(ref val2, 558749639u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
{
return;
}
base.__rpc_exec_stage = (__RpcExecStage)0;
Plugin.mls.LogDebug((object)"SetPlayerColourServerRpc Sent");
if (!((NetworkBehaviour)this).IsServer)
{
return;
}
CFPlayerData cFPlayerData = default(CFPlayerData);
cFPlayerData.ClientId = clientId;
cFPlayerData.Mode = mode;
cFPlayerData.Colors = colors;
cFPlayerData.Speed = speed;
CFPlayerData cFPlayerData2 = cFPlayerData;
int num = -1;
for (int i = 0; i < PlayerData.Count; i++)
{
if (PlayerData[i].ClientId == clientId)
{
num = i;
break;
}
}
if (num >= 0)
{
PlayerData[num] = cFPlayerData2;
}
else
{
PlayerData.Add(cFPlayerData2);
}
}
protected override void __initializeVariables()
{
if (PlayerData == null)
{
throw new Exception("CFNetwork.PlayerData cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)PlayerData).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)PlayerData, "PlayerData");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)PlayerData);
((NetworkBehaviour)this).__initializeVariables();
}
protected override void __initializeRpcs()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Expected O, but got Unknown
((NetworkBehaviour)this).__registerRpc(558749639u, new RpcReceiveHandler(__rpc_handler_558749639), "SetPlayerColourServerRpc");
((NetworkBehaviour)this).__initializeRpcs();
}
private static void __rpc_handler_558749639(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: 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_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_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: 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)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
ulong clientId = default(ulong);
ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
FlashlightMode mode = default(FlashlightMode);
((FastBufferReader)(ref reader)).ReadValueSafe<FlashlightMode>(ref mode, default(ForEnums));
FixedString128Bytes colors = default(FixedString128Bytes);
((FastBufferReader)(ref reader)).ReadValueSafe<FixedString128Bytes>(ref colors, default(ForFixedStrings));
int speed = default(int);
ByteUnpacker.ReadValueBitPacked(reader, ref speed);
target.__rpc_exec_stage = (__RpcExecStage)1;
((CFNetwork)(object)target).SetPlayerColourServerRpc(clientId, mode, colors, speed);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "CFNetwork";
}
}
[HarmonyPatch]
public class NetworkObjectManager
{
private static GameObject networkPrefab;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
public static void Init()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
if (!((Object)(object)networkPrefab != (Object)null))
{
networkPrefab = (GameObject)Assets.MainAssetBundle.LoadAsset("CFNetworkHandler");
networkPrefab.AddComponent<CFNetwork>();
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void SpawnNetworkHandler()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
}
}
}
public static class Patches
{
[HarmonyPatch(typeof(FlashlightItem))]
public class CFFlashlightItemPatch
{
[HarmonyPatch("SwitchFlashlight")]
[HarmonyPostfix]
public static void SwitchFlashlightPatch(FlashlightItem __instance, bool on)
{
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
//IL_0118: 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_025f: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null)
{
return;
}
if (!((GrabbableObject)__instance).isBeingUsed)
{
Plugin.flashlightWasActive = false;
return;
}
ulong playerClientId = ((GrabbableObject)__instance).playerHeldBy.playerClientId;
if (playerClientId == Plugin.playerId)
{
if (Plugin.firstFlashlight)
{
if (Plugin.activeState.Colors.Count > 0 && Plugin.activeState.Mode == FlashlightMode.Fixed && Plugin.activeState.Colors[0] == Color.white)
{
HUDManager.Instance.DisplayTip("Change flashlight colour!", "Type 'cf' into the ship terminal for guidance!", false, false, "LC_Tip1");
}
Plugin.firstFlashlight = false;
}
if (on && !Plugin.flashlightWasActive && Plugin.activeState.Mode == FlashlightMode.Random)
{
Plugin.flashlightWasActive = true;
int index;
Color uniqueRandomColor = Helpers.GetUniqueRandomColor(Plugin.randomColours, Plugin.prevRandIndex, out index);
Plugin.activeState.Colors[0] = uniqueRandomColor;
Plugin.prevRandIndex = index;
CFNetwork.Instance.SetPlayerColourServerRpc(Plugin.playerId, FlashlightMode.Random, FixedString128Bytes.op_Implicit(Helpers.ColorToHexString(uniqueRandomColor)), 0);
}
FlashlightData flashlight = new FlashlightData(__instance, Plugin.activeState.Colors, Plugin.activeState.Mode, Plugin.activeState.Speed);
Plugin.flashlightHandler.SetFlashlight(flashlight);
return;
}
CFPlayerData? playerData = CFNetwork.Instance.GetPlayerData(playerClientId);
if (!playerData.HasValue)
{
Plugin.mls.LogDebug((object)$"No player data found - id {playerClientId}");
return;
}
FlashlightData flashlightData = new FlashlightData(__instance, playerData.Value.GetColors(), playerData.Value.Mode, playerData.Value.Speed);
if (!Plugin.config.syncCyclicFX.Value && flashlightData.Mode != 0)
{
flashlightData.Mode = FlashlightMode.Fixed;
if (flashlightData.Colors.Count < 1)
{
flashlightData.Colors = new List<Color>(1) { Color.white };
}
}
if (!Plugin.config.syncOthers.Value)
{
flashlightData.Mode = FlashlightMode.Fixed;
flashlightData.Colors = new List<Color>(1) { Color.white };
}
Plugin.flashlightHandler.SetFlashlight(flashlightData);
}
}
[HarmonyPatch(typeof(PlayerControllerB))]
public class CFPlayerControllerBPatch
{
[HarmonyPatch("SpawnPlayerAnimation")]
[HarmonyPostfix]
public static void SpawnPlayerPatch(PlayerControllerB __instance)
{
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
if (__instance == null)
{
Plugin.mls.LogError((object)"PlayerControllerB instance is null");
return;
}
Plugin.playerId = __instance.playerClientId;
Plugin.playerMaxHealth = __instance.health;
string text;
FlashlightMode mode;
if (!Plugin.config.syncOwn.Value || !Plugin.config.syncCyclicFX.Value)
{
text = "#FFFFFF";
mode = FlashlightMode.Fixed;
}
else
{
text = Helpers.ColorsToHexString(Plugin.activeState.Colors);
mode = Plugin.activeState.Mode;
}
CFNetwork.Instance.SetPlayerColourServerRpc(Plugin.playerId, mode, FixedString128Bytes.op_Implicit(text), Plugin.activeState.Speed);
Plugin.mls.LogInfo((object)$"Player spawned with client id: {Plugin.playerId}");
}
[HarmonyPatch("Update")]
[HarmonyPostfix]
public static void UpdatePatch()
{
Plugin.flashlightHandler.CFUpdate(Time.deltaTime);
}
}
[HarmonyPatch(typeof(NetworkBehaviour))]
public class CFNetworkBehaviourPatch
{
[HarmonyPatch("OnDestroy")]
[HarmonyPostfix]
public static void OnDestroyPatch(NetworkBehaviour __instance)
{
FlashlightItem val = (FlashlightItem)(object)((__instance is FlashlightItem) ? __instance : null);
if (val != null)
{
Plugin.flashlightHandler.RemoveFlashlight(val);
Plugin.mls.LogDebug((object)"Flashlight destroyed. Removed from handler.");
}
}
}
[HarmonyPatch(typeof(RoundManager))]
public class CFRoundManagerPatch
{
[HarmonyPatch("OnDestroy")]
[HarmonyPostfix]
public static void OnDestroyPatch(RoundManager __instance)
{
Plugin.flashlightHandler.Flashlights.Clear();
Plugin.mls.LogDebug((object)"Game ended. Cleared handler.");
}
}
}
[BepInPlugin("Cubly.ColourfulFlashlights", "ColourfulFlashlights", "4.0.1")]
public class Plugin : BaseUnityPlugin
{
public const string MOD_NAME = "ColourfulFlashlights";
private const string MOD_GUID = "Cubly.ColourfulFlashlights";
public const string MOD_VERSION = "4.0.1";
public static string userPresetsPath = Path.Combine(Paths.ConfigPath, "ColourfulFlashlights", "UserPresets.json");
public static string configPath = Path.Combine(Paths.ConfigPath, "ColourfulFlashlights", "Config.cfg");
private readonly Harmony harmony = new Harmony("Cubly.ColourfulFlashlights");
public static Plugin Instance;
public static ConfigHandler config = new ConfigHandler();
public static ManualLogSource mls;
public static Dictionary<string, FlashlightState> UserPresets = new Dictionary<string, FlashlightState>();
public static Dictionary<ulong, Color> PlayerColours = new Dictionary<ulong, Color>();
public static ulong playerId;
public static int playerMaxHealth = 100;
public static bool firstFlashlight = true;
public static FlashlightState activeState = new FlashlightState();
public static bool flashlightWasActive = false;
public static List<Color> randomColours = new List<Color>();
public static int prevRandIndex = -1;
public static FlashlightHandler flashlightHandler = new FlashlightHandler();
private FileSystemWatcher watcher;
private DateTime lastReload;
private void Awake()
{
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
mls = Logger.CreateLogSource("Cubly.ColourfulFlashlights");
config.Init();
SaveHandler.Init();
harmony.PatchAll();
Assets.PopulateAssets();
watcher = new FileSystemWatcher(Path.GetDirectoryName(configPath))
{
NotifyFilter = NotifyFilters.LastWrite
};
watcher.Changed += delegate(object _, FileSystemEventArgs e)
{
Thread.Sleep(100);
if ((DateTime.Now - lastReload).TotalMilliseconds > 300.0)
{
lastReload = DateTime.Now;
if (e.FullPath.EndsWith("UserPresets.json"))
{
mls.LogInfo((object)"Reloading user presets...");
SaveHandler.LoadUserPresets();
}
else if (e.FullPath.EndsWith("Config.cfg"))
{
mls.LogInfo((object)"Reloading configuration...");
config.configFile.Reload();
mls.LogInfo((object)"Loaded configuration.");
}
}
};
watcher.EnableRaisingEvents = true;
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
mls.LogInfo((object)"ColourfulFlashlights 4.0.1 loaded!");
}
}
public class UserData
{
public string name { get; set; }
public FlashlightMode mode { get; set; } = FlashlightMode.Fixed;
public int speed { get; set; } = 10;
public List<string> colours { get; set; } = new List<string>();
}
internal class SaveHandler
{
public static void Init()
{
try
{
Directory.CreateDirectory(Path.GetDirectoryName(Plugin.userPresetsPath));
if (!File.Exists(Plugin.userPresetsPath))
{
UserData item = new UserData
{
name = "example"
};
List<UserData> list = new List<UserData>(1) { item };
string path = Path.Combine(Paths.ConfigPath, "Cubly.ColourfulFlashlights.cfg");
if (File.Exists(path))
{
Plugin.mls.LogInfo((object)"Migrating old configuration to UserPresets.json");
List<UserData> list2 = MigrateOldConfig();
if (list2.Count > 0)
{
list = list2;
File.Delete(path);
}
}
string contents = JsonConvert.SerializeObject((object)list, (Formatting)1);
File.WriteAllText(Plugin.userPresetsPath, contents);
Plugin.mls.LogInfo((object)"Created UserPresets.json");
}
}
catch (Exception ex)
{
Plugin.mls.LogInfo((object)"Error initialising ColourfulFlashlights save data.");
Plugin.mls.LogError((object)ex.Message);
}
LoadData();
LoadUserPresets();
}
public static void SaveData()
{
try
{
string path = Application.persistentDataPath + "\\ColourfulFlashlights.json";
string contents = JsonUtility.ToJson((object)Plugin.activeState);
File.WriteAllText(path, contents);
Plugin.mls.LogInfo((object)"Data saved.");
}
catch (Exception ex)
{
Plugin.mls.LogInfo((object)"Error when saving data.");
Plugin.mls.LogError((object)ex.Message);
}
}
public static void LoadData()
{
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: 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)
try
{
string path = Application.persistentDataPath + "\\ColourfulFlashlights.json";
string path2 = Application.persistentDataPath + "\\ColourfulFlashlights.txt";
if (File.Exists(path))
{
string text = File.ReadAllText(path);
FlashlightState flashlightState = JsonUtility.FromJson<FlashlightState>(text);
if (flashlightState.Colors.Count == 0 && flashlightState.Mode != FlashlightMode.Random)
{
flashlightState.Colors.Add(Color.white);
if (flashlightState.Mode == FlashlightMode.Health)
{
flashlightState.Colors.Add(Color.red);
}
}
if (!Enum.IsDefined(typeof(FlashlightMode), flashlightState.Mode))
{
flashlightState.Mode = FlashlightMode.Fixed;
}
Plugin.activeState = flashlightState;
Plugin.mls.LogInfo((object)"Loaded data from save.");
if (File.Exists(path2))
{
File.Delete(path2);
Plugin.mls.LogInfo((object)"Removed old save data.");
}
}
else
{
Plugin.activeState.Colors.Add(Color.white);
Plugin.mls.LogInfo((object)"Save file not found, loading defaults...");
}
}
catch (Exception ex)
{
Plugin.activeState.Colors.Add(Color.white);
Plugin.mls.LogInfo((object)"Invalid save file, loading defaults...");
Plugin.mls.LogError((object)ex.Message);
}
}
public static void LoadUserPresets()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
try
{
string userPresetsPath = Plugin.userPresetsPath;
if (File.Exists(userPresetsPath))
{
string text = File.ReadAllText(userPresetsPath);
if (string.IsNullOrWhiteSpace(text))
{
Plugin.mls.LogInfo((object)"No presets were loaded! UserPresets.json is empty!");
return;
}
JsonSerializerSettings val = new JsonSerializerSettings
{
ObjectCreationHandling = (ObjectCreationHandling)2
};
List<UserData> list = JsonConvert.DeserializeObject<List<UserData>>(text, val);
if (list != null)
{
Plugin.UserPresets.Clear();
for (int i = 0; i < list.Count; i++)
{
UserData userData = list[i];
string text2 = userData.name.Replace(" ", "").ToLowerInvariant();
if (text2.Length > 15)
{
text2 = text2.Substring(0, 15);
}
if (Plugin.UserPresets.ContainsKey(text2))
{
continue;
}
UserData userData2 = userData;
if (userData2.colours == null)
{
List<string> list3 = (userData2.colours = new List<string>());
}
userData.colours = userData.colours.Where((string c) => Helpers.IsValidHexCode(c)).ToList();
if (userData.colours.Count == 0 && userData.mode != FlashlightMode.Random)
{
userData.colours.Add("#FFFFFF");
if (userData.mode == FlashlightMode.Health)
{
userData.colours.Add("#FF0000");
}
}
if (!Enum.IsDefined(typeof(FlashlightMode), userData.mode))
{
userData.mode = FlashlightMode.Fixed;
}
Plugin.UserPresets[text2] = new FlashlightState
{
Mode = userData.mode,
Speed = Math.Clamp(userData.speed, 1, 20),
Colors = Helpers.HexListToColors(userData.colours.Take(16).ToList())
};
}
if (Plugin.UserPresets.Count > 0)
{
int count = Plugin.UserPresets.Count;
Plugin.mls.LogInfo((object)string.Format("Loaded {0} user preset{1}.", count, (count > 1) ? "s" : ""));
}
else
{
Plugin.mls.LogInfo((object)"No presets were loaded!");
}
}
else
{
Plugin.mls.LogInfo((object)"No presets were loaded! UserPresets.json is empty!");
}
}
else
{
Plugin.mls.LogInfo((object)"No presets were loaded! UserPreset.json contains invalid data.");
}
}
catch (Exception ex)
{
Plugin.mls.LogInfo((object)"Could not load user presets. Maybe the syntax is wrong?");
Plugin.mls.LogError((object)ex.Message);
}
}
public static bool SaveUserPreset(string name, FlashlightState state)
{
try
{
Plugin.mls.LogInfo((object)"Saving user presets...");
if (Plugin.UserPresets.ContainsKey(name))
{
Plugin.UserPresets[name] = state;
}
else
{
Plugin.UserPresets.Add(name, state);
}
List<UserData> list = new List<UserData>();
foreach (KeyValuePair<string, FlashlightState> userPreset in Plugin.UserPresets)
{
userPreset.Deconstruct(out var key, out var value);
string name2 = key;
FlashlightState flashlightState = value;
UserData item = new UserData
{
name = name2,
mode = flashlightState.Mode,
speed = flashlightState.Speed,
colours = Helpers.ColorsToHexList(flashlightState.Colors)
};
list.Add(item);
}
string userPresetsPath = Plugin.userPresetsPath;
string contents = JsonConvert.SerializeObject((object)list, (Formatting)1);
File.WriteAllText(Plugin.userPresetsPath, contents);
Plugin.mls.LogInfo((object)"Saved user presets.");
return true;
}
catch (Exception ex)
{
Plugin.mls.LogInfo((object)"Failed to save user presets!");
Plugin.mls.LogError((object)ex.Message);
return false;
}
}
private static List<UserData> MigrateOldConfig()
{
ConfigEntry<string> val = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<string>("Custom Presets", "Custom 1", "", (ConfigDescription)null);
ConfigEntry<string> val2 = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<string>("Custom Presets", "Custom 2", "", (ConfigDescription)null);
ConfigEntry<string> val3 = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<string>("Custom Presets", "Custom 3", "", (ConfigDescription)null);
ConfigEntry<string>[] array = new ConfigEntry<string>[3] { val, val2, val3 };
List<UserData> list = new List<UserData>();
((BaseUnityPlugin)Plugin.Instance).Config.Reload();
ConfigEntry<string> val4 = default(ConfigEntry<string>);
for (int i = 0; i < array.Length; i++)
{
if (((BaseUnityPlugin)Plugin.Instance).Config.TryGetEntry<string>(((ConfigEntryBase)array[i]).Definition, ref val4))
{
Plugin.mls.LogInfo((object)$"cfg {i} - val: {val4.Value}");
list.Add(new UserData
{
name = (i + 1).ToString(),
speed = 0,
mode = FlashlightMode.Fixed,
colours = new List<string>(1) { val4.Value }
});
}
((BaseUnityPlugin)Plugin.Instance).Config.Remove(((ConfigEntryBase)array[i]).Definition);
}
return list;
}
}
[HarmonyPatch(typeof(TerminalEvent))]
public static class TerminalPatch
{
public static Terminal terminal;
private static bool modifiedOtherNode;
private static string presetNameToSave;
[HarmonyPatch(typeof(Terminal), "Awake")]
[HarmonyPostfix]
public static void TerminalAwake(Terminal __instance)
{
terminal = __instance;
}
[HarmonyPatch(typeof(Terminal), "BeginUsingTerminal")]
[HarmonyPostfix]
private static void OnBeginUsingTerminal(Terminal __instance)
{
if (modifiedOtherNode)
{
return;
}
modifiedOtherNode = true;
TerminalKeyword[] allKeywords = __instance.terminalNodes.allKeywords;
foreach (TerminalKeyword val in allKeywords)
{
if (((Object)val).name == "Other")
{
TerminalNode specialKeywordResult = val.specialKeywordResult;
string text = ">SCAN\nTo scan for the number of items left on the current planet.";
string value = "\n\n>CF\nTo customise the colour of your flashlight.";
int num = specialKeywordResult.displayText.IndexOf(text);
if (num > -1)
{
int startIndex = num + text.Length;
specialKeywordResult.displayText = specialKeywordResult.displayText.Insert(startIndex, value);
}
}
}
}
[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
[HarmonyPrefix]
private static bool ParsePlayerSentence(ref TerminalNode __result, Terminal __instance)
{
//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
//IL_031d: Unknown result type (might be due to invalid IL or missing references)
//IL_0329: Unknown result type (might be due to invalid IL or missing references)
//IL_0335: Unknown result type (might be due to invalid IL or missing references)
//IL_0341: Unknown result type (might be due to invalid IL or missing references)
//IL_034d: Unknown result type (might be due to invalid IL or missing references)
//IL_076c: Unknown result type (might be due to invalid IL or missing references)
//IL_0771: Unknown result type (might be due to invalid IL or missing references)
//IL_0785: Unknown result type (might be due to invalid IL or missing references)
//IL_07d9: Unknown result type (might be due to invalid IL or missing references)
//IL_07de: Unknown result type (might be due to invalid IL or missing references)
//IL_07f2: Unknown result type (might be due to invalid IL or missing references)
if (__instance.screenText.text.Length < 1)
{
return true;
}
string text = __instance.screenText.text;
int textAdded = __instance.textAdded;
int length = text.Length;
int num = length - textAdded;
string text2 = text.Substring(num, length - num).ToLowerInvariant().Trim();
string[] array = text2.Split(' ');
if (array.Length == 0)
{
return true;
}
if (presetNameToSave != null)
{
if ("confirm".StartsWith(text2))
{
if (SaveHandler.SaveUserPreset(presetNameToSave, Plugin.activeState))
{
__result = SuccessNode("Overwrote the preset with name: " + presetNameToSave + "\n\nTo use this preset at anytime, enter:\ncf preset " + presetNameToSave);
}
else
{
__result = ErrorNode("There was an error trying to save user presets.\n\nPlease try again.");
}
presetNameToSave = null;
return false;
}
__result = CustomNode("Cancelled preset save operation!\n\nYour preset: '" + presetNameToSave + "' was not overwritten.");
presetNameToSave = null;
return true;
}
if (array[0] == "cf")
{
if (array.Length == 1)
{
__result = BaseNode();
return false;
}
switch (array[1])
{
case "help":
__result = HelpNode();
return false;
case "rainbow":
{
int speedFromArgs2 = Helpers.GetSpeedFromArgs(array);
Helpers.UpdateState(new List<Color>(1) { Color.white }, FlashlightMode.Rainbow, speedFromArgs2);
__result = SuccessNode("'Rainbow' effect applied!\n\n[New State]\n" + Helpers.GetStateText(Plugin.activeState));
return false;
}
case "disco":
{
int speedFromArgs = Helpers.GetSpeedFromArgs(array);
List<Color> colours3 = new List<Color>(5)
{
Color.red,
Color.blue,
Color.green,
Color.magenta,
Color.yellow
};
Helpers.UpdateState(colours3, FlashlightMode.Cycle, speedFromArgs);
__result = SuccessNode("'Disco' effect applied!\n\n[New State]\n" + Helpers.GetStateText(Plugin.activeState));
return false;
}
case "random":
Helpers.UpdateState(new List<Color>(), FlashlightMode.Random, 0);
__result = SuccessNode("'Random' effect applied!\n\n[New State]\n" + Helpers.GetStateText(Plugin.activeState));
return false;
case "health":
Helpers.UpdateState(new List<Color>(2)
{
Color.white,
Color.red
}, FlashlightMode.Health, 0);
__result = SuccessNode("'Health' effect applied!\n\n[New State]\n" + Helpers.GetStateText(Plugin.activeState));
return false;
case "state":
__result = CustomNode("[Current State]\n" + Helpers.GetStateText(Plugin.activeState) + "\n");
return false;
case "preset":
{
FlashlightState value;
if (array.Length < 3)
{
if (Plugin.UserPresets.Count > 0)
{
__result = CustomNode("You can create custom presets in the UserPresets.json configuration file. Find more information on the plugin's Thunderstore page.\n\n[Current Presets]\n" + string.Join(", ", Plugin.UserPresets.Keys) + "\n\nExample usage: cf preset " + Plugin.UserPresets.Keys.First() + "\n");
}
else
{
__result = CustomNode("You can create custom presets in the UserPresets.json configuration file. Find more information on the plugin's Thunderstore page.\n\n[Current Presets]\nNo presets were found!\n\nMake sure to correctly define presets in UserPresets.json\n");
}
}
else if (Plugin.UserPresets.TryGetValue(array[2], out value))
{
Helpers.UpdateState(value.Colors, value.Mode, value.Speed);
__result = CustomNode("Preset applied!\n\n[New State]\n" + Helpers.GetStateText(Plugin.activeState, array[2]) + "\n");
}
else if (Plugin.UserPresets.Count > 0)
{
__result = CustomNode("The preset '" + array[2] + "' could not be found!\n\n[Current Presets]\n" + string.Join(", ", Plugin.UserPresets.Keys) + "\n\nExample usage: cf preset " + Plugin.UserPresets.Keys.First());
}
else
{
__result = CustomNode("The preset '" + array[2] + "' could not be found!\n\n[Current Presets]\nNo presets were found!\n\nMake sure to correctly define presets in UserPresets.json");
}
return false;
}
case "speed":
{
FlashlightMode mode = Plugin.activeState.Mode;
if ((mode == FlashlightMode.Fixed || (uint)(mode - 3) <= 1u) ? true : false)
{
__result = CustomNode($"Your flashlight is set to: {Plugin.activeState.Mode}\n\nThe speed setting is not used for this mode.");
}
else if (array.Length < 3)
{
__result = ErrorNode("Please provide a speed [1-20]\nHigher is faster.\n\ne.g. cf speed 8");
}
else
{
FlashlightState activeState = Plugin.activeState;
int speedFromArgs3 = Helpers.GetSpeedFromArgs(array);
Helpers.UpdateState(activeState.Colors, activeState.Mode, speedFromArgs3);
__result = SuccessNode($"Speed updated [{activeState.Speed} -> {speedFromArgs3}]\n\n[New State]\n{Helpers.GetStateText(Plugin.activeState)}");
}
return false;
}
case "save":
if (array.Length < 3)
{
__result = ErrorNode("A name for the preset was not provided!\n\nPlease provide a name, for example:\ncf save mypreset\n\nIf you provide the name of an existing preset, that preset will be overwritten. Preset names are case-insensitive and can be a maximum of 15 characters long.");
}
else
{
string text3 = array[2].Trim().ToLowerInvariant();
if (text3.Length > 15)
{
__result = ErrorNode($"Preset name too long!\n\nYour preset name was {text3.Length}.\nThe maximum length is 15 characters.");
return false;
}
if (Plugin.UserPresets.ContainsKey(text3))
{
presetNameToSave = text3;
__result = ConfirmSaveNode(text3);
}
else if (SaveHandler.SaveUserPreset(text3, Plugin.activeState))
{
__result = SuccessNode("Saved the current flashlight state as a new preset with name: " + text3 + "\n\nTo use this preset at anytime, enter:\ncf preset " + text3);
}
else
{
__result = ErrorNode("There was an error trying to save user presets.\n\nPlease try again.");
}
}
return false;
default:
{
Color? val = Helpers.NameToColor(array[1]);
if (val.HasValue)
{
Color valueOrDefault = val.GetValueOrDefault();
if (true)
{
List<Color> colours = new List<Color>(1) { valueOrDefault };
Helpers.UpdateState(colours, FlashlightMode.Fixed, 0);
__result = SuccessNode("Colour " + array[1] + " applied!\n\n[New State]\n" + Helpers.GetStateText(Plugin.activeState));
goto IL_083f;
}
}
val = Helpers.HexStringToColor(array[1]);
if (val.HasValue)
{
Color valueOrDefault2 = val.GetValueOrDefault();
if (true)
{
List<Color> colours2 = new List<Color>(1) { valueOrDefault2 };
Helpers.UpdateState(colours2, FlashlightMode.Fixed, 0);
__result = SuccessNode("Colour " + array[1] + " applied!\n\n[New State]\n" + Helpers.GetStateText(Plugin.activeState));
goto IL_083f;
}
}
__result = ErrorNode("Please provide a valid colour or command!\n\nExamples: cf purple cf #FF00CC\n\nEnter cf help for a list of commands.");
goto IL_083f;
}
case null:
break;
IL_083f:
return false;
}
}
return true;
}
private static TerminalNode BaseNode()
{
//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_0011: 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)
//IL_0020: Expected O, but got Unknown
return new TerminalNode
{
displayText = "[ColourfulFlashlights] Version 4.0.0\n\nCustomise your flashlight colour!\n\nBasic usage:\n\n>CF [colour] e.g. cf purple\n\nValid colours: white, blue, red, yellow, orange, green, pink, purple\n\nYou can also use a hex code, e.g. cf #FF00DD\n\n>CF HELP\nFor more options and a list of colour names\n\n\n",
clearPreviousText = true,
acceptAnything = false
};
}
private static TerminalNode HelpNode()
{
//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_0011: 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)
//IL_0020: Expected O, but got Unknown
return new TerminalNode
{
displayText = "[ColourfulFlashlights]\n\n>CF [colour] e.g. cf #ff00dd\nUse a colour name (see below) or hex code\n\n>CF PRESET [name] e.g. cf preset 2\nLoad a preset by name from UserPresets.json\n\n>CF SPEED [1-20]\nChange the speed of an effect\n\n>CF [effect] [speed]\nUse a built-in effect: random, rainbow, disco\n\nValid colour names:\nwhite, blue, red, yellow, orange, green, pink, purple\n\n",
clearPreviousText = true,
acceptAnything = false
};
}
private static TerminalNode SuccessNode(string text)
{
//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_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
return new TerminalNode
{
displayText = "[ColourfulFlashlights]\n\nSUCCESS!\n\n" + text + "\n\n\n",
clearPreviousText = true,
acceptAnything = false
};
}
private static TerminalNode ErrorNode(string text)
{
//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_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
return new TerminalNode
{
displayText = "[ColourfulFlashlights]\n\nERROR!\n\n" + text + "\n\n\n",
clearPreviousText = true,
acceptAnything = false
};
}
private static TerminalNode CustomNode(string text)
{
//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_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
return new TerminalNode
{
displayText = "[ColourfulFlashlights]\n\n" + text + "\n\n",
clearPreviousText = true,
acceptAnything = false
};
}
private static TerminalNode ConfirmSaveNode(string presetName)
{
//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_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
return new TerminalNode
{
displayText = "[ColourfulFlashlights]\n\nEXISTING PRESET!\n\nYou are about to overwrite the preset: " + presetName + "\n\nPlease CONFIRM or DENY.\n\n\n",
isConfirmationNode = true,
acceptAnything = false,
clearPreviousText = true
};
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "ColourfulFlashlights";
public const string PLUGIN_NAME = "ColourfulFlashlights";
public const string PLUGIN_VERSION = "4.0.1";
}
}
namespace ColourfulFlashlights.Properties
{
[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[DebuggerNonUserCode]
[CompilerGenerated]
internal class Resources
{
private static ResourceManager resourceMan;
private static CultureInfo resourceCulture;
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static ResourceManager ResourceManager
{
get
{
if (resourceMan == null)
{
ResourceManager resourceManager = new ResourceManager("ColourfulFlashlights.Properties.Resources", typeof(Resources).Assembly);
resourceMan = resourceManager;
}
return resourceMan;
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
internal static CultureInfo Culture
{
get
{
return resourceCulture;
}
set
{
resourceCulture = value;
}
}
internal static byte[] cfasset
{
get
{
object @object = ResourceManager.GetObject("cfasset", resourceCulture);
return (byte[])@object;
}
}
internal Resources()
{
}
}
}
namespace __GEN
{
internal class NetworkVariableSerializationHelper
{
[RuntimeInitializeOnLoadMethod]
internal static void InitializeSerialization()
{
NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<CFPlayerData>();
NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<CFPlayerData>();
}
}
}
namespace ColourfulFlashlights.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
