/// <inheritdoc/>
protected override void OnExploding(ExplodingGrenadeEventArgs ev)
{
if (ev.Grenade.TryGetComponent(out Grenade grenade))
{
PlacedCharges.Remove(grenade);
}
}
private void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (ev.GrenadeType == GrenadeType.Flashbang)
{
foreach (Player player in TrackedPlayers)
{
float dist = Vector3.Distance(ev.Grenade.transform.position, player.Position);
if (dist <= 20f)
{
if (Physics.Linecast(ev.Grenade.transform.position, player.Position, player.ReferenceHub.playerMovementSync.CollidableSurfaces))
{
return;
}
float damage = FlashbangBaseDamage - (dist * FlashbangFalloffMultiplier);
if (damage < 0)
{
damage = 0f;
}
else if (damage > FlashbangBaseDamage)
{
damage = FlashbangBaseDamage;
}
Log.Debug($"{nameof(OnExplodingGrenade)}: Damage: {damage} - {dist} {player.Nickname}", Plugin.Singleton.Config.Debug);
player.Hurt(new ExplosionDamageHandler(ev.Thrower != null ? ev.Thrower.Footprint : new Footprint(Server.Host.ReferenceHub), Vector3.zero, damage, 0));
DoFlashEffect(player, dist);
}
}
}
}
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 bool Prefix(FragGrenade __instance)
{
Vector3 position = __instance.transform.position;
List <API.Features.Player> players = new List <API.Features.Player>();
foreach (GameObject gameObject in PlayerManager.players)
{
if (ServerConsole.FriendlyFire || !(gameObject != __instance.thrower.gameObject) || gameObject.GetComponent <WeaponManager>().GetShootPermission(__instance.throwerTeam, false))
{
PlayerStats component2 = gameObject.GetComponent <PlayerStats>();
if (component2 == null || !component2.ccm.InWorld)
{
continue;
}
float num2 = __instance.damageOverDistance.Evaluate(Vector3.Distance(position, component2.transform.position)) * (component2.ccm.IsHuman() ? ConfigFile.ServerConfig.GetFloat("human_grenade_multiplier", 0.7f) : ConfigFile.ServerConfig.GetFloat("scp_grenade_multiplier", 1f));
if (num2 > __instance.absoluteDamageFalloff)
{
players.Add(Exiled.API.Features.Player.Get(gameObject));
}
}
}
ExplodingGrenadeEventArgs ev = new ExplodingGrenadeEventArgs(players, true, __instance.gameObject);
Handlers.Map.OnExplodingGrenade(ev);
return(ev.IsAllowed);
}
private static bool Prefix(FlashGrenade __instance)
{
List <Exiled.API.Features.Player> players = new List <Exiled.API.Features.Player>();
foreach (GameObject gameObject in PlayerManager.players)
{
Vector3 position = __instance.transform.position;
ReferenceHub hub = ReferenceHub.GetHub(gameObject);
Flashed effect = hub.playerEffectsController.GetEffect <Flashed>();
Deafened effect2 = hub.playerEffectsController.GetEffect <Deafened>();
if (effect == null || __instance.thrower == null || (!__instance.Network_friendlyFlash && !effect.Flashable(ReferenceHub.GetHub(__instance.thrower.gameObject), position, __instance.viewLayerMask)))
{
continue;
}
float num = __instance.powerOverDistance.Evaluate(Vector3.Distance(gameObject.transform.position, position) / ((position.y > 900f) ? __instance.distanceMultiplierSurface : __instance.distanceMultiplierFacility)) * __instance.powerOverDot.Evaluate(Vector3.Dot(hub.PlayerCameraReference.forward, (hub.PlayerCameraReference.position - position).normalized));
byte b = (byte)Mathf.Clamp(Mathf.RoundToInt(num * 10f * __instance.maximumDuration), 1, 255);
if (b >= effect.Intensity && num > 0f)
{
players.Add(API.Features.Player.Get(gameObject));
}
}
ExplodingGrenadeEventArgs ev = new ExplodingGrenadeEventArgs(players, false, __instance.gameObject);
Handlers.Map.OnExplodingGrenade(ev);
return(ev.IsAllowed);
}
private static void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (Methods.IgnoredGrenades.Remove(ev.Grenade.gameObject))
{
ev.IsAllowed = false;
}
}
internal void OnExplodeGrenade(ExplodingGrenadeEventArgs ev)
{
if (ev.IsFrag)
{
if (!config.Grenade.canGrenadeExplode)
{
ev.IsAllowed = false;
}
if (!config.Grenade.canGrenadeDealDamageGlobal)
{
ev.TargetToDamages.Clear();
}
else
{
foreach (var target in ev.TargetToDamages)
{
if (!config.Grenade.canGrenadeDealDamage[target.Key.Role])
{
ev.TargetToDamages[target.Key] = 0f;
}
}
}
}
else
if (!config.Grenade.canFlashGrenadeExplode)
{
ev.IsAllowed = false;
}
}
public void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (!TrackingAndMethods.PlayersWithSubclasses.ContainsKey(ev.Thrower) ||
(!TrackingAndMethods.PlayersWithSubclasses[ev.Thrower].Abilities.Contains(AbilityType.HealGrenadeFlash) &&
!TrackingAndMethods.PlayersWithSubclasses[ev.Thrower].Abilities.Contains(AbilityType.HealGrenadeFrag)))
{
Log.Debug($"Player with name {ev.Thrower.Nickname} has no subclass", Subclass.Instance.Config.Debug);
return;
}
if (TrackingAndMethods.PlayersWithSubclasses[ev.Thrower].Abilities.Contains(AbilityType.HealGrenadeFlash) && !ev.IsFrag)
{
if (!TrackingAndMethods.CanUseAbility(ev.Thrower, AbilityType.HealGrenadeFlash, TrackingAndMethods.PlayersWithSubclasses[ev.Thrower]))
{
TrackingAndMethods.DisplayCantUseAbility(ev.Thrower, AbilityType.HealGrenadeFlash, TrackingAndMethods.PlayersWithSubclasses[ev.Thrower], "heal flash");
return;
}
TrackingAndMethods.UseAbility(ev.Thrower, AbilityType.HealGrenadeFlash, TrackingAndMethods.PlayersWithSubclasses[ev.Thrower]);
ev.IsAllowed = false;
UpdateHealths(ev, "HealGrenadeFlashHealAmount");
}
else if (TrackingAndMethods.PlayersWithSubclasses[ev.Thrower].Abilities.Contains(AbilityType.HealGrenadeFrag) && ev.IsFrag)
{
if (!TrackingAndMethods.CanUseAbility(ev.Thrower, AbilityType.HealGrenadeFrag, TrackingAndMethods.PlayersWithSubclasses[ev.Thrower]))
{
TrackingAndMethods.DisplayCantUseAbility(ev.Thrower, AbilityType.HealGrenadeFrag, TrackingAndMethods.PlayersWithSubclasses[ev.Thrower], "heal frag");
return;
}
TrackingAndMethods.UseAbility(ev.Thrower, AbilityType.HealGrenadeFrag, TrackingAndMethods.PlayersWithSubclasses[ev.Thrower]);
ev.IsAllowed = false;
UpdateHealths(ev, "HealGrenadeFragHealAmount");
}
//if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Thrower))
//{
// foreach (EPlayer target in ev.Targets)
// {
// if (target.Team != ev.Thrower.Team) continue;
// if (Tracking.PlayersWithSubclasses.ContainsKey(ev.Thrower) && Tracking.PlayersWithSubclasses.ContainsKey(target) &&
// Tracking.PlayersWithSubclasses[ev.Thrower].AdvancedFFRules.Contains(Tracking.PlayersWithSubclasses[target].Name))
// {
// target.Hurt(ev.TargetToDamages[target], DamageTypes.Grenade);
// continue;
// }
// if (Tracking.FriendlyFired.Contains(target) || (Tracking.PlayersWithSubclasses.ContainsKey(ev.Thrower) &&
// !Tracking.PlayersWithSubclasses[ev.Thrower].BoolOptions["DisregardHasFF"] &&
// Tracking.PlayersWithSubclasses[ev.Thrower].BoolOptions["HasFriendlyFire"]) ||
// (Tracking.PlayersWithSubclasses.ContainsKey(target) && !Tracking.PlayersWithSubclasses[target].BoolOptions["DisregardTakesFF"] &&
// Tracking.PlayersWithSubclasses[target].BoolOptions["TakesFriendlyFire"]))
// {
// if (!Tracking.FriendlyFired.Contains(target) && !Tracking.PlayersWithSubclasses[target].BoolOptions["TakesFriendlyFire"])
// Tracking.AddToFF(ev.Thrower);
// target.Hurt(ev.TargetToDamages[target], DamageTypes.Grenade);
// //ev.IsAllowed = true;
// }
// }
//}
}
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));
}
private void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (Check(ev.Grenade))
{
Log.Debug($"{ev.Thrower.Nickname} threw an implosion grenade!", CustomItems.Instance.Config.IsDebugEnabled);
Dictionary <Player, float> copiedList = new Dictionary <Player, float>();
foreach (KeyValuePair <Player, float> kvp in ev.TargetToDamages)
{
if (kvp.Value > 0)
{
copiedList.Add(kvp.Key, kvp.Value);
}
}
ev.TargetToDamages.Clear();
Log.Debug("IG: List cleared.", CustomItems.Instance.Config.IsDebugEnabled);
effectedPlayers = NorthwoodLib.Pools.ListPool <Player> .Shared.Rent();
foreach (Player player in copiedList.Keys)
{
ev.TargetToDamages.Add(player, copiedList[player] * DamageModifier);
if (BlacklistedRoles.Contains(player.Role))
{
continue;
}
Log.Debug($"{player.Nickname} starting suction", CustomItems.Instance.Config.IsDebugEnabled);
try
{
if (layerMask == 0)
{
layerMask = ev.Grenade.GetComponent <FragGrenade>().hurtLayerMask;
}
foreach (Transform grenadePoint in player.ReferenceHub.playerStats.grenadePoints)
{
bool line = Physics.Linecast(ev.Grenade.transform.position, grenadePoint.position, layerMask);
Log.Debug($"{player.Nickname} - {line}", CustomItems.Instance.Config.IsDebugEnabled);
if (!line)
{
effectedPlayers.Add(player);
Coroutines.Add(Timing.RunCoroutine(DoSuction(player, ev.Grenade.transform.position + (Vector3.up * 1.5f))));
break;
}
}
}
catch (Exception exception)
{
Log.Error($"{nameof(OnExplodingGrenade)} error: {exception}");
}
}
}
}
/// <summary>
/// Trims colliders from the given array.
/// </summary>
/// <param name="ev"><inheritdoc cref="ExplodingGrenadeEventArgs"/></param>
/// <param name="colliderArray">The list of colliders to trim from.</param>
/// <returns>An array of colliders.</returns>
public static Collider[] TrimColliders(ExplodingGrenadeEventArgs ev, Collider[] colliderArray)
{
List <Collider> colliders = new();
foreach (Collider collider in colliderArray)
{
if (collider.TryGetComponent(out IDestructible dest) &&
ReferenceHub.TryGetHubNetID(dest.NetworkId, out ReferenceHub hub) &&
Player.Get(hub) is Player player && !ev.TargetsToAffect.Contains(player))
{
colliders.Add(collider);
}
public void OnGrenadeExplosion(ExplodingGrenadeEventArgs ev)
{
foreach (Player p in ev.TargetToDamages.Keys)
{
if (p.IsNPC())
{
Npc component = Npc.Get(p);
if (!component.NPCPlayer.IsGodModeEnabled)
{
p.Hurt(ev.TargetToDamages[p], ev.Thrower, DamageTypes.Grenade);
}
}
}
}
/// <inheritdoc/>
protected override void OnExploding(ExplodingGrenadeEventArgs ev)
{
ev.IsAllowed = false;
Log.Debug($"{ev.Thrower.Nickname} threw an implosion grenade!", CustomItems.Instance.Config.IsDebugEnabled);
List <Player> copiedList = new List <Player>();
foreach (Player player in ev.TargetsToAffect)
{
copiedList.Add(player);
}
ev.TargetsToAffect.Clear();
Log.Debug("IG: List cleared.", CustomItems.Instance.Config.IsDebugEnabled);
effectedPlayers = NorthwoodLib.Pools.ListPool <Player> .Shared.Rent();
foreach (Player player in copiedList)
{
if (BlacklistedRoles.Contains(player.Role))
{
continue;
}
Log.Debug($"{player.Nickname} starting suction", CustomItems.Instance.Config.IsDebugEnabled);
try
{
if (layerMask == 0)
{
if (ev.Grenade is ExplosionGrenade explosionGrenade)
{
layerMask = explosionGrenade._detectionMask;
}
}
bool line = Physics.Linecast(ev.Grenade.transform.position, player.Position, layerMask);
Log.Debug($"{player.Nickname} - {line}", CustomItems.Instance.Config.IsDebugEnabled);
if (line)
{
effectedPlayers.Add(player);
Coroutines.Add(Timing.RunCoroutine(DoSuction(player, ev.Grenade.transform.position + (Vector3.up * 1.5f))));
}
}
catch (Exception exception)
{
Log.Error($"{nameof(OnExploding)} error: {exception}");
}
}
}
private void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (CheckGrenade(ev.Grenade))
{
Log.Debug($"{ev.Thrower.Nickname} threw an implosion grenade!", Plugin.Singleton.Config.Debug);
Dictionary <Player, float> copiedList = new Dictionary <Player, float>();
foreach (KeyValuePair <Player, float> kvp in ev.TargetToDamages)
{
if (kvp.Value > 0)
{
copiedList.Add(kvp.Key, kvp.Value);
}
}
ev.TargetToDamages.Clear();
Log.Debug($"IG: List cleared.", Plugin.Singleton.Config.Debug);
foreach (Player player in copiedList.Keys)
{
ev.TargetToDamages.Add(player, copiedList[player] * Plugin.Singleton.Config.ItemConfigs.ImpCfg.DamageModifier);
Log.Debug($"{player.Nickname} starting suction", Plugin.Singleton.Config.Debug);
try
{
if (layerMask == 0)
{
layerMask = ev.Grenade.GetComponent <FragGrenade>().hurtLayerMask;
}
foreach (Transform grenadePoint in player.ReferenceHub.playerStats.grenadePoints)
{
bool line = Physics.Linecast(ev.Grenade.transform.position, grenadePoint.position, layerMask);
Log.Debug($"{player.Nickname} - {line}", Plugin.Singleton.Config.Debug);
if (!line)
{
Coroutines.Add(Timing.RunCoroutine(DoSuction(player, ev.Grenade.transform.position + (Vector3.up * 1.5f))));
break;
}
}
}
catch (Exception e)
{
Log.Error($"REEEE: {e.Message}\n{e.StackTrace}");
}
}
}
}
private void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (CheckGrenade(ev.Grenade))
{
ev.IsAllowed = false;
Room room = Map.FindParentRoom(ev.Grenade);
room.TurnOffLights(Plugin.Singleton.Config.ItemConfigs.EmpCfg.Duration);
Log.Debug($"{room.Doors.Count()} - {room.Type}");
foreach (DoorVariant door in room.Doors)
{
Log.Debug($"Opening a door!", Plugin.Singleton.Config.Debug);
door.NetworkTargetState = true;
door.ServerChangeLock(DoorLockReason.NoPower, true);
Timing.CallDelayed(Plugin.Singleton.Config.ItemConfigs.EmpCfg.Duration, () => door.ServerChangeLock(DoorLockReason.NoPower, false));
foreach (Player player in Player.List)
{
if (player.Role == RoleType.Scp079)
{
if (player.Camera.Room() == room)
{
Room homeRoom = Map.Rooms.FirstOrDefault(r => r.Name.Contains("079"));
if (homeRoom == null)
{
Log.Error($"HAH ROOM IS NULL BITCH");
continue;
}
player.Camera = homeRoom.GetComponentInParent <Camera079>();
}
if (!string.IsNullOrEmpty(player.Speaker))
{
player.Speaker = string.Empty;
}
break;
}
}
}
}
}
internal void ExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (Plugin.Instance.Config.ExplodingGrenade == "")
{
return;
}
string message = Plugin.Instance.Config.ExplodingGrenade.Replace("%frag%", ev.IsFrag.ToString());
string targets = string.Join(", ", ev.Targets);
message = message.Replace("%targets%", targets);
if (Plugin.Instance.Config.debug_to_console)
{
Log.Debug(message: "[ " + Plugin.Instance.Config.map_name + "] " + message);
}
Plugin.sendWebHook(Plugin.Instance.Config.map_url, message, Plugin.Instance.Config.map_name);
}
private static bool Prefix(FlashGrenade __instance)
{
try
{
Dictionary <Player, float> players = new Dictionary <Player, float>();
foreach (GameObject gameObject in PlayerManager.players)
{
Vector3 position = __instance.transform.position;
ReferenceHub hub = ReferenceHub.GetHub(gameObject);
Flashed effect = hub.playerEffectsController.GetEffect <Flashed>();
Deafened effect2 = hub.playerEffectsController.GetEffect <Deafened>();
if (effect == null || __instance.thrower == null ||
(!__instance.Network_friendlyFlash && !effect.Flashable(
ReferenceHub.GetHub(__instance.thrower.gameObject), position, __instance._ignoredLayers)))
{
continue;
}
float num = __instance.powerOverDistance.Evaluate(
Vector3.Distance(gameObject.transform.position, position) / ((position.y > 900f)
? __instance.distanceMultiplierSurface
: __instance.distanceMultiplierFacility)) *
__instance.powerOverDot.Evaluate(Vector3.Dot(hub.PlayerCameraReference.forward, (hub.PlayerCameraReference.position - position).normalized));
byte b = (byte)Mathf.Clamp(Mathf.RoundToInt(num * 10f * __instance.maximumDuration), 1, 255);
if (b >= effect.Intensity && num > 0f)
{
players.Add(Player.Get(gameObject), num);
}
}
ExplodingGrenadeEventArgs ev = new ExplodingGrenadeEventArgs(Player.Get(__instance.throwerGameObject), players, false, __instance.gameObject);
Handlers.Map.OnExplodingGrenade(ev);
return(ev.IsAllowed);
}
catch (Exception exception)
{
Log.Error($"{typeof(ExplodingFlashGrenade).FullName}:\n{exception}");
return(true);
}
}
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;
}
}
}
}
/// <inheritdoc/>
protected override void OnExploding(ExplodingGrenadeEventArgs ev)
{
ev.IsAllowed = false;
Room room = Exiled.API.Features.Map.FindParentRoom(ev.Grenade.gameObject);
TeslaGate gate = null;
Log.Debug($"{ev.Grenade.transform.position} - {room.Position} - {Room.List.Count()}", CustomItems.Instance.Config.IsDebugEnabled);
LockedRooms079.Add(room);
room.TurnOffLights(Duration);
if (DisableTeslaGates)
{
foreach (TeslaGate teslaGate in TeslaGate.List)
{
if (Exiled.API.Features.Map.FindParentRoom(teslaGate.GameObject) == room)
{
disabledTeslaGates.Add(teslaGate);
gate = teslaGate;
break;
}
}
}
Log.Debug($"{room.Doors.Count()} - {room.Type}", CustomItems.Instance.Config.IsDebugEnabled);
foreach (Door door in room.Doors)
{
if (door == null ||
(!string.IsNullOrEmpty(door.Nametag) && BlacklistedDoorNames.Contains(door.Nametag)) ||
(door.DoorLockType > 0 && !OpenLockedDoors) ||
(door.RequiredPermissions.RequiredPermissions != KeycardPermissions.None && !OpenKeycardDoors))
{
continue;
}
Log.Debug("Opening a door!", CustomItems.Instance.Config.IsDebugEnabled);
door.IsOpen = true;
door.ChangeLock(DoorLockType.NoPower);
if (!lockedDoors.Contains(door))
{
lockedDoors.Add(door);
}
Timing.CallDelayed(Duration, () =>
{
door.Unlock();
lockedDoors.Remove(door);
});
}
foreach (Player player in Player.List)
{
if (player.Role.As <Scp079Role>() is Scp079Role scp079)
{
if (scp079.Camera != null && scp079.Camera.Room == room)
{
scp079.SetCamera(198);
}
}
if (player.CurrentRoom != room)
{
continue;
}
foreach (Item item in player.Items)
{
switch (item)
{
case Radio radio:
radio.Disable();
break;
case Flashlight flashlight:
flashlight.Active = false;
break;
case Firearm firearm:
{
foreach (FirearmAttachment attachment in firearm.Attachments)
{
if (attachment.Name == AttachmentNameTranslation.Flashlight)
{
attachment.IsEnabled = false;
}
}
break;
}
}
}
}
Timing.CallDelayed(Duration, () =>
{
try
{
LockedRooms079.Remove(room);
}
catch (Exception e)
{
Log.Debug($"REMOVING LOCKED ROOM: {e}");
}
if (gate != null)
{
try
{
disabledTeslaGates.Remove(gate);
}
catch (Exception e)
{
Log.Debug($"REMOVING DISABLED TESLA: {e}");
}
}
});
}
/// <summary> /// Called before a grenade explodes. /// </summary> /// <param name="ev">The <see cref="ExplodingGrenadeEventArgs"/> instance.</param> public static void OnExplodingGrenade(ExplodingGrenadeEventArgs ev) => ExplodingGrenade.InvokeSafely(ev);
/// <inheritdoc cref="Events.Handlers.Map.OnExplodingGrenade(ExplodingGrenadeEventArgs)"/>
public void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
Log.Info($"A frag grenade thrown by {ev.Thrower.Nickname} is exploding: {ev.Grenade.name}\n[Targets]\n\n{string.Join("\n", ev.TargetToDamages.Select(player => $"[{player.Key.Nickname} ({player.Value} HP)]"))}");
}
/// <inheritdoc cref="Exiled.Events.Handlers.Map.OnExplodingGrenade(ExplodingGrenadeEventArgs)"/>
public void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
Log.Info($"A grenade thrown by {ev.Thrower.Nickname} is exploding: {ev.Grenade.name}\n[Targets]\n\n{string.Join("\n", ev.TargetsToAffect.Select(player => $"[{player.Nickname}]"))}");
}
public static bool Prefix(FragGrenade __instance, ref bool __result)
{
Player thrower = Player.Get(__instance.thrower.gameObject);
Dictionary <Player, float> damages = new Dictionary <Player, float>();
Vector3 position = ((EffectGrenade)__instance).transform.position;
int num = 0;
Collider[] colliderArray = Physics.OverlapSphere(position, __instance.chainTriggerRadius, (int)__instance.damageLayerMask);
int index = 0;
foreach (GameObject obj2 in PlayerManager.players)
{
if (!ServerConsole.FriendlyFire && ((obj2 != ((EffectGrenade)__instance).thrower.gameObject) &&
(!obj2.GetComponent <WeaponManager>().GetShootPermission(((EffectGrenade)__instance).throwerTeam, false))))
{
continue;
}
PlayerStats component = obj2.GetComponent <PlayerStats>();
if ((component != null) && component.ccm.InWorld)
{
float amount = (float)(__instance.damageOverDistance.Evaluate(Vector3.Distance(position, component.transform.position)) * (component.ccm.IsHuman() ? ConfigFile.ServerConfig.GetFloat("human_grenade_multiplier", 0.7f) : ConfigFile.ServerConfig.GetFloat("scp_grenade_multiplier", 1f)));
damages.Add(Player.Get(obj2), amount);
}
}
var ev = new ExplodingGrenadeEventArgs(thrower, damages, true, __instance.gameObject);
Exiled.Events.Handlers.Map.OnExplodingGrenade(ev);
if (!ev.IsAllowed)
{
return(false);
}
while (index < colliderArray.Length)
{
Collider collider = colliderArray[index];
BreakableWindow component = collider.GetComponent <BreakableWindow>();
if (component != null)
{
if ((component.transform.position - position).sqrMagnitude <= __instance.sqrChainTriggerRadius)
{
component.ServerDamageWindow(500f);
}
}
else
{
DoorVariant componentInParent = collider.GetComponentInParent <DoorVariant>();
if (componentInParent != null && componentInParent is IDamageableDoor damageableDoor)
{
damageableDoor.ServerDamage(__instance.damageOverDistance.Evaluate(Vector3.Distance(position, componentInParent.transform.position)), DoorDamageType.Grenade);
}
else if (((__instance.chainLengthLimit == -1) || (__instance.chainLengthLimit > ((EffectGrenade)__instance).currentChainLength)) && ((__instance.chainConcurrencyLimit == -1) || (__instance.chainConcurrencyLimit > num)))
{
Pickup componentInChildren = collider.GetComponentInChildren <Pickup>();
if ((componentInChildren != null) && __instance.ChangeIntoGrenade(componentInChildren))
{
num = (int)(num + 1);
}
}
}
index = (int)(index + 1);
}
foreach (var item in damages)
{
if (item.Value > __instance.absoluteDamageFalloff)
{
PlayerStats component = item.Key.GameObject.GetComponent <PlayerStats>();
Transform[] grenadePoints = component.grenadePoints;
index = 0;
while (true)
{
if (index < grenadePoints.Length)
{
Transform transform = grenadePoints[index];
if (Physics.Linecast(position, transform.position, (int)__instance.hurtLayerMask))
{
index = (int)(index + 1);
continue;
}
component.HurtPlayer(new PlayerStats.HitInfo(item.Value, (((EffectGrenade)__instance).thrower != null) ? ((EffectGrenade)__instance).thrower.hub.LoggedNameFromRefHub() : ((string)"(UNKNOWN)"), DamageTypes.Grenade, ((EffectGrenade)__instance).thrower.hub.queryProcessor.PlayerId), item.Key.GameObject, false);
}
if (!component.ccm.IsAnyScp())
{
ReferenceHub hub = item.Key.ReferenceHub;
float duration = __instance.statusDurationOverDistance.Evaluate(Vector3.Distance(position, component.transform.position));
hub.playerEffectsController.EnableEffect(hub.playerEffectsController.GetEffect <Burned>(), duration, false);
hub.playerEffectsController.EnableEffect(hub.playerEffectsController.GetEffect <Concussed>(), duration, false);
}
break;
}
}
}
//if (Tracking.PlayersWithSubclasses.ContainsKey(thrower) && Tracking.PlayersWithSubclasses[thrower].Abilities.Contains(AbilityType.HealGrenadeFrag))
//{
// if (!Tracking.CanUseAbility(thrower, AbilityType.HealGrenadeFrag, Tracking.PlayersWithSubclasses[thrower]))
// {
// Tracking.DisplayCantUseAbility(thrower, AbilityType.HealGrenadeFrag, Tracking.PlayersWithSubclasses[thrower], "heal frag");
// }
// else
// {
// Tracking.UseAbility(thrower, AbilityType.HealGrenadeFrag, Tracking.PlayersWithSubclasses[thrower]);
// UnityEngine.Collider[] colliders = UnityEngine.Physics.OverlapSphere(__instance.transform.position, 4);
// Subclass.Instance.map.UpdateHealths(colliders, thrower, "HealGrenadeFragHealAmount");
// return false;
// }
//}
string str = (((Grenade)((EffectGrenade)__instance)).thrower != null) ? ((Grenade)((EffectGrenade)__instance)).thrower.hub.LoggedNameFromRefHub() : ((string)"(UNKNOWN)");
string[] textArray1 = new string[] { "Player ", (string)str, "'s ", (string)((Grenade)((EffectGrenade)__instance)).logName, " grenade exploded." };
ServerLogs.AddLog(ServerLogs.Modules.Logger, string.Concat((string[])textArray1), ServerLogs.ServerLogType.GameEvent, false);
if (((EffectGrenade)__instance).serverGrenadeEffect != null)
{
Transform transform = ((Grenade)((EffectGrenade)__instance)).transform;
Object.Instantiate <GameObject>(((EffectGrenade)__instance).serverGrenadeEffect, transform.position, transform.rotation);
}
__result = true;
return(false);
}
/// <inheritdoc/>
protected override void OnExploding(ExplodingGrenadeEventArgs ev)
{
PlacedCharges.Remove(Pickup.Get(ev.Grenade));
}
private void OnExplodingGrenade(ExplodingGrenadeEventArgs ev)
{
if (!Check(ev.Grenade))
{
return;
}
ev.IsAllowed = false;
Room room = Exiled.API.Features.Map.FindParentRoom(ev.Grenade);
TeslaGate gate = null;
Log.Debug($"{ev.Grenade.transform.position} - {room.Position} - {Exiled.API.Features.Map.Rooms.Count}", CustomItems.Instance.Config.IsDebugEnabled);
LockedRooms079.Add(room);
room.TurnOffLights(Duration);
if (DisableTeslaGates)
{
foreach (TeslaGate teslaGate in Exiled.API.Features.Map.TeslaGates)
{
if (Exiled.API.Features.Map.FindParentRoom(teslaGate.gameObject) == room)
{
disabledTeslaGates.Add(teslaGate);
gate = teslaGate;
break;
}
}
}
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.List)
{
if (player.Role == RoleType.Scp079)
{
if (player.Camera != null && player.Camera.Room() == room)
{
player.SetCamera(198);
}
}
if (player.CurrentRoom != room)
{
continue;
}
foreach (Inventory.SyncItemInfo item in player.ReferenceHub.inventory.items)
{
if (item.id == ItemType.Radio)
{
player.ReferenceHub.inventory.items.ModifyDuration(player.ReferenceHub.GetComponent <Radio>().myRadio, 0f);
}
else if (player.ReferenceHub.weaponManager.syncFlash)
{
player.ReferenceHub.weaponManager.syncFlash = false;
}
}
}
Timing.CallDelayed(Duration, () =>
{
LockedRooms079.Remove(room);
if (gate != null)
{
disabledTeslaGates.Remove(gate);
}
});
}
