private void OnEntityDeath(BaseCombatEntity entity, HitInfo hitInfo)
{
if (blockOnDestroy)
{
if (hitInfo == null || hitInfo.WeaponPrefab == null || hitInfo.Initiator == null || !IsEntityBlocked(entity))
{
return;
}
if (damageTypes.Contains(hitInfo.damageTypes.GetMajorityDamageType().ToString()))
{
StructureAttack(entity, hitInfo.Initiator, hitInfo.WeaponPrefab.LookupShortPrefabName(), hitInfo.HitPositionWorld);
}
return;
}
if (entity.ToPlayer() == null)
{
return;
}
var player = entity.ToPlayer();
if ((raidBlock || combatBlock) && unblockOnDeath && IsEscapeBlocked(player))
{
timer.In(0.3f, delegate()
{
StopBlocking(player.UserIDString);
});
}
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitinfo)
{
if (hitinfo.hasDamage)
{
float dd = 0.0f;
bool armourDamaged = false;
if (hitinfo.damageTypes?.Get(Rust.DamageType.Drowned) > 0.0f)
{
dd = getDamageDeduction(entity.ToPlayer(), Rust.DamageType.Drowned);
float newdamage = getScaledDamage(hitinfo.damageTypes.Get(Rust.DamageType.Drowned), dd);
hitinfo.damageTypes.Set(Rust.DamageType.Drowned, newdamage);
armourDamaged = true;
}
if (hitinfo.damageTypes?.Get(Rust.DamageType.Cold) > 0.0f && entity.ToPlayer().IsSwimming())
{
dd = getDamageDeduction(entity.ToPlayer(), Rust.DamageType.Cold);
float newdamage = getScaledDamage(hitinfo.damageTypes.Get(Rust.DamageType.Cold), dd);
hitinfo.damageTypes.Set(Rust.DamageType.Cold, newdamage);
armourDamaged = true;
}
if (armourDamaged && damageArmour)
{
foreach (Item i in entity.ToPlayer().inventory.containerWear.itemList)
{
if (i.info.name.ToLower().Contains("hazmat"))
{
i.condition = i.condition - armourDamageAmount;
}
}
}
}
}
void OnEntityDeath(BaseCombatEntity victim, HitInfo info)
{
if (victim?.ToPlayer()?.xp?.CurrentLevel != null && LevelLossOnDeath != 0)
{
SetLevel(victim.ToPlayer(), Mathx.Clamp(Convert.ToInt32(victim.ToPlayer().xp.CurrentLevel - (victim.ToPlayer().xp.CurrentLevel / 100) * LevelLossOnDeath), MinimalLevel, MaximalLevel));
}
}
private void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitinfo)
{
if (!hitinfo.hasDamage)
{
return;
}
float deduction;
//var armorDamaged = false;
if (hitinfo.damageTypes?.Get(Rust.DamageType.Cold) > 0.0f && entity.ToPlayer().IsSwimming())
{
deduction = GetDamageDeduction(entity.ToPlayer(), Rust.DamageType.Cold);
var newdamage = GetScaledDamage(hitinfo.damageTypes.Get(Rust.DamageType.Cold), deduction);
hitinfo.damageTypes.Set(Rust.DamageType.Cold, newdamage);
//armorDamaged = true;
}
if (hitinfo.damageTypes?.Get(Rust.DamageType.Drowned) > 0.0f)
{
deduction = GetDamageDeduction(entity.ToPlayer(), Rust.DamageType.Drowned);
var newdamage = GetScaledDamage(hitinfo.damageTypes.Get(Rust.DamageType.Drowned), deduction);
hitinfo.damageTypes.Set(Rust.DamageType.Drowned, newdamage);
//armorDamaged = true;
}
/*if (armorDamaged && damageArmor)
* {
* foreach (var item in entity.ToPlayer().inventory.containerWear.itemList)
* if (item.info.name.ToLower().Contains("hazmat")) item.condition = item.condition - armorDamageAmount;
* }*/
}
public void SuddenDeath(BaseCombatEntity entity, HitInfo hitInfo)
{
if (entity as BasePlayer == null || hitInfo == null)
{
return;
}
if (entity.ToPlayer() != null)
{
IemUtils.DLog("player died");
BasePlayer player = entity.ToPlayer();
if (GetIemPlayerById(player.UserIDString) != null)
{
IemUtils.GLog("scaling damage");
hitInfo.damageTypes.Scale(DamageType.Bullet, 1000f);
hitInfo.damageTypes.Scale(DamageType.Arrow, 1000f);
hitInfo.damageTypes.Scale(DamageType.Blunt, 1000f);
hitInfo.damageTypes.Scale(DamageType.Explosion, 1000f);
hitInfo.damageTypes.Scale(DamageType.Stab, 1000f);
//hitInfo.damageTypes.Scale(DamageType., 1000f);
}
else
{
IemUtils.GLog("not found player");
}
}
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
if (!(entity is BasePlayer))
{
return;
}
if (!adminProtection.ContainsKey(entity.ToPlayer().UserIDString))
{
return;
}
if (!(info.Initiator is BasePlayer))
{
return;
}
BasePlayer targetplayer = info.InitiatorPlayer;
if (targetplayer.IsConnected)
{
if (GUIinfo.ContainsKey(targetplayer.UserIDString))
{
return;
}
DoGUI(targetplayer, adminProtection[entity.ToPlayer().UserIDString], false, null);
}
return;
}
/// <summary>
/// Sends data about a player death
/// </summary>
/// <param name="victim"></param>
/// <param name="info"></param>
void OnEntityDeath(BaseCombatEntity victim, HitInfo info)
{
var target = victim?.ToPlayer();
var attacker = info?.Initiator?.ToPlayer();
var entity = info?.Initiator;
if (victim?.ToPlayer() != null && info?.Initiator?.ToPlayer() != null)
{
if (target.userID == attacker.userID)
{
Puts("Self-Inflicted Death: " + target.displayName + "(" + info.damageTypes.GetMajorityDamageType() + ")");
return;
}
var weapon = info?.Weapon?.GetItem()?.info?.displayName?.english ?? "Unknown";
var bone = info?.boneName ?? "Unknown";
var attackerHealth = Convert.ToString(info.Initiator.Health()) ?? "Unknown";
var distance = Convert.ToString(attacker.Distance(target.transform.position)) ?? "Unknown";
var data = new Dictionary <string, string> {
{ "VictimID", target.userID.ToString() },
{ "KillerID", attacker.userID.ToString() },
{ "KillerHP", attackerHealth },
{ "Weapon", weapon },
{ "Distance", distance },
{ "Bone", bone }
};
this.sendData(this.getEndpoint("playerKilled"), data, "Sending Kill to Website");
}
}
private object CanBeTargeted(BaseCombatEntity target, MonoBehaviour turret)
{
if (target is BasePlayer)
{
var isInvisible = Vanish?.Call("IsInvisible", target);
if (isInvisible != null && (bool)isInvisible)
{
return(null);
}
var isStealthed = Skills?.Call("isStealthed", target);
if (isStealthed != null && (bool)isStealthed)
{
return(null);
}
}
if (!(turret is AutoTurret))
{
return(null);
}
if (animalOverride == true && target.GetComponent <BaseNPC>() != null)
{
if (animals.Count > 0)
{
if (animals.Contains(target.ShortPrefabName.Replace(".prefab", "").ToLower()))
{
return(false);
}
else
{
return(null);
}
}
else
{
return(false);
}
}
if (target.ToPlayer() == null)
{
return(null);
}
BasePlayer targetPlayer = target.ToPlayer();
if (adminOverride && targetPlayer.IsConnected() && targetPlayer.net.connection.authLevel > 0)
{
return(false);
}
else if (sleepOverride && targetPlayer.IsSleeping())
{
return(false);
}
return(null);
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
try
{
if (info.Initiator.ToPlayer().IsValid())
{
BasePlayer ply = info.Initiator.ToPlayer();
Dictionary <DamageType, float> dmg = new Dictionary <DamageType, float>();
float EdittedTotal = 0;
float total = info.damageTypes.Total();
float scale = sd.ScaleDamageGive;
float hund = 100;
float scalecal = scale / hund;
int DamageTypeMax = (int)DamageType.LAST;
for (var i = 0; i < DamageTypeMax; i++)
{
EdittedTotal = info.damageTypes.Get((DamageType)i);
Double level = sd.PlayerLevel[ply.UserIDString];
if (level > sd.MaxScaleDamageGive)
{
level = sd.MaxScaleDamageGive;
}
for (int x = 0; x < level; x++)
{
EdittedTotal = EdittedTotal + (EdittedTotal * scalecal);
}
info.damageTypes.Set((DamageType)i, EdittedTotal);
}
}
if (entity.ToPlayer().IsValid())
{
BasePlayer ply = entity.ToPlayer();
float EdittedTotal = 0;
float total = info.damageTypes.Total();
float scale = sd.ScaleDamageGive;
float hund = 100;
float scalecal = scale / hund;
int DamageTypeMax = (int)DamageType.LAST;
for (var i = 0; i < DamageTypeMax; i++)
{
EdittedTotal = info.damageTypes.Get((DamageType)i);
float NotEdittedTotal = info.damageTypes.Get((DamageType)i);
Double level = sd.PlayerLevel[ply.UserIDString];
for (int x = 0; x < level; x++)
{
if (EdittedTotal <= (NotEdittedTotal * (sd.MaxScaleDamageReceive / 100)))
{
EdittedTotal = EdittedTotal - (EdittedTotal * scalecal);
}
}
info.damageTypes.Set((DamageType)i, EdittedTotal);
}
}
}
catch
{
}
return;
}
void OnEntityTakeDamage(BaseCombatEntity vic, HitInfo hitInfo)
{
if (vic == null || hitInfo == null || vic.ToPlayer() == null)
{
return;
}
lastHitInfo[vic.ToPlayer()] = hitInfo;
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
{
if (!configData.Settings.KillAllEntitiesOnDeath)
{
return;
}
if (entity == null)
{
return;
}
if (!entity.ToPlayer())
{
return;
}
if (configData.Settings.LimitToPVPDeath && !info?.Initiator?.ToPlayer())
{
return;
}
var player = entity.ToPlayer();
if (CheckPermission(player, Permission))
{
return;
}
foreach (var entityofplayer in BaseNetworkable.serverEntities.Where(x => (x as BaseEntity).OwnerID == player.userID).ToList())
{
entity2 = entityofplayer.ShortPrefabName;
if (configData.Settings.DropLootFromChests && LootContainers.Contains(entity2))
{
var entityofplayertest = entityofplayer as BaseCombatEntity;
entityofplayertest.Hurt(99999999999, Rust.DamageType.Slash);
continue;
}
if (entityofplayer is BuildingBlock)
{
if (configData.ExclusionList.Excluded.Contains(entityofplayer.ShortPrefabName))
{
continue;
}
var entityasbuildingblock = entityofplayer as BuildingBlock;
grade = entityasbuildingblock.grade.ToString().ToLower();
if (grade == "twigs")
{
grade = "twig";
}
entity2 = entityofplayer.ShortPrefabName + "." + grade;
}
if (configData.ExclusionList.Excluded.Contains(entity2))
{
continue;
}
entityofplayer.Kill();
}
}
HitInfo TryGetLastHit(BaseCombatEntity vic)
{
if (vic == null || vic.ToPlayer() == null)
{
return(null);
}
if (lastHitInfo.ContainsKey(vic.ToPlayer()))
{
return(lastHitInfo[vic.ToPlayer()]);
}
return(null);
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
if (entity?.ToPlayer() != null && info?.Initiator?.ToPlayer() != null)
{
NextTick(() =>
{
if (entity.ToPlayer().IsWounded())
{
LastWounded[entity.ToPlayer().userID] = info;
}
});
}
}
string GetVictim(BaseCombatEntity vic)
{
string victim = "Unknown Victim";
if (vic != null)
{
if (vic.ToPlayer() != null)
{
victim = vic.ToPlayer().displayName; // Get Name of the Victim.
}
}
return(victim);
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
{
try
{
if (entity == info.Initiator)
{
return;
}
if (entity == null || info.Initiator == null)
{
return;
}
if (info?.Initiator?.ToPlayer() == null && (entity?.name?.Contains("autospawn") ?? false))
{
return;
}
if (entity.ToPlayer() != null)
{
if (entity.ToPlayer().IsWounded())
{
info = TryGetLastWounded(entity.ToPlayer().userID, info);
}
}
if (entity != null && entity is BasePlayer && info?.Initiator != null && info.Initiator is BasePlayer)
{
PlayerData victimData = PlayerData.Find((BasePlayer)entity);
PlayerData attackerData = PlayerData.Find((BasePlayer)info.Initiator);
victimData.deaths++;
attackerData.kills++;
victimData.Save();
attackerData.Save();
if (!AllPlayerIds.Contains(victimData.id))
{
AllPlayerIds.Add(victimData.id);
}
if (!AllPlayerIds.Contains(attackerData.id))
{
AllPlayerIds.Add(attackerData.id);
}
SaveAllPlayers();
}
}
catch (Exception ex)
{
}
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
{
if (usingCS && hasStarted && entity != null && !isEnding)
{
var attacker = hitInfo.InitiatorPlayer;
if (attacker == null)
{
return;
}
var helicopter = entity.GetComponent <CSHelicopter>();
if (helicopter != null && !attacker.GetComponent <CSPlayer>())
{
hitInfo.damageTypes = new DamageTypeList();
hitInfo.HitEntity = null;
hitInfo.HitMaterial = 0;
hitInfo.PointStart = Vector3.zero;
return;
}
if (attacker.GetComponent <CSPlayer>())
{
if (entity is BasePlayer)
{
if (entity.ToPlayer() == null || hitInfo == null)
{
return;
}
if (entity.ToPlayer().userID != hitInfo.Initiator.ToPlayer().userID)
{
if (entity.GetComponent <CSPlayer>())
{
hitInfo.damageTypes.ScaleAll(configData.PlayerSettings.FFDamageScale);
SendReply(attacker, MSG("fFire"));
}
}
}
if (helicopter != null)
{
int points = entity.GetComponent <CSHelicopter>().TakeDamage(hitInfo);
RefreshHealthUI(helicopter);
hitInfo.damageTypes = new DamageTypeList();
hitInfo.HitEntity = null;
hitInfo.HitMaterial = 0;
hitInfo.PointStart = Vector3.zero;
attacker.GetComponent <CSPlayer>().points += points;
}
}
}
}
void OnEntityDeath(BaseCombatEntity victim, HitInfo info)
{
if (victim == null)
{
return;
}
if (victim.ToPlayer() != null)
{
IemUtils.GLog("player died - calling hooks");
BasePlayer player = victim.ToPlayer();
PlayerDying(player, info);
}
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo hitInfo)
{
if (entity == null || entity as BasePlayer == null)
{
return;
}
BasePlayer player = entity.ToPlayer();
if (!player.IsConnected())
{
return;
}
if (ProtectAdmin && player.IsAdmin())
{
return;
}
var playerInfo = ServerMgr.Instance.persistance.GetPlayerInfo(player.userID);
var blueprints = playerInfo.unlockedItems;
if (blueprints.Count == 0)
{
return;
}
var blueprint = blueprints.ToList()[UnityEngine.Random.Range(0, blueprints.Count)];
blueprints.Remove(blueprint);
ServerMgr.Instance.persistance.SetPlayerInfo(player.userID, playerInfo);
player.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
ItemDefinition bp = ItemManager.FindItemDefinition(blueprint);
timer.Once(3f, () =>
{
PrintToChat(player, Prefix + " " + Lang("BlueprintUnlearned", player.UserIDString, bp.displayName.translated));
});
}
bool?OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
if (_Instance == null)
{
return(null);
}
// If entity being attacked is a normal player and
// the initiator is not a npc player
if (entity is BasePlayer && !(entity is NPCPlayer) && !(entity is HTNPlayer) &&
info.Initiator != null && !(info.Initiator is NPCPlayer || info.Initiator is HTNPlayer))
{
if (!_Instance.ContainsPlayer(entity.ToPlayer().userID))
{
info.DidHit = false;
return(true);
}
}
// Disable damage to these types
if (entity is BuildingBlock ||
entity is AnimatedBuildingBlock ||
entity is Signage ||
//entity is StorageContainer*/
entity is Barricade /*||
* entity is DecayEntity*/)
{
info.damageTypes = new DamageTypeList();
}
return(null);
}
private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
if (!(entity is BasePlayer))
{
return(null);
}
var attacker = info?.InitiatorPlayer;
var victim = entity?.ToPlayer();
if (!IsInvisible(victim) && !IsInvisible(attacker))
{
return(null);
}
if (IsInvisible(attacker) && HasPerm(attacker.UserIDString, permdamage))
{
return(null);
}
if (info != null)
{
info.damageTypes = _EmptyDmgList;
info.HitMaterial = 0;
info.PointStart = Vector3.zero;
info.HitEntity = null;
}
return(true);
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
{
try
{
var attacker = info?.InitiatorPlayer;
var victim = entity.ToPlayer();
if (victim != null)
{
if (attacker != null)
{
if (configData.Exemptions.FriendsExempt && IsFriend(attacker.userID, entity.ToPlayer().userID))
{
return;
}
if (configData.Exemptions.ClansExempt && IsClanmate(attacker.userID, entity.ToPlayer().userID))
{
return;
}
}
if (configData.Exemptions.AdminExempt && victim.IsAdmin())
{
return;
}
if (IsPlaying(victim))
{
return;
}
DeductPlayerXP(victim, attacker);
}
}
catch { }
}
void OnEntityDeath(BaseCombatEntity Entity, HitInfo Info)
{
BasePlayer Player = Entity.ToPlayer();
if (Player != null)
{
if (IsPresident(Player.userID))
{
BasePlayer Killer = null;
if (Info != null)
{
Killer = Info.Initiator.ToPlayer();
}
if (Killer != null && Killer.userID != Player.userID)
{
SetPresident(Killer.userID);
PrintToChat(string.Format(lang.GetMessage("PresidentMurdered", this), Killer.displayName));
}
else
{
SetPresident(0);
PrintToChat(string.Format(lang.GetMessage("PresidentDied", this)));
}
}
}
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo hitinfo)
{
if (entity is BasePlayer)
{
BasePlayer victim = entity.ToPlayer();
//Handle when a player dies, for example check who killed and increase their score.
if (hitinfo.damageTypes.Has(DamageType.Suicide))
{
}
else
{
try
{
BasePlayer killer = hitinfo.Initiator.ToPlayer();
playerKills[killer] = playerKills[killer] + 1;
playerDeaths[victim] = playerDeaths[victim] + 1;
SendReply(victim, "You was killed by: " + killer.displayName + " using " + StripWeapons(hitinfo.Weapon.LookupShortPrefabName()));
SendReply(killer, "You killed: " + victim.displayName);
}
catch (Exception ex)
{
Puts(ex.Message);
//Error can occur on player suicide, this is to catch that.
}
}
timer.Once(0.5f, () =>
{
spawnPlayerinPVPArea(victim);
});
}
}
private void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
var player = entity.ToPlayer();
if (player == null || info == null)
{
return;
}
if (!TeleportTimers.ContainsKey(player))
{
return;
}
NextTick(() =>
{
if (info.damageTypes.Total() <= 0)
{
return;
}
if (cancelTpPlayerDamage && info?.Initiator is BasePlayer)
{
CancelTp(player, Lang("TeleportCancelledPlayerDamage", player.UserIDString));
}
else if (cancelTpFallDamage && info.damageTypes.Has(DamageType.Fall))
{
CancelTp(player, Lang("TeleportCancelledFallDamage", player.UserIDString));
}
});
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo hitInfo)
{
if (entity == null || hitInfo == null || hitInfo.Initiator == null)
{
return;
}
BasePlayer playerKilled = entity.ToPlayer();
BasePlayer playerKiller = hitInfo.Initiator as BasePlayer;
if (playerKilled == null || playerKiller == null || playerKilled == playerKiller)
{
return;
}
DeathEvent deathEvent = new DeathEvent();
deathEvent.killerSteamId = playerKiller.userID;
deathEvent.killerName = playerKiller.displayName;
deathEvent.killedSteamId = playerKilled.userID;
deathEvent.killedName = playerKilled.displayName;
deathEvent.datetime = DateTime.Now;
deathEvent.distance = Math.Sqrt(
Math.Pow(playerKilled.transform.position.x - playerKiller.transform.position.x, 2) +
Math.Pow(playerKilled.transform.position.y - playerKiller.transform.position.y, 2) +
Math.Pow(playerKilled.transform.position.z - playerKiller.transform.position.z, 2));
deathEvent.weapon = hitInfo.Weapon.GetItem().info.displayName.english;
deathEvent.isHeadshot = hitInfo.isHeadshot;
deathEvent.isSleeping = playerKilled.IsSleeping();
PrintToChat(GetDeathMessage(deathEvent));
}
private void OnRunPlayerMetabolism(PlayerMetabolism m, BaseCombatEntity entity)
{
var player = entity.ToPlayer();
if (player == null)
{
return;
}
#if DEBUG
PrintWarning($"Health before: {player.health}");
PrintWarning($"Calories before: {player.metabolism.calories.value}");
PrintWarning($"Hydration before: {player.metabolism.hydration.value}");
#endif
if (permission.UserHasPermission(player.UserIDString, permBoost))
{
player.health = Mathf.Clamp(player.health + config.HealthGainRate, 0f, 100f);
m.calories.value = Mathf.Clamp(m.calories.value - config.CaloriesLossRate, m.calories.min, m.calories.max);
m.hydration.value = Mathf.Clamp(m.hydration.value - config.HydrationLossRate, m.hydration.min, m.hydration.max);
}
else if (permission.UserHasPermission(player.UserIDString, permNone))
{
m.calories.value = m.calories.max;
m.hydration.value = m.hydration.max;
}
#if DEBUG
PrintWarning($"Health after: {player.health}");
PrintWarning($"Calories after: {player.metabolism.calories.value}");
PrintWarning($"Hydration after: {player.metabolism.hydration.value}");
#endif
}
private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
{
if (entity == null || info == null)
{
return;
}
// NPC - Animals
if (info.Initiator is BaseNpc || entity is BaseNpc)
{
return;
}
// Helicopter
if (info.Initiator is BaseHelicopter)
{
return;
}
// Player kills
if (entity is BasePlayer && info.Initiator is BasePlayer)
{
BasePlayer victim = entity.ToPlayer();
BasePlayer attacker = info.Initiator.ToPlayer();
Helper.Chat.Broadcast($"<color=#32AADD>{attacker.displayName}</color> killed <color=#32AADD>{victim.displayName}</color>");
}
}
private void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
{
try
{
if (UseTB)
{
if (entity is BasePlayer && hitInfo.Initiator is BasePlayer)
{
if (entity as BasePlayer == null || hitInfo == null)
{
return;
}
var victim = entity.ToPlayer();
var attacker = hitInfo.Initiator.ToPlayer();
if (victim != attacker)
{
if (victim.GetComponent <TBPlayer>() && attacker.GetComponent <TBPlayer>())
{
if (victim.GetComponent <TBPlayer>().team == attacker.GetComponent <TBPlayer>().team)
{
hitInfo.damageTypes.ScaleAll(configData.Options.FF_DamageScale);
SendReply(hitInfo.Initiator as BasePlayer, "Friendly Fire!");
}
}
}
}
}
}
catch (Exception ex)
{
}
}
private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
{
if (GameStarted)
{
if (info == null || entity == null)
{
return;
}
if (entity is BaseNpc)
{
return;
}
BasePlayer victim = entity.ToPlayer();
if (info?.Initiator?.ToPlayer() == null)
{
return;
}
BasePlayer killer = info.Initiator.ToPlayer();
if (victim == null || killer == null)
{
return;
}
if (BlueTeam.Contains(killer.userID))
{
BasePlayer.activePlayerList.ForEach(x => SendChatMessage(x, CurrentKill, String.Format(CurrentBlue, killer.displayName), String.Format(CurrentRed, victim.displayName)));
}
else if (RedTeam.Contains(killer.userID))
{
BasePlayer.activePlayerList.ForEach(x => SendChatMessage(x, CurrentKill, String.Format(CurrentRed, killer.displayName), String.Format(CurrentBlue, victim.displayName)));
}
}
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo hitinfo)
{
if (entity != null && entity is BasePlayer)
{
BasePlayer victim = entity.ToPlayer();
ulong vicSteamID = victim.userID;
if (!storedData.deaths.ContainsKey(victim.userID))
{
storedData.deaths.Add(vicSteamID, 1);
}
else
{
storedData.deaths[vicSteamID] = storedData.deaths[vicSteamID] + 1;
}
if (hitinfo != null && hitinfo.Initiator != null && hitinfo.Initiator is BasePlayer)
{
BasePlayer attacker = hitinfo.Initiator.ToPlayer();
ulong attSteamId = attacker.userID;
if (!storedData.kills.ContainsKey(attacker.userID))
{
storedData.kills.Add(attSteamId, 1);
}
else
{
storedData.kills[attSteamId] = storedData.kills[attSteamId] + 1;
}
}
Interface.GetMod().DataFileSystem.WriteObject("KillStats", storedData);
}
}
void OnEntityDeath(BaseCombatEntity vic, HitInfo hitInfo)
{
if(hitInfo == null) return;
string victimstring = "None";
string killerstring = "None";
string weapon = "";
string msg = null;
string dmg = FirstUpper(vic.lastDamage.ToString());
if(dmg == null || dmg == "") dmg = "None";
string bodypart = GetFormattedBodypart(StringPool.Get(hitInfo.HitBone), true);
if(bodypart == null || bodypart == "") bodypart = "None";
string victim = "";
string attacker = null;
bool sleeping = false;
try
{
if(hitInfo.Initiator != null)
{
if(hitInfo.Initiator.ToPlayer() != null)
{
attacker = hitInfo.Initiator.ToPlayer().displayName;
}
else
{
attacker = FirstUpper(hitInfo.Initiator.LookupShortPrefabName());
}
}
else
{
attacker = "None";
}
}
catch (Exception ex)
{
ConVar.Server.Log("Oxide/Logs/DeathNotes_ErrorLog.txt", "Failed at getting attacker: " + ex.Message.ToString());
return;
}
try
{
if(!vic.ToString().Contains("corpse"))
{
if(vic != null)
{
if(vic.ToPlayer() != null)
{
victim = vic.ToPlayer().displayName;
sleeping = (bool)vic.ToPlayer().IsSleeping();
// Is it Suicide or Metabolism?
if(dmg == "Suicide" && (bool)Config["Settings", "ShowSuicides"]) msg = dmg;
if(metabolism.Contains(dmg) && (bool)Config["Settings", "ShowMetabolismDeaths"]) msg = dmg;
// Is Attacker a Player?
if(hitInfo.Initiator != null && hitInfo.Initiator.ToPlayer() != null && playerDamageTypes.Contains(dmg) && hitInfo.WeaponPrefab.ToString().Contains("grenade") == false)
{
if(hitInfo.WeaponPrefab.ToString().Contains("hunting") || hitInfo.WeaponPrefab.ToString().Contains("bow"))
{
if(sleeping) msg = "ArrowSleep";
else msg = "Arrow";
}
else
{
if(sleeping) msg = dmg + "Sleep";
else msg = dmg;
}
}
// Is Attacker an explosive?
else if(dmg == "Explosion" || dmg == "Stab" && (bool)Config["Settings", "ShowExplosionDeaths"])
{
msg = "Explosion";
}
// Is Attacker a trap?
else if(traps.Contains(attacker) && (bool)Config["Settings", "ShowTrapDeaths"])
{
msg = "Trap";
}
// Is Attacker a Barricade?
else if(barricadeDamageTypes.Contains(dmg) && (bool)Config["Settings", "ShowBarricadeDeaths"])
{
msg = "Barricade";
}
// Is Attacker an Animal?
else if(dmg == "Bite" && (bool)Config["Settings", "ShowAnimalKills"])
{
if(sleeping) msg = "BiteSleep";
else msg = "Bite";
}
}
// Victim is an Animal
else if(vic.ToString().Contains("animals") && (bool)Config["Settings", "ShowAnimalDeaths"])
{
victim = FirstUpper(vic.LookupShortPrefabName());
msg = "AnimalDeath";
if(dmg == "Explosion") msg = "Explosion";
}
}
}
}
catch (Exception ex)
{
ConVar.Server.Log("Oxide/Logs/DeathNotes_ErrorLog.txt", "Failed at getting victim: " + ex.Message.ToString());
return;
}
if(msg != null)
{
if(hitInfo.Weapon != null) weapon = hitInfo.Weapon.GetItem().info.displayName.english.ToString();
if(weapon.Contains("Semi-Automatic Pistol")) weapon = "Semi-Automatic Pistol";
string formattedDistance = "";
if(hitInfo.Initiator != null)
formattedDistance = GetFormattedDistance(GetDistance(vic, hitInfo.Initiator));
string formattedVictim = GetFormattedVictim(victim, false);
string formattedAttacker = GetFormattedAttacker(attacker, false);
string formattedAnimal = GetFormattedAnimal(attacker);
string formattedBodypart = GetFormattedBodypart(bodypart, false);
string formattedWeapon = GetFormattedWeapon(weapon);
string rawVictim = GetFormattedVictim(victim, true);
string rawAttacker = GetFormattedAttacker(attacker, true);
string rawAnimal = attacker;
string rawBodypart = GetFormattedBodypart(bodypart, true);
string rawWeapon = weapon;
string deathmsg = Config["Messages", msg].ToString();
string rawmsg = Config["Messages", msg].ToString();
deathmsg = deathmsg.Replace("{victim}", formattedVictim);
rawmsg = rawmsg.Replace("{victim}", rawVictim);
if(hitInfo.Initiator != null)
{
if(hitInfo.Initiator.ToPlayer() == null) deathmsg = deathmsg.Replace("{attacker}", formattedAnimal);
else deathmsg = deathmsg.Replace("{attacker}", formattedAttacker);
if(hitInfo.Initiator.ToPlayer() == null) rawmsg = rawmsg.Replace("{attacker}", rawAnimal);
else rawmsg = rawmsg.Replace("{attacker}", rawAttacker);
}
try
{
if (vic.ToString().Contains("animals") && hitInfo.Initiator == null)
{
return;
}
if (vic.ToString().Contains("animals") && hitInfo.Initiator.ToString().Contains("animals"))
{
return;
}
if(vic.ToPlayer() == null && hitInfo.Initiator == null)
{
return;
}
}
catch (Exception ex)
{
ConVar.Server.Log("Oxide/Logs/DeathNotes_ErrorLog.txt", "Failed at checking for victim & attacker: " + ex.Message.ToString());
return;
}
if(formattedBodypart != null) deathmsg = deathmsg.Replace("{bodypart}", formattedBodypart);
if(hitInfo.Initiator != null) deathmsg = deathmsg.Replace("{distance}", formattedDistance);
if(hitInfo.Weapon != null) deathmsg = deathmsg.Replace("{weapon}", formattedWeapon);
if(formattedBodypart != null) rawmsg = rawmsg.Replace("{bodypart}", rawBodypart);
if(hitInfo.Initiator != null) rawmsg = rawmsg.Replace("{distance}", GetDistance(vic, hitInfo.Initiator));
if(hitInfo.Weapon != null) rawmsg = rawmsg.Replace("{weapon}", rawWeapon);
try
{
AddNewToConfig(rawBodypart, weapon);
BroadcastDeath(prefix + " " + GetFormattedMessage(deathmsg), rawmsg, vic);
}
catch (Exception ex)
{
ConVar.Server.Log("Oxide/Logs/DeathNotes_ErrorLog.txt", "Failed at sending Message & new2Config: " + ex.Message.ToString());
return;
}
}
}
HitInfo TryGetLastHit(BaseCombatEntity vic)
{
if(vic == null || vic.ToPlayer() == null) return null;
if(lastHitInfo.ContainsKey(vic.ToPlayer())) return lastHitInfo[vic.ToPlayer()];
return null;
}
void OnEntityTakeDamage(BaseCombatEntity vic, HitInfo hitInfo)
{
if(vic == null || hitInfo == null || vic.ToPlayer() == null) return;
lastHitInfo[vic.ToPlayer()] = hitInfo;
}
string GetVictim(BaseCombatEntity vic)
{
string victim = "Unknown Victim";
if(vic != null)
{
if(vic.ToPlayer() != null)
{
victim = vic.ToPlayer().displayName;
}
else
{
victim = FirstUpper(vic.LookupShortPrefabName() ?? "Unknown Victim");
victim = victim.Replace(".prefab", "");
}
}
return victim;
}
void OnEntityDeath(BaseCombatEntity entity, HitInfo hitinfo)
{
if (entity != null && entity is BasePlayer)
{
BasePlayer victim = entity.ToPlayer();
ulong vicSteamID = victim.userID;
if (!storedData.deaths.ContainsKey(victim.userID))
storedData.deaths.Add(vicSteamID, 1);
else
storedData.deaths[vicSteamID] = storedData.deaths[vicSteamID] + 1;
if (hitinfo != null && hitinfo.Initiator != null && hitinfo.Initiator is BasePlayer)
{
BasePlayer attacker = hitinfo.Initiator.ToPlayer();
ulong attSteamId = attacker.userID;
if (!storedData.kills.ContainsKey(attacker.userID))
storedData.kills.Add(attSteamId, 1);
else
storedData.kills[attSteamId] = storedData.kills[attSteamId] + 1;
}
Interface.GetMod().DataFileSystem.WriteObject("KillStats", storedData);
}
}
