Пример #1
0
        public void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
        {
            if (!Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) || !Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.BypassTeslaGates))
            {
                return;
            }
            SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];

            if (Tracking.PlayerJustBypassedTeslaGate(ev.Player)) // The triggering tesla happens a lot, this allows the bypass to last 3 seconds.
            {
                ev.IsTriggerable = false;
                return;
            }
            if (Tracking.OnCooldown(ev.Player, AbilityType.BypassTeslaGates, subClass))
            {
                Tracking.DisplayCooldown(ev.Player, AbilityType.BypassTeslaGates, subClass, "bypass tesla gates", Time.time);
            }
            else
            {
                Log.Debug($"Player with subclass {Tracking.PlayersWithSubclasses[ev.Player].Name} has been allowed to bypass tesla gate", Subclass.Instance.Config.Debug);
                Tracking.AddCooldown(ev.Player, AbilityType.BypassTeslaGates);
                if (!Tracking.PlayersThatBypassedTeslaGates.ContainsKey(ev.Player))
                {
                    Tracking.PlayersThatBypassedTeslaGates.Add(ev.Player, 0);
                }
                Tracking.PlayersThatBypassedTeslaGates[ev.Player] = Time.time;
                ev.IsTriggerable = false;
                //ev.Player.IsUsingStamina = false;
            }
        }
Пример #2
0
 public void OnUnlockingGenerator(UnlockingGeneratorEventArgs ev)
 {
     if (ev.IsAllowed)
     {
         return;
     }
     if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) &&
         Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.BypassKeycardReaders))
     {
         SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
         if (Tracking.OnCooldown(ev.Player, AbilityType.BypassKeycardReaders, subClass))
         {
             Tracking.DisplayCooldown(ev.Player, AbilityType.BypassKeycardReaders, subClass, "bypass keycard readers", Time.time);
         }
         else
         {
             Log.Debug($"Player with subclass {Tracking.PlayersWithSubclasses[ev.Player].Name} has been allowed to access locked locker", Subclass.Instance.Config.Debug);
             Tracking.AddCooldown(ev.Player, AbilityType.BypassKeycardReaders);
             ev.IsAllowed = true;
         }
     }
 }
Пример #3
0
 public void OnInteractingDoor(InteractingDoorEventArgs ev)
 {
     if (ev.Door.doorType == Door.DoorTypes.HeavyGate)
     {
         if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player))
         {
             SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
             if (subClass.Abilities.Contains(AbilityType.PryGates))
             {
                 if (Tracking.OnCooldown(ev.Player, AbilityType.PryGates, subClass))
                 {
                     Tracking.DisplayCooldown(ev.Player, AbilityType.PryGates, subClass, "pry gates", Time.time);
                 }
                 else
                 {
                     Tracking.AddCooldown(ev.Player, AbilityType.PryGates);
                     ev.Door.PryGate();
                 }
             }
         }
     }
     else if (!ev.IsAllowed && !ev.Door.Networkdestroyed && !ev.Door.Networklocked && Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) &&
              Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.BypassKeycardReaders))
     {
         SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
         if (Tracking.OnCooldown(ev.Player, AbilityType.BypassKeycardReaders, subClass))
         {
             Tracking.DisplayCooldown(ev.Player, AbilityType.BypassKeycardReaders, subClass, "bypass keycard readers", Time.time);
         }
         else
         {
             Log.Debug($"Player with subclass {Tracking.PlayersWithSubclasses[ev.Player].Name} has been allowed to access door with permission level {ev.Door.PermissionLevels}", Subclass.Instance.Config.Debug);
             Tracking.AddCooldown(ev.Player, AbilityType.BypassKeycardReaders);
             ev.IsAllowed = true;
         }
     }
 }
Пример #4
0
        public void AttemptRevive(SendingConsoleCommandEventArgs ev, SubClass subClass, bool necro = false)
        {
            Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} attempt", Subclass.Instance.Config.Debug);
            AbilityType ability = necro ? AbilityType.Necromancy : AbilityType.Revive;

            if (Tracking.OnCooldown(ev.Player, ability, subClass))
            {
                Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} on cooldown", Subclass.Instance.Config.Debug);
                Tracking.DisplayCooldown(ev.Player, necro ? AbilityType.Necromancy : AbilityType.Revive, subClass, necro ? "necromancy" : "revive", Time.time);
                return;
            }

            List <Collider> colliders = Physics.OverlapSphere(ev.Player.Position, 3f).Where(e => e.gameObject.GetComponentInParent <Ragdoll>() != null).ToList();

            colliders.Sort((Collider x, Collider y) =>
            {
                return(Vector3.Distance(x.gameObject.transform.position, ev.Player.Position).CompareTo(Vector3.Distance(y.gameObject.transform.position, ev.Player.Position)));
            });

            if (colliders.Count == 0)
            {
                ev.ReturnMessage = "You must be near a dead body to use this command";
                ev.Player.Broadcast(2, "You must be near a dead body.");
                Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} overlap did not hit a ragdoll", Subclass.Instance.Config.Debug);
                return;
            }

            Ragdoll doll = colliders[0].gameObject.GetComponentInParent <Ragdoll>();

            if (doll.owner == null)
            {
                Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} failed", Subclass.Instance.Config.Debug);
                ev.ReturnMessage = "This player is not revivable.";
                ev.Player.Broadcast(2, "This player is not revivable.");
                return;
            }

            EPlayer owner = EPlayer.Get(colliders[0].gameObject.GetComponentInParent <Ragdoll>().owner.PlayerId);

            if (owner != null && !owner.IsAlive)
            {
                if (!necro && Tracking.GetPreviousTeam(owner) != null &&
                    Tracking.GetPreviousTeam(owner) == ev.Player.Team)
                {
                    owner.Role = (RoleType)Tracking.GetPreviousRole(owner);
                }
                else if (necro)
                {
                    owner.Role = RoleType.Scp0492;
                    Tracking.AddZombie(ev.Player, owner);
                    owner.IsFriendlyFireEnabled = true;
                }
                if (owner.Role != RoleType.Spectator)
                {
                    Timing.CallDelayed(0.2f, () =>
                    {
                        owner.Position = colliders[0].gameObject.transform.position + new Vector3(0, 1f, 0);
                    });
                    UnityEngine.Object.DestroyImmediate(doll.gameObject, true);
                    Tracking.AddCooldown(ev.Player, ability);
                    Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} succeeded", Subclass.Instance.Config.Debug);
                }
                else
                {
                    Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} failed", Subclass.Instance.Config.Debug);
                    ev.ReturnMessage = "This player is not revivable.";
                    ev.Player.Broadcast(2, "This player is not revivable.");
                }
            }
            else
            {
                Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} failed", Subclass.Instance.Config.Debug);
                ev.ReturnMessage = "This player is not revivable.";
                ev.Player.Broadcast(2, "This player is not revivable.");
            }
        }
Пример #5
0
        public void OnSendingConsoleCommand(SendingConsoleCommandEventArgs ev)
        {
            Log.Debug($"Player {ev.Player.Nickname} sent a console command", Subclass.Instance.Config.Debug);
            ev.IsAllowed = false;
            switch (ev.Name)
            {
            case "revive":
                Log.Debug($"Player {ev.Player.Nickname} is attempting to revive", Subclass.Instance.Config.Debug);
                if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) && Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.Revive))
                {
                    SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
                    AttemptRevive(ev, subClass);
                }
                else
                {
                    ev.ReturnMessage = "You don't have the ability to revive!";
                }
                break;

            case "necro":
                Log.Debug($"Player {ev.Player.Nickname} is attempting to necro", Subclass.Instance.Config.Debug);
                if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) && Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.Necromancy))
                {
                    SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
                    AttemptRevive(ev, subClass, true);
                }
                else
                {
                    ev.ReturnMessage = "You don't have the ability to necro!";
                }
                break;

            case "locate":
                if (ev.Player.Role != RoleType.Scp93953 && ev.Player.Role != RoleType.Scp93989 &&
                    (!Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) ||
                     !Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.Scp939Vision)))
                {
                    Log.Debug($"Player {ev.Player.Nickname} failed to echolocate", Subclass.Instance.Config.Debug);
                    ev.ReturnMessage = "You must be SCP-939 or have a subclass with its visuals to use this command";
                    return;
                }

                if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) && Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.Echolocate))
                {
                    SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
                    if (Tracking.OnCooldown(ev.Player, AbilityType.Echolocate, subClass))
                    {
                        Log.Debug($"Player {ev.Player.Nickname} failed to echolocate", Subclass.Instance.Config.Debug);
                        Tracking.DisplayCooldown(ev.Player, AbilityType.Echolocate, subClass, "echolocation", Time.time);
                        return;
                    }

                    Collider[] colliders = Physics.OverlapSphere(ev.Player.Position, subClass.FloatOptions.ContainsKey("EcholocateRadius") ? subClass.FloatOptions["EcholocateRadius"] : 10f);

                    foreach (Collider PlayerCollider in colliders.Where(c => EPlayer.Get(c.gameObject) != null))
                    {
                        EPlayer.Get(PlayerCollider.gameObject).ReferenceHub.footstepSync?.CmdScp939Noise(100f);
                    }

                    Tracking.AddCooldown(ev.Player, AbilityType.Echolocate);
                    Log.Debug($"Player {ev.Player.Nickname} successfully used echolocate", Subclass.Instance.Config.Debug);
                }
                break;

            case "noclip":
                Log.Debug($"Player {ev.Player.Nickname} is attempting to noclip", Subclass.Instance.Config.Debug);
                if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) && Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.NoClip))
                {
                    SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
                    if (Tracking.OnCooldown(ev.Player, AbilityType.NoClip, subClass))
                    {
                        Log.Debug($"Player {ev.Player.Nickname} failed to noclip - cooldown", Subclass.Instance.Config.Debug);
                        Tracking.DisplayCooldown(ev.Player, AbilityType.NoClip, subClass, "noclip", Time.time);
                        return;
                    }
                    bool previous = ev.Player.NoClipEnabled;
                    ev.Player.NoClipEnabled = !ev.Player.NoClipEnabled;
                    Tracking.AddCooldown(ev.Player, AbilityType.NoClip);
                    if (subClass.FloatOptions.ContainsKey("NoClipTime"))
                    {
                        Timing.CallDelayed(subClass.FloatOptions["NoClipTime"], () =>
                        {
                            if (ev.Player.NoClipEnabled != previous)
                            {
                                ev.Player.NoClipEnabled = previous;
                            }
                        });
                    }
                    Log.Debug($"Player {ev.Player.Nickname} successfully noclipped", Subclass.Instance.Config.Debug);
                }
                else
                {
                    ev.ReturnMessage = "You must have the noclip ability to use this command";
                    Log.Debug($"Player {ev.Player.Nickname} could not noclip", Subclass.Instance.Config.Debug);
                }
                break;

            case "flash":
                if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) && Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.FlashOnCommand))
                {
                    SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];
                    if (Tracking.OnCooldown(ev.Player, AbilityType.FlashOnCommand, subClass))
                    {
                        Log.Debug($"Player {ev.Player.Nickname} failed to flash on command", Subclass.Instance.Config.Debug);
                        Tracking.DisplayCooldown(ev.Player, AbilityType.FlashOnCommand, subClass, "flash", Time.time);
                        return;
                    }

                    // Credit to KoukoCocoa's AdminTools for the grenade spawn script below, I was lost. https://github.com/KoukoCocoa/AdminTools/
                    GrenadeManager  grenadeManager = ev.Player.ReferenceHub.gameObject.GetComponent <GrenadeManager>();
                    GrenadeSettings settings       = grenadeManager.availableGrenades.FirstOrDefault(g => g.inventoryID == ItemType.GrenadeFlash);
                    Grenade         grenade        = UnityEngine.Object.Instantiate(settings.grenadeInstance).GetComponent <Grenade>();
                    grenade.fuseDuration = subClass.FloatOptions.ContainsKey("FlashOnCommandFuseTimer") ? subClass.FloatOptions["FlashOnCommandFuseTimer"] : 0.3f;
                    grenade.FullInitData(grenadeManager, ev.Player.Position, Quaternion.Euler(grenade.throwStartAngle),
                                         grenade.throwLinearVelocityOffset, grenade.throwAngularVelocity);
                    NetworkServer.Spawn(grenade.gameObject);
                    Tracking.AddCooldown(ev.Player, AbilityType.FlashOnCommand);
                    Log.Debug($"Player {ev.Player.Nickname} successfully used flash on commad", Subclass.Instance.Config.Debug);
                }
                else
                {
                    ev.ReturnMessage = "You must have the flash on command ability to use this command";
                    Log.Debug($"Player {ev.Player.Nickname} could not flash on command", Subclass.Instance.Config.Debug);
                }
                break;

            case "invis":
                if (!Tracking.PlayersWithSubclasses.ContainsKey(ev.Player) || !Tracking.PlayersWithSubclasses[ev.Player].Abilities.Contains(AbilityType.InvisibleOnCommand))
                {
                    ev.ReturnMessage = "You must have the invisible on command ability to use this command";
                    Log.Debug($"Player {ev.Player.Nickname} could not go invisible on command", Subclass.Instance.Config.Debug);
                    return;
                }
                Scp268 scp268 = ev.Player.ReferenceHub.playerEffectsController.GetEffect <Scp268>();
                if (scp268 != null)
                {
                    SubClass subClass = Tracking.PlayersWithSubclasses[ev.Player];

                    if (scp268.Enabled)
                    {
                        Log.Debug($"Player {ev.Player.Nickname} failed to go invisible on command", Subclass.Instance.Config.Debug);
                        ev.Player.Broadcast(3, "You're already invisible!");
                        return;
                    }

                    if (Tracking.OnCooldown(ev.Player, AbilityType.InvisibleOnCommand, subClass))
                    {
                        Log.Debug($"Player {ev.Player.Nickname} failed to go invisible on command", Subclass.Instance.Config.Debug);
                        Tracking.DisplayCooldown(ev.Player, AbilityType.InvisibleOnCommand, subClass, "invisible", Time.time);
                        return;
                    }

                    //scp268.Duration = subClass.FloatOptions.ContainsKey("InvisibleOnCommandDuration") ?
                    //    subClass.FloatOptions["InvisibleOnCommandDuration"]*2f : 30f*2f;

                    //ev.Player.ReferenceHub.playerEffectsController.EnableEffect(scp268);

                    ev.Player.ReferenceHub.playerEffectsController.EnableEffect <Scp268>();
                    Tracking.PlayersInvisibleByCommand.Add(ev.Player);
                    Timing.CallDelayed(subClass.FloatOptions.ContainsKey("InvisibleOnCommandDuration") ?
                                       subClass.FloatOptions["InvisibleOnCommandDuration"] : 30f, () => {
                        if (Tracking.PlayersInvisibleByCommand.Contains(ev.Player))
                        {
                            Tracking.PlayersInvisibleByCommand.Remove(ev.Player);
                        }
                        if (scp268.Enabled)
                        {
                            ev.Player.ReferenceHub.playerEffectsController.DisableEffect <Scp268>();
                        }
                    });

                    Tracking.AddCooldown(ev.Player, AbilityType.InvisibleOnCommand);
                }
                break;

            default:
                ev.IsAllowed = true;
                break;
            }
        }