Update

Author: MS-crew

Commands/CensorsInfo.cs

@@ -15,13 +15,13 @@ public class CensorsInfo : ICommand
 
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (PlayerExtensions.Scp96sCencors.Count == 0)
+            if (PlayerExtensions.Scp96Censors.Count == 0)
             {
                 response = "No active SCP-96 sensors.";
                 return true;
             }
 
-            IEnumerable<string> lines = PlayerExtensions.Scp96sCencors.Select(data =>
+            IEnumerable<string> lines = PlayerExtensions.Scp96Censors.Select(data =>
             {
                 string schematicName = data.Value?.name ?? "null";
                 return $"{data.Key.Nickname} -> {schematicName}";

Commands/ScramblesInfo.cs

@@ -15,13 +15,13 @@ public class ScramblesInfo : ICommand
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
 
-            if (ProjectSCRAMBLE.ActiveScramblePlayers.Count == 0)
+            if (ProjectSCRAMBLE.SCRAMBLE.ActiveScramblePlayers.Count == 0)
             {
                 response = "No active scramble player.";
                 return true;
             }
 
-            IEnumerable<string> lines = ProjectSCRAMBLE.ActiveScramblePlayers.Select(data =>
+            IEnumerable<string> lines = ProjectSCRAMBLE.SCRAMBLE.ActiveScramblePlayers.Select(data =>
             {
                 string mainPlayer = data.Key.Nickname;
                 List<string> scrambled = [.. data.Value.Select(p => p.Nickname)];

Configs/Config.cs

@@ -27,37 +27,53 @@ public class Config : IConfig
         [Description("How much power should the SCRAMBLEs use to obfuscate 96's face? (1 = default, >1 = faster, <1 = slower)")]
         public float ChargeUsageMultiplayer { get; set; } = 1;
 
-        [Description("Attach to head or Directl attach to player")]
+        [Description("Attach to head or Directly attach to player")]
         public bool AttachCensorToHead { get; set; } = true;
 
         [Description("0.1 is okey, 0.01 better/good , 0.001 greater")]
         public float AttachToHeadsyncInterval { get; set; } = 0.01f;
 
+#if PMER
         [Description("Censor schematic name")]
         public string CensorSchematic { get; set; } = "Censormain";
+#else
+        [Description("Rotate censor randomly")]
+        public bool CensorRotate { get; set; } = true;
+
+        [Description("Censor Color")]
+        public Color CensorColor { get; set; } = new Color(0, 0, 0, 1);
+#endif
+
+        [Description("Censor scale")]
+        public Vector3 CensorScale { get; set; } = Vector3.one * 0.5f;
 
-        [Description("Censor schematic scale")]
-        public Vector3 CensorSchematicScale { get; set; } = new Vector3(0.5f, 0.5f , 0.5f);
 
         [Description("Wearing time (default 5)")]
-        public float ActivateTime { get; set; } = 1f;
+        public bool OverrideWearingTime { get; set; } = true;
+        public float WearingTime { get; set; } = 1f;
+
 
         [Description("Removal time (default 5.1)")]
-        public float DeactivateTime { get; set; } = 1f;
+        public bool OverrideWearingOffTime { get; set; } = true;
+        public float WearingOffTime { get; set; } = 1f;
+
 
         [Description("Custom item settings")]
         public ProjectSCRAMBLE ProjectSCRAMBLE { get; set; } = new ProjectSCRAMBLE();
 
+
         [Description("Hint settings")]
         public Hints Hint { get; set; } = new Hints();
         public class Hints 
         {
-            public float XCordinate { get; set; } = 370;
             public float YCordinate { get; set; } = 90;
+#if HSM
+            public float XCordinate { get; set; } = 370;
             public int FontSize { get; set; } = 20;
 
             [Description("0 = left , 1 = right, 2 = center")]
             public int Alligment { get; set; } = 0;
+#endif
         }
     }
 }

EventHandlers.cs

@@ -1,39 +1,48 @@
-using MEC;
+using System.Linq;
+
+using MEC;
 using UnityEngine;
 using PlayerRoles;
-using System.Linq;
+using ProjectSCRAMBLE.Extensions;
+
 using Exiled.API.Enums;
 using Exiled.API.Features;
 using Exiled.API.Extensions;
-using ProjectSCRAMBLE.Extensions;
-using ProjectMER.Features.Objects;
 using Exiled.Events.EventArgs.Player;
 using Exiled.Events.EventArgs.Scp096;
+
 using Scp96Event = Exiled.Events.Handlers.Scp096;
 using PlayerEvent = Exiled.Events.Handlers.Player;
+using Scp914Event = Exiled.Events.Handlers.Scp914;
+using Exiled.Events.EventArgs.Scp914;
+
+#if PMER
+using ProjectMER.Features.Objects;
+#endif
 
 namespace ProjectSCRAMBLE
 {
     public class EventHandlers
     {
-        public void Sucsribe()
+        public void Subscribe()
         {
             PlayerEvent.Verified += OnVerified;
             PlayerEvent.Spawned += OnChangedRole;
             PlayerEvent.ReceivingEffect += OnChangeEffect;
-            
+
             Scp96Event.AddingTarget += OnAddingTarget;
         }
 
-        public void UnSucsribe()
-        {
+        public void Unsubscribe()
+        {   
             PlayerEvent.Verified -= OnVerified;
             PlayerEvent.Spawned -= OnChangedRole;
             PlayerEvent.ReceivingEffect -= OnChangeEffect;
 
             Scp96Event.AddingTarget -= OnAddingTarget;
         }
 
+
         private void OnChangedRole(SpawnedEventArgs ev)
         {
             if (ProjectSCRAMBLE.SCRAMBLE == null)
@@ -46,23 +55,29 @@ private void OnChangedRole(SpawnedEventArgs ev)
             }
             else if (ev.Player.Role == RoleTypeId.Scp096)
             {
-                Timing.CallDelayed(0.5f, () => ev.Player.AddCensor());
+                Timing.CallDelayed(0.5f, ev.Player.AddCensor);
                 Log.Debug($"Scp96:{ev.Player.Nickname} added censor");
             }
         }
 
         public void OnAddingTarget(AddingTargetEventArgs ev)
         {
-            if (!ev.IsLooking || !ProjectSCRAMBLE.ActiveScramblePlayers.ContainsKey(ev.Target))
+            if (!ev.IsLooking)
                 return;
 
-            bool shouldRandomError = Plugin.Instance.Config.RandomError && Random.Range(0f, 100f) <= Plugin.Instance.Config.RandomErrorChance;
+            if (!ProjectSCRAMBLE.SCRAMBLE.ActiveScramblePlayers.ContainsKey(ev.Target))
+                return;
+
+            Config config = Plugin.Instance.Config;
+            Translation translation = Plugin.Instance.Translation;
 
-            if (!Plugin.Instance.Config.ScrambleCharge)
+            bool shouldRandomError = config.RandomError && Random.Range(0f, 100f) <= config.RandomErrorChance;
+
+            if (!config.ScrambleCharge)
             {
                 if (shouldRandomError)
                 {
-                    ev.Target.AddSCRAMBLEHint(Plugin.Instance.Translation.Error);
+                    ev.Target.AddSCRAMBLEHint(translation.Error);
                     return;
                 }
 
@@ -71,7 +86,9 @@ public void OnAddingTarget(AddingTargetEventArgs ev)
             }
 
             ushort serial = 0;
-            foreach (var key in ev.Target.Inventory.UserInventory.Items.Keys)
+
+            var items = ev.Target.Inventory.UserInventory.Items.Keys;
+            foreach (ushort key in items)
             {
                 if (ProjectSCRAMBLE.SCRAMBLE.TrackedSerials.Contains(key))
                 {
@@ -96,31 +113,32 @@ [SCRAMBLE ERROR]
                 return;
             }
 
-            if (!ProjectSCRAMBLE.ScrambleCharges.TryGetValue(serial, out float charge))
+            if (!ProjectSCRAMBLE.SCRAMBLE.ScrambleCharges.TryGetValue(serial, out float charge))
             {
-                ProjectSCRAMBLE.ScrambleCharges[serial] = 100f;
-                ev.Target.AddSCRAMBLEHint(Plugin.Instance.Translation.Charge.Replace("{charge}", charge.FormatCharge()));
+                charge = 100f;
+                ProjectSCRAMBLE.SCRAMBLE.ScrambleCharges[serial] = charge;
+                ev.Target.AddSCRAMBLEHint(translation.Charge.Replace("{charge}", charge.FormatCharge()));
                 ev.IsAllowed = false;
                 return;
             }
 
             if (charge <= 0f)
             {
-                ev.Target.AddSCRAMBLEHint(Plugin.Instance.Translation.OffCharge);
+                ev.Target.AddSCRAMBLEHint(translation.OffCharge);
                 ev.Target.DeObfuscateScp96s();
                 return;
             }
 
-            ProjectSCRAMBLE.ScrambleCharges[serial] -= Time.deltaTime * Plugin.Instance.Config.ChargeUsageMultiplayer;
+            ProjectSCRAMBLE.SCRAMBLE.ScrambleCharges[serial] -= Time.deltaTime * config.ChargeUsageMultiplayer;
 
             if (shouldRandomError)
             {
-                ev.Target.AddSCRAMBLEHint(Plugin.Instance.Translation.Error);
-                Timing.CallDelayed(0.5f , () => ev.Target.AddSCRAMBLEHint(Plugin.Instance.Translation.Charge.Replace("{charge}", charge.FormatCharge())));
+                ev.Target.AddSCRAMBLEHint(translation.Error);
+                Timing.CallDelayed(0.5f , () => ev.Target.AddSCRAMBLEHint(translation.Charge.Replace("{charge}", charge.FormatCharge())));
                 return;
             }
 
-            ev.Target.AddSCRAMBLEHint(Plugin.Instance.Translation.Charge.Replace("{charge}", charge.FormatCharge()));
+            ev.Target.AddSCRAMBLEHint(translation.Charge.Replace("{charge}", charge.FormatCharge()));
             ev.IsAllowed = false;
         }
 
@@ -131,7 +149,7 @@ private void OnChangeEffect(ReceivingEffectEventArgs ev)
 
             ev.Player.RemoveSCRAMBLEHint();
 
-            if (!ProjectSCRAMBLE.ActiveScramblePlayers.ContainsKey(ev.Player))
+            if (!ProjectSCRAMBLE.SCRAMBLE.ActiveScramblePlayers.ContainsKey(ev.Player))
                 return;
 
             ev.Player.DeObfuscateScp96s();
@@ -140,9 +158,9 @@ private void OnChangeEffect(ReceivingEffectEventArgs ev)
 
         public void OnVerified(VerifiedEventArgs ev)
         {
-            foreach (SchematicObject schmt in PlayerExtensions.Scp96sCencors.Values)
+            foreach (GameObject censor in PlayerExtensions.Scp96Censors.Values)
             {
-                ev.Player.DestroySchematic(schmt);
+                ev.Player.HideNetworkObject(censor);
             }
         }
     }

Extensions/CommonExtensions.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+
+using Exiled.API.Features;
+
+using HarmonyLib;
+
+using MEC;
+
+using UnityEngine;
+
+using Utils.NonAllocLINQ;
+
+namespace ProjectSCRAMBLE.Extensions
+{
+    public static class CommonExtensions
+    {
+        public static string FormatCharge(this float Float) 
+        { 
+           return ((int)Float).ToString(); 
+        }
+
+        public static void PatchSingleType(this Harmony harmony, Type patchClass)
+        {
+            PatchClassProcessor processor = new(harmony, patchClass);
+            processor.Patch();
+        }
+
+        public static void AttachToTransform(this Transform thisTransform, Transform targetTransform)
+        {
+            Timing.RunCoroutine(Methods.TrackHead(thisTransform, targetTransform, Plugin.Instance.Config.AttachToHeadsyncInterval));
+        }
+
+        public static void HideForUnGlassesPlayer(this GameObject gameObject, Player CensorOwner)
+        {
+            foreach (Player normalply in Player.List)
+            {
+                if (normalply.IsHost)
+                    continue;
+
+                if (ProjectSCRAMBLE.SCRAMBLE.ActiveScramblePlayers.TryGetValue(normalply, out List<Player> scp96s))
+                {
+                    scp96s.AddIfNotContains(CensorOwner);
+                    continue;
+                }
+
+                normalply.HideNetworkObject(gameObject);
+            }
+        }
+    }
+}