using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
[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("SchizophreniaMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SchizophreniaMod")]
[assembly: AssemblyTitle("SchizophreniaMod")]
[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.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace SchizophreniaMod
{
[BepInPlugin("com.tibby.schizophrenia", "Schizophrenia Mod", "1.1.0")]
public class SchizophreniaBase : BaseUnityPlugin
{
public static ManualLogSource mls;
private void Awake()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
mls = Logger.CreateLogSource("SchizoDebug");
new Harmony("com.tibby.schizophrenia").PatchAll();
mls.LogWarning((object)"=== SCHIZOPHRENIA MOD v1.1.0 LOADED ===");
mls.LogInfo((object)"Audio hallucination system initialized.");
}
}
public static class AudioClipDatabase
{
public static readonly HashSet<string> Blacklist = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{
"SnareFleaTipChannel", "SlimeIdle", "NutcrackerVentCrawl", "GhostlySynth2", "CrawlerDie", "SpiderDie", "NutcrackerDie", "StingrayDie", "BushWolfDie", "KillCaveDweller",
"BugDie", "SporeDamage", "SporeDamageB", "SporeDamageC", "SporeDamageD", "PlantSpores", "HangPlayerOnCeiling", "ClingToPlayerLocal", "LradBrainwashingSignal1", "LradBrainwashingSignal4",
"LradBrainwashingSignal6", "LradBrainwashingSignal7", "LradBrainwashingSignal8", "KillPlayerSpring", "MaskComedyAttach", "JackInTheBoxTheme"
};
public static readonly Dictionary<string, string[]> EnemyClipPatterns = new Dictionary<string, string[]>
{
{
"Centipede",
new string[3] { "centipedewalk", "clingto", "snarebuildup" }
},
{
"Bunker Spider",
new string[8] { "spiderattack", "spiderhit", "stunspider", "hitweb", "breakweb", "spoolinplayerweb", "clickingmandibles", "stuckweb" }
},
{
"HoarderBug",
new string[4] { "hoarderbugcry", "chitter", "bugwalk", "takeitems" }
},
{
"Flowerman",
new string[3] { "flowerman", "bracken", "crackneck" }
},
{
"Crawler",
new string[6] { "hitcrawler", "stuncrawler", "chargeforward", "startchargeforward", "longroar", "shortroar" }
},
{
"Puffer",
new string[4] { "puffsfx", "frighten", "rattletail", "hiss" }
},
{
"Jester",
new string[5] { "jesterstomp", "pop1", "chatteringteeth", "icecreamtruck", "turncrank" }
},
{
"DressGirl",
new string[6] { "monsternoise", "phonescream", "breathe1", "ghostlysynth", "wallrumblevoice", "voicecry" }
},
{
"Spring",
new string[4] { "spring1", "spring2", "spring3", "springwobble" }
},
{
"Nutcracker",
new string[6] { "nutcrackerangry", "nutcrackerhiteye", "nutcrackerturn", "headgoup", "hitmetal", "shotgunreloadnutcracker" }
},
{
"Butler",
new string[7] { "butlerstab", "butlerblowup", "butlersuitrustle", "butlerbeeswarm", "butlerstep", "butleruntuckknife", "butlermurdertheme" }
},
{
"Masked",
new string[5] { "maskattackplayer", "maskfacelightup", "maskpuke", "maskcry", "masklaugh" }
},
{
"Hygrodere",
new string[5] { "walkslime", "hitslime", "slimekillplayer", "slimeangry", "slimedance" }
},
{
"Barber",
new string[2] { "scissorssnip", "scissors" }
},
{
"Maneater",
new string[7] { "babycry", "babypuke", "babysquirm", "babyfootstep", "cavedweller", "chewmeat", "biteplay" }
}
};
public static readonly Dictionary<string, string[]> MoonIndoorEnemies = new Dictionary<string, string[]>
{
{
"experimentation",
new string[9] { "Bunker Spider", "Centipede", "Hygrodere", "HoarderBug", "Puffer", "Crawler", "Flowerman", "DressGirl", "Nutcracker" }
},
{
"assurance",
new string[11]
{
"Centipede", "HoarderBug", "Bunker Spider", "Hygrodere", "Crawler", "Maneater", "Flowerman", "Puffer", "Barber", "DressGirl",
"Nutcracker"
}
},
{
"vow",
new string[10] { "Flowerman", "HoarderBug", "Maneater", "Centipede", "Bunker Spider", "Hygrodere", "Puffer", "Barber", "Crawler", "Spring" }
},
{
"offense",
new string[10] { "Crawler", "Bunker Spider", "Hygrodere", "Centipede", "Spring", "HoarderBug", "Puffer", "Maneater", "Flowerman", "Nutcracker" }
},
{
"march",
new string[11]
{
"Crawler", "Bunker Spider", "Flowerman", "Centipede", "HoarderBug", "Hygrodere", "Spring", "Puffer", "Maneater", "Nutcracker",
"Jester"
}
},
{
"adamance",
new string[13]
{
"Bunker Spider", "Centipede", "HoarderBug", "Hygrodere", "Flowerman", "Puffer", "Crawler", "Spring", "Maneater", "Nutcracker",
"Masked", "DressGirl", "Jester"
}
},
{
"rend",
new string[12]
{
"Nutcracker", "Jester", "Flowerman", "Bunker Spider", "Spring", "Centipede", "Masked", "DressGirl", "Butler", "Barber",
"Puffer", "Hygrodere"
}
},
{
"dine",
new string[13]
{
"Butler", "Barber", "Flowerman", "Centipede", "Hygrodere", "HoarderBug", "Jester", "Nutcracker", "Spring", "DressGirl",
"Crawler", "Puffer", "Maneater"
}
},
{
"titan",
new string[12]
{
"Jester", "Nutcracker", "Flowerman", "Bunker Spider", "Spring", "Crawler", "Centipede", "HoarderBug", "Masked", "Hygrodere",
"DressGirl", "Puffer"
}
},
{
"artifice",
new string[15]
{
"Bunker Spider", "Flowerman", "Nutcracker", "HoarderBug", "Crawler", "Jester", "Butler", "Puffer", "Masked", "Spring",
"Centipede", "Hygrodere", "Barber", "DressGirl", "Maneater"
}
},
{
"embrion",
new string[10] { "HoarderBug", "Hygrodere", "Barber", "Puffer", "Crawler", "Spring", "Bunker Spider", "Nutcracker", "Centipede", "Flowerman" }
}
};
public static string[] GetIndoorEnemiesForMoon(string planetName)
{
string text = planetName.ToLower();
foreach (KeyValuePair<string, string[]> moonIndoorEnemy in MoonIndoorEnemies)
{
if (text.Contains(moonIndoorEnemy.Key))
{
return moonIndoorEnemy.Value;
}
}
return EnemyClipPatterns.Keys.ToArray();
}
}
public class GhostAudioMover : MonoBehaviour
{
[CompilerGenerated]
private sealed class <MoveRoutine>d__1 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public AudioSource src;
public Vector3 dir;
public float speed;
public float dur;
public GhostAudioMover <>4__this;
private float <elapsed>5__1;
private float <startVol>5__2;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <MoveRoutine>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//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)
//IL_0077: 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_0086: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<elapsed>5__1 = 0f;
<startVol>5__2 = (((Object)(object)src != (Object)null) ? src.volume : 0f);
break;
case 1:
<>1__state = -1;
break;
}
if (<elapsed>5__1 < dur && (Object)(object)src != (Object)null)
{
Transform transform = ((Component)<>4__this).transform;
transform.position += dir * speed * Time.deltaTime;
if (<elapsed>5__1 > dur * 0.8f)
{
src.volume = Mathf.Lerp(<startVol>5__2, 0f, (<elapsed>5__1 - dur * 0.8f) / (dur * 0.2f));
}
<elapsed>5__1 += Time.deltaTime;
<>2__current = null;
<>1__state = 1;
return true;
}
Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
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();
}
}
public void Initialize(AudioSource src, Vector3 dir, float speed, float dur)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
((MonoBehaviour)this).StartCoroutine(MoveRoutine(src, dir, speed, dur));
}
[IteratorStateMachine(typeof(<MoveRoutine>d__1))]
private IEnumerator MoveRoutine(AudioSource src, Vector3 dir, float speed, float dur)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <MoveRoutine>d__1(0)
{
<>4__this = this,
src = src,
dir = dir,
speed = speed,
dur = dur
};
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
public class PlayerSchizoPatch
{
private static float timer = 0f;
private static bool isSystemActive = false;
private static float activationCountdown = 120f;
private static bool countdownExpired = false;
private static float countdownLogTimer = 0f;
private static readonly Dictionary<ulong, float> PlayerCooldowns = new Dictionary<ulong, float>();
private const float COOLDOWN_DURATION = 18f;
private static List<(AudioClip clip, string enemyName)> _cachedClips = null;
private static string _lastPlanetName = "";
private static Dictionary<string, Dictionary<string, int>> PlayerHallucinationStats = new Dictionary<string, Dictionary<string, int>>();
[HarmonyPostfix]
private static void Postfix(PlayerControllerB __instance)
{
if (!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled)
{
return;
}
ulong playerClientId = __instance.playerClientId;
if (PlayerCooldowns.TryGetValue(playerClientId, out var value) && value > 0f)
{
PlayerCooldowns[playerClientId] = Mathf.Max(0f, value - Time.deltaTime);
}
if ((Object)(object)StartOfRound.Instance == (Object)null || !StartOfRound.Instance.shipHasLanded)
{
if (isSystemActive)
{
ResetSystem();
}
return;
}
SelectableLevel currentLevel = StartOfRound.Instance.currentLevel;
if (currentLevel.levelID == 3 || currentLevel.PlanetName.ToLower().Contains("gordion"))
{
if (isSystemActive)
{
ResetSystem();
}
return;
}
if (!isSystemActive)
{
if (StartOfRound.Instance.allPlayerScripts.Any((PlayerControllerB p) => p.isPlayerControlled && p.isInsideFactory))
{
isSystemActive = true;
SchizophreniaBase.mls.LogWarning((object)"!!! [SYSTEM ACTIVE] A player entered the facility !!!");
return;
}
if (!countdownExpired)
{
activationCountdown -= Time.deltaTime;
countdownLogTimer -= Time.deltaTime;
if (countdownLogTimer <= 0f)
{
countdownLogTimer = 10f;
}
if (activationCountdown <= 0f)
{
activationCountdown = 0f;
countdownExpired = true;
isSystemActive = true;
SchizophreniaBase.mls.LogWarning((object)"!!! [SYSTEM ACTIVE] 120s countdown expired !!!");
}
}
if (!isSystemActive)
{
return;
}
}
if (__instance.isInsideFactory && !__instance.isInHangarShipRoom)
{
timer += Time.deltaTime;
if (timer >= 1f)
{
timer = 0f;
ProcessLogic(__instance);
}
}
}
private static void ResetSystem()
{
PrintRoundSummary();
isSystemActive = false;
activationCountdown = 120f;
countdownExpired = false;
countdownLogTimer = 0f;
PlayerCooldowns.Clear();
PlayerHallucinationStats.Clear();
_cachedClips = null;
_lastPlanetName = "";
}
private static void ProcessLogic(PlayerControllerB player)
{
ulong playerClientId = player.playerClientId;
if (!PlayerCooldowns.TryGetValue(playerClientId, out var value) || !(value > 0f))
{
float num = Mathf.Clamp(player.insanityLevel / 50f, 0f, 1f);
float num2 = 0.0015f + num * 0.0015f;
float num3 = CalculateWeight(player);
float num4 = num2 * num3;
float value2 = Random.value;
if (value2 < num4)
{
PlaySchizoAudio(player);
}
}
}
private static float CalculateWeight(PlayerControllerB player)
{
return StartOfRound.Instance.allPlayerScripts.Count((PlayerControllerB p) => (Object)(object)p != (Object)(object)player && !p.isPlayerDead && p.isPlayerControlled && p.isInsideFactory && Vector3.Distance(((Component)player).transform.position, ((Component)p).transform.position) < 15f) switch
{
0 => 2f,
1 => 1f,
_ => 0.5f,
};
}
private static void PlaySchizoAudio(PlayerControllerB player)
{
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: 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_00e6: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Expected O, but got Unknown
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
SelectableLevel val = StartOfRound.Instance?.currentLevel;
if ((Object)(object)val == (Object)null)
{
return;
}
string planetName = val.PlanetName;
if (_cachedClips == null || _lastPlanetName != planetName)
{
_lastPlanetName = planetName;
_cachedClips = BuildClipCache(planetName, val);
}
if (_cachedClips.Count != 0)
{
(AudioClip, string) tuple = _cachedClips[Random.Range(0, _cachedClips.Count)];
AudioClip item = tuple.Item1;
string item2 = tuple.Item2;
float num = Random.Range(15f, 25f);
Vector3 position = ((Component)player).transform.position;
Vector3 val2 = Random.insideUnitSphere;
Vector3 val3 = position + ((Vector3)(ref val2)).normalized * num;
NavMeshHit val4 = default(NavMeshHit);
Vector3 val5 = (NavMesh.SamplePosition(val3, ref val4, 10f, -1) ? ((NavMeshHit)(ref val4)).position : val3);
GameObject val6 = new GameObject("SchizoGhost");
val6.transform.position = val5;
AudioSource val7 = val6.AddComponent<AudioSource>();
val7.spatialize = false;
val7.spatialBlend = 1f;
val7.rolloffMode = (AudioRolloffMode)1;
val7.minDistance = 10f;
val7.maxDistance = 40f;
val7.volume = 0.8f;
val7.clip = item;
AudioMixerGroup val8 = ((IEnumerable<AudioMixerGroup>)Resources.FindObjectsOfTypeAll<AudioMixerGroup>()).FirstOrDefault((Func<AudioMixerGroup, bool>)((AudioMixerGroup g) => ((Object)g).name == "Master"));
if ((Object)(object)val8 != (Object)null)
{
val7.outputAudioMixerGroup = val8;
}
val2 = val5 - ((Component)player).transform.position;
Vector3 normalized = ((Vector3)(ref val2)).normalized;
val6.AddComponent<GhostAudioMover>().Initialize(val7, normalized, 3f, item.length);
if (!PlayerHallucinationStats.ContainsKey(player.playerUsername))
{
PlayerHallucinationStats[player.playerUsername] = new Dictionary<string, int>();
}
if (!PlayerHallucinationStats[player.playerUsername].ContainsKey(item2))
{
PlayerHallucinationStats[player.playerUsername][item2] = 0;
}
PlayerHallucinationStats[player.playerUsername][item2]++;
val7.Play();
PlayerCooldowns[player.playerClientId] = 18f;
}
}
private static List<(AudioClip, string)> BuildClipCache(string planetName, SelectableLevel level)
{
List<(AudioClip, string)> list = new List<(AudioClip, string)>();
string[] indoorEnemiesForMoon = AudioClipDatabase.GetIndoorEnemiesForMoon(planetName);
AudioClip[] array = Resources.FindObjectsOfTypeAll<AudioClip>();
HashSet<string> hashSet = new HashSet<string>();
AudioClip[] array2 = array;
foreach (AudioClip val in array2)
{
if ((Object)(object)val == (Object)null || val.length < 0.1f || AudioClipDatabase.Blacklist.Contains(((Object)val).name))
{
continue;
}
string clipLower = ((Object)val).name.ToLower();
foreach (KeyValuePair<string, string[]> enemyClipPattern in AudioClipDatabase.EnemyClipPatterns)
{
string key = enemyClipPattern.Key;
if (!indoorEnemiesForMoon.Contains(key) || !enemyClipPattern.Value.Any((string pattern) => clipLower.Contains(pattern)))
{
continue;
}
string item = key + "_" + ((Object)val).name;
if (hashSet.Add(item))
{
list.Add((val, key));
}
break;
}
}
if ((Object)(object)level != (Object)null)
{
HashSet<string> hashSet2 = new HashSet<string>(list.Select(((AudioClip, string) r) => r.Item2));
string[] array3 = indoorEnemiesForMoon;
foreach (string enemyKey in array3)
{
if (hashSet2.Contains(enemyKey))
{
continue;
}
EnemyType val2 = level.Enemies.Select((SpawnableEnemyWithRarity e) => e.enemyType).FirstOrDefault((Func<EnemyType, bool>)((EnemyType e) => (Object)(object)e != (Object)null && e.enemyName != null && AudioClipDatabase.EnemyClipPatterns.ContainsKey(enemyKey) && (e.enemyName.Contains(enemyKey) || enemyKey.Contains(e.enemyName) || NameMatchesKey(e.enemyName, enemyKey))));
if ((Object)(object)val2 == (Object)null || val2.audioClips == null || val2.audioClips.Length == 0)
{
continue;
}
int num = 0;
AudioClip[] audioClips = val2.audioClips;
foreach (AudioClip val3 in audioClips)
{
if (!((Object)(object)val3 == (Object)null) && !(val3.length < 0.1f) && !AudioClipDatabase.Blacklist.Contains(((Object)val3).name))
{
string item2 = enemyKey + "_" + ((Object)val3).name;
if (hashSet.Add(item2))
{
list.Add((val3, enemyKey));
num++;
}
}
}
}
}
return list;
}
private static bool NameMatchesKey(string enemyName, string enemyKey)
{
if (enemyName == null || enemyKey == null)
{
return false;
}
string text = enemyName.ToLower().Replace(" ", "").Replace("-", "");
string text2 = enemyKey.ToLower().Replace(" ", "").Replace("-", "");
if (text == text2)
{
return true;
}
return text2 switch
{
"hoarderbug" => text.Contains("hoarding") || text.Contains("hoarder"),
"centipede" => text.Contains("centipede") || text.Contains("snare"),
"flowerman" => text.Contains("flowerman") || text.Contains("bracken"),
"crawler" => text.Contains("crawler") || text.Contains("thumper"),
"puffer" => text.Contains("puffer") || text.Contains("spore"),
"dressgirl" => text.Contains("dressgirl") || text.Contains("girl"),
"spring" => text.Contains("spring") || text.Contains("coil"),
"hygrodere" => text.Contains("hygrodere") || text.Contains("blob") || text.Contains("slime"),
"maneater" => text.Contains("maneater") || text.Contains("cavedweller") || text.Contains("cave"),
"bunker spider" => text.Contains("spider") || text.Contains("bunker"),
_ => text.Contains(text2) || text2.Contains(text),
};
}
private static void PrintRoundSummary()
{
if (PlayerHallucinationStats.Count == 0)
{
return;
}
SchizophreniaBase.mls.LogWarning((object)"========================================");
SchizophreniaBase.mls.LogWarning((object)" HALLUCINATION SUMMARY");
SchizophreniaBase.mls.LogWarning((object)"========================================");
foreach (KeyValuePair<string, Dictionary<string, int>> item in PlayerHallucinationStats.OrderBy((KeyValuePair<string, Dictionary<string, int>> x) => x.Key))
{
IOrderedEnumerable<KeyValuePair<string, int>> source = item.Value.OrderByDescending((KeyValuePair<string, int> x) => x.Value);
int num = source.Sum((KeyValuePair<string, int> x) => x.Value);
string text = string.Join(", ", source.Select((KeyValuePair<string, int> x) => $"{x.Value}x {x.Key}"));
SchizophreniaBase.mls.LogWarning((object)(" " + item.Key + ": " + text));
SchizophreniaBase.mls.LogWarning((object)$" Total: {num} hallucination(s)");
}
SchizophreniaBase.mls.LogWarning((object)"========================================");
}
}
}
