public static bool Prefix(RagdollManager __instance, Vector3 pos, Quaternion rot, int classId, PlayerStats.HitInfo ragdollInfo, bool allowRecall, string ownerID, string ownerNick, int playerId)
{
if (Configs.ragdoll_cleanup < 0)
{
return(true);
}
Log.Debug($"[RagdollCleanupPatch] {Enum.Parse(typeof(RoleType), classId.ToString())}{pos} Time:{Time.time} Cleanuptimes:{Configs.ragdoll_cleanup}");
Role role = __instance.ccm.Classes.SafeGet(classId);
if (role.model_ragdoll != null)
{
GameObject gameObject = UnityEngine.Object.Instantiate(role.model_ragdoll, pos + role.ragdoll_offset.position, Quaternion.Euler(rot.eulerAngles + role.ragdoll_offset.rotation));
NetworkServer.Spawn(gameObject);
gameObject.GetComponent <Ragdoll>().Networkowner = new Ragdoll.Info(ownerID, ownerNick, ragdollInfo, role, playerId);
gameObject.GetComponent <Ragdoll>().NetworkallowRecall = allowRecall;
ragdolls.Add(gameObject, Time.time);
}
if (ragdollInfo.GetDamageType().isScp || ragdollInfo.GetDamageType() == DamageTypes.Pocket)
{
__instance.RegisterScpFrag();
}
else if (ragdollInfo.GetDamageType() == DamageTypes.Grenade)
{
RoundSummary.kills_by_frag++;
}
return(false);
}
public static void Prefix(PlayerStats __instance, ref PlayerStats.HitInfo info, GameObject go)
{
try
{
if (go == null)
{
return;
}
var killer = __instance.GetPlayer();
if (info.GetDamageType() == DamageTypes.Grenade)
{
killer = Player.GetPlayer(info.PlayerId);
}
var player = go.GetPlayer();
Events.InvokePlayerHurtEvent(player, killer, ref info);
if (player.GodMode)
{
return;
}
if (player.Health + player.ArtificialHealth - info.Amount <= 0)
{
Events.InvokePlayerDieEvent(player, killer, info);
}
}
catch (Exception e)
{
Log.Error($"PlayerDamageEvent Error: {e}");
}
}
public static SimpleHitInfo Parse(this PlayerStats.HitInfo hitInfo)
{
return(new SimpleHitInfo()
{
Amount = hitInfo.Amount,
Attacker = hitInfo.Attacker,
Tool = hitInfo.Tool,
DamageType = hitInfo.GetDamageType().Parse(),
Time = hitInfo.Time
});
}
public static bool Prefix(Scp096 __instance, PlayerStats.HitInfo info)
{
if (info.GetDamageType().isWeapon&& SCP096Re.instance.Config.re096_damage_add_target)
{
GameObject playerObject = info.GetPlayerObject();
if (playerObject != null && __instance.CanEnrage)
{
__instance.AddTarget(playerObject);
__instance.Windup(false);
}
}
__instance.TimeUntilShieldRecharge = 10f;
return(false);
}
public new bool HurtPlayer(PlayerStats.HitInfo info, GameObject go)
{
if (!go.GetComponent <CharacterClassManager>().isLocalPlayer&& info.GetDamageType() != DamageTypes.None && !go.GetComponent <CharacterClassManager>().GodMode)
{
//if (Commands.CustomInternalCommands.nodamageplayers.ContainsKey(go.GetComponent<RemoteAdmin.QueryProcessor>().PlayerId))
// info.Amount = 0;
PheggPlayer pPlayer = new PheggPlayer(go);
PlayerStats Pstats = go.GetComponent <PlayerStats>();
PheggPlayer pAttacker = null;
if (info.GetPlayerObject() != null)
{
pAttacker = new PheggPlayer(info.GetPlayerObject());
}
if (Pstats.Health - info.Amount < 1)
{
try
{
Base.Debug("Triggering PlayerDeathEvent");
PluginManager.TriggerEvent <IEventHandlerPlayerDeath>(new PlayerDeathEvent(pPlayer, pAttacker, info.Amount, info.GetDamageType()));
}
catch (Exception e)
{
Base.Error($"Error triggering PlayerDeathEvent: {e.InnerException.ToString()}");
}
}
else
{
try
{
Base.Debug("Triggering PlayerHurtEvent");
PluginManager.TriggerEvent <IEventHandlerPlayerHurt>(new PlayerHurtEvent(pPlayer, pAttacker, info.Amount, info.GetDamageType()));
}
catch (Exception e)
{
Base.Error($"Error triggering PlayerHurtEvent: {e.InnerException.ToString()}");
}
}
}
return(orig_HurtPlayer(info, go));
}
public new void SpawnRagdoll(Vector3 pos, Quaternion rot, Vector3 velocity, int classId, PlayerStats.HitInfo ragdollInfo, bool allowRecall, string ownerID, string ownerNick, int playerId)
{
var ragdollDT = ragdollInfo.GetDamageType();
if (PMConfigFile.enable008 && (ragdollDT == DamageTypes.Scp0492 || ragdollDT == DamageTypes.Poison))
{
return;
}
else if (ragdollDT == DamageTypes.Pocket)
{
var gos = new List <GameObject>(GameObject.FindGameObjectsWithTag("RoomID"));
gos.AddRange(GameObject.FindGameObjectsWithTag("PD_EXIT"));
var list = new List <Vector3>();
foreach (GameObject go in gos)
{
list.Add(go.transform.position);
}
foreach (Scp106PlayerScript scp106PlayerScript in FindObjectsOfType <Scp106PlayerScript>())
{
if (scp106PlayerScript.portalPosition != Vector3.zero)
{
list.Add(scp106PlayerScript.portalPosition);
}
}
pos = GetPos(list);
allowRecall = false;
}
orig_SpawnRagdoll(pos, rot, velocity, classId, ragdollInfo, allowRecall, ownerID, ownerNick, playerId);
}
public static void Prefix(PlayerStats __instance, ref PlayerStats.HitInfo info, GameObject go)
{
if (EventPlugin.PlayerHurtPatchDisable)
{
return;
}
try
{
if (info.GetDamageType() == DamageTypes.Pocket)
{
bool allow = true;
Events.InvokePocketDimDamage(__instance.gameObject, ref allow);
if (!allow)
{
info.Amount = 0f;
}
if (info.Amount >= go.GetComponent <PlayerStats>().health)
{
Events.InvokePocketDimDeath(__instance.gameObject, ref allow);
}
if (!allow)
{
info.Amount = 0f;
}
}
if (info.GetDamageType() == DamageTypes.Grenade)
{
Events.InvokePlayerHurt(__instance, ref info, go, info.PlyId);
}
else
{
Events.InvokePlayerHurt(__instance, ref info, go);
}
if (info.Amount >= go.GetComponent <PlayerStats>().health || (go.GetComponent <PlayerStats>().health - info.Amount) <= 1f)
{
CharacterClassManager ccm = go.GetComponent <CharacterClassManager>();
if (ccm != null)
{
if (DeathStuff.Contains(ccm.UserId))
{
return;
}
DeathStuff.Add(ccm.UserId);
}
if (info.GetDamageType() == DamageTypes.Grenade)
{
Events.InvokePlayerDeath(__instance, ref info, go, info.PlyId);
}
else
{
Events.InvokePlayerDeath(__instance, ref info, go);
}
}
}
catch (Exception e)
{
Log.Error($"Player hurt/death event error: {e}");
}
}
private static bool Prefix(PlayerStats __instance, ref PlayerStats.HitInfo info, GameObject go)
{
try
{
if (go == null)
{
return(true);
}
API.Features.Player attacker = API.Features.Player.Get(info.IsPlayer ? info.RHub.gameObject : __instance.gameObject);
API.Features.Player target = API.Features.Player.Get(go);
if (target == null || target.IsHost)
{
return(true);
}
if (info.GetDamageType() == DamageTypes.Recontainment && target.Role == RoleType.Scp079)
{
Scp079.OnRecontained(new RecontainedEventArgs(target));
var eventArgs = new DiedEventArgs(null, target, info);
Player.OnDied(eventArgs);
}
if (attacker == null || attacker.IsHost)
{
return(true);
}
var ev = new HurtingEventArgs(attacker, target, info);
if (ev.Target.IsHost)
{
return(true);
}
Player.OnHurting(ev);
info = ev.HitInformations;
if (!ev.IsAllowed)
{
return(false);
}
if (!ev.Target.IsGodModeEnabled && (ev.Amount == -1 || ev.Amount >= ev.Target.Health + ev.Target.AdrenalineHealth))
{
var dyingEventArgs = new DyingEventArgs(ev.Attacker, ev.Target, ev.HitInformations);
Player.OnDying(dyingEventArgs);
if (!dyingEventArgs.IsAllowed)
{
return(false);
}
}
return(true);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.Hurting: {e}\n{e.StackTrace}");
return(true);
}
}
internal static void CalculateFF(GameObject Victim, PlayerStats.HitInfo info, out float damage)
{
try
{
damage = info.Amount;
if (!DetectorEnabled || !DoCheck || Victim.GetComponent <CharacterClassManager>().CurClass == RoleType.Spectator || (!info.GetDamageType().isWeapon&& info.GetDamageType() != DamageTypes.Grenade))
{
return;
}
FFInfo ffInfo = new FFInfo
{
DamageType = info.GetDamageType(),
HitInfo = info,
Target = ReferenceHub.GetHub(Victim),
Attacker = ReferenceHub.GetHub(info.GetPlayerObject()),
};
if (ffInfo.Attacker.playerId == ffInfo.Target.playerId)
{
return;
}
if (ffInfo.Target.characterClassManager.CurClass == RoleType.ClassD && ffInfo.Attacker.characterClassManager.CurClass == RoleType.ClassD)
{
UpdateLegitDamage(ffInfo.Attacker.characterClassManager.UserId);
return;
}
if (ffInfo.DamageType == DamageTypes.Grenade)
{
if (GrenadeThrowers.ContainsKey(ffInfo.Attacker.characterClassManager.UserId))
{
ffInfo.GrenadeThrower = GrenadeThrowers[ffInfo.Attacker.characterClassManager.UserId];
//Base.Info("FFInfoGrenadeThrower Set.");
}
else
{
ffInfo.GrenadeThrower = new GrenadeThrower
{
Role = ffInfo.Attacker.characterClassManager.CurClass,
Team = ffInfo.Attacker.characterClassManager.CurRole.team,
UserId = ffInfo.Attacker.characterClassManager.UserId,
DetonatePosition = ffInfo.Target.playerMovementSync.RealModelPosition
};
//Base.Info("FFInfoGrenadeThrower Default.");
}
ffInfo.NearbyPlayers = GetNearbyPlayersGrenade(GrenadeThrowers[ffInfo.Attacker.characterClassManager.UserId].DetonatePosition);
}
else
{
ffInfo.NearbyPlayers = GetNearbyPlayers(ffInfo);
}
if (ffInfo.Attacker.characterClassManager.CurRole.team == Team.RIP && ffInfo.DamageType == DamageTypes.Grenade)
{
ffInfo.AttackerTeam = ffInfo.GrenadeThrower.Team;
}
//Base.Info(ffInfo.AttackerTeam.ToString());
foreach (ReferenceHub hub in ffInfo.NearbyPlayers)
{
if (IsFF(ffInfo, hub))
{
ffInfo.Friendlies.Add(hub);
}
else
{
ffInfo.Hostiles.Add(hub);
}
}
bool isFF = IsFF(ffInfo, ffInfo.Target);
//Base.Info(isFF.ToString());
if (DamageList.ContainsKey(ffInfo.Attacker.characterClassManager.UserId))
{
ffInfo.LastLegitDamage = DamageList[ffInfo.Attacker.characterClassManager.UserId];
}
else
{
ffInfo.LastLegitDamage = new DateTime();
}
if (isFF)
{
if ((DateTime.Now - ffInfo.LastLegitDamage).TotalSeconds > 10 && (ffInfo.Hostiles.Count < 1 && ffInfo.Friendlies.Count > 0))
{
damage = 0;
HandleList(ffInfo);
}
}
else
{
if (DamageList.ContainsKey(ffInfo.Attacker.characterClassManager.UserId))
{
ffInfo.LastLegitDamage = DateTime.Now;
}
else
{
DamageList.Add(ffInfo.Attacker.characterClassManager.UserId, DateTime.Now);
}
}
}
catch (Exception e)
{
Base.Error(e.ToString());
damage = info.Amount;
}
#region E
//damage = info.Amount;
//if (!DoCheck || Victim.GetComponent<CharacterClassManager>().CurClass == RoleType.Spectator)
// return;
//DamageTypes.DamageType damageType = info.GetDamageType();
//if (!damageType.isWeapon && damageType != DamageTypes.Grenade)
//{
// updateLegitDamage(info.GetPlayerObject().GetComponent<CharacterClassManager>().UserId);
// return;
//}
//ReferenceHub vicHub = ReferenceHub.GetHub(Victim);
//ReferenceHub attHub = ReferenceHub.GetHub(info.GetPlayerObject());
//if (vicHub.characterClassManager.CurClass == RoleType.ClassD && attHub.characterClassManager.CurClass == RoleType.ClassD)
//{
// updateLegitDamage(info.GetPlayerObject().GetComponent<CharacterClassManager>().UserId);
// return;
//}
//if (vicHub.playerId == attHub.playerId)
//{
// updateLegitDamage(info.GetPlayerObject().GetComponent<CharacterClassManager>().UserId);
// return;
//}
//List<ReferenceHub> Hubs = new List<ReferenceHub>();
//List<ReferenceHub> Hostiles = new List<ReferenceHub>();
//List<ReferenceHub> Friendlies = new List<ReferenceHub>();
//if (info.GetDamageType() == DamageTypes.Grenade)
//{
// if (GrenadeThrowers.ContainsKey(attHub.characterClassManager.UserId))
// Hubs = GetNearbyPlayersGrenade(GrenadeThrowers[attHub.characterClassManager.UserId].DetonatePosition);
//}
//else
// Hubs = GetNearbyPlayers(attHub, Victim);
//Team attackerTeam = Team.RIP;
//if (attHub.characterClassManager.CurClass == RoleType.Spectator && info.GetDamageType() == DamageTypes.Grenade)
//{
// if (GrenadeThrowers.ContainsKey(attHub.characterClassManager.UserId))
// {
// attackerTeam = GrenadeThrowers[attHub.characterClassManager.UserId].Team;
// }
//}
//else
// attackerTeam = attHub.characterClassManager.CurRole.team;
//foreach (ReferenceHub hub in Hubs)
//{
// if (!IsFF(attHub, hub, attackerTeam))
// Hostiles.Add(hub);
// else
// Friendlies.Add(hub);
//}
//if (!DamageList.ContainsKey(attHub.characterClassManager.UserId) || (DateTime.Now - DamageList[attHub.characterClassManager.UserId]).TotalSeconds > 9)
//{
// if (Friendlies.Count > 0 && Hostiles.Count < 1)
// {
// damage = 0;
// HandleList(attHub, info, Victim, Friendlies, Hostiles);
// }
//}
//else
//{
//AddLegitDamage:
// updateLegitDamage(info.GetPlayerObject().GetComponent<CharacterClassManager>().UserId);
//}
#endregion
}
public static void Prefix(PlayerStats __instance, ref PlayerStats.HitInfo info, GameObject go)
{
if (EventPlugin.PlayerHurtPatchDisable)
{
return;
}
try
{
if (go == null) // As far as I remember, it's possible @iRebbok
{
return;
}
var goReferenceHub = ReferenceHub.GetHub(go);
// observe the order of calling the event, first there is damage to the player
if (info.GetDamageType() == DamageTypes.Grenade)
{
Events.InvokePlayerHurt(__instance, ref info, go, info.PlyId);
}
else
{
Events.InvokePlayerHurt(__instance, ref info, go);
}
// GodMode players can't die
if (goReferenceHub.characterClassManager.GodMode)
{
return;
}
bool isDied = goReferenceHub.playerStats.health - info.Amount < 1f;
// If the last attack was from the 'ARTIFICIALDEGEN', then hp not change
if (goReferenceHub.playerStats.unsyncedArtificialHealth > 0f && !goReferenceHub.playerStats.lastHitInfo.Attacker.Equals("ARTIFICIALDEGEN"))
{
// reduced attack damage for unsyncedHp
var reducedDamage = info.Amount * goReferenceHub.playerStats.artificialNormalRatio;
// the remainder of the damage
var remainderDamage = info.Amount - reducedDamage;
var finalUnsyncedHp = goReferenceHub.playerStats.unsyncedArtificialHealth - reducedDamage;
if (finalUnsyncedHp < 0f)
{
remainderDamage += Mathf.Abs(goReferenceHub.playerStats.unsyncedArtificialHealth);
goReferenceHub.playerStats.unsyncedArtificialHealth = 0f;
}
var finalHp = goReferenceHub.playerStats.health - remainderDamage;
// Don't use bitwise operations,
// this is the hp that will remain after everything
isDied = finalHp < 1f;
}
if (info.GetDamageType() == DamageTypes.Pocket)
{
bool allow = true;
Events.InvokePocketDimDamage(__instance.gameObject, ref allow);
if (!allow)
{
info.Amount = 0f;
}
if (isDied)
{
Events.InvokePocketDimDeath(__instance.gameObject, ref allow);
}
if (!allow)
{
info.Amount = 0f;
}
}
// don't need to check if it contains more damage
if (isDied)
{
// I don't think that's possible
// ReferenceHub can't be without CharterClassManager
//if (goReferenceHub.characterClassManager != null)
//{
// Checking to re-call the event for this player??? Does it work?
//
if (DeathStuff.Contains(goReferenceHub.characterClassManager.UserId))
{
return;
}
DeathStuff.Add(goReferenceHub.characterClassManager.UserId);
//}
if (info.GetDamageType() == DamageTypes.Grenade)
{
Events.InvokePlayerDeath(__instance, ref info, go, info.PlyId);
}
else
{
Events.InvokePlayerDeath(__instance, ref info, go);
}
}
}
catch (Exception exception)
{
Log.Error($"PocketDimDamageEvent/PocketDimDeathEvent/PlayerHurtEvent error: {exception}");
}
}
private static bool Prefix(PlayerStats __instance, out bool __result, PlayerStats.HitInfo info, GameObject go, bool noTeamDamage = false, bool IsValidDamage = true)
{
try
{
__result = false;
var player = go?.GetPlayer();
var killer = __instance?.GetPlayer();
if (player == null)
{
return(false);
}
if (info.GetDamageType() == DamageTypes.Grenade)
{
killer = SynapseController.Server.GetPlayer(info.PlayerId);
}
else if (info.GetDamageType() == DamageTypes.Pocket)
{
killer = Server.Get.Players.FirstOrDefault(x => x.Scp106Controller.PocketPlayers.Contains(player));
if (SynapseExtensions.CanNotHurtByScp(player))
{
return(false);
}
}
bool flag = false;
bool flag2 = false;
bool flag3 = go == null;
ReferenceHub referenceHub = flag3 ? null : ReferenceHub.GetHub(go);
if (info.Amount < 0f)
{
if (flag3)
{
info.Amount = Mathf.Abs(999999f);
}
else
{
info.Amount = ((referenceHub.playerStats != null) ? Mathf.Abs(referenceHub.playerStats.Health + referenceHub.playerStats.syncArtificialHealth + 10f) : Mathf.Abs(999999f));
}
}
if (__instance._burned.Enabled)
{
info.Amount *= __instance._burned.DamageMult;
}
if (info.Amount > 2.14748365E+09f)
{
info.Amount = 2.14748365E+09f;
}
if (info.GetDamageType().isWeapon&& referenceHub.characterClassManager.IsAnyScp() && info.GetDamageType() != DamageTypes.MicroHid)
{
info.Amount *= __instance.weaponManager.weapons[(int)__instance.weaponManager.curWeapon].scpDamageMultiplier;
}
if (flag3)
{
__result = false;
return(false);
}
PlayerStats playerStats = referenceHub.playerStats;
CharacterClassManager characterClassManager = referenceHub.characterClassManager;
if (playerStats == null || characterClassManager == null)
{
__result = false;
return(false);
}
if (characterClassManager.GodMode)
{
__result = false;
return(false);
}
if (__instance.ccm.CurRole.team == Team.SCP && __instance.ccm.Classes.SafeGet(characterClassManager.CurClass).team == Team.SCP && __instance.ccm != characterClassManager)
{
__result = false;
return(false);
}
if (characterClassManager.SpawnProtected && !__instance._allowSPDmg)
{
__result = false;
return(false);
}
bool flag4 = !noTeamDamage && info.IsPlayer && referenceHub != info.RHub && referenceHub.characterClassManager.Fraction == info.RHub.characterClassManager.Fraction;
if (flag4)
{
info.Amount *= PlayerStats.FriendlyFireFactor;
}
float health = playerStats.Health;
if (__instance.lastHitInfo.Attacker == "ARTIFICIALDEGEN")
{
playerStats.unsyncedArtificialHealth -= info.Amount;
if (playerStats.unsyncedArtificialHealth < 0f)
{
playerStats.unsyncedArtificialHealth = 0f;
}
}
else
{
var allow = true;
try
{
Server.Get.Events.Player.InvokePlayerDamageEvent(player, killer, ref info, out allow);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerDamage Event failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
if (!allow)
{
__result = false;
return(false);
}
if (playerStats.unsyncedArtificialHealth > 0f)
{
float num = info.Amount * playerStats.artificialNormalRatio;
float num2 = info.Amount - num;
playerStats.unsyncedArtificialHealth -= num;
if (playerStats.unsyncedArtificialHealth < 0f)
{
num2 += Mathf.Abs(playerStats.unsyncedArtificialHealth);
playerStats.unsyncedArtificialHealth = 0f;
}
playerStats.Health -= num2;
if (playerStats.Health > 0f && playerStats.Health - num <= 0f && characterClassManager.CurRole.team != Team.SCP)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "didntevenfeelthat");
}
}
else
{
playerStats.Health -= info.Amount;
}
if (playerStats.Health < 0f)
{
playerStats.Health = 0f;
}
playerStats.lastHitInfo = info;
}
PlayableScpsController component = go.GetComponent <PlayableScpsController>();
if (component != null && (object)component.CurrentScp is PlayableScps.Interfaces.IDamagable damagable)
{
damagable.OnDamage(info);
}
if (playerStats.Health < 1f && characterClassManager.CurClass != RoleType.Spectator)
{
if (component != null && (object)component.CurrentScp is PlayableScps.Interfaces.IImmortalScp immortalScp && !immortalScp.OnDeath(info, __instance.gameObject))
{
__result = false;
return(false);
}
foreach (Scp079PlayerScript scp079PlayerScript in Scp079PlayerScript.instances)
{
Scp079Interactable.ZoneAndRoom otherRoom = go.GetComponent <Scp079PlayerScript>().GetOtherRoom();
bool flag5 = false;
foreach (Scp079Interaction scp079Interaction in scp079PlayerScript.ReturnRecentHistory(12f, __instance._filters))
{
foreach (Scp079Interactable.ZoneAndRoom zoneAndRoom in scp079Interaction.interactable.currentZonesAndRooms)
{
if (zoneAndRoom.currentZone == otherRoom.currentZone && zoneAndRoom.currentRoom == otherRoom.currentRoom)
{
flag5 = true;
}
}
}
if (flag5)
{
scp079PlayerScript.RpcGainExp(ExpGainType.KillAssist, characterClassManager.CurClass);
}
}
if (RoundSummary.RoundInProgress() && RoundSummary.roundTime < 60 && IsValidDamage)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "wowreally");
}
if (__instance.isLocalPlayer && info.PlayerId != referenceHub.queryProcessor.PlayerId)
{
RoundSummary.Kills++;
}
flag = true;
if (characterClassManager.CurClass == RoleType.Scp096)
{
ReferenceHub hub = ReferenceHub.GetHub(go);
if (hub != null && hub.scpsController.CurrentScp is PlayableScps.Scp096 && (hub.scpsController.CurrentScp as PlayableScps.Scp096).PlayerState == PlayableScps.Scp096PlayerState.Enraging)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "unvoluntaryragequit");
}
}
else if (info.GetDamageType() == DamageTypes.Pocket)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "newb");
}
else if (info.GetDamageType() == DamageTypes.Scp173)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "firsttime");
}
else if (info.GetDamageType() == DamageTypes.Grenade && info.PlayerId == referenceHub.queryProcessor.PlayerId)
{
__instance.TargetAchieve(characterClassManager.connectionToClient, "iwanttobearocket");
}
else if (info.GetDamageType().isWeapon)
{
Inventory inventory = referenceHub.inventory;
if (characterClassManager.CurClass == RoleType.Scientist)
{
Item itemByID = inventory.GetItemByID(inventory.curItem);
if (itemByID != null && itemByID.itemCategory == ItemCategory.Keycard && __instance.GetComponent <CharacterClassManager>().CurClass == RoleType.ClassD)
{
__instance.TargetAchieve(__instance.connectionToClient, "betrayal");
}
}
if (Time.realtimeSinceStartup - __instance._killStreakTime > 30f || __instance._killStreak == 0)
{
__instance._killStreak = 0;
__instance._killStreakTime = Time.realtimeSinceStartup;
}
if (__instance.GetComponent <WeaponManager>().GetShootPermission(characterClassManager, true))
{
__instance._killStreak++;
}
if (__instance._killStreak >= 5)
{
__instance.TargetAchieve(__instance.connectionToClient, "pewpew");
}
if ((__instance.ccm.CurRole.team == Team.MTF || __instance.ccm.Classes.SafeGet(__instance.ccm.CurClass).team == Team.RSC) && characterClassManager.CurClass == RoleType.ClassD)
{
__instance.TargetStats(__instance.connectionToClient, "dboys_killed", "justresources", 50);
}
}
else if (__instance.ccm.CurRole.team == Team.SCP && go.GetComponent <MicroHID>().CurrentHidState != MicroHID.MicroHidState.Idle)
{
__instance.TargetAchieve(__instance.connectionToClient, "illpassthanks");
}
if (player.RealTeam == Team.RSC && player.RealTeam == Team.SCP)
{
__instance.TargetAchieve(__instance.connectionToClient, "timetodoitmyself");
}
bool flag6 = info.IsPlayer && referenceHub == info.RHub;
flag2 = flag4;
if (flag6)
{
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, string.Concat(new string[]
{
referenceHub.LoggedNameFromRefHub(),
" playing as ",
referenceHub.characterClassManager.CurRole.fullName,
" committed a suicide using ",
info.GetDamageName(),
"."
}), ServerLogs.ServerLogType.Suicide, false);
}
else
{
ServerLogs.AddLog(ServerLogs.Modules.ClassChange, string.Concat(new string[]
{
referenceHub.LoggedNameFromRefHub(),
" playing as ",
referenceHub.characterClassManager.CurRole.fullName,
" has been killed by ",
info.Attacker,
" using ",
info.GetDamageName(),
info.IsPlayer ? (" playing as " + info.RHub.characterClassManager.CurRole.fullName + ".") : "."
}), flag2 ? ServerLogs.ServerLogType.Teamkill : ServerLogs.ServerLogType.KillLog, false);
}
if (info.GetDamageType().isScp || info.GetDamageType() == DamageTypes.Pocket)
{
RoundSummary.kills_by_scp++;
}
else if (info.GetDamageType() == DamageTypes.Grenade)
{
RoundSummary.kills_by_frag++;
}
try
{
Server.Get.Events.Player.InvokePlayerDeathEvent(player, killer, info);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerDeath Event failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
if (!__instance._pocketCleanup || info.GetDamageType() != DamageTypes.Pocket)
{
referenceHub.inventory.ServerDropAll();
PlayerMovementSync playerMovementSync = referenceHub.playerMovementSync;
if (characterClassManager.Classes.CheckBounds(characterClassManager.CurClass) && info.GetDamageType() != DamageTypes.RagdollLess)
{
__instance.GetComponent <RagdollManager>().SpawnRagdoll(go.transform.position, go.transform.rotation, (playerMovementSync == null) ? Vector3.zero : playerMovementSync.PlayerVelocity, (int)characterClassManager.CurClass, info, characterClassManager.CurRole.team > Team.SCP, go.GetComponent <Dissonance.Integrations.MirrorIgnorance.MirrorIgnorancePlayer>().PlayerId, referenceHub.nicknameSync.DisplayName, referenceHub.queryProcessor.PlayerId);
}
}
else
{
referenceHub.inventory.Clear();
}
characterClassManager.NetworkDeathPosition = go.transform.position;
if (characterClassManager.CurRole.team == Team.SCP)
{
if (characterClassManager.CurClass == RoleType.Scp0492)
{
NineTailedFoxAnnouncer.CheckForZombies(go);
}
else
{
GameObject x = null;
foreach (GameObject gameObject in PlayerManager.players)
{
if (gameObject.GetComponent <RemoteAdmin.QueryProcessor>().PlayerId == info.PlayerId)
{
x = gameObject;
}
}
if (x != null)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, string.Empty);
}
else
{
DamageTypes.DamageType damageType = info.GetDamageType();
if (damageType == DamageTypes.Tesla)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "TESLA");
}
else if (damageType == DamageTypes.Nuke)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "WARHEAD");
}
else if (damageType == DamageTypes.Decont)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "DECONTAMINATION");
}
else if (characterClassManager.CurClass != RoleType.Scp079)
{
NineTailedFoxAnnouncer.AnnounceScpTermination(characterClassManager.CurRole, info, "UNKNOWN");
}
}
}
}
playerStats.SetHPAmount(100);
characterClassManager.SetClassID(RoleType.Spectator);
player.CustomRole = null;
foreach (var larry in Server.Get.Players.Where(x => x.Scp106Controller.PocketPlayers.Contains(player)))
{
larry.Scp106Controller.PocketPlayers.Remove(player);
}
}
else
{
Vector3 pos = Vector3.zero;
float num3 = 40f;
if (info.GetDamageType().isWeapon)
{
GameObject playerOfID = __instance.GetPlayerOfID(info.PlayerId);
if (playerOfID != null)
{
pos = go.transform.InverseTransformPoint(playerOfID.transform.position).normalized;
num3 = 100f;
}
}
else if (info.GetDamageType() == DamageTypes.Pocket)
{
PlayerMovementSync component2 = __instance.ccm.GetComponent <PlayerMovementSync>();
if (component2.RealModelPosition.y > -1900f)
{
component2.OverridePosition(Vector3.down * 1998.5f, 0f, true);
}
}
__instance.TargetBloodEffect(go.GetComponent <NetworkIdentity>().connectionToClient, pos, Mathf.Clamp01(info.Amount / num3));
}
Respawning.RespawnTickets singleton = Respawning.RespawnTickets.Singleton;
Team team = characterClassManager.CurRole.team;
byte b = (byte)team;
if (b != 0)
{
if (b == 3)
{
if (flag)
{
Team team2 = __instance.ccm.Classes.SafeGet(characterClassManager.CurClass).team;
if (team2 == Team.CDP && team2 == Team.CHI)
{
singleton.GrantTickets(Respawning.SpawnableTeamType.ChaosInsurgency, __instance._respawn_tickets_ci_scientist_died_count, false);
}
}
}
}
else if (characterClassManager.CurClass != RoleType.Scp0492)
{
for (float num4 = 1f; num4 > 0f; num4 -= __instance._respawn_tickets_mtf_scp_hurt_interval)
{
float num5 = (float)playerStats.maxHP * num4;
if (health > num5 && playerStats.Health < num5)
{
singleton.GrantTickets(Respawning.SpawnableTeamType.NineTailedFox, __instance._respawn_tickets_mtf_scp_hurt_count, false);
}
}
}
if (component != null && (object)component.CurrentScp is PlayableScps.Interfaces.IDamagable damagable2)
{
damagable2.OnDamage(info);
}
if (!flag4 || FriendlyFireConfig.PauseDetector || PermissionsHandler.IsPermitted(info.RHub.serverRoles.Permissions, PlayerPermissions.FriendlyFireDetectorImmunity))
{
__result = flag;
return(false);
}
if (FriendlyFireConfig.IgnoreClassDTeamkills && referenceHub.characterClassManager.CurRole.team == Team.CDP && info.RHub.characterClassManager.CurRole.team == Team.CDP)
{
__result = flag;
return(false);
}
if (flag2)
{
if (info.RHub.FriendlyFireHandler.Respawn.RegisterKill())
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Window.RegisterKill())
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Life.RegisterKill())
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Round.RegisterKill())
{
__result = flag;
return(false);
}
}
if (info.RHub.FriendlyFireHandler.Respawn.RegisterDamage(info.Amount))
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Window.RegisterDamage(info.Amount))
{
__result = flag;
return(false);
}
if (info.RHub.FriendlyFireHandler.Life.RegisterDamage(info.Amount))
{
__result = flag;
return(false);
}
info.RHub.FriendlyFireHandler.Round.RegisterDamage(info.Amount);
__result = flag;
return(false);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerDamage Patch failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
__result = false;
return(true);
}
}
