public static DamageType GetDamageType(this DamageHandlerBase handler)
{
if (handler == null)
{
return(DamageType.Unknown);
}
if (Enum.TryParse <DamageType>(handler.GetType().Name.Replace("DamageHandler", ""), out var type))
{
if (type == DamageType.Universal)
{
var id = (handler as UniversalDamageHandler).TranslationId;
if (id < 0 || id > 23)
{
return(DamageType.Universal);
}
return((DamageType)id);
}
return(type);
}
return(DamageType.Unknown);
}
/// <summary>
/// Initializes a new instance of the <see cref="DiedEventArgs"/> class.
/// </summary>
/// <param name="target"><inheritdoc cref="Target"/></param>
/// <param name="damageHandler"><inheritdoc cref="DamageHandler"/></param>
public DiedEventArgs(Player target, DamageHandlerBase damageHandler)
{
Killer = damageHandler is AttackerDamageHandler attackerDamageHandler?Player.Get(attackerDamageHandler.Attacker.Hub) : null;
Target = target;
Handler = new DamageHandler(target, damageHandler);
}
private static bool OnDeath(PlayerStats __instance, DamageHandlerBase handler, out bool __state)
{
try
{
var standardhandler = handler as StandardDamageHandler;
var type = handler.GetDamageType();
var victim = __instance.GetPlayer();
var attacker = handler is AttackerDamageHandler ahandler?ahandler.Attacker.GetPlayer() : null;
if (type == DamageType.PocketDecay)
{
attacker = Server.Get.Players.FirstOrDefault(x => x.Scp106Controller.PocketPlayers.Contains(victim));
}
SynapseController.Server.Events.Player.InvokePlayerDeathEvent(victim, attacker, type, out var allow);
if (!allow)
{
victim.Health = 1;
}
if (allow)
{
victim.DeathPosition = victim.Position;
}
__state = allow;
return(allow);
}
catch (Exception e)
{
__state = true;
Logger.Get.Error($"Synapse-Event: PlayerDeath event failed!!\n{e}");
return(true);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DyingEventArgs"/> class.
/// </summary>
/// <param name="target"><inheritdoc cref="Target"/></param>
/// <param name="damageHandler"><inheritdoc cref="DamageHandler"/></param>
public DyingEventArgs(Player target, DamageHandlerBase damageHandler)
{
ItemsToDrop = new List <Item>(target.Items.ToList());
Killer = damageHandler is AttackerDamageHandler attackerDamageHandler?Player.Get(attackerDamageHandler.Attacker.Hub) : null;
Target = target;
Handler = new DamageHandler(target, damageHandler);
}
/// <summary>
/// Initializes a new instance of the <see cref="DamageHandler"/> class.
/// </summary>
/// <param name="target">The <see cref="Player"/> target of the handler.</param>
/// <param name="handlerBase">The <see cref="DamageHandlerBase"/> to initialize from.</param>
public DamageHandler(Player target, DamageHandlerBase handlerBase)
{
Base = handlerBase;
Target = target;
Attacker = handlerBase is AttackerDamageHandler attacker?Player.Get(attacker.Attacker.Hub) : null;
Item = handlerBase is FirearmDamageHandler ? Attacker.CurrentItem : null;
}
/// <summary>
/// Initializes a new instance of the <see cref="SpawningRagdollEventArgs"/> class.
/// </summary>
/// <param name="ragdollInfo"><inheritdoc cref="Info"/></param>
/// <param name="damageHandlerBase"><inheritdoc cref="DamageHandlerBase"/></param>
/// <param name="isAllowed"><inheritdoc cref="IsAllowed"/></param>
public SpawningRagdollEventArgs(
RagdollInfo ragdollInfo,
DamageHandlerBase damageHandlerBase,
bool isAllowed = true)
{
Info = ragdollInfo;
DamageHandlerBase = damageHandlerBase;
Owner = Player.Get(ragdollInfo.OwnerHub);
IsAllowed = isAllowed;
}
/// <summary>
/// Initializes a new instance of the <see cref="AnnouncingScpTerminationEventArgs"/> class.
/// </summary>
/// <param name="scp"><inheritdoc cref="Player"/></param>
/// <param name="damageHandlerBase"><inheritdoc cref="DamageHandler"/></param>
/// <param name="isAllowed"><inheritdoc cref="IsAllowed"/></param>
public AnnouncingScpTerminationEventArgs(Player scp, DamageHandlerBase damageHandlerBase, bool isAllowed = true)
{
Player = scp;
Role = scp.ReferenceHub.characterClassManager.CurRole;
Handler = new DamageHandler(scp, damageHandlerBase);
Killer = damageHandlerBase is AttackerDamageHandler attackerDamageHandler?API.Features.Player.Get(attackerDamageHandler.Attacker.Hub) : null;
TerminationCause = damageHandlerBase.CassieDeathAnnouncement;
IsAllowed = isAllowed;
}
/// <summary>
/// Initializes a new instance of the <see cref="Ragdoll"/> class.
/// </summary>
/// <param name="player">The ragdoll's <see cref="Player">owner</see>.</param>
/// <param name="handler">The player's <see cref="DamageHandlerBase"/>.</param>
/// <param name="canBeSpawned">A value that represents whether the ragdoll can be spawned.</param>
public Ragdoll(Player player, DamageHandlerBase handler, bool canBeSpawned = false)
{
GameObject model_ragdoll = player.ReferenceHub.characterClassManager.CurRole.model_ragdoll;
if (model_ragdoll is null || !Object.Instantiate(model_ragdoll).TryGetComponent(out RagDoll ragdoll))
{
return;
}
ragdoll.NetworkInfo = new RagdollInfo(player.ReferenceHub, handler, model_ragdoll.transform.localPosition, model_ragdoll.transform.localRotation);
this.ragdoll = ragdoll;
Map.RagdollsValue.Add(this);
if (canBeSpawned)
{
Spawn();
}
}
private static bool WriteDamageHandler(NetworkWriter writer, DamageHandlerBase info)
{
try
{
if (info?.GetType() == typeof(Turret.SynapseTurretDamageHandler))
{
writer?.WriteByte(DamageHandlers.IdsByTypeHash[typeof(CustomReasonDamageHandler).FullName.GetStableHashCode()]);
info?.WriteAdditionalData(writer);
return(false);
}
return(true);
}
catch (Exception ex)
{
Logger.Get.Error("Synapse-Turret: Failed to write Data of SynapseTurretDamageHandler:\n" + ex);
return(true);
}
}
private static bool OnDamage(HitboxIdentity __instance, DamageHandlerBase handler)
{
try
{
if (handler is AttackerDamageHandler ahandler)
{
var ply = __instance.TargetHub.GetPlayer();
var attacker = ahandler.Attacker.GetPlayer();
Logger.Get.Debug($"{ply == null} - {attacker == null}");
return(SynapseExtensions.GetHarmPermission(attacker, ply));
}
}
catch (Exception ex)
{
Logger.Get.Error($"Synapse-FF: PlayerDamage failed!!\n{ex}");
}
return(true);
}
/// <summary>
/// Announce the termination of a custom SCP name.
/// </summary>
/// <param name="scpname">SCP Name.</param>
/// <param name="info">Hit Information.</param>
public static void CustomSCPTermination(string scpname, DamageHandlerBase info)
{
string result = scpname;
if (info is MicroHidDamageHandler)
{
result += " SUCCESSFULLY TERMINATED BY AUTOMATIC SECURITY SYSTEM";
}
else if (info is WarheadDamageHandler)
{
result += " SUCCESSFULLY TERMINATED BY ALPHA WARHEAD";
}
else if (info is UniversalDamageHandler)
{
result += " LOST IN DECONTAMINATION SEQUENCE";
}
else if (info is FirearmDamageHandler firearmDamageHandler && Player.Get(firearmDamageHandler.Attacker.Hub) is Player attacker)
{
result += " CONTAINEDSUCCESSFULLY " + ConvertTeam(attacker.Team, attacker.UnitName);
}
private static bool DealDamagePatch(PlayerStats __instance, DamageHandlerBase handler)
{
try
{
if (!__instance._hub.characterClassManager.IsAlive ||
__instance._hub.characterClassManager.GodMode)
{
return(false);
}
var standardhandler = handler as StandardDamageHandler;
var type = handler.GetDamageType();
var victim = __instance.GetPlayer();
var attacker = handler is AttackerDamageHandler ahandler?ahandler.Attacker.GetPlayer() : null;
var damage = standardhandler.Damage;
if (type == DamageType.PocketDecay)
{
attacker = Server.Get.Players.FirstOrDefault(x => x.Scp106Controller.PocketPlayers.Contains(victim));
if (attacker != null && !SynapseExtensions.GetHarmPermission(attacker, victim))
{
return(false);
}
}
SynapseController.Server.Events.Player.InvokePlayerDamageEvent(victim, attacker, ref damage, type, out var allow);
standardhandler.Damage = damage;
return(allow);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerDamage event failed!!\n{e}");
return(true);
}
}
private static bool Prefix(ShootingTarget __instance, ref bool __result, float damage, DamageHandlerBase handler, Vector3 exactHit)
{
try
{
if (handler is not AttackerDamageHandler attackerDamageHandler)
{
__result = false;
return(false);
}
if (attackerDamageHandler.Attacker.Hub is null)
{
__result = false;
return(false);
}
DamagingShootingTargetEventArgs ev = new(
Player.Get(attackerDamageHandler.Attacker.Hub),
damage,
Vector3.Distance(attackerDamageHandler.Attacker.Hub.transform.position, __instance._bullsEye.position),
exactHit,
__instance,
handler);
Handlers.Player.OnDamagingShootingTarget(ev);
if (!ev.IsAllowed)
{
__result = false;
return(false);
}
foreach (ReferenceHub referenceHub in ReferenceHub.GetAllHubs().Values)
{
if (__instance._syncMode || referenceHub == attackerDamageHandler.Attacker.Hub)
{
__instance.TargetRpcReceiveData(referenceHub.characterClassManager.connectionToClient, ev.Amount, ev.Distance, exactHit, handler);
}
}
__result = true;
return(false);
}
catch (Exception exception)
{
Log.Error($"{typeof(DamagingShootingTarget).FullName}.{nameof(Prefix)}:\n{exception}");
return(false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DamagingShootingTargetEventArgs"/> class.
/// </summary>
/// <param name="player"><inheritdoc cref="Player"/></param>
/// <param name="damage"><inheritdoc cref="Amount"/></param>
/// <param name="distance"><inheritdoc cref="Distance"/></param>
/// <param name="shootingTarget"><inheritdoc cref="ShootingTarget"/></param>
/// <param name="damageHandler"><inheritdoc cref="Item"/></param>
/// <param name="hitLocation"><inheritdoc cref="HitLocation"/></param>
/// <param name="isAllowed"><inheritdoc cref="IsAllowed"/></param>
public DamagingShootingTargetEventArgs(Player player, float damage, float distance, Vector3 hitLocation, AdminToys.ShootingTarget shootingTarget, DamageHandlerBase damageHandler, bool isAllowed = true)
{
Player = player;
Amount = damage;
Distance = distance;
ShootingTarget = ShootingTargetToy.Get(shootingTarget);
Item = player.CurrentItem;
DamageHandler = (AttackerDamageHandler)damageHandler;
HitLocation = hitLocation;
IsAllowed = isAllowed;
}
/// <summary>
/// Initializes a new instance of the <see cref="OwnerDyingEventArgs"/> class.
/// </summary>
/// <param name="item"><inheritdoc cref="Item"/></param>
/// <param name="target"><inheritdoc cref="DyingEventArgs.Target"/></param>
/// <param name="damageHandler"><inheritdoc cref="DyingEventArgs.DamageHandler"/></param>
public OwnerDyingEventArgs(Item item, Player target, DamageHandlerBase damageHandler)
: base(target, damageHandler)
{
Item = item;
}
public bool Hurt(DamageHandlerBase handlerbase) => PlayerStats.DealDamage(handlerbase);
/// <summary> /// Announce a SCP Termination. /// </summary> /// <param name="scp">SCP to announce termination of.</param> /// <param name="info">HitInformation.</param> public static void SCPTermination(Player scp, DamageHandlerBase info) => NineTailedFoxAnnouncer.AnnounceScpTermination(scp.ReferenceHub, info);
