public void UpdateHealths(ExplodingGrenadeEventArgs ev, string type)
{
UnityEngine.Collider[] colliders = UnityEngine.Physics.OverlapSphere(ev.Grenade.transform.position, 4);
foreach (UnityEngine.Collider collider in colliders.Where(c => c.name == "Player"))
{
EPlayer player = EPlayer.Get(collider.gameObject);
if (player != null && player.Team == ev.Thrower.Team)
{
if (TrackingAndMethods.PlayersWithSubclasses.ContainsKey(player) && TrackingAndMethods.PlayersWithSubclasses[player].Abilities.Contains(AbilityType.CantHeal))
{
return;
}
if (TrackingAndMethods.PlayersWithSubclasses[ev.Thrower].FloatOptions.ContainsKey(type))
{
if (TrackingAndMethods.PlayersWithSubclasses[ev.Thrower].FloatOptions[type] + player.Health > player.MaxHealth)
{
player.Health = player.MaxHealth;
}
else
{
player.Health += TrackingAndMethods.PlayersWithSubclasses[ev.Thrower].FloatOptions[type];
}
}
else
{
player.Health = player.MaxHealth;
}
}
}
}
private static void Prefix(ReferenceHub __instance)
{
try
{
var player = PlayerAPI.Get(__instance);
// Means it's the server
if (player == null)
{
return;
}
PlayerEvents.OnDestroying(new DestroyingEventArgs(player));
PlayerAPI.Dictionary.Remove(player.GameObject);
PlayerAPI.UnverifiedPlayers.Remove(__instance);
PlayerAPI.IdsCache.Remove(player.Id);
if (player.UserId != null)
{
PlayerAPI.UserIdsCache.Remove(player.UserId);
}
}
catch (Exception ex)
{
Log.Error($"{typeof(Destroying).FullName}.{nameof(Prefix)}:\n{ex}");
}
}
public void OnShooting(ShootingEventArgs ev)
{
if (Tracking.PlayersInvisibleByCommand.Contains(ev.Shooter))
{
Tracking.PlayersInvisibleByCommand.Remove(ev.Shooter);
}
EPlayer target = EPlayer.Get(ev.Target);
if (target != null)
{
if (Tracking.PlayerHasFFToPlayer(ev.Shooter, target))
{
Log.Debug($"Attacker: {ev.Shooter.Nickname} has been granted friendly fire", Subclass.Instance.Config.Debug);
ev.Shooter.IsFriendlyFireEnabled = true;
Timing.CallDelayed(0.1f, () =>
{
ev.Shooter.IsFriendlyFireEnabled = false;
});
}
else
{
Log.Debug($"Attacker: {ev.Shooter.Nickname} has not been granted friendly fire", Subclass.Instance.Config.Debug);
}
}
}
public void UpdateHealths(UnityEngine.Collider[] colliders, EPlayer thrower, string type)
{
foreach (UnityEngine.Collider collider in colliders.Where(c => c.name == "Player"))
{
EPlayer player = EPlayer.Get(collider.gameObject);
if (player != null && player.Team == thrower.Team)
{
if (TrackingAndMethods.PlayersWithSubclasses[thrower].FloatOptions.ContainsKey(type))
{
if (TrackingAndMethods.PlayersWithSubclasses[thrower].FloatOptions[type] + player.Health > player.MaxHealth)
{
player.Health = player.MaxHealth;
}
else
{
player.Health += TrackingAndMethods.PlayersWithSubclasses[thrower].FloatOptions[type];
}
}
else
{
player.Health = player.MaxHealth;
}
}
}
}
private void DoFlashEffect(Player player, float distance)
{
if (ResetConsumptionOnFlashed)
{
if (ConsumptionStacks[player] > 0)
{
if (distance < 6 && ConsumptionStacks[player] > 1)
{
ConsumptionStacks[player]--;
}
else if (distance > 15)
{
ConsumptionStacks[player]++;
}
if ((ConsumptionStacks[player] / 2) >= 3)
{
ConsumptionStacks[player] -= 3;
}
else if ((ConsumptionStacks[player] / 2) >= 2)
{
ConsumptionStacks[player] -= 2;
}
else
{
ConsumptionStacks[player]--;
}
}
player.ShowHint($"You now have {ConsumptionStacks[player]} stacks of Consumption!", 10);
int newIntensity = ConsumptionStacks[player] / (MaxConsumption / 2);
player.ChangeEffectIntensity(EffectType.Scp207, (byte)newIntensity);
}
if (TeleportOnFlashed)
{
player.Position = Vector3.down * 1950f;
Timing.CallDelayed(15f, () =>
{
foreach (Player ply in Player.Get(Team.SCP))
{
if (player == ply)
{
continue;
}
player.Position = ply.Position + Vector3.up;
break;
}
Door hczArmoryDoor = Exiled.API.Features.Map.GetDoorByName("HCZ_ARMORY");
Transform transform = hczArmoryDoor.Base.transform;
player.Position = transform.position + transform.forward * 2f;
});
}
}
private void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (!Check(ev.Grenade))
{
return;
}
ev.IsAllowed = false;
Room room = Exiled.API.Features.Map.FindParentRoom(ev.Grenade);
Log.Debug($"{ev.Grenade.transform.position} - {room.Position} - {Exiled.API.Features.Map.Rooms.Count}", CustomItems.Instance.Config.IsDebugEnabled);
LockedRooms079.Add(room);
room.TurnOffLights(Duration);
Log.Debug($"{room.Doors.Count()} - {room.Type}", CustomItems.Instance.Config.IsDebugEnabled);
foreach (DoorVariant door in room.Doors)
{
if (door == null ||
(!string.IsNullOrEmpty(door.GetNametag()) && BlacklistedDoorNames.Contains(door.GetNametag())) ||
(door.NetworkActiveLocks > 0 && !OpenLockedDoors) ||
(door.RequiredPermissions.RequiredPermissions != KeycardPermissions.None && !OpenKeycardDoors))
{
continue;
}
Log.Debug("Opening a door!", CustomItems.Instance.Config.IsDebugEnabled);
door.NetworkTargetState = true;
door.ServerChangeLock(DoorLockReason.NoPower, true);
if (lockedDoors.Contains(door))
{
lockedDoors.Add(door);
}
Timing.CallDelayed(Duration, () =>
{
door.ServerChangeLock(DoorLockReason.NoPower, false);
lockedDoors.Remove(door);
});
}
foreach (Player player in Player.Get(RoleType.Scp079))
{
if (player.Camera != null && player.Camera.Room() == room)
{
player.SetCamera(198);
}
}
Timing.CallDelayed(Duration, () => LockedRooms079.Remove(room));
}
public bool Execute(ArraySegment <string> arguments, ICommandSender sender, out string response)
{
PlayerCommandSender playerCommandSender = sender as PlayerCommandSender;
EPlayer pplayer = EPlayer.Get(((CommandSender)sender).SenderId);
if (!CmdCooldown.Contains(pplayer))
{
if (sender is PlayerCommandSender ply && EPlayer.Get(ply.SenderId) is EPlayer pp && pp.Role == RoleType.Scp173)
{
foreach (var effect in pp.ReferenceHub.playerEffectsController.AllEffects.Values
.Where(x => x.GetType() == typeof(Scp268) || x.GetType() == typeof(Amnesia)))
{
if (!effect.Enabled)
{
pp.ReferenceHub.playerEffectsController.EnableEffect(effect, 15f);
}
else
{
effect.ServerDisable();
}
}
pp.IsInvisible = !pp.IsInvisible;
pp.Broadcast(5, $"You are now {(pp.IsInvisible ? "invisible" : "visible")}!");
response = $"You are {(pp.IsInvisible ? "Invisible" : "Visible")} now";
if (pp.IsInvisible)
{
Timing.CallDelayed(15f, () =>
{
pp.IsInvisible = false;
});
}
foreach (EPlayer shitass in EPlayer.List)
{
if (shitass.ReferenceHub.playerEffectsController.GetEffect <Amnesia>().Enabled&& pp.Role == RoleType.Scp173)
{
Scp173.TurnedPlayers.Add(shitass);
}
}
Coroutine.Add(Timing.RunCoroutine(VentCooldown(Singleton.Config.VentCooldown, pp)));
CmdCooldown.Add(pp);
return(true);
}
else
{
response = "You are not SCP-173";
return(false);
}
}
public IEnumerator <float> Bleed()
{
while (bleeding != null && bleeding.Count > 0)
{
double HealthPerSec = BleedEffect.Instance.Config.HealthDrainPerSecond;
double HealthPerSecInc = BleedEffect.Instance.Config.HealthDrainPerSecondIncrease;
foreach (var ent in bleeding)
{
double amount = HealthPerSec;
EPlayer p = EPlayer.Get(ent.Key);
if (p.IsGodModeEnabled)
{
bleeding.Remove(ent.Key);
}
if (ent.Value > 1)
{
if (BleedEffect.Instance.Config.HealthDrainExponential)
{
double power = ent.Value;
if (amount < 1)
{
power /= BleedEffect.Instance.Config.HealthDrainDivisor;
}
amount = Math.Pow(HealthPerSec, power);
}
else
{
amount += HealthPerSecInc * (ent.Value - 1);
}
}
Log.Debug($"Player with id {ent.Key} has drained {amount} health.", BleedEffect.Instance.Config.Debug);
if (p.Health - amount <= 0)
{
bleeding.Remove(ent.Key);
beenShot.Remove(ent.Key);
p.Kill(DamageTypes.Bleeding);
continue;
}
p.Health -= (float)amount;
}
yield return(Timing.WaitForSeconds(1f));
}
BleedEffect.Instance.mainCoroEnabled = false;
Log.Debug($"Stopping Coro {co}", BleedEffect.Instance.Config.Debug);
BleedEffect.Instance.Coroutines.Remove(co);
Timing.KillCoroutines(co);
yield break;
}
public void UpdateHealths(UnityEngine.Collider[] colliders, EPlayer thrower, string type)
{
foreach (UnityEngine.Collider collider in colliders.Where(c => c.name == "Player"))
{
EPlayer player = EPlayer.Get(collider.gameObject);
if (player != null && player.Team == thrower.Team)
{
try
{
player.Health += Tracking.PlayersWithSubclasses[thrower].FloatOptions[type];
}
catch (KeyNotFoundException e)
{
player.Health = player.MaxHealth;
}
}
}
}
public void UpdateHealths(ExplodingGrenadeEventArgs ev, string type)
{
UnityEngine.Collider[] colliders = UnityEngine.Physics.OverlapSphere(ev.Grenade.transform.position, 4);
foreach (UnityEngine.Collider collider in colliders.Where(c => c.name == "Player"))
{
EPlayer player = EPlayer.Get(collider.gameObject);
if (player != null && player.Team == ev.Thrower.Team)
{
try
{
player.Health += Tracking.PlayersWithSubclasses[ev.Thrower].FloatOptions[type];
}
catch (KeyNotFoundException e)
{
player.Health = player.MaxHealth;
}
}
}
}
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.");
}
}
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;
}
}
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 (TrackingAndMethods.OnCooldown(ev.Player, ability, subClass))
{
Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} on cooldown", Subclass.Instance.Config.Debug);
TrackingAndMethods.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.Player.Broadcast(2, Subclass.Instance.Config.ReviveFailedNoBodyMessage);
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.Player.Broadcast(2, Subclass.Instance.Config.CantReviveMessage);
return;
}
if (doll.owner.DeathCause.GetDamageType() == DamageTypes.Lure)
{
Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} failed", Subclass.Instance.Config.Debug);
ev.Player.Broadcast(2, Subclass.Instance.Config.CantReviveMessage);
return;
}
EPlayer owner = EPlayer.Get(colliders[0].gameObject.GetComponentInParent <Ragdoll>().owner.PlayerId);
if (owner != null && !owner.IsAlive)
{
bool revived = false;
if (!necro && TrackingAndMethods.GetPreviousTeam(owner) != null &&
TrackingAndMethods.GetPreviousTeam(owner) == ev.Player.Team)
{
if (TrackingAndMethods.PlayersThatJustGotAClass.ContainsKey(owner))
{
TrackingAndMethods.PlayersThatJustGotAClass[owner] = Time.time + 3f;
}
else
{
TrackingAndMethods.PlayersThatJustGotAClass.Add(owner, Time.time + 3f);
}
owner.SetRole((RoleType)TrackingAndMethods.GetPreviousRole(owner), true);
if (TrackingAndMethods.PreviousSubclasses.ContainsKey(owner) && TrackingAndMethods.PreviousSubclasses[owner].AffectsRoles.Contains((RoleType)TrackingAndMethods.GetPreviousRole(owner)))
{
TrackingAndMethods.AddClass(owner, TrackingAndMethods.PreviousSubclasses[owner], false, true);
}
owner.Inventory.Clear();
revived = true;
}
else if (necro)
{
owner.Role = RoleType.Scp0492;
TrackingAndMethods.AddZombie(ev.Player, owner);
owner.IsFriendlyFireEnabled = true;
revived = true;
}
if (revived)
{
Timing.CallDelayed(0.2f, () =>
{
owner.ReferenceHub.playerMovementSync.OverridePosition(ev.Player.Position + new Vector3(0.3f, 1f, 0), 0, true);
});
UnityEngine.Object.DestroyImmediate(doll.gameObject, true);
TrackingAndMethods.AddCooldown(ev.Player, ability);
TrackingAndMethods.UseAbility(ev.Player, ability, subClass);
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.Player.Broadcast(2, Subclass.Instance.Config.CantReviveMessage);
}
}
else
{
Log.Debug($"Player {ev.Player.Nickname} {(necro ? "necromancy" : "revive")} failed", Subclass.Instance.Config.Debug);
ev.Player.Broadcast(2, Subclass.Instance.Config.CantReviveMessage);
}
}
