zoom, death checks, improvements

EBro912 · EBro912 · commit 4548998f5eaa · 2024-01-08T23:02:34.000-05:00
diff --git a/Inputs.cs b/Inputs.cs
@@ -13,5 +13,11 @@ internal class Inputs : LcInputActions
 
         [InputAction("<Mouse>/rightButton", Name = "Toggle Flashlight")]
         public InputAction FlashlightKey { get; set; }
+
+        [InputAction("<Mouse>/scroll/down", Name = "Zoom Out")]
+        public InputAction ZoomOutKey { get; set; }
+
+        [InputAction("<Mouse>/scroll/up", Name = "Zoom In")]
+        public InputAction ZoomInKey { get; set; }
     }
 }
diff --git a/Patches/EnemyAI_Patches.cs b/Patches/EnemyAI_Patches.cs
@@ -9,6 +9,7 @@ private static void Postfix(EnemyAI __instance)
         {
             Spectatable s = __instance.gameObject.AddComponent<Spectatable>();
             s.enemyName = __instance.enemyType.enemyName;
+            s.enemyInstance = __instance;
         }
     }
 }
diff --git a/Patches/HUDManager_Patches.cs b/Patches/HUDManager_Patches.cs
@@ -28,8 +28,14 @@ private static void Postfix(HUDManager __instance)
                     string swapKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.SwapKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);
                     string menuKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.MenuKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);
                     string flashlightKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.FlashlightKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);
+                    string zoomOutKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.ZoomOutKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);
+                    string zoomInKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.ZoomInKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);
                     // who needs to change the y position when u can just \n: sunglasses:
-                    __instance.holdButtonToEndGameEarlyText.text += $"\n\n\n\n\nSwitch to {(SpectateEnemies.Instance.SpectatingEnemies ? "Players" : "Enemies")}: [{swapKey}]\nToggle Flashlight : [{flashlightKey}] (Click)\nConfig Menu : [{menuKey}]";
+                    if (SpectateEnemies.Instance.SpectatingEnemies)
+                        __instance.holdButtonToEndGameEarlyText.text += $"\n\n\n\n\nSpectate Players: [{swapKey}]\nFlashlight : [{flashlightKey}]\nZoom Out [{zoomOutKey}]\nZoom In [{zoomInKey}]\nConfig Menu : [{menuKey}]";
+                    else
+                        __instance.holdButtonToEndGameEarlyText.text += $"\n\n\n\n\nSpectate Enemies: [{swapKey}]\nFlashlight : [{flashlightKey}]\nConfig Menu : [{menuKey}]";
+
                 }
             }
         }
diff --git a/Patches/MaskedPlayerEnemy_Patches.cs b/Patches/MaskedPlayerEnemy_Patches.cs
@@ -15,6 +15,7 @@ private static void Postfix(MaskedPlayerEnemy __instance)
             {
                 s.maskedName = __instance.mimickingPlayer.playerUsername;
             }
+            s.enemyInstance = __instance;
         }
     }
 }
diff --git a/Patches/QuickMenuManager_Patches.cs b/Patches/QuickMenuManager_Patches.cs
@@ -12,7 +12,7 @@ private static void Postfix(QuickMenuManager __instance)
             {
                 GameObject obj = new("SpectateEnemiesObject");
                 SpectateEnemies spec = obj.AddComponent<SpectateEnemies>();
-                spec.PopulateSettings(__instance.testAllEnemiesLevel);
+                spec.PopulateSettings();
             }
         }
     }
diff --git a/Spectatable.cs b/Spectatable.cs
@@ -1,4 +1,5 @@
-﻿using UnityEngine;
+﻿using System;
+using UnityEngine;
 
 namespace SpectateEnemy
 {
@@ -7,6 +8,7 @@ internal class Spectatable : MonoBehaviour
         public SpectatableType type = SpectatableType.Enemy;
         public string enemyName = "Enemy";
         public string maskedName = string.Empty;
+        public EnemyAI enemyInstance = null;
     }
 
     internal enum SpectatableType
diff --git a/SpectateEnemies.cs b/SpectateEnemies.cs
@@ -17,11 +17,12 @@ internal class SpectateEnemies : MonoBehaviour
         private static readonly Dictionary<string, bool> settings = [];
 
         private bool WindowOpen = false;
-        private Rect window = new(10, 10, 500, 300);
+        private Rect window = new(10, 10, 500, 400);
 
         public int SpectatedEnemyIndex = -1;
         public bool SpectatingEnemies = false;
         public Spectatable[] SpectatorList;
+        public float zoomLevel = 1f;
 
         private void Awake()
         {
@@ -39,6 +40,8 @@ private void SetupKeybinds()
             Plugin.Inputs.SwapKey.performed += OnSwapKeyPressed;
             Plugin.Inputs.MenuKey.performed += OnMenuKeyPressed;
             Plugin.Inputs.FlashlightKey.performed += OnFlashlightKeyPressed;
+            Plugin.Inputs.ZoomOutKey.performed += OnZoomOutPressed;
+            Plugin.Inputs.ZoomInKey.performed += OnZoomInPressed;
         }
 
         private void OnSwapKeyPressed(InputAction.CallbackContext context)
@@ -85,6 +88,24 @@ private void OnFlashlightKeyPressed(InputAction.CallbackContext context)
             }  
         }
 
+        private void OnZoomOutPressed(InputAction.CallbackContext context)
+        {
+            if (!context.performed) return;
+            if (!SpectatingEnemies) return;
+            zoomLevel += 0.1f;
+            if (zoomLevel > 10f)
+                zoomLevel = 10f;
+        }
+
+        private void OnZoomInPressed(InputAction.CallbackContext context)
+        {
+            if (!context.performed) return;
+            if (!SpectatingEnemies) return;
+            zoomLevel -= 0.1f;
+            if (zoomLevel < 1f)
+                zoomLevel = 1f;
+        }
+
         private void LateUpdate()
         {
             if (SpectatingEnemies)
@@ -94,17 +115,20 @@ private void LateUpdate()
                     SpectatingEnemies = false;
                     return;
                 }
-                if (SpectatedEnemyIndex >= SpectatorList.Length)
-                {
-                    GetNextValidSpectatable();
-                    return;
-                }
                 Spectatable currentEnemy = SpectatorList.ElementAtOrDefault(SpectatedEnemyIndex);
                 if (currentEnemy == null)
                 {
                     GetNextValidSpectatable();
                     return;
                 }
+                if (currentEnemy.type == SpectatableType.Enemy || currentEnemy.type == SpectatableType.Masked)
+                {
+                    if (currentEnemy.enemyInstance != null && currentEnemy.enemyInstance.isEnemyDead)
+                    {
+                        GetNextValidSpectatable();
+                        return;
+                    }
+                }
                 Vector3? position = GetSpectatePosition(currentEnemy);
                 if (!position.HasValue)
                 {
@@ -115,20 +139,20 @@ private void LateUpdate()
                 {
                     TryFixName(ref currentEnemy);
                 }
-                HUDManager.Instance.localPlayer.spectateCameraPivot.position = position.Value + GetZoomDistance(currentEnemy);
+                GameNetworkManager.Instance.localPlayerController.spectateCameraPivot.position = position.Value + Vector3.up * zoomLevel;
                 if (currentEnemy.type == SpectatableType.Masked && currentEnemy.maskedName != string.Empty)
-                    HUDManager.Instance.spectatingPlayerText.text = "(Spectating: " + currentEnemy.maskedName + ")";
+                    HUDManager.Instance.spectatingPlayerText.text = string.Format("(Spectating: {0}) [{1:F1}x]", currentEnemy.maskedName, zoomLevel);
                 else
-                    HUDManager.Instance.spectatingPlayerText.text = "(Spectating: " + currentEnemy.enemyName + ")";
-                Plugin.raycastSpectate.Invoke(HUDManager.Instance.localPlayer, []);
+                    HUDManager.Instance.spectatingPlayerText.text = string.Format("(Spectating: {0}) [{1:F1}x]", currentEnemy.enemyName, zoomLevel);
+                Plugin.raycastSpectate.Invoke(GameNetworkManager.Instance.localPlayerController, []);
             }
         }
 
         private Vector3? GetSpectatePosition(Spectatable obj)
         {
             if (obj.type == SpectatableType.Enemy || obj.type == SpectatableType.Masked)
             {
-                EnemyAI enemy = obj.GetComponent<EnemyAI>();
+                EnemyAI enemy = obj.enemyInstance;
                 if (enemy != null)
                 {
                     return enemy.eye == null ? enemy.transform.position : enemy.eye.position;
@@ -153,16 +177,6 @@ private void LateUpdate()
             return null;
         }
 
-        private Vector3 GetZoomDistance(Spectatable obj)
-        {
-            if (obj.enemyName == "ForestGiant")
-                return Vector3.up * 3;
-            if (obj.enemyName == "MouthDog" || obj.enemyName == "Jester")
-                return Vector3.up * 2;
-            else
-                return Vector3.up;
-        }
-
         private void TryFixName(ref Spectatable obj)
         {
             if (obj.gameObject.TryGetComponent(out MaskedPlayerEnemy masked))
@@ -195,7 +209,7 @@ public void ToggleSpectatingMode(PlayerControllerB __instance)
             SpectatingEnemies = !SpectatingEnemies;
             if (SpectatingEnemies)
             {
-                SpectatorList = FindObjectsByType<Spectatable>(FindObjectsSortMode.None);
+                SpectatorList = FindObjectsByType<Spectatable>(FindObjectsSortMode.None).Where(x => settings[x.enemyName]).ToArray();
                 if (SpectatorList.Length == 0)
                 {
                     SpectatingEnemies = false;
@@ -210,17 +224,11 @@ public void ToggleSpectatingMode(PlayerControllerB __instance)
                     }
                     else
                     {
-                        List<Spectatable> matches = SpectatorList.Where(x => settings[x.enemyName]).ToList();
-                        if (matches.Count == 0)
-                        {
-                            Plugin.displaySpectatorTip.Invoke(HUDManager.Instance, ["No enemies to spectate"]);
-                            return;
-                        }
                         float closest = 999999f;
                         int index = 0;
-                        for (int i = 0; i < matches.Count; i++)
+                        for (int i = 0; i < SpectatorList.Length; i++)
                         {
-                            float dist = (matches[i].transform.position - __instance.spectatedPlayerScript.transform.position).sqrMagnitude;
+                            float dist = (SpectatorList[i].transform.position - __instance.spectatedPlayerScript.transform.position).sqrMagnitude;
                             if (dist < closest * closest)
                             {
                                 closest = dist;
@@ -230,36 +238,25 @@ public void ToggleSpectatingMode(PlayerControllerB __instance)
                         SpectatedEnemyIndex = index;
                     }
                 }
-                else
-                {
-                    if (!settings[SpectatorList[SpectatedEnemyIndex].enemyName])
-                    {
-                        GetNextValidSpectatable();
-                    }
-                }
                 __instance.spectatedPlayerScript = null;
             }
             else
             {
                 __instance.spectatedPlayerScript = __instance.playersManager.allPlayerScripts.FirstOrDefault(x => !x.isPlayerDead && x.isPlayerControlled);
-                HUDManager.Instance.spectatingPlayerText.text = "(Spectating: " + __instance.spectatedPlayerScript.playerUsername + ")";
+                HUDManager.Instance.spectatingPlayerText.text = $"(Spectating: {__instance.spectatedPlayerScript.playerUsername})";
             }
         }
 
-        public void PopulateSettings(SelectableLevel level)
+        public void PopulateSettings()
         {
-            foreach (SpawnableEnemyWithRarity t in level.Enemies)
-            {
-                settings.TryAdd(t.enemyType.enemyName, true);
-            }
-            foreach (SpawnableEnemyWithRarity t in level.OutsideEnemies)
+            EnemyType[] allEnemies = Resources.FindObjectsOfTypeAll<EnemyType>();
+            foreach (EnemyType type in allEnemies)
             {
-                settings.TryAdd(t.enemyType.enemyName, true);
-            }
-            foreach (SpawnableEnemyWithRarity t in level.DaytimeEnemies)
-            {
-                settings.TryAdd(t.enemyType.enemyName, false);
+                if (type.enemyName == "Red pill" || type.enemyName == "Lasso")
+                    continue;
+                settings.TryAdd(type.enemyName, !type.isDaytimeEnemy);
             }
+
             settings.TryAdd("Landmine", false);
             settings.TryAdd("Turret", false);
 
@@ -278,9 +275,10 @@ public void PopulateSettings(SelectableLevel level)
                     {
                         string[] c = s.Split(':');
                         if (c.Length != 2) continue;
-                        if (settings.ContainsKey(c[0]))
+                        if (settings.ContainsKey(c[0])) {
                             if (bool.TryParse(c[1], out bool value))
                                 settings[c[0]] = value;
+                        }
                     }
                     Debug.LogWarning("[SpectateEnemies]: Config loaded");
                 }
@@ -292,9 +290,9 @@ public void PopulateSettings(SelectableLevel level)
             catch (Exception)
             {
                 Debug.LogWarning("[SpectateEnemies]: Config failed to load, using default values!");
-            }
+            } 
 
-            // AssertSettings();
+            AssertSettings();
         }
 
         private void OnApplicationQuit()
@@ -324,6 +322,7 @@ public bool SpectateNextEnemy()
 
         private void GetNextValidSpectatable()
         {
+            SpectatorList = FindObjectsByType<Spectatable>(FindObjectsSortMode.None).Where(x => settings[x.enemyName]).ToArray();
             int enemiesChecked = 0;
             int current = SpectatedEnemyIndex;
             while (enemiesChecked < SpectatorList.Length)
@@ -333,10 +332,21 @@ private void GetNextValidSpectatable()
                 {
                     current = 0;
                 }
-                if (settings[SpectatorList[current].enemyName])
+                Spectatable enemy = SpectatorList.ElementAtOrDefault(current);
+                if (enemy != null)
                 {
-                    SpectatedEnemyIndex = current;
-                    return;
+                    if (enemy.type == SpectatableType.Enemy || enemy.type == SpectatableType.Masked)
+                    {
+                        if (enemy.enemyInstance != null && enemy.enemyInstance.isEnemyDead)
+                        {
+                            continue;
+                        }
+                    }
+                    if (settings.ContainsKey(enemy.enemyName))
+                    {
+                        SpectatedEnemyIndex = current;
+                        return;
+                    }
                 }
                 enemiesChecked++;
             }
diff --git a/SpectateEnemy.csproj b/SpectateEnemy.csproj
@@ -4,7 +4,7 @@
     <TargetFramework>netstandard2.1</TargetFramework>
     <AssemblyName>SpectateEnemy</AssemblyName>
     <Description>My first plugin</Description>
-    <Version>2.0.0</Version>
+    <Version>2.2.0</Version>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <LangVersion>latest</LangVersion>
     <RestoreAdditionalProjectSources>
@@ -30,6 +30,9 @@
     <Reference Include="Assembly-CSharp">
       <HintPath>F:\SteamLibrary\steamapps\common\Lethal Company\Lethal Company_Data\Managed\Assembly-CSharp.dll</HintPath>
     </Reference>
+    <Reference Include="LethalCompanyInputUtils">
+      <HintPath>F:\SteamLibrary\steamapps\common\Lethal Company\BepInEx\plugins\LethalCompanyInputUtils.dll</HintPath>
+    </Reference>
     <Reference Include="Unity.InputSystem">
       <HintPath>F:\SteamLibrary\steamapps\common\Lethal Company\Lethal Company_Data\Managed\Unity.InputSystem.dll</HintPath>
     </Reference>

Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,11 @@ internal class Inputs : LcInputActions`
`13`	`13`
`14`	`14`	`[InputAction("<Mouse>/rightButton", Name = "Toggle Flashlight")]`
`15`	`15`	`public InputAction FlashlightKey { get; set; }`
	`16`	`+`
	`17`	`+ [InputAction("<Mouse>/scroll/down", Name = "Zoom Out")]`
	`18`	`+ public InputAction ZoomOutKey { get; set; }`
	`19`	`+`
	`20`	`+ [InputAction("<Mouse>/scroll/up", Name = "Zoom In")]`
	`21`	`+ public InputAction ZoomInKey { get; set; }`
`16`	`22`	`}`
`17`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ private static void Postfix(EnemyAI __instance)`
`9`	`9`	`{`
`10`	`10`	`Spectatable s = __instance.gameObject.AddComponent<Spectatable>();`
`11`	`11`	`s.enemyName = __instance.enemyType.enemyName;`
	`12`	`+ s.enemyInstance = __instance;`
`12`	`13`	`}`
`13`	`14`	`}`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,8 +28,14 @@ private static void Postfix(HUDManager __instance)`
`28`	`28`	`string swapKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.SwapKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);`
`29`	`29`	`string menuKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.MenuKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);`
`30`	`30`	`string flashlightKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.FlashlightKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);`
	`31`	`+ string zoomOutKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.ZoomOutKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);`
	`32`	`+ string zoomInKey = InputControlPath.ToHumanReadableString(Plugin.Inputs.ZoomInKey.bindings[0].effectivePath, InputControlPath.HumanReadableStringOptions.OmitDevice);`
`31`	`33`	`// who needs to change the y position when u can just \n: sunglasses:`
`32`		`- __instance.holdButtonToEndGameEarlyText.text += $"\n\n\n\n\nSwitch to {(SpectateEnemies.Instance.SpectatingEnemies ? "Players" : "Enemies")}: [{swapKey}]\nToggle Flashlight : [{flashlightKey}] (Click)\nConfig Menu : [{menuKey}]";`
	`34`	`+ if (SpectateEnemies.Instance.SpectatingEnemies)`
	`35`	`+ __instance.holdButtonToEndGameEarlyText.text += $"\n\n\n\n\nSpectate Players: [{swapKey}]\nFlashlight : [{flashlightKey}]\nZoom Out [{zoomOutKey}]\nZoom In [{zoomInKey}]\nConfig Menu : [{menuKey}]";`
	`36`	`+ else`
	`37`	`+ __instance.holdButtonToEndGameEarlyText.text += $"\n\n\n\n\nSpectate Enemies: [{swapKey}]\nFlashlight : [{flashlightKey}]\nConfig Menu : [{menuKey}]";`
	`38`	`+`
`33`	`39`	`}`
`34`	`40`	`}`
`35`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ private static void Postfix(MaskedPlayerEnemy __instance)`
`15`	`15`	`{`
`16`	`16`	`s.maskedName = __instance.mimickingPlayer.playerUsername;`
`17`	`17`	`}`
	`18`	`+ s.enemyInstance = __instance;`
`18`	`19`	`}`
`19`	`20`	`}`
`20`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ private static void Postfix(QuickMenuManager __instance)`
`12`	`12`	`{`
`13`	`13`	`GameObject obj = new("SpectateEnemiesObject");`
`14`	`14`	`SpectateEnemies spec = obj.AddComponent<SpectateEnemies>();`
`15`		`- spec.PopulateSettings(__instance.testAllEnemiesLevel);`
	`15`	`+ spec.PopulateSettings();`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using UnityEngine;`
	`1`	`+using System;`
	`2`	`+using UnityEngine;`
`2`	`3`
`3`	`4`	`namespace SpectateEnemy`
`4`	`5`	`{`
`@@ -7,6 +8,7 @@ internal class Spectatable : MonoBehaviour`
`7`	`8`	`public SpectatableType type = SpectatableType.Enemy;`
`8`	`9`	`public string enemyName = "Enemy";`
`9`	`10`	`public string maskedName = string.Empty;`
	`11`	`+ public EnemyAI enemyInstance = null;`
`10`	`12`	`}`
`11`	`13`
`12`	`14`	`internal enum SpectatableType`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,12 @@ internal class SpectateEnemies : MonoBehaviour`
`17`	`17`	`private static readonly Dictionary<string, bool> settings = [];`
`18`	`18`
`19`	`19`	`private bool WindowOpen = false;`
`20`		`- private Rect window = new(10, 10, 500, 300);`
	`20`	`+ private Rect window = new(10, 10, 500, 400);`
`21`	`21`
`22`	`22`	`public int SpectatedEnemyIndex = -1;`
`23`	`23`	`public bool SpectatingEnemies = false;`
`24`	`24`	`public Spectatable[] SpectatorList;`
	`25`	`+ public float zoomLevel = 1f;`
`25`	`26`
`26`	`27`	`private void Awake()`
`27`	`28`	`{`
`@@ -39,6 +40,8 @@ private void SetupKeybinds()`
`39`	`40`	`Plugin.Inputs.SwapKey.performed += OnSwapKeyPressed;`
`40`	`41`	`Plugin.Inputs.MenuKey.performed += OnMenuKeyPressed;`
`41`	`42`	`Plugin.Inputs.FlashlightKey.performed += OnFlashlightKeyPressed;`
	`43`	`+ Plugin.Inputs.ZoomOutKey.performed += OnZoomOutPressed;`
	`44`	`+ Plugin.Inputs.ZoomInKey.performed += OnZoomInPressed;`
`42`	`45`	`}`
`43`	`46`
`44`	`47`	`private void OnSwapKeyPressed(InputAction.CallbackContext context)`
`@@ -85,6 +88,24 @@ private void OnFlashlightKeyPressed(InputAction.CallbackContext context)`
`85`	`88`	`}`
`86`	`89`	`}`
`87`	`90`
	`91`	`+ private void OnZoomOutPressed(InputAction.CallbackContext context)`
	`92`	`+ {`
	`93`	`+ if (!context.performed) return;`
	`94`	`+ if (!SpectatingEnemies) return;`
	`95`	`+ zoomLevel += 0.1f;`
	`96`	`+ if (zoomLevel > 10f)`
	`97`	`+ zoomLevel = 10f;`
	`98`	`+ }`
	`99`	`+`
	`100`	`+ private void OnZoomInPressed(InputAction.CallbackContext context)`
	`101`	`+ {`
	`102`	`+ if (!context.performed) return;`
	`103`	`+ if (!SpectatingEnemies) return;`
	`104`	`+ zoomLevel -= 0.1f;`
	`105`	`+ if (zoomLevel < 1f)`
	`106`	`+ zoomLevel = 1f;`
	`107`	`+ }`
	`108`	`+`
`88`	`109`	`private void LateUpdate()`
`89`	`110`	`{`
`90`	`111`	`if (SpectatingEnemies)`
`@@ -94,17 +115,20 @@ private void LateUpdate()`
`94`	`115`	`SpectatingEnemies = false;`
`95`	`116`	`return;`
`96`	`117`	`}`
`97`		`- if (SpectatedEnemyIndex >= SpectatorList.Length)`
`98`		`- {`
`99`		`- GetNextValidSpectatable();`
`100`		`- return;`
`101`		`- }`
`102`	`118`	`Spectatable currentEnemy = SpectatorList.ElementAtOrDefault(SpectatedEnemyIndex);`
`103`	`119`	`if (currentEnemy == null)`
`104`	`120`	`{`
`105`	`121`	`GetNextValidSpectatable();`
`106`	`122`	`return;`
`107`	`123`	`}`
	`124`	`+ if (currentEnemy.type == SpectatableType.Enemy \|\| currentEnemy.type == SpectatableType.Masked)`
	`125`	`+ {`
	`126`	`+ if (currentEnemy.enemyInstance != null && currentEnemy.enemyInstance.isEnemyDead)`
	`127`	`+ {`
	`128`	`+ GetNextValidSpectatable();`
	`129`	`+ return;`
	`130`	`+ }`
	`131`	`+ }`
`108`	`132`	`Vector3? position = GetSpectatePosition(currentEnemy);`
`109`	`133`	`if (!position.HasValue)`
`110`	`134`	`{`
`@@ -115,20 +139,20 @@ private void LateUpdate()`
`115`	`139`	`{`
`116`	`140`	`TryFixName(ref currentEnemy);`
`117`	`141`	`}`
`118`		`- HUDManager.Instance.localPlayer.spectateCameraPivot.position = position.Value + GetZoomDistance(currentEnemy);`
	`142`	`+ GameNetworkManager.Instance.localPlayerController.spectateCameraPivot.position = position.Value + Vector3.up * zoomLevel;`
`119`	`143`	`if (currentEnemy.type == SpectatableType.Masked && currentEnemy.maskedName != string.Empty)`
`120`		`- HUDManager.Instance.spectatingPlayerText.text = "(Spectating: " + currentEnemy.maskedName + ")";`
	`144`	`+ HUDManager.Instance.spectatingPlayerText.text = string.Format("(Spectating: {0}) [{1:F1}x]", currentEnemy.maskedName, zoomLevel);`
`121`	`145`	`else`
`122`		`- HUDManager.Instance.spectatingPlayerText.text = "(Spectating: " + currentEnemy.enemyName + ")";`
`123`		`- Plugin.raycastSpectate.Invoke(HUDManager.Instance.localPlayer, []);`
	`146`	`+ HUDManager.Instance.spectatingPlayerText.text = string.Format("(Spectating: {0}) [{1:F1}x]", currentEnemy.enemyName, zoomLevel);`
	`147`	`+ Plugin.raycastSpectate.Invoke(GameNetworkManager.Instance.localPlayerController, []);`
`124`	`148`	`}`
`125`	`149`	`}`
`126`	`150`
`127`	`151`	`private Vector3? GetSpectatePosition(Spectatable obj)`
`128`	`152`	`{`
`129`	`153`	`if (obj.type == SpectatableType.Enemy \|\| obj.type == SpectatableType.Masked)`
`130`	`154`	`{`
`131`		`- EnemyAI enemy = obj.GetComponent<EnemyAI>();`
	`155`	`+ EnemyAI enemy = obj.enemyInstance;`
`132`	`156`	`if (enemy != null)`
`133`	`157`	`{`
`134`	`158`	`return enemy.eye == null ? enemy.transform.position : enemy.eye.position;`
`@@ -153,16 +177,6 @@ private void LateUpdate()`
`153`	`177`	`return null;`
`154`	`178`	`}`
`155`	`179`
`156`		`- private Vector3 GetZoomDistance(Spectatable obj)`
`157`		`- {`
`158`		`- if (obj.enemyName == "ForestGiant")`
`159`		`- return Vector3.up * 3;`
`160`		`- if (obj.enemyName == "MouthDog" \|\| obj.enemyName == "Jester")`
`161`		`- return Vector3.up * 2;`
`162`		`- else`
`163`		`- return Vector3.up;`
`164`		`- }`
`165`		`-`
`166`	`180`	`private void TryFixName(ref Spectatable obj)`
`167`	`181`	`{`
`168`	`182`	`if (obj.gameObject.TryGetComponent(out MaskedPlayerEnemy masked))`
`@@ -195,7 +209,7 @@ public void ToggleSpectatingMode(PlayerControllerB __instance)`
`195`	`209`	`SpectatingEnemies = !SpectatingEnemies;`
`196`	`210`	`if (SpectatingEnemies)`
`197`	`211`	`{`
`198`		`- SpectatorList = FindObjectsByType<Spectatable>(FindObjectsSortMode.None);`
	`212`	`+ SpectatorList = FindObjectsByType<Spectatable>(FindObjectsSortMode.None).Where(x => settings[x.enemyName]).ToArray();`
`199`	`213`	`if (SpectatorList.Length == 0)`
`200`	`214`	`{`
`201`	`215`	`SpectatingEnemies = false;`
`@@ -210,17 +224,11 @@ public void ToggleSpectatingMode(PlayerControllerB __instance)`
`210`	`224`	`}`
`211`	`225`	`else`
`212`	`226`	`{`
`213`		`- List<Spectatable> matches = SpectatorList.Where(x => settings[x.enemyName]).ToList();`
`214`		`- if (matches.Count == 0)`
`215`		`- {`
`216`		`- Plugin.displaySpectatorTip.Invoke(HUDManager.Instance, ["No enemies to spectate"]);`
`217`		`- return;`
`218`		`- }`
`219`	`227`	`float closest = 999999f;`
`220`	`228`	`int index = 0;`
`221`		`- for (int i = 0; i < matches.Count; i++)`
	`229`	`+ for (int i = 0; i < SpectatorList.Length; i++)`
`222`	`230`	`{`
`223`		`- float dist = (matches[i].transform.position - __instance.spectatedPlayerScript.transform.position).sqrMagnitude;`
	`231`	`+ float dist = (SpectatorList[i].transform.position - __instance.spectatedPlayerScript.transform.position).sqrMagnitude;`
`224`	`232`	`if (dist < closest * closest)`
`225`	`233`	`{`
`226`	`234`	`closest = dist;`
`@@ -230,36 +238,25 @@ public void ToggleSpectatingMode(PlayerControllerB __instance)`
`230`	`238`	`SpectatedEnemyIndex = index;`
`231`	`239`	`}`
`232`	`240`	`}`
`233`		`- else`
`234`		`- {`
`235`		`- if (!settings[SpectatorList[SpectatedEnemyIndex].enemyName])`
`236`		`- {`
`237`		`- GetNextValidSpectatable();`
`238`		`- }`
`239`		`- }`
`240`	`241`	`__instance.spectatedPlayerScript = null;`
`241`	`242`	`}`
`242`	`243`	`else`
`243`	`244`	`{`
`244`	`245`	`__instance.spectatedPlayerScript = __instance.playersManager.allPlayerScripts.FirstOrDefault(x => !x.isPlayerDead && x.isPlayerControlled);`
`245`		`- HUDManager.Instance.spectatingPlayerText.text = "(Spectating: " + __instance.spectatedPlayerScript.playerUsername + ")";`
	`246`	`+ HUDManager.Instance.spectatingPlayerText.text = $"(Spectating: {__instance.spectatedPlayerScript.playerUsername})";`
`246`	`247`	`}`
`247`	`248`	`}`
`248`	`249`
`249`		`- public void PopulateSettings(SelectableLevel level)`
	`250`	`+ public void PopulateSettings()`
`250`	`251`	`{`
`251`		`- foreach (SpawnableEnemyWithRarity t in level.Enemies)`
`252`		`- {`
`253`		`- settings.TryAdd(t.enemyType.enemyName, true);`
`254`		`- }`
`255`		`- foreach (SpawnableEnemyWithRarity t in level.OutsideEnemies)`
	`252`	`+ EnemyType[] allEnemies = Resources.FindObjectsOfTypeAll<EnemyType>();`
	`253`	`+ foreach (EnemyType type in allEnemies)`
`256`	`254`	`{`
`257`		`- settings.TryAdd(t.enemyType.enemyName, true);`
`258`		`- }`
`259`		`- foreach (SpawnableEnemyWithRarity t in level.DaytimeEnemies)`
`260`		`- {`
`261`		`- settings.TryAdd(t.enemyType.enemyName, false);`
	`255`	`+ if (type.enemyName == "Red pill" \|\| type.enemyName == "Lasso")`
	`256`	`+ continue;`
	`257`	`+ settings.TryAdd(type.enemyName, !type.isDaytimeEnemy);`
`262`	`258`	`}`
	`259`	`+`
`263`	`260`	`settings.TryAdd("Landmine", false);`
`264`	`261`	`settings.TryAdd("Turret", false);`
`265`	`262`
`@@ -278,9 +275,10 @@ public void PopulateSettings(SelectableLevel level)`
`278`	`275`	`{`
`279`	`276`	`string[] c = s.Split(':');`
`280`	`277`	`if (c.Length != 2) continue;`
`281`		`- if (settings.ContainsKey(c[0]))`
	`278`	`+ if (settings.ContainsKey(c[0])) {`
`282`	`279`	`if (bool.TryParse(c[1], out bool value))`
`283`	`280`	`settings[c[0]] = value;`
	`281`	`+ }`
`284`	`282`	`}`
`285`	`283`	`Debug.LogWarning("[SpectateEnemies]: Config loaded");`
`286`	`284`	`}`
`@@ -292,9 +290,9 @@ public void PopulateSettings(SelectableLevel level)`
`292`	`290`	`catch (Exception)`
`293`	`291`	`{`
`294`	`292`	`Debug.LogWarning("[SpectateEnemies]: Config failed to load, using default values!");`
`295`		`- }`
	`293`	`+ }`
`296`	`294`
`297`		`- // AssertSettings();`
	`295`	`+ AssertSettings();`
`298`	`296`	`}`
`299`	`297`
`300`	`298`	`private void OnApplicationQuit()`
`@@ -324,6 +322,7 @@ public bool SpectateNextEnemy()`
`324`	`322`
`325`	`323`	`private void GetNextValidSpectatable()`
`326`	`324`	`{`
	`325`	`+ SpectatorList = FindObjectsByType<Spectatable>(FindObjectsSortMode.None).Where(x => settings[x.enemyName]).ToArray();`
`327`	`326`	`int enemiesChecked = 0;`
`328`	`327`	`int current = SpectatedEnemyIndex;`
`329`	`328`	`while (enemiesChecked < SpectatorList.Length)`
`@@ -333,10 +332,21 @@ private void GetNextValidSpectatable()`
`333`	`332`	`{`
`334`	`333`	`current = 0;`
`335`	`334`	`}`
`336`		`- if (settings[SpectatorList[current].enemyName])`
	`335`	`+ Spectatable enemy = SpectatorList.ElementAtOrDefault(current);`
	`336`	`+ if (enemy != null)`
`337`	`337`	`{`
`338`		`- SpectatedEnemyIndex = current;`
`339`		`- return;`
	`338`	`+ if (enemy.type == SpectatableType.Enemy \|\| enemy.type == SpectatableType.Masked)`
	`339`	`+ {`
	`340`	`+ if (enemy.enemyInstance != null && enemy.enemyInstance.isEnemyDead)`
	`341`	`+ {`
	`342`	`+ continue;`
	`343`	`+ }`
	`344`	`+ }`
	`345`	`+ if (settings.ContainsKey(enemy.enemyName))`
	`346`	`+ {`
	`347`	`+ SpectatedEnemyIndex = current;`
	`348`	`+ return;`
	`349`	`+ }`
`340`	`350`	`}`
`341`	`351`	`enemiesChecked++;`
`342`	`352`	`}`