private void OnPlayerHurting(object sender, HurtingEventArgs e)
{
if (e.IsLocal && PlayerExtension.IsGodMode)
{
e.Handled = true;
}
}
/// <inheritdoc/>
protected override void OnHurting(HurtingEventArgs ev)
{
if (Check(ev.Attacker.CurrentItem) && ev.Attacker != ev.Target && ev.DamageType == DamageTypes.FromWeaponId(ev.Attacker.ReferenceHub.weaponManager.curWeapon))
{
ev.Amount = 0f;
}
}
private static void Prefix(PlayerStats __instance, ref PlayerStats.HitInfo info, GameObject go)
{
if (go == null)
{
return;
}
API.Features.Player attacker = API.Features.Player.Get(__instance.gameObject);
API.Features.Player target = API.Features.Player.Get(go);
if (attacker == null || target == null || attacker.IsHost || target.IsHost)
{
return;
}
var ev = new HurtingEventArgs(API.Features.Player.Get(__instance.gameObject), API.Features.Player.Get(go), info);
if (ev.Target.IsHost)
{
return;
}
Player.OnHurting(ev);
info = ev.HitInformations;
}
public void OnPlayerHurt(HurtingEventArgs ev)
{
if (Blackout.active && ParseHandler(ev.Handler.Base) == DamageTypes.Nuke && ev.Target.Team == Team.SCP)
{
ev.Amount = 0;
}
}
private void OnHurting(HurtingEventArgs ev)
{
if (ev.Attacker != null && Check(ev.Attacker) && ev.Target.Role.Side == Side.Scp)
{
ev.IsAllowed = Server.FriendlyFire || ev.Attacker.IsFriendlyFireEnabled;
}
}
private void OnPlayerHurting(object sender, HurtingEventArgs e)
{
if (e.IsLocal && _commands.IsGodMode)
{
e.Handled = true;
}
}
public void OnHurt(HurtingEventArgs ev)
{
if (ev.IsAllowed == false)
{
return;
}
if (ev.Target == ev.Attacker)
{
return;
}
if (ev.DamageType.isWeapon || ev.DamageType.isScp)
{
try
{
if (ev.Attacker.AdvancedTeam().IsTeamFriendly(ev.Attacker.AdvancedTeam()) && !this.plugin.Config.FriendlyFire)
{
ev.IsAllowed = false;
ev.Attacker.ShowHint(Instance.Translation.FriendlyFireHint, 5);
Log.Debug("Protected a player in " + ev.Target.AdvancedTeam().Name + " from " + ev.Attacker.AdvancedTeam().Name, this.plugin.Config.Debug);
}
}
catch (Exception)
{
Log.Debug("Player possibly left so we caught this error");
}
}
}
internal void OnHurting(HurtingEventArgs ev)
{
if (ev.Target.Role == RoleType.Scp0492)
{
ev.Amount = ev.Attacker?.IsAlive ?? false ? ev.DamageType == DamageTypes.Usp ? 10000 : 0 : 0;
}
}
public void OnPlayerHurt(HurtingEventArgs ev)
{
if (ev.Target.Id == playerReferenceHub.playerId && ev.Target.Role == RoleType.Scp0492 && ev.DamageType == DamageTypes.Scp207)
{
ev.Amount = 0.0f;
}
}
internal static void OnHurting(HurtingEventArgs ev)
{
if (Methods.FriendlyFireUsers.Contains(ev.Attacker.UserId))
{
Methods.RemoveFf(ev.Attacker);
}
if (!API.IsScp035(ev.Target) && !API.IsScp035(ev.Attacker))
{
return;
}
if (!Config.ScpFriendlyFire && (ev.Target.Team == Team.SCP || ev.Attacker.Team == Team.SCP))
{
ev.IsAllowed = false;
return;
}
if (!Config.TutorialFriendlyFire && (ev.Target.Team == Team.TUT || ev.Attacker.Team == Team.TUT))
{
ev.IsAllowed = false;
return;
}
if (ev.Attacker.Side == ev.Target.Side)
{
Methods.GrantFf(ev.Attacker);
}
}
public void OnPlayerHurt(HurtingEventArgs ev)
{
if (scp372.Contains(ev.Attacker.UserId) && ev.Target.Team == Team.SCP || scp372.Contains(ev.Target.UserId) && ev.Attacker.Team == Team.SCP)
{
ev.IsAllowed = false;
}
}
public void OnDamage(HurtingEventArgs ev)
{
if (!PlayerInfoDict.ContainsKey(ev.Attacker.UserId))
{
return;
}
if (ev.DamageType == DamageTypes.MicroHid && !FFREVERSE.Instance.Config.FFMicro)
{
return;
}
PlayerInfo pinfo = PlayerInfoDict[ev.Attacker.UserId];
if (ev.Attacker.Side == ev.Target.Side && ev.Attacker.Id != ev.Target.Id && !roundend)
{
if (pinfo.teamKills >= FFREVERSE.Instance.Config.FFKills || pinfo.teamDamage >= FFREVERSE.Instance.Config.FFDamage)
{
ev.Attacker.ShowHint("<b><color=#F52929>Инверсия \"огня по своим\" включена</color></b>", 5);
ev.Attacker.Hurt(ev.Amount, DamageTypes.E11StandardRifle, ev.Attacker.DisplayNickname);
ev.IsAllowed = false;
}
else
{
ev.Attacker.ShowHint("<color=#F52929>Не наносите урон своим союзникам</color>", 3);
}
pinfo.teamDamage += ev.Amount;
}
}
public void OnHurt(HurtingEventArgs ev)
{
if ((ev.Attacker.Role == RoleType.Scp93953 || ev.Attacker.Role == RoleType.Scp93989 || ev.Attacker.Role == RoleType.Scp0492) && (player.Id == ev.Target.Id))
{// Remove the 'negative' effect
SCP999x.Extensions.Extensions.removeNegativeStatusEffect(player);
}
}
private static void Prefix(PlayerStats __instance, ref PlayerStats.HitInfo info, GameObject go, bool noTeamDamage = false)
{
try
{
if (go == null)
{
return;
}
API.Features.Player attacker = API.Features.Player.Get(__instance.gameObject);
API.Features.Player target = API.Features.Player.Get(go);
if (attacker == null || target == null || attacker.IsHost || target.IsHost)
{
return;
}
var ev = new HurtingEventArgs(API.Features.Player.Get(__instance.gameObject), API.Features.Player.Get(go), info);
if (ev.Target.IsHost)
{
return;
}
Handlers.Player.OnHurting(ev);
info = ev.HitInformations;
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.Hurting: {e}\n{e.StackTrace}");
}
}
/// <inheritdoc/>
protected override void OnHurting(HurtingEventArgs ev)
{
base.OnHurting(ev);
if (ev.Attacker == ev.Target || (ev.Target.Team == Team.SCP && ResistantScps && Random.Range(1, 101) <= ScpResistChance))
{
return;
}
float duration = Duration;
if (!tranquilizedPlayers.TryGetValue(ev.Target, out _))
{
tranquilizedPlayers.Add(ev.Target, 1);
}
tranquilizedPlayers[ev.Target] *= ResistanceModifier;
duration -= tranquilizedPlayers[ev.Target];
if (duration > 0f)
{
Timing.RunCoroutine(DoTranquilize(ev.Target, duration));
}
}
public void OnPlayerHurt(HurtingEventArgs ev)
{
if (ev.Attacker.Role == RoleType.Scp0492 && ev.Target != ev.Attacker)
{
if (SCP008X.Instance.Config.ZombieDamage >= 0)
{
ev.Amount = SCP008X.Instance.Config.ZombieDamage;
Log.Debug($"Damage overriden to be {ev.Amount}.", SCP008X.Instance.Config.DebugMode);
}
if (SCP008X.Instance.Config.Scp008Buff >= 0)
{
ev.Attacker.ArtificialHealth += SCP008X.Instance.Config.Scp008Buff;
Log.Debug($"Added {SCP008X.Instance.Config.Scp008Buff} AHP to {ev.Attacker}.", SCP008X.Instance.Config.DebugMode);
}
int chance = Gen.Next(0, 101);
if (chance <= SCP008X.Instance.Config.InfectionChance && ev.Target.Team != Team.SCP)
{
try
{
Infect(ev.Target);
Log.Debug($"Successfully infected {ev.Target} with {chance}% probability.", SCP008X.Instance.Config.DebugMode);
}
catch (Exception e)
{
Log.Error($"Failed to infect {ev.Target}! {e}");
throw;
}
}
}
}
private void OnHurting(HurtingEventArgs ev)
{
if (CheckItem(ev.Attacker.CurrentItem))
{
ev.Amount = 0;
if (ev.Target.Team == Team.SCP && Plugin.Singleton.Config.ItemConfigs.TranqCfg.ResistantScps)
{
if (Plugin.Singleton.Rng.Next(100) <= Plugin.Singleton.Config.ItemConfigs.TranqCfg.ScpResistChance)
{
return;
}
}
float dur = Plugin.Singleton.Config.ItemConfigs.TranqCfg.Duration;
if (!TranquilizedPlayers.ContainsKey(ev.Target))
{
TranquilizedPlayers.Add(ev.Target, 0);
}
dur -= (TranquilizedPlayers[ev.Target] * Plugin.Singleton.Config.ItemConfigs.TranqCfg.ResistanceModifier);
if (dur > 0f)
{
Timing.RunCoroutine(DoTranquilize(ev.Target, dur));
}
}
}
/// <inheritdoc/>
protected override void OnHurting(HurtingEventArgs ev)
{
if (ev.Attacker != ev.Target && ev.Handler.Base is FirearmDamageHandler firearmDamageHandler && firearmDamageHandler.WeaponType == ev.Attacker.CurrentItem.Type)
{
ev.Amount *= DamageMultiplier;
}
}
public static void OnPlayerHit(HurtingEventArgs ev)
{
if (EnableZombieAOEDamage && SCP049AbilityController.CureCounter >= DocRework.config.MinCures)
{
SCP0492AbilityController.DealAOEDamage(ev.Attacker, ev.Target, ZombieAOEDamage);
}
}
/// <inheritdoc/>
protected override void OnHurting(HurtingEventArgs ev)
{
if (ev.Attacker != ev.Target && ev.DamageType == DamageTypes.FromWeaponId(ev.Attacker.ReferenceHub.weaponManager.curWeapon))
{
ev.Amount *= DamageMultiplier;
}
}
public void OnHurting(HurtingEventArgs ev)
{
if (BloodLust049.Instance.bloodLustActive && ev.Target.Role == RoleType.Scp049 && (ev.DamageType == DamageTypes.Scp207 || ev.DamageType == DamageTypes.Bleeding))
{
ev.IsAllowed = false;
}
}
/// <inheritdoc/>
protected override void OnHurting(HurtingEventArgs ev)
{
if (Damage > 0)
{
ev.Amount *= Damage;
}
}
private void OnHurting(HurtingEventArgs ev)
{
if (CheckItem(ev.Attacker.CurrentItem))
{
ev.Amount *= Plugin.Singleton.Config.ItemConfigs.SniperCfg.DamageMultiplier;
}
}
public void RunWhenPlayerIsHurt(HurtingEventArgs ev)
{
if (ev.Attacker != ev.Target && ev.Attacker == player)
{
ev.Amount = int.MaxValue;
}
}
internal void OnPlayerHurt(HurtingEventArgs ev)
{
if (pluginInstance.Config.CuffedImmunityPlayers?.ContainsKey(ev.Target.Team) == true)
{
ev.IsAllowed = !(pluginInstance.Functions.IsTeamImmune(ev.Target, ev.Attacker) && pluginInstance.Functions.CuffedCheck(ev.Target) && pluginInstance.Functions.CheckSafeZones(ev.Target));
}
}
void PlayerHurt(HurtingEventArgs ev)
{
if (ev.DamageType.isScp || ev.DamageType.isWeapon || ev.DamageType == DamageTypes.Wall)
{
ev.IsAllowed = false;
}
}
public void OnHurting(HurtingEventArgs ev)
{
if (Singleton.Config.WhitelistedRoles.Contains(ev.Target.Role) && ev.DamageType == DamageTypes.Scp207)
{
ev.Amount = 0f;
}
}
public void OnHurt(HurtingEventArgs ev)
{
if (ev.Target.IsNPC())
{
Npc npc = Npc.Get(ev.Target);
npc.FireEvent(new NPCHurtEvent(npc, ev.Attacker));
}
}
internal static bool InvokeHurting(object player, object damageSource, int damage, bool isPvP, bool isCritical)
{
var args = new HurtingEventArgs((Player)player, (PlayerDeathReason)damageSource, damage, isPvP,
isCritical);
Hurting?.Invoke(null, args);
return(args.Handled);
}
public void OnHurting(HurtingEventArgs ev)
{
if (ev.Attacker.Role == RoleType.Scp173 && ev.Attacker.IsInvisible)
{
ev.IsAllowed = false;
ev.Amount = 0f;
}
}
