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 HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using LightFlickerZooks;
using MelonLoader;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(LightFlickerMod), "LightFlickerGB", "1.0.0", "Zooks", null)]
[assembly: MelonGame("Boneloaf", "Gang Beasts")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SubwayDeathGB")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("sd for GB")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SubwayDeathGB")]
[assembly: AssemblyTitle("SubwayDeathGB")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace LightFlickerZooks
{
public class LightFlickerMod : MelonMod
{
[CompilerGenerated]
private sealed class <DelayedCacheMapLights>d__17 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <DelayedCacheMapLights>d__17(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitForSeconds(2f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
CacheMapLights();
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 <FlickerRoutine>d__23 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public List<Light> lights;
private float <duration>5__2;
private float <elapsed>5__3;
private Dictionary<Light, bool> <originalStates>5__4;
private float <originalAmbientIntensity>5__5;
private Color <originalAmbientLight>5__6;
private float <originalReflectionIntensity>5__7;
private float <waitTime>5__8;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <FlickerRoutine>d__23(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();
}
}
<originalStates>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
//IL_01ab: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
isFlickering = true;
<duration>5__2 = 1.5f;
<elapsed>5__3 = 0f;
<originalStates>5__4 = lights.ToDictionary((Light l) => l, (Light l) => ((Behaviour)l).enabled);
<originalAmbientIntensity>5__5 = RenderSettings.ambientIntensity;
<originalAmbientLight>5__6 = RenderSettings.ambientLight;
<originalReflectionIntensity>5__7 = RenderSettings.reflectionIntensity;
<>1__state = -3;
break;
case 1:
<>1__state = -3;
<elapsed>5__3 += <waitTime>5__8;
break;
}
if (<elapsed>5__3 < <duration>5__2)
{
bool flag = Random.value > 0.45f;
float num = (flag ? 1f : 0f);
foreach (Light light in lights)
{
if ((Object)(object)light != (Object)null)
{
((Behaviour)light).enabled = <originalStates>5__4[light] && flag;
}
}
foreach (Renderer lightRenderer in lightRenderers)
{
SetRendererColor(lightRenderer, flag);
}
RenderSettings.ambientIntensity = <originalAmbientIntensity>5__5 * num;
RenderSettings.ambientLight = <originalAmbientLight>5__6 * num;
RenderSettings.reflectionIntensity = <originalReflectionIntensity>5__7 * num;
<waitTime>5__8 = Random.Range(0.04f, 0.12f);
<>2__current = (object)new WaitForSeconds(<waitTime>5__8);
<>1__state = 1;
return true;
}
<>m__Finally1();
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
<>1__state = -1;
foreach (Light light in lights)
{
if ((Object)(object)light != (Object)null && <originalStates>5__4.ContainsKey(light))
{
((Behaviour)light).enabled = <originalStates>5__4[light];
}
}
foreach (Renderer lightRenderer in lightRenderers)
{
SetRendererColor(lightRenderer, restore: true);
}
RenderSettings.ambientIntensity = <originalAmbientIntensity>5__5;
RenderSettings.ambientLight = <originalAmbientLight>5__6;
RenderSettings.reflectionIntensity = <originalReflectionIntensity>5__7;
isFlickering = false;
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static string soundFilePath;
private static AudioClip deathClip;
private static bool isFlickering = false;
private static bool isMapActive = false;
private static float lastTriggerTime = -999f;
private static AudioSource activeSource = null;
private static readonly string[] AllowedMaps = new string[4] { "subway", "lighthouse", "chute", "grind" };
private static readonly string[] LightKeywords = new string[8] { "light", "neon", "bulb", "lamp", "fixture", "glow", "emiss", "spotlight" };
private static List<Light> cachedMapLights = new List<Light>();
private static List<Renderer> lightRenderers = new List<Renderer>();
private static Dictionary<Renderer, Color> originalEmissionColors = new Dictionary<Renderer, Color>();
private static Dictionary<Renderer, bool> originalEmissionKeywords = new Dictionary<Renderer, bool>();
private static Dictionary<Renderer, Color> originalBaseColors = new Dictionary<Renderer, Color>();
public override void OnInitializeMelon()
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Expected O, but got Unknown
//IL_018b: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Expected O, but got Unknown
soundFilePath = Path.Combine(MelonEnvironment.UserDataDirectory, "LightFlicker", "lightflicker.wav");
Directory.CreateDirectory(Path.GetDirectoryName(soundFilePath));
if (!File.Exists(soundFilePath))
{
MelonLogger.Error("[LightFlicker] Place 'lightflicker.wav' in: " + Path.GetDirectoryName(soundFilePath));
}
Harmony val = new Harmony("LightFlicker");
Dictionary<string, string> dictionary = new Dictionary<string, string>
{
{ "Actor", "Eliminate" },
{ "HealthTracker", "Kill" },
{ "ActorDeathAudio", "OnBeastDeath" },
{ "BreakJointsOnDeath", "OnDeath" }
};
foreach (Assembly item in from a in AppDomain.CurrentDomain.GetAssemblies()
where ((ReadOnlySpan<string>)new string[4] { "Il2CppAssembly-CSharp", "Il2CppFemur", "Il2CppGB", "Assembly-CSharp" }).Contains(a.GetName().Name)
select a)
{
try
{
Type[] types = item.GetTypes();
foreach (Type type in types)
{
if (type == null || !dictionary.ContainsKey(type.Name))
{
continue;
}
string methodTarget = dictionary[type.Name];
foreach (MethodInfo item2 in from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
where m.Name == methodTarget && !m.IsGenericMethod
select m)
{
try
{
HarmonyMethod val2 = new HarmonyMethod(typeof(LightFlickerMod).GetMethod((type.Name == "Actor") ? "OnActorEliminatedPostfix" : "OnGenericDeathPostfix"));
val.Patch((MethodBase)item2, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
MelonLogger.Msg("[LightFlicker] Patched " + type.Name + "." + methodTarget);
}
catch
{
}
}
}
}
catch
{
}
}
}
public override void OnLateInitializeMelon()
{
if (File.Exists(soundFilePath))
{
deathClip = LoadWavFile(soundFilePath);
}
}
private static AudioClip LoadWavFile(string filePath)
{
try
{
byte[] array = File.ReadAllBytes(filePath);
if (array.Length < 44)
{
return null;
}
int num = 12;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
int num6 = 0;
while (num < array.Length - 8)
{
char c = (char)array[num];
string text = c.ToString();
c = (char)array[num + 1];
string text2 = c.ToString();
c = (char)array[num + 2];
string text3 = c.ToString();
c = (char)array[num + 3];
string text4 = text + text2 + text3 + c;
int num7 = BitConverter.ToInt32(array, num + 4);
num += 8;
if (num + num7 > array.Length)
{
break;
}
if (text4 == "fmt ")
{
num2 = BitConverter.ToInt16(array, num + 2);
num3 = BitConverter.ToInt32(array, num + 4);
num4 = BitConverter.ToInt16(array, num + 14);
}
else if (text4 == "data")
{
num5 = num;
num6 = num7;
break;
}
num += num7;
}
if (num5 == 0 || num6 == 0 || num2 == 0)
{
return null;
}
int num8 = num6 / (num4 / 8);
float[] array2 = new float[num8];
for (int i = 0; i < num8; i++)
{
switch (num4)
{
case 16:
array2[i] = (float)BitConverter.ToInt16(array, num5 + i * 2) / 32768f;
break;
case 24:
{
int num9 = num5 + i * 3;
int num10 = array[num9] | (array[num9 + 1] << 8) | (array[num9 + 2] << 16);
if (((uint)num10 & 0x800000u) != 0)
{
num10 |= -16777216;
}
array2[i] = (float)num10 / 8388608f;
break;
}
case 32:
array2[i] = BitConverter.ToSingle(array, num5 + i * 4);
break;
case 8:
array2[i] = (float)(array[num5 + i] - 128) / 128f;
break;
}
}
AudioClip obj = AudioClip.Create("LightFlickerSound", num8 / num2, num2, num3, false);
obj.SetData(Il2CppStructArray<float>.op_Implicit(array2), 0);
((Object)obj).hideFlags = (HideFlags)52;
return obj;
}
catch (Exception ex)
{
MelonLogger.Error("[LightFlicker] WAV Error: " + ex.Message);
return null;
}
}
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
{
isMapActive = AllowedMaps.Any((string map) => sceneName.ToLower().Contains(map));
isFlickering = false;
if (isMapActive)
{
MelonCoroutines.Start(DelayedCacheMapLights());
return;
}
cachedMapLights.Clear();
lightRenderers.Clear();
}
[IteratorStateMachine(typeof(<DelayedCacheMapLights>d__17))]
private static IEnumerator DelayedCacheMapLights()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <DelayedCacheMapLights>d__17(0);
}
private static void CacheMapLights()
{
//IL_00d9: 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)
try
{
cachedMapLights.Clear();
lightRenderers.Clear();
originalEmissionColors.Clear();
originalEmissionKeywords.Clear();
originalBaseColors.Clear();
cachedMapLights.AddRange(((IEnumerable<Light>)Resources.FindObjectsOfTypeAll<Light>()).Where(delegate(Light l)
{
//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)
object obj3;
if (l == null)
{
obj3 = null;
}
else
{
GameObject gameObject2 = ((Component)l).gameObject;
if (gameObject2 == null)
{
obj3 = null;
}
else
{
Scene scene2 = gameObject2.scene;
obj3 = ((Scene)(ref scene2)).name;
}
}
return obj3 != null;
}));
foreach (Renderer item in ((IEnumerable<Renderer>)Resources.FindObjectsOfTypeAll<Renderer>()).Where(delegate(Renderer r)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
Renderer obj = r;
object obj2;
if (obj == null)
{
obj2 = null;
}
else
{
GameObject gameObject = ((Component)obj).gameObject;
if (gameObject == null)
{
obj2 = null;
}
else
{
Scene scene = gameObject.scene;
obj2 = ((Scene)(ref scene)).name;
}
}
return obj2 != null && LightKeywords.Any((string k) => ((Object)((Component)r).gameObject).name.ToLower().Contains(k) || ((Object)(object)r.sharedMaterial != (Object)null && ((Object)r.sharedMaterial).name.ToLower().Contains(k)));
}))
{
Material material = item.material;
if (!((Object)(object)material != (Object)null))
{
continue;
}
bool flag = false;
if (material.HasProperty("_EmissionColor"))
{
lightRenderers.Add(item);
originalEmissionColors[item] = material.GetColor("_EmissionColor");
originalEmissionKeywords[item] = material.IsKeywordEnabled("_EMISSION");
flag = true;
}
string text = (material.HasProperty("_BaseColor") ? "_BaseColor" : (material.HasProperty("_Color") ? "_Color" : null));
if (text != null)
{
if (!flag)
{
lightRenderers.Add(item);
}
originalBaseColors[item] = material.GetColor(text);
}
}
MelonLogger.Msg($"[LightFlicker] Cached {cachedMapLights.Count} lights & {lightRenderers.Count} meshes.");
}
catch (Exception ex)
{
MelonLogger.Error("[LightFlicker] Cache Error: " + ex.Message);
}
}
public static void OnPlayerDeath(Vector3 position)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
if (isMapActive && !(Time.time - lastTriggerTime < 0.15f))
{
lastTriggerTime = Time.time;
Play3DSound(position);
TriggerFlicker();
}
}
private static void Play3DSound(Vector3 position)
{
if ((Object)(object)deathClip == (Object)null || ((Object)(object)activeSource != (Object)null && activeSource.isPlaying))
{
return;
}
try
{
if (!((Object)(object)Camera.main == (Object)null))
{
activeSource = ((Component)Camera.main).gameObject.AddComponent<AudioSource>();
activeSource.clip = deathClip;
AudioMixerGroup val = ((IEnumerable<AudioMixerGroup>)Resources.FindObjectsOfTypeAll<AudioMixerGroup>()).FirstOrDefault((Func<AudioMixerGroup, bool>)((AudioMixerGroup g) => (Object)(object)g != (Object)null && ((Object)g).name.Equals("Vocals", StringComparison.OrdinalIgnoreCase)));
if ((Object)(object)val != (Object)null)
{
activeSource.outputAudioMixerGroup = val;
}
activeSource.spatialBlend = 1f;
activeSource.volume = 0.75f;
activeSource.minDistance = 100f;
activeSource.maxDistance = 1000f;
activeSource.rolloffMode = (AudioRolloffMode)0;
activeSource.Play();
Object.Destroy((Object)(object)activeSource, deathClip.length + 0.5f);
}
}
catch (Exception ex)
{
MelonLogger.Error("[LightFlicker] PlayAudio Error: " + ex.Message);
}
}
private static void TriggerFlicker()
{
if (!isFlickering)
{
if (cachedMapLights.Count == 0)
{
CacheMapLights();
}
cachedMapLights.RemoveAll((Light l) => (Object)(object)l == (Object)null);
lightRenderers.RemoveAll((Renderer r) => (Object)(object)r == (Object)null);
if (cachedMapLights.Count > 0)
{
MelonCoroutines.Start(FlickerRoutine(cachedMapLights));
}
}
}
private static void SetRendererColor(Renderer r, bool restore)
{
//IL_00e0: 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_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)r == (Object)null || (Object)(object)r.material == (Object)null)
{
return;
}
Material material = r.material;
string text = (material.HasProperty("_BaseColor") ? "_BaseColor" : (material.HasProperty("_Color") ? "_Color" : null));
if (text != null && originalBaseColors.ContainsKey(r))
{
material.SetColor(text, restore ? originalBaseColors[r] : Color.black);
}
if (!material.HasProperty("_EmissionColor"))
{
return;
}
if (restore)
{
if (originalEmissionColors.ContainsKey(r))
{
material.SetColor("_EmissionColor", originalEmissionColors[r]);
}
if (originalEmissionKeywords.ContainsKey(r) && originalEmissionKeywords[r])
{
material.EnableKeyword("_EMISSION");
}
else
{
material.DisableKeyword("_EMISSION");
}
}
else
{
material.SetColor("_EmissionColor", Color.black);
material.DisableKeyword("_EMISSION");
}
}
[IteratorStateMachine(typeof(<FlickerRoutine>d__23))]
private static IEnumerator FlickerRoutine(List<Light> lights)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <FlickerRoutine>d__23(0)
{
lights = lights
};
}
private static void TriggerDeath(object instance)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
Component val = (Component)((instance is Component) ? instance : null);
if (val != null)
{
OnPlayerDeath(val.transform.position);
}
}
public static void OnActorEliminatedPostfix(object __instance)
{
TriggerDeath(__instance);
}
public static void OnGenericDeathPostfix(object __instance)
{
TriggerDeath(__instance);
}
}
}
