public static void deployableKO(DeployableObject dep, DamageEvent e)
{
try
{
InstaKOCommand command = ChatCommand.GetCommand("instako") as InstaKOCommand;
if (command.IsOn(e.attacker.client.userID))
{
try
{
Helper.Log("StructDestroyed.txt", string.Concat(new object[] { e.attacker.client.netUser.displayName, " [", e.attacker.client.netUser.userID, "] destroyed (InstaKO) ", NetUser.FindByUserID(dep.ownerID).displayName, "'s ", dep.gameObject.name.Replace("(Clone)", "") }));
}
catch
{
if (Core.userCache.ContainsKey(dep.ownerID))
{
Helper.Log("StructDestroyed.txt", string.Concat(new object[] { e.attacker.client.netUser.displayName, " [", e.attacker.client.netUser.userID, "] destroyed (InstaKO) ", Core.userCache[dep.ownerID], "'s ", dep.gameObject.name.Replace("(Clone)", "") }));
}
}
dep.OnKilled();
}
else
{
dep.UpdateClientHealth();
}
}
catch
{
dep.UpdateClientHealth();
}
}
public void HandleDamageEvent(DamageEvent e)
{
if (shieldAction.shouldTakeDamage (e.Location)) {
TakeDamage (e.Value);
}
if(shieldAction.shouldReflect(e.Location)){
e.DamageReturn ();
}
}
public HurtEvent(ref DamageEvent d)
{
Fougerite.Player player = Fougerite.Player.FindByPlayerClient(d.attacker.client);
if (player != null)
{
this.Attacker = player;
}
else
{
this.Attacker = new NPC(d.attacker.character);
}
Fougerite.Player player2 = Fougerite.Player.FindByPlayerClient(d.victim.client);
if (player2 != null)
{
this.Victim = player2;
}
else
{
this.Victim = new NPC(d.victim.character);
}
this.DamageEvent = d;
this.WeaponData = null;
this.IsDecay = false;
string weaponName = "Unknown";
if (d.extraData != null)
{
WeaponImpact extraData = d.extraData as WeaponImpact;
this.WeaponData = extraData;
if (extraData.dataBlock != null)
{
weaponName = extraData.dataBlock.name;
}
}
else
{
if (d.attacker.id is TimedExplosive) {
weaponName = "Explosive Charge";
} else if (d.attacker.id is TimedGrenade) {
weaponName = "F1 Grenade";
} else if (d.attacker.id.ToString().Contains("MutantBear")) {
weaponName = "Mutant Bear Claw";
} else if (d.attacker.id.ToString().Contains("Bear")) {
weaponName = "Bear Claw";
} else if (d.attacker.id.ToString().Contains("MutantWolf")) {
weaponName = "Mutant Wolf Claw";
} else if (d.attacker.id.ToString().Contains("Wolf")) {
weaponName = "Wolf Claw";
} else if (d.attacker.id.Equals(d.victim.id)) {
weaponName = String.Format("Self ({0})", DamageType);
} else {
weaponName = "Hunting Bow";
}
}
this.WeaponName = weaponName;
}
public SwingEvent GetSwingEvent(int swing)
{
var swingEvent = comboChain[swing];
var d = new DamageEvent();
d.damage = CalculateDamage(damage, swing);
d.knockback = knockback;
swingEvent.damage = d;
return swingEvent;
}
public DestroyEvent(ref DamageEvent d, Entity ent, bool isdecay)
{
Fougerite.Player player = Fougerite.Player.FindByPlayerClient(d.attacker.client);
if (player != null) {
this.Attacker = player;
}
this.WeaponData = null;
this.IsDecay = isdecay;
this.DamageEvent = d;
this.Entity = ent;
string weaponName = "Unknown";
if (d.extraData != null)
{
WeaponImpact extraData = d.extraData as WeaponImpact;
this.WeaponData = extraData;
if (extraData.dataBlock != null)
{
weaponName = extraData.dataBlock.name;
}
}
else
{
if (d.attacker.id is TimedExplosive)
weaponName = "Explosive Charge";
else if (d.attacker.id is TimedGrenade)
weaponName = "F1 Grenade";
else if (d.attacker.id.ToString().Contains("MutantBear"))
weaponName = "Mutant Bear Claw";
else if (d.attacker.id.ToString().Contains("Bear"))
weaponName = "Bear Claw";
else if (d.attacker.id.ToString().Contains("MutantWolf"))
weaponName = "Mutant Wolf Claw";
else if (d.attacker.id.ToString().Contains("Wolf"))
weaponName = "Wolf Claw";
else if (d.attacker.id.Equals(d.victim.id))
weaponName = String.Format("Self ({0})", DamageType);
else
weaponName = "Hunting Bow";
}
this.WeaponName = weaponName;
}
void OnTriggerEnter(Collider other)
{
if(other.isTrigger) return;
if(this.data == null)
this.data = new DamageEvent(this.owner, damage, knockbackForce, 0, team);
if(this.data.owner == null)
this.data.owner = gameObject;
if(effects.Length > 0)
{
foreach(string effect in effects)
{
string[] bits = effect.Split('=');
this.data.effects[bits[0]] = float.Parse(bits[1]);
}
}
this.data.bullet = gameObject;
this.data.victim = other.gameObject;
if(speed > 0.0f)
this.data.ranged = true;
other.gameObject.SendMessage("OnShot", this.data, SendMessageOptions.DontRequireReceiver);
//this.data.owner.BroadcastMessage("OnShotHit", this.data, SendMessageOptions.DontRequireReceiver);
if(!penetrates)
OnKill();
//if(other.gameObject.GetComponent(Dude) == null)
//{
// OnKill();
//}
}
private void OnPlayerDeath(TakeDamage takedamage, DamageEvent damage, object tags)
{
string weapon = tags.GetProperty("weapon").ToString();
string deathtype = tags.GetProperty("deathType").ToString();
string killer = tags.GetProperty("killer").ToString();
string bodyPart = tags.GetProperty("bodypart").ToString();
string message = null;
if (bodyParts.ContainsKey(bodyPart))
{
tags.SetProperty("bodypart", bodyParts[bodyPart]);
}
switch (deathtype)
{
case "human":
{
if (weapon == "Spike Wall" && killer == "Unknown")
{
tags.SetProperty("killerId", PlayerDatabase?.Call("GetPlayerData", tags.GetProperty("killerId"), "name") ?? tags.GetProperty("killerId"));
}
message = getDeathMessage("PvP", weapon, tags);
break;
}
default:
{
message = getDeathMessage("EvP", killer, tags);
break;
}
}
if (message != null)
{
rust.BroadcastChat(chatName, message);
}
//Puts((string)Death?.CallHook("GetDeathString", "Killer: {killer} {killerId} Killed: {killed} {killedId} Weapon: {weapon} BodyPart: {bodypart} Distance: {distance} DeathType: {deathType} Location: {location}", tags) ?? "Unknown");
}
public static void HurtKilled(DamageEvent damage)
{
ulong num = 0uL;
string text = "";
ulong num2 = 0uL;
string text2 = "";
PlayerClient client = damage.victim.client;
PlayerClient client2 = damage.attacker.client;
bool flag = !(damage.victim.idMain is Character);
bool flag2 = !(damage.attacker.idMain is Character);
UserData userData = (client != null) ? Users.GetBySteamID(client.userID) : null;
UserData userData2 = (client2 != null) ? Users.GetBySteamID(client2.userID) : null;
if (userData == null)
{
}
ClanData clanData = (userData2 != null) ? userData2.Clan : null;
if (!flag2 || !(client2 == null))
{
if (client2 != null)
{
text2 = damage.attacker.client.netUser.displayName;
}
else
{
text2 = Helper.NiceName(damage.attacker.character.name);
Config.Get("NAMES." + ((userData == null) ? Core.Languages[0] : userData.Language), text2, ref text2, true);
}
if (flag)
{
if (!(damage.victim.idMain is SleepingAvatar) || !Economy.FeeSleeper)
{
return;
}
SleepingAvatar sleepingAvatar = damage.victim.idMain as SleepingAvatar;
if (sleepingAvatar == null)
{
return;
}
UserData bySteamID = Users.GetBySteamID(sleepingAvatar.ownerID);
if (bySteamID == null)
{
return;
}
ulong balance = Economy.GetBalance(bySteamID.SteamID);
text = bySteamID.Username;
if (Economy.FeeMurder)
{
num = (ulong)Math.Abs(balance * Economy.FeeMurderPercent / 100f);
}
if (Economy.PayMurder)
{
num2 = (ulong)Math.Abs(balance * Economy.PayMurderPercent / 100f);
}
if (num2 > 0uL && Clans.Enabled && clanData != null)
{
if (clanData.Level.BonusMembersPayMurder > 0u)
{
num2 += num2 * (ulong)clanData.Level.BonusMembersPayMurder / 100uL;
}
if (clanData.Tax > 0u)
{
ulong num3 = num2 * (ulong)clanData.Tax / 100uL;
clanData.Balance += num3;
num2 -= num3;
}
}
if (num2 > 0uL)
{
Economy.BalanceAdd(client2.userID, num2);
}
if (num > 0uL)
{
Economy.BalanceSub(bySteamID.SteamID, num);
}
}
else if (client != null)
{
text = damage.victim.client.netUser.displayName;
ulong balance2 = Economy.GetBalance(client.userID);
if (client2 == null)
{
if (Economy.FeeDeath)
{
num = (ulong)Math.Abs(balance2 * Economy.FeeDeathPercent / 100f);
}
}
else if (!(client2 == client) && !flag2)
{
if (client2 != client && !flag2)
{
Economy.Get(client2.userID).PlayersKilled++;
if (Economy.FeeMurder)
{
num = (ulong)Math.Abs(balance2 * Economy.FeeMurderPercent / 100f);
}
if (Economy.PayMurder)
{
num2 = (ulong)Math.Abs(balance2 * Economy.PayMurderPercent / 100f);
}
}
}
else if (Economy.FeeSuicide)
{
num = (ulong)Math.Abs(balance2 * Economy.FeeSuicidePercent / 100f);
}
if (num2 > 0uL && Clans.Enabled && clanData != null)
{
if (clanData.Level.BonusMembersPayMurder > 0u)
{
num2 += num2 * (ulong)clanData.Level.BonusMembersPayMurder / 100uL;
}
if (clanData.Tax > 0u)
{
ulong num4 = num2 * (ulong)clanData.Tax / 100uL;
clanData.Balance += num4;
num2 -= num4;
}
}
if (num2 > 0uL)
{
Economy.BalanceAdd(client2.userID, num2);
}
if (num > 0uL)
{
Economy.BalanceSub(client.userID, num);
}
Economy.Get(client.userID).Deaths++;
}
else if (client2 != null)
{
text = Helper.NiceName(damage.victim.character.name);
if (text.Equals("Chicken", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostChicken != 0uL)
{
num2 = Economy.CostChicken;
}
Economy.Get(client2.userID).AnimalsKilled++;
}
else if (text.Equals("Rabbit", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostRabbit != 0uL)
{
num2 = Economy.CostRabbit;
}
Economy.Get(client2.userID).AnimalsKilled++;
}
else if (text.Equals("Boar", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostBoar != 0uL)
{
num2 = Economy.CostBoar;
}
Economy.Get(client2.userID).AnimalsKilled++;
}
else if (text.Equals("Stag", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostStag != 0uL)
{
num2 = Economy.CostStag;
}
Economy.Get(client2.userID).AnimalsKilled++;
}
else if (text.Equals("Wolf", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostWolf != 0uL)
{
num2 = Economy.CostWolf;
}
Economy.Get(client2.userID).AnimalsKilled++;
}
else if (text.Equals("Bear", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostBear != 0uL)
{
num2 = Economy.CostBear;
}
Economy.Get(client2.userID).AnimalsKilled++;
}
else if (text.Equals("Mutant Wolf", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostMutantWolf != 0uL)
{
num2 = Economy.CostMutantWolf;
}
Economy.Get(client2.userID).MutantsKilled++;
}
else if (text.Equals("Mutant Bear", StringComparison.OrdinalIgnoreCase))
{
if (Economy.CostMutantBear != 0uL)
{
num2 = Economy.CostMutantBear;
}
Economy.Get(client2.userID).MutantsKilled++;
}
else
{
ConsoleSystem.LogWarning("[WARNING] Economy: Creature '" + text + "' not have cost of death.");
}
Config.Get("NAMES." + ((userData2 == null) ? Core.Languages[0] : userData2.Language), text, ref text, true);
if (num2 > 0uL && Clans.Enabled && clanData != null)
{
if (clanData.Level.BonusMembersPayMurder > 0u)
{
num2 += num2 * (ulong)clanData.Level.BonusMembersPayMurder / 100uL;
}
if (clanData.Tax > 0u)
{
ulong num5 = num2 * (ulong)clanData.Tax / 100uL;
clanData.Balance += num5;
num2 -= num5;
}
}
if (num2 > 0uL)
{
Economy.BalanceAdd(client2.userID, num2);
}
}
if (client2 != null && num2 > 0uL)
{
string text3 = Config.GetMessage("Economy.PlayerDeath.Pay", client2.netUser, null);
if (flag)
{
text3 = Config.GetMessage("Economy.SleeperDeath.Pay", client2.netUser, null);
}
text3 = text3.Replace("%DEATHPAY%", num2.ToString("N0") + Economy.CurrencySign);
text3 = text3.Replace("%VICTIM%", text);
Broadcast.Message(client2.netPlayer, text3, null, 0f);
}
if (client != null && num > 0uL)
{
string text4 = Config.GetMessage("Economy.PlayerDeath.Fee", client.netUser, null);
if (client2 == client || flag2)
{
text4 = Config.GetMessage("Economy.PlayerSuicide.Fee", client.netUser, null);
}
text4 = text4.Replace("%DEATHFEE%", num.ToString("N0") + Economy.CurrencySign);
text4 = text4.Replace("%KILLER%", text2);
text4 = text4.Replace("%VICTIM%", text);
Broadcast.Message(client.netPlayer, text4, null, 0f);
}
}
}
void PlayerKilled_Test()
{
try
{
DamageEvent damageEvent = new DamageEvent();
Log("PlayerKilled_Test: Test 1");
Hooks.PlayerHurt(ref damageEvent);
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
public HurtEvent(ref DamageEvent d, Fougerite.Entity en)
: this(ref d)
{
this.Entity = en;
}
public void RegisterDamageEvent(DamageEvent e)
{
m_DmgEvents += e;
}
private void OnKilled(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnKilled");
// Print death message
var netUser = damage.victim.client.netUser;
if (netUser == null) return;
Puts("Player " + netUser.displayName + " has died!");
}
public static void OnAIHurt(ref DamageEvent damage)
{
if (damage.attacker.idMain != null)
{
if (isPlayer(damage.attacker.idMain))
{
PlayerClient attackerClient = damage.attacker.client;
if (destroyerList.Contains(attackerClient.userID.ToString()))
{
beingDestroyed.Add(damage.victim.idMain.gameObject);
damage.amount = 1000f;
damage.status = LifeStatus.WasKilled;
}
}
}
}
public static void HostileHurt(DamageEvent damage, HostileWildlifeAI HWAI)
{
try
{
bool b = false;
try
{
if (isPlayer(damage.attacker.idMain))
{
b = hiddenList.Contains(damage.attacker.client.userID.ToString()) && HWAI._targetTD == damage.attacker.client.controllable.GetComponent<TakeDamage>();
}
}
catch (Exception ex)
{
Vars.conLog.Error("HH: " + ex.ToString());
}
if (!HWAI.HasTarget() && (damage.attacker.character != null) && !b)
{
HWAI.SetAttackTarget(damage.attacker.character.gameObject.GetComponent<TakeDamage>());
HWAI.ExitCurrentState();
HWAI.EnterState_Chase();
}
if (b && HWAI.HasTarget())
HWAI._targetTD = null;
}
catch (Exception ex)
{
Vars.conLog.Error(ex.ToString());
}
}
public DeathEvent(ref DamageEvent d)
: base(ref d)
{
this._drop = true;
}
protected override LifeStatus Hurt(ref DamageEvent damage)
{
return(base.Hurt(ref damage));
}
public void OnDamage(Bowhead.Actors.Pawn p, float d, bool directHit)
{
DamageEvent?.Invoke(p, d, directHit);
}
public static void OnAIKilled(BasicWildLifeAI BWAI, DamageEvent damage)
{
BWAI.ExitCurrentState();
BWAI.EnterState_Dead();
Facepunch.NetworkView networkView = BWAI.networkView;
NetCull.RemoveRPCsByName(networkView, "GetNetworkUpdate");
object[] args = new object[] { BWAI._myTransform.position, damage.attacker.networkViewID };
networkView.RPC("ClientDeath", uLink.RPCMode.Others, args);
if (beingDestroyed.Contains(damage.victim.idMain.gameObject))
NetCull.Destroy(damage.victim.idMain.gameObject);
else
BWAI.Invoke("DelayedDestroy", 90f);
WildlifeManager.RemoveWildlifeInstance(BWAI);
}
void OnKilled(TakeDamage takedamage, DamageEvent damage)
{
if (!(takedamage is HumanBodyTakeDamage))
{
return;
}
NetUser Attacker = damage.attacker.client?.netUser ?? null;
NetUser Victim = damage.victim.client?.netUser ?? null;
if (Attacker == null || Victim == null)
{
return;
}
int Strike;
DateTime Time;
var AttackerID = Attacker.userID;
if (HeadShotChecker.TryGetValue(AttackerID, out Time))
{
if ((Time - DateTime.Now).Seconds < 10)
{
if (Strikes.TryGetValue(AttackerID, out Strike))
{
if (Strike >= 2)
{
damage.attacker.client.netUser.Kick(NetError.ConnectionBanned, true);
SendLogServer($"{Attacker.displayName} Detected Aimbot Hack | Will Kick from the server");
}
else
{
Strikes[AttackerID]++;
}
}
else
{
Strikes.Add(AttackerID, 1);
}
}
else
{
Debug.Log("Timer No es Mayor");
var TimerAdd = DateTime.Now.AddSeconds(10);
HeadShotChecker[AttackerID] = TimerAdd;
if (Strikes.ContainsKey(AttackerID))
{
Strikes[AttackerID] = 0;
}
else
{
Strikes.Add(AttackerID, 1);
}
}
}
else
{
Debug.Log("No Existe la Clave");
var TimerAdd = DateTime.Now.AddSeconds(10);
HeadShotChecker.Add(AttackerID, TimerAdd);
}
}
public static void OnHumanHurt(ref DamageEvent damage)
{
try
{
PlayerClient victim = damage.victim.client;
TakeDamage takeDamage = victim.controllable.GetComponent<TakeDamage>();
PlayerClient attacker = null;
if (godList.Contains(victim.userID.ToString()))
{
damage.amount = 0f;
}
string victimFaction = "Neutral";
string attackerFaction = "";
KeyValuePair<string, Dictionary<string, string>>[] possibleFactions = Array.FindAll(factions.ToArray(), (KeyValuePair<string, Dictionary<string, string>> kv) => kv.Value.ContainsKey(victim.userID.ToString()));
if (possibleFactions.Count() > 0)
{
victimFaction = possibleFactions[0].Key;
}
if (isPlayer(damage.attacker.idMain))
{
attacker = damage.attacker.client;
possibleFactions = Array.FindAll(factions.ToArray(), (KeyValuePair<string, Dictionary<string, string>> kv) => kv.Value.ContainsKey(attacker.userID.ToString()));
if (possibleFactions.Count() > 0)
attackerFaction = possibleFactions[0].Key;
if (inSafeZone.ContainsKey(attacker) && !inWarZone.ContainsKey(attacker))
{
Broadcast.noticeTo(attacker.netPlayer, "☃", "You cannot hurt players while in a safe zone!");
damage.amount = 0f;
}
else if (inSafeZone.ContainsKey(victim) && !inWarZone.ContainsKey(victim))
{
Broadcast.noticeTo(attacker.netPlayer, "☃", "You cannot hurt players in a safe zone!");
damage.amount = 0f;
}
}
else
{
if (inSafeZone.ContainsKey(victim) && !inWarZone.ContainsKey(victim))
{
damage.amount = 0f;
}
}
if (victimFaction == attackerFaction && damage.attacker.IsDifferentPlayer(victim))
{
if (damage.damageTypes == DamageTypeFlags.damage_bullet)
{
Broadcast.sideNoticeTo(attacker.netPlayer, "You shot " + victim.userName);
Broadcast.sideNoticeTo(victim.netPlayer, attacker.userName + " shot you");
}
else
{
Broadcast.sideNoticeTo(attacker.netPlayer, "You hit " + victim.userName);
Broadcast.sideNoticeTo(victim.netPlayer, attacker.userName + " hit you");
}
if (!inWarZone.ContainsKey(attacker) && !inWarZone.ContainsKey(victim))
{
if (!friendlyFire)
{
damage.amount = 0f;
}
}
else
{
damage.amount = damage.amount * warFriendlyDamage;
}
}
else
{
if (damage.attacker.IsDifferentPlayer(victim) && alliances.ContainsKey(attackerFaction))
{
if (alliances[attackerFaction].Contains(victimFaction))
{
if (damage.damageTypes == DamageTypeFlags.damage_bullet)
{
Broadcast.sideNoticeTo(attacker.netPlayer, "You shot an ally");
Broadcast.sideNoticeTo(victim.netPlayer, "An ally shot you");
}
else
{
Broadcast.sideNoticeTo(attacker.netPlayer, "You hit an ally");
Broadcast.sideNoticeTo(victim.netPlayer, "An ally hit you");
}
if (!inWarZone.ContainsKey(attacker) && !inWarZone.ContainsKey(victim))
{
if (!alliedFire)
damage.amount = (damage.amount * 2) / 3;
}
else
{
damage.amount = damage.amount * warAllyDamage;
}
}
}
else
{
if (!inWarZone.ContainsKey(attacker) && !inWarZone.ContainsKey(victim))
{
damage.amount = damage.amount * neutralDamage;
}
else
{
damage.amount = damage.amount * warDamage;
}
}
if (!godList.Contains(victim.userID.ToString()))
{
if (isTeleporting.Contains(victim))
{
wasHit.Add(victim);
}
if (isAccepting.Contains(victim))
{
wasHit.Add(victim);
}
}
}
if (takeDamage.health > damage.amount)
{
damage.status = LifeStatus.IsAlive;
}
else
{
damage.status = LifeStatus.WasKilled;
}
}
catch { }
}
public static void HurtKilled(DamageEvent damage)
{
ulong amount = 0L;
string key = "";
ulong costChicken = 0L;
string displayName = "";
PlayerClient client = damage.victim.client;
PlayerClient client2 = damage.attacker.client;
bool flag = !(damage.victim.idMain is Character);
bool flag2 = !(damage.attacker.idMain is Character);
UserData data = (client != null) ? Users.GetBySteamID(client.userID) : null;
UserData data2 = (client2 != null) ? Users.GetBySteamID(client2.userID) : null;
if (data == null)
{
}
ClanData data3 = (data2 != null) ? data2.Clan : null;
if (!flag2 || (client2 != null))
{
if (client2 != null)
{
displayName = damage.attacker.client.netUser.displayName;
}
else
{
displayName = Helper.NiceName(damage.attacker.character.name);
Config.Get("NAMES." + ((data == null) ? Core.Languages[0] : data.Language), displayName, ref displayName, true);
}
if (flag)
{
if (!(damage.victim.idMain is SleepingAvatar) || !FeeSleeper)
{
return;
}
SleepingAvatar idMain = damage.victim.idMain as SleepingAvatar;
if (idMain == null)
{
return;
}
UserData bySteamID = Users.GetBySteamID(idMain.ownerID);
if (bySteamID == null)
{
return;
}
ulong balance = GetBalance(bySteamID.SteamID);
key = bySteamID.Username;
if (FeeMurder)
{
amount = (ulong)Math.Abs((float)((balance * FeeMurderPercent) / 100f));
}
if (PayMurder)
{
costChicken = (ulong)Math.Abs((float)((balance * PayMurderPercent) / 100f));
}
if (((costChicken > 0L) && Clans.Enabled) && (data3 != null))
{
if (data3.Level.BonusMembersPayMurder > 0)
{
costChicken += (costChicken * data3.Level.BonusMembersPayMurder) / ((ulong)100L);
}
if (data3.Tax > 0)
{
ulong num4 = (costChicken * data3.Tax) / ((ulong)100L);
data3.Balance += num4;
costChicken -= num4;
}
}
if (costChicken > 0L)
{
BalanceAdd(client2.userID, costChicken);
}
if (amount > 0L)
{
BalanceSub(bySteamID.SteamID, amount);
}
}
else if (client != null)
{
key = damage.victim.client.netUser.displayName;
ulong num5 = GetBalance(client.userID);
if (client2 == null)
{
if (FeeDeath)
{
amount = (ulong)Math.Abs((float)((num5 * FeeDeathPercent) / 100f));
}
}
else if ((client2 != client) && !flag2)
{
if ((client2 != client) && !flag2)
{
UserEconomy economy1 = Get(client2.userID);
economy1.PlayersKilled++;
if (FeeMurder)
{
amount = (ulong)Math.Abs((float)((num5 * FeeMurderPercent) / 100f));
}
if (PayMurder)
{
costChicken = (ulong)Math.Abs((float)((num5 * PayMurderPercent) / 100f));
}
}
}
else if (FeeSuicide)
{
amount = (ulong)Math.Abs((float)((num5 * FeeSuicidePercent) / 100f));
}
if (((costChicken > 0L) && Clans.Enabled) && (data3 != null))
{
if (data3.Level.BonusMembersPayMurder > 0)
{
costChicken += (costChicken * data3.Level.BonusMembersPayMurder) / ((ulong)100L);
}
if (data3.Tax > 0)
{
ulong num6 = (costChicken * data3.Tax) / ((ulong)100L);
data3.Balance += num6;
costChicken -= num6;
}
}
if (costChicken > 0L)
{
BalanceAdd(client2.userID, costChicken);
}
if (amount > 0L)
{
BalanceSub(client.userID, amount);
}
UserEconomy economy2 = Get(client.userID);
economy2.Deaths++;
}
else if (client2 != null)
{
key = Helper.NiceName(damage.victim.character.name);
if (key.Equals("Chicken", StringComparison.OrdinalIgnoreCase))
{
if (CostChicken != 0L)
{
costChicken = CostChicken;
}
UserEconomy economy3 = Get(client2.userID);
economy3.AnimalsKilled++;
}
else if (key.Equals("Rabbit", StringComparison.OrdinalIgnoreCase))
{
if (CostRabbit != 0L)
{
costChicken = CostRabbit;
}
UserEconomy economy4 = Get(client2.userID);
economy4.AnimalsKilled++;
}
else if (key.Equals("Boar", StringComparison.OrdinalIgnoreCase))
{
if (CostBoar != 0L)
{
costChicken = CostBoar;
}
UserEconomy economy5 = Get(client2.userID);
economy5.AnimalsKilled++;
}
else if (key.Equals("Stag", StringComparison.OrdinalIgnoreCase))
{
if (CostStag != 0L)
{
costChicken = CostStag;
}
UserEconomy economy6 = Get(client2.userID);
economy6.AnimalsKilled++;
}
else if (key.Equals("Wolf", StringComparison.OrdinalIgnoreCase))
{
if (CostWolf != 0L)
{
costChicken = CostWolf;
}
UserEconomy economy7 = Get(client2.userID);
economy7.AnimalsKilled++;
}
else if (key.Equals("Bear", StringComparison.OrdinalIgnoreCase))
{
if (CostBear != 0L)
{
costChicken = CostBear;
}
UserEconomy economy8 = Get(client2.userID);
economy8.AnimalsKilled++;
}
else if (key.Equals("Mutant Wolf", StringComparison.OrdinalIgnoreCase))
{
if (CostMutantWolf != 0L)
{
costChicken = CostMutantWolf;
}
UserEconomy economy9 = Get(client2.userID);
economy9.MutantsKilled++;
}
else if (key.Equals("Mutant Bear", StringComparison.OrdinalIgnoreCase))
{
if (CostMutantBear != 0L)
{
costChicken = CostMutantBear;
}
UserEconomy economy10 = Get(client2.userID);
economy10.MutantsKilled++;
}
else
{
ConsoleSystem.LogWarning("[WARNING] Economy: Creature '" + key + "' not have cost of death.");
}
Config.Get("NAMES." + ((data2 == null) ? Core.Languages[0] : data2.Language), key, ref key, true);
if (((costChicken > 0L) && Clans.Enabled) && (data3 != null))
{
if (data3.Level.BonusMembersPayMurder > 0)
{
costChicken += (costChicken * data3.Level.BonusMembersPayMurder) / ((ulong)100L);
}
if (data3.Tax > 0)
{
ulong num7 = (costChicken * data3.Tax) / ((ulong)100L);
data3.Balance += num7;
costChicken -= num7;
}
}
if (costChicken > 0L)
{
BalanceAdd(client2.userID, costChicken);
}
}
if ((client2 != null) && (costChicken > 0L))
{
string text = Config.GetMessage("Economy.PlayerDeath.Pay", client2.netUser, null);
if (flag)
{
text = Config.GetMessage("Economy.SleeperDeath.Pay", client2.netUser, null);
}
text = text.Replace("%DEATHPAY%", costChicken.ToString("N0") + CurrencySign).Replace("%VICTIM%", key);
Broadcast.Message(client2.netPlayer, text, null, 0f);
}
if ((client != null) && (amount > 0L))
{
string str4;
str4 = str4 = Config.GetMessage("Economy.PlayerDeath.Fee", client.netUser, null);
if ((client2 == client) || flag2)
{
str4 = Config.GetMessage("Economy.PlayerSuicide.Fee", client.netUser, null);
}
str4 = str4.Replace("%DEATHFEE%", amount.ToString("N0") + CurrencySign).Replace("%KILLER%", displayName).Replace("%VICTIM%", key);
Broadcast.Message(client.netPlayer, str4, null, 0f);
}
}
}
public static void OnHurt(TakeDamage takeDamage, ref DamageEvent damage)
{
if (damage.extraData != null)
{
if (damage.victim.idMain is Character)
{
if (isPlayer(damage.victim.idMain))
{
OnHumanHurt(ref damage);
}
else
{
OnAIHurt(ref damage);
}
}
else
{
if (damage.victim.idMain is StructureComponent || damage.victim.idMain is DeployableObject)
{
if (isPlayer(damage.attacker.idMain))
{
if (destroyerList.Contains(damage.attacker.userID.ToString()))
{
beingDestroyed.Add(damage.victim.idMain.gameObject);
NetCull.Destroy(damage.victim.idMain.gameObject);
}
else if (destroyerAllList.Contains(damage.attacker.userID.ToString()))
{
if (damage.victim.idMain is StructureComponent)
{
HashSet<StructureComponent> structureComponents = damage.victim.idMain.gameObject.GetComponent<StructureComponent>()._master._structureComponents;
List<GameObject> toDestroy = new List<GameObject>();
foreach (var kv in structureComponents)
{
if (kv.gameObject != null)
{
toDestroy.Add(kv.gameObject);
}
}
foreach (GameObject GO in toDestroy)
{
if (GO != null)
{
beingDestroyed.Add(GO);
NetCull.Destroy(GO);
}
}
}
if (damage.victim.idMain is DeployableObject)
{
beingDestroyed.Add(damage.victim.idMain.gameObject);
NetCull.Destroy(damage.victim.idMain.gameObject);
}
}
else
{
if (inZone(damage.victim.idMain.transform.position))
{
damage.amount = 0f;
damage.status = LifeStatus.IsAlive;
}
if (ownershipList.Contains(damage.attacker.userID.ToString()))
{
damage.amount = 0f;
damage.status = LifeStatus.IsAlive;
string ownerUID = "";
if (damage.victim.idMain is StructureComponent)
ownerUID = (damage.victim.idMain as StructureComponent)._master.ownerID.ToString();
if (damage.victim.idMain is DeployableObject)
ownerUID = (damage.victim.idMain as DeployableObject).ownerID.ToString();
Thread t = new Thread((DE) =>
{
Broadcast.noticeTo(((DamageEvent)DE).attacker.client.netPlayer, "✲", "This is owned by " + grabNameByUID(ownerUID) + "!");
});
t.Start(damage);
}
}
}
}
}
}
else
{
if (damage.victim.idMain is Character)
{
if (isPlayer(damage.victim.idMain))
{
if (godList.Contains(damage.victim.userID.ToString()))
{
damage.amount = 0f;
damage.status = LifeStatus.IsAlive;
}
}
}
}
}
private void OnHurt(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnHurt");
}
public static void SetDeathReason(PlayerClient playerClient, ref DamageEvent damage)
{
try
{
if (playerClient != null)
{
if (playerClient.netPlayer != null)
{
if (NetCheck.PlayerValid(playerClient.netPlayer))
{
IDMain idMain = damage.attacker.idMain;
string message = "";
if (idMain != null)
{
idMain = idMain.idMain;
if (idMain is Character)
{
Character character = idMain as Character;
Controller playerControlledController = character.playerControlledController;
if (playerControlledController != null)
{
if (playerControlledController.playerClient == playerClient)
{
if (killList.Contains(playerClient))
{
killList.Remove(playerClient);
DeathScreen.SetReason(playerClient.netPlayer, "You fell victim to /kill");
Broadcast.broadcastAll(playerClient.userName + " fell victim to /kill.");
}
else
{
DeathScreen.SetReason(playerClient.netPlayer, "You killed yourself. You silly sod.");
if (Vars.suicideMessages)
{
message = Vars.suicideMessage.Replace("$VICTIM$", playerClient.userName);
Broadcast.broadcastAll(message);
}
}
return;
}
Character killerChar;
Character victimChar;
Character.FindByUser(playerControlledController.playerClient.userID, out killerChar);
Character.FindByUser(playerClient.userID, out victimChar);
Vector3 killerPos = killerChar.transform.position;
Vector3 victimPos = victimChar.transform.position;
double distance = Math.Round(Vector3.Distance(killerPos, victimPos));
WeaponImpact extraData = damage.extraData as WeaponImpact;
if (wasHit.Contains(playerClient))
{
wasHit.Remove(playerClient);
}
if (extraData != null)
{
if (Vars.murderMessages)
{
message = Vars.murderMessage.Replace("$VICTIM$", playerClient.userName).Replace("$KILLER$", playerControlledController.playerClient.userName).Replace("$WEAPON$", extraData.dataBlock.name).Replace("$PART$", BodyParts.GetNiceName(damage.bodyPart)).Replace("$DISTANCE$", Convert.ToString(distance) + "m");
Broadcast.broadcastAll(message);
}
DeathScreen.SetReason(playerClient.netPlayer, playerControlledController.playerClient.userName + " killed you using a " + extraData.dataBlock.name + " with a hit to your " + BodyParts.GetNiceName(damage.bodyPart));
return;
}
if (Vars.murderMessages)
{
message = Vars.murderMessageUnknown.Replace("$VICTIM$", playerClient.userName).Replace("$KILLER$", playerControlledController.playerClient.userName);
Broadcast.broadcastAll(message);
}
DeathScreen.SetReason(playerClient.netPlayer, playerControlledController.playerClient.userName + " killed you with a hit to your " + BodyParts.GetNiceName(damage.bodyPart));
return;
}
}
string killer = idMain.ToString();
if (killer.Contains("(Clone)"))
killer = killer.Substring(0, killer.IndexOf("(Clone)"));
switch (killer)
{
case "MutantBear":
killer = "Mutant Bear";
break;
case "MutantWolf":
killer = "Mutant Wolf";
break;
}
Character victimChar2;
Character.FindByUser(playerClient.userID, out victimChar2);
if (Vars.accidentMessages)
{
message = Vars.accidentMessage.Replace("$VICTIM$", victimChar2.netUser.displayName).Replace("$KILLER$", killer);
Broadcast.broadcastAll(message);
}
DeathScreen.SetReason(playerClient.netPlayer, "You were killed by a " + killer);
}
}
}
}
}
catch (Exception ex)
{
Vars.conLog.Error("SDR: " + ex.ToString());
}
}
void EntityHurt_Test()
{
try
{
Entity Ent = null;
if (World.GetWorld().Entities.ToArray().Length > 2)
Ent = World.GetWorld().Entities.ToArray()[2];
if (Ent == null)
Log("EntityHurt_Test: Ent == null!");
DamageEvent damageEvent = new DamageEvent();
damageEvent.amount = 50f;
Log("EntityHurt_Test: Test 1");
Hooks.EntityHurt(Ent, ref damageEvent);
Fougerite.Player player = null;
Ent.ChangeOwner(player);
Log("EntityHurt_Test: Test 2");
Hooks.EntityHurt(Ent, ref damageEvent);
Log("EntityHurt_Test: Test 3");
Hooks.EntityHurt(null, ref damageEvent);
Ent = new Entity(new object());
Log("EntityHurt_Test: Test 4");
Hooks.EntityHurt(Ent, ref damageEvent);
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
public void OnHurt(DamageEvent damage)
{
}
/// <summary>
/// Performs a melee attack for the monster
/// </summary>
/// <returns>The length in seconds for the attack animation</returns>
public float MeleeAttack()
{
var target = AttackTarget as Creature;
var targetPlayer = AttackTarget as Player;
var targetPet = AttackTarget as CombatPet;
var combatPet = this as CombatPet;
if (target == null || !target.IsAlive)
{
FindNextTarget();
return(0.0f);
}
if (CurrentMotionState.Stance == MotionStance.NonCombat)
{
DoAttackStance();
}
// choose a random combat maneuver
var maneuver = GetCombatManeuver();
if (maneuver == null)
{
Console.WriteLine($"Combat maneuver null! Stance {CurrentMotionState.Stance}, MotionTable {MotionTableId:X8}");
return(0.0f);
}
AttackHeight = maneuver.AttackHeight;
DoSwingMotion(AttackTarget, maneuver, out float animLength, out var attackFrames);
PhysicsObj.stick_to_object(AttackTarget.PhysicsObj.ID);
var numStrikes = attackFrames.Count;
var actionChain = new ActionChain();
var prevTime = 0.0f;
for (var i = 0; i < numStrikes; i++)
{
actionChain.AddDelaySeconds(attackFrames[i] * animLength - prevTime);
prevTime = attackFrames[i] * animLength;
actionChain.AddAction(this, () =>
{
if (AttackTarget == null || IsDead)
{
return;
}
if (WeenieType == WeenieType.GamePiece)
{
target.TakeDamage(this, DamageType.Slash, target.Health.Current);
(this as GamePiece).OnDealtDamage();
return;
}
var weapon = GetEquippedWeapon();
var damageEvent = DamageEvent.CalculateDamage(this, target, weapon, maneuver);
//var damage = CalculateDamage(ref damageType, maneuver, bodyPart, ref critical, ref shieldMod);
if (damageEvent.HasDamage)
{
if (combatPet != null || targetPet != null)
{
// combat pet inflicting or receiving damage
//Console.WriteLine($"{target.Name} taking {Math.Round(damage)} {damageType} damage from {Name}");
target.TakeDamage(this, damageEvent.DamageType, damageEvent.Damage);
EmitSplatter(target, damageEvent.Damage);
}
else if (targetPlayer != null)
{
// this is a player taking damage
targetPlayer.TakeDamage(this, damageEvent);
if (damageEvent.ShieldMod != 1.0f)
{
var shieldSkill = targetPlayer.GetCreatureSkill(Skill.Shield);
Proficiency.OnSuccessUse(targetPlayer, shieldSkill, shieldSkill.Current); // ?
}
}
}
else
{
target.OnEvade(this, CombatType.Melee);
}
if (combatPet != null)
{
combatPet.PetOnAttackMonster(target);
}
});
}
actionChain.EnqueueChain();
// TODO: figure out exact speed / delay formula
var meleeDelay = ThreadSafeRandom.Next(MeleeDelayMin, MeleeDelayMax);
NextAttackTime = Timers.RunningTime + animLength + meleeDelay;
return(animLength);
}
object CancelDamage(DamageEvent damage)
{
damage.amount = 0f;
damage.status = LifeStatus.IsAlive;
return(damage);
}
public void OnHurt(DamageEvent damage)
{
this.MarkDamageTime();
}
public DeathEvent(ref DamageEvent d) : base(ref d)
{
this.DropItems = true;
}
public void ModifyRecievedEvent(DamageEvent damageEvent)
{
damageEvent.DamageAmount = Mathf.Max(1, damageEvent.DamageAmount - DamageReduction);
}
private object OnProcessDamageEvent(TakeDamage takedamage, DamageEvent damage)
{
var dmg = Interface.CallHook("ModifyDamage", takedamage, damage);
if (dmg is DamageEvent)
damage = (DamageEvent)dmg;
if ((bool)takenodamage.GetValue(takedamage)) return null;
var lifeStatus = damage.status;
if (lifeStatus == LifeStatus.WasKilled)
{
takedamage.health = 0f;
Interface.CallHook("OnKilled", takedamage, damage);
}
else if (lifeStatus == LifeStatus.IsAlive)
{
takedamage.health -= damage.amount;
Interface.CallHook("OnHurt", takedamage, damage);
}
return damage;
}
public HurtEvent(ref DamageEvent d)
{
//Logger.LogDebug(string.Format("[DamageEvent] {0}", d.ToString()));
try
{
this._sleeper = false;
this.DamageEvent = d;
this.WeaponData = null;
this.IsDecay = false;
this._status = d.status;
string weaponName = "Unknown";
if (d.victim.idMain is DeployableObject)
{
if (d.victim.id.ToString().ToLower().Contains("sleeping"))
{
this._sleeper = true;
DeployableObject sleeper = d.victim.idMain as DeployableObject;
this.Victim = new Sleeper(sleeper);
}
else
{
this.Victim = new Entity(d.victim.idMain.GetComponent <DeployableObject>());
}
this._playervictim = false;
}
else if (d.victim.idMain is StructureComponent)
{
this.Victim = new Entity(d.victim.idMain.GetComponent <StructureComponent>());
this._playervictim = false;
}
else if (d.victim.id is SpikeWall)
{
this._playerattacker = false;
this.Victim = new Entity(d.victim.idMain.GetComponent <DeployableObject>());
}
else if (d.victim.client != null)
{
this.Victim = Fougerite.Server.Cache[d.victim.client.userID];
this._playervictim = true;
}
else if (d.victim.character != null)
{
this.Victim = new NPC(d.victim.character);
this._playervictim = false;
}
if (!(bool)d.attacker.id)
{
if (d.victim.client != null)
{
weaponName = this.DamageType;
this._playerattacker = false;
this.Attacker = null;
}
}
else if (d.attacker.id is SpikeWall)
{
this._playerattacker = false;
this.Attacker = new Entity(d.attacker.idMain.GetComponent <DeployableObject>());
weaponName = d.attacker.id.ToString().Contains("Large") ? "Large Spike Wall" : "Spike Wall";
}
else if (d.attacker.id is SupplyCrate)
{
this._playerattacker = false;
this.Attacker = new Entity(d.attacker.idMain.gameObject);
weaponName = "Supply Crate";
}
else if (d.attacker.id is Metabolism && d.victim.id is Metabolism)
{
//this.Attacker = Fougerite.Server.Cache[d.attacker.client.userID];
this.Attacker = Fougerite.Player.FindByPlayerClient(d.attacker.client);
this._playerattacker = false;
this.Victim = this.Attacker;
ICollection <string> list = new List <string>();
Fougerite.Player vic = this.Victim as Fougerite.Player;
if (vic.IsStarving)
{
list.Add("Starvation");
}
if (vic.IsRadPoisoned)
{
list.Add("Radiation");
/*if (vic.RadLevel > 5000)
* {
* vic.AddRads(-vic.RadLevel);
* d.amount = 0;
* _de.amount = 0;
* Logger.LogDebug("[RadiationHack] Someone tried to kill " + vic.Name + " with radiation hacks.");
* }*/
}
if (vic.IsPoisoned)
{
list.Add("Poison");
}
if (vic.IsBleeding)
{
list.Add("Bleeding");
}
if (list.Contains("Bleeding"))
{
if (this.DamageType != "Unknown" && !list.Contains(this.DamageType))
{
list.Add(this.DamageType);
}
}
if (list.Count > 0)
{
weaponName = string.Format("Self ({0})", string.Join(",", list.ToArray()));
}
else
{
weaponName = this.DamageType;
}
}
else if (d.attacker.client != null)
{
this.Attacker = Fougerite.Server.Cache[d.attacker.client.userID];
this._playerattacker = true;
if (d.extraData != null)
{
WeaponImpact extraData = d.extraData as WeaponImpact;
this.WeaponData = extraData;
if (extraData.dataBlock != null)
{
weaponName = extraData.dataBlock.name;
}
}
else
{
if (d.attacker.id is TimedExplosive)
{
weaponName = "Explosive Charge";
}
else if (d.attacker.id is TimedGrenade)
{
weaponName = "F1 Grenade";
}
else
{
weaponName = "Hunting Bow";
}
if (d.victim.client != null)
{
if (!d.attacker.IsDifferentPlayer(d.victim.client) && !(this.Victim is Entity))
{
weaponName = "Fall Damage";
}
else if (!d.attacker.IsDifferentPlayer(d.victim.client) && (this.Victim is Entity))
{
weaponName = "Hunting Bow";
}
}
}
}
else if (d.attacker.character != null)
{
this.Attacker = new NPC(d.attacker.character);
this._playerattacker = false;
weaponName = string.Format("{0} Claw", (this.Attacker as NPC).Name);
}
this.WeaponName = weaponName;
}
catch (Exception ex)
{
Logger.LogDebug(string.Format("[HurtEvent] Error. " + ex.ToString()));
}
}
public void Damage(GameObject source, int damage)
{
DamageEvent eventArgs = new DamageEvent(source, gameObject, damage);
EventBus.Publish(eventArgs);
}
private void OnHurt(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnHurt");
// Print damage taken
var netUser = damage.victim.client.netUser;
if (netUser == null) return;
Puts("Player " + netUser.displayName + " took " + damage.amount + " damage!");
}
public DamageEvent DamageTarget(Creature target, WorldObject damageSource)
{
if (target.Health.Current <= 0)
{
return(null);
}
// check PK status
var targetPlayer = target as Player;
if (targetPlayer != null)
{
var pkError = CheckPKStatusVsTarget(this, targetPlayer, null);
if (pkError != null)
{
Session.Network.EnqueueSend(new GameEventWeenieErrorWithString(Session, pkError[0], target.Name));
targetPlayer.Session.Network.EnqueueSend(new GameEventWeenieErrorWithString(targetPlayer.Session, pkError[1], Name));
return(null);
}
}
var damageEvent = DamageEvent.CalculateDamage(this, target, damageSource);
if (damageEvent.HasDamage)
{
OnDamageTarget(target, damageEvent.CombatType, damageEvent.IsCritical);
if (targetPlayer != null)
{
targetPlayer.TakeDamage(this, damageEvent.DamageType, damageEvent.Damage, damageEvent.BodyPart, damageEvent.IsCritical);
}
else
{
target.TakeDamage(this, damageEvent.DamageType, damageEvent.Damage, damageEvent.IsCritical);
}
}
else
{
if (targetPlayer != null && targetPlayer.UnderLifestoneProtection)
{
Session.Network.EnqueueSend(new GameMessageSystemChat($"The Lifestone's magic protects {target.Name} from the attack!", ChatMessageType.Magic));
}
else
{
Session.Network.EnqueueSend(new GameMessageSystemChat($"{target.Name} evaded your attack.", ChatMessageType.CombatSelf));
}
}
if (damageEvent.HasDamage && target.IsAlive)
{
var attackConditions = new AttackConditions();
if (damageEvent.RecklessnessMod > 1.0f)
{
attackConditions |= AttackConditions.Recklessness;
}
if (damageEvent.SneakAttackMod > 1.0f)
{
attackConditions |= AttackConditions.SneakAttack;
}
// notify attacker
var intDamage = (uint)Math.Round(damageEvent.Damage);
Session.Network.EnqueueSend(new GameEventAttackerNotification(Session, target.Name, damageEvent.DamageType, (float)intDamage / target.Health.MaxValue, intDamage, damageEvent.IsCritical, attackConditions));
// splatter effects
if (targetPlayer == null)
{
Session.Network.EnqueueSend(new GameMessageSound(target.Guid, Sound.HitFlesh1, 0.5f));
if (damageEvent.Damage >= target.Health.MaxValue * 0.25f)
{
var painSound = (Sound)Enum.Parse(typeof(Sound), "Wound" + ThreadSafeRandom.Next(1, 3), true);
Session.Network.EnqueueSend(new GameMessageSound(target.Guid, painSound, 1.0f));
}
var splatter = (PlayScript)Enum.Parse(typeof(PlayScript), "Splatter" + GetSplatterHeight() + GetSplatterDir(target));
Session.Network.EnqueueSend(new GameMessageScript(target.Guid, splatter));
}
// handle Dirty Fighting
if (GetCreatureSkill(Skill.DirtyFighting).AdvancementClass >= SkillAdvancementClass.Trained)
{
FightDirty(target);
}
}
if (damageEvent.Damage > 0.0f)
{
Session.Network.EnqueueSend(new GameEventUpdateHealth(Session, target.Guid.Full, (float)target.Health.Current / target.Health.MaxValue));
}
if (targetPlayer == null)
{
OnAttackMonster(target);
}
return(damageEvent);
}
private void ModifyDamage(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("ModifyDamage");
}
public static LifeStatus HurtSelf(IDBase victim, TakeDamage.Quantity damageQuantity, out DamageEvent damage, object extraData = null)
{
return TakeDamage.HurtShared(victim, victim, damageQuantity, out damage, extraData);
}
public void OnDestroy()
{
unit = null;
DamageEvent.RemoveAllListeners();
}
public static LifeStatus KillSelf(IDBase victim, out DamageEvent damage, object extraData = null)
{
return TakeDamage.HurtShared(victim, victim, TakeDamage.Quantity.AllHealth, out damage, extraData);
}
/*void OnSetPlayer(int playerNum)
{
humanPlayer = playerNum;
}*/
void OnShotHit(DamageEvent data)
{
// we send damagedealt in Dude now ... that might not be a good idea
//Director.GetSingleton().SendMessage("OnDamageDealt", data);
}
protected virtual void ApplyDamageTypeList(ref DamageEvent damage, DamageTypeList damageTypes)
{
for (int i = 0; i < 6; i++)
{
if (!Mathf.Approximately(damageTypes[i], 0f))
{
damage.damageTypes = (DamageTypeFlags)((int)damage.damageTypes | 1 << (i & 31));
damage.amount = damage.amount + damageTypes[i];
}
}
}
public HurtEvent(ref DamageEvent d)
{
Fougerite.Player player = Fougerite.Player.FindByPlayerClient(d.attacker.client);
if (player != null)
{
this.Attacker = player;
}
else
{
this.Attacker = new NPC(d.attacker.character);
}
Fougerite.Player player2 = Fougerite.Player.FindByPlayerClient(d.victim.client);
if (player2 != null)
{
this.Victim = player2;
}
else
{
this.Victim = new NPC(d.victim.character);
}
this.DamageEvent = d;
this.WeaponData = null;
this.IsDecay = false;
string weaponName = "Unknown";
if (d.extraData != null)
{
WeaponImpact extraData = d.extraData as WeaponImpact;
this.WeaponData = extraData;
if (extraData.dataBlock != null)
{
weaponName = extraData.dataBlock.name;
}
}
else
{
if (d.attacker.id is TimedExplosive)
{
weaponName = "Explosive Charge";
}
else if (d.attacker.id is TimedGrenade)
{
weaponName = "F1 Grenade";
}
else if (d.attacker.id.ToString().Contains("MutantBear"))
{
weaponName = "Mutant Bear Claw";
}
else if (d.attacker.id.ToString().Contains("Bear"))
{
weaponName = "Bear Claw";
}
else if (d.attacker.id.ToString().Contains("MutantWolf"))
{
weaponName = "Mutant Wolf Claw";
}
else if (d.attacker.id.ToString().Contains("Wolf"))
{
weaponName = "Wolf Claw";
}
else if (d.attacker.id.Equals(d.victim.id))
{
weaponName = String.Format("Self ({0})", DamageType);
}
else
{
weaponName = "Hunting Bow";
}
}
this.WeaponName = weaponName;
}
protected virtual LifeStatus Hurt(ref DamageEvent damage)
{
if (this.dead)
{
damage.status = LifeStatus.IsDead;
}
else if (this.health <= damage.amount)
{
damage.status = LifeStatus.WasKilled;
}
else
{
damage.status = LifeStatus.IsAlive;
}
this.ProcessDamageEvent(ref damage);
if (this.ShouldRelayDamageEvent(ref damage))
{
base.SendMessage("OnHurt", damage, SendMessageOptions.DontRequireReceiver);
}
if (damage.status == LifeStatus.WasKilled)
{
base.SendMessage("OnKilled", damage, SendMessageOptions.DontRequireReceiver);
}
return damage.status;
}
private void ModifyDamage(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("ModifyDamage");
}
protected void ProcessDamageEvent(ref DamageEvent damage)
{
if (this.takenodamage)
{
return;
}
LifeStatus lifeStatu = damage.status;
if (lifeStatu == LifeStatus.IsAlive)
{
TakeDamage takeDamage = this;
takeDamage._health = takeDamage._health - damage.amount;
}
else if (lifeStatu == LifeStatus.WasKilled)
{
this._health = 0f;
}
}
private void OnKilled(TakeDamage takedamage, DamageEvent damage)
{
HookCalled("OnKilled");
}
protected bool ShouldRelayDamageEvent(ref DamageEvent damage)
{
switch (damage.status)
{
case LifeStatus.IsAlive:
{
return this.sendMessageWhenAlive;
}
case LifeStatus.WasKilled:
{
return this.sendMessageWhenKilled;
}
case LifeStatus.IsDead:
{
return this.sendMessageWhenDead;
}
}
Debug.LogWarning(string.Concat("Unhandled LifeStatus ", damage.status), this);
return false;
}
public void ExecuteDealDamage(IAttacker target, int value, DamageType type)
{
DamageEvent.Call(new DamageEventArgs(this, target, value, type));
}
private static LifeStatus HurtShared(IDBase attacker, IDBase victim, TakeDamage.Quantity damageQuantity, out DamageEvent damage, object extraData = null)
{
damage = new DamageEvent();
TakeDamage takeDamage;
if (victim)
{
IDMain dMain = victim.idMain;
if (dMain)
{
takeDamage = (!(dMain is Character) ? dMain.GetLocal<TakeDamage>() : ((Character)dMain).takeDamage);
if (takeDamage && !takeDamage.takenodamage)
{
takeDamage.MarkDamageTime();
damage.victim.id = victim;
damage.attacker.id = attacker;
damage.amount = damageQuantity.@value;
damage.sender = takeDamage;
damage.status = (!takeDamage.dead ? LifeStatus.IsAlive : LifeStatus.IsDead);
damage.damageTypes = (DamageTypeFlags)0;
damage.extraData = extraData;
if ((int)damageQuantity.Unit == -1)
{
takeDamage.ApplyDamageTypeList(ref damage, damageQuantity.list);
}
takeDamage.Hurt(ref damage);
return damage.status;
}
}
}
damage.victim.id = null;
damage.attacker.id = null;
damage.amount = 0f;
damage.sender = null;
damage.damageTypes = (DamageTypeFlags)0;
damage.status = LifeStatus.Failed;
damage.extraData = extraData;
return LifeStatus.Failed;
}
void NPCKilled_Test()
{
try
{
DamageEvent damageEvent = new DamageEvent();
Log("NPCKilled_Test: Test 1");
Hooks.NPCKilled(ref damageEvent);
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
// Token: 0x06001318 RID: 4888 protected abstract void OnDamageEvent(DamageEvent damageEvent);
public void Damage(float damage, Vector3 hitPoint, AttributeChangeCause cause = AttributeChangeCause.FORCED, Damageable attacker = null, DamageType type = DamageType.NONE)
{
// Invoke a damage event
DamageEvent e = new DamageEvent {
cause = cause, victim = this, attacker = attacker, type = type, damage = damage
};
OnDamageEvent?.Invoke(this, e);
if (e.cancel == true)
{
return;
} // return if the event has been cancelled by any subscriber
bool hadImmunity = false;
bool hadWeakness = false;
bool hadResistance = false;
// Check for immunity
for (int i = 0; i < immunities.Length; i++)
{
if (e.type == immunities[i])
{
e.damage = 0;
hadImmunity = true;
break;
}
}
// Modify any damage by any weaknesses or resistances
if (e.damage > 0 && e.type != DamageType.NONE)
{
for (int i = 0; i < weaknesses.Length; i++)
{
if (e.type == weaknesses[i])
{
e.damage *= 2;
hadWeakness = true;
break;
}
}
for (int i = 0; i < resistances.Length; i++)
{
if (e.type == resistances[i])
{
e.damage /= 2;
hadResistance = true;
break;
}
}
}
// If the damage is enough to kill, invoke a death event
if (GetAttributeValue(Attributes.HEALTH) - e.damage <= 0)
{
DeathEvent e2 = new DeathEvent {
cause = cause, victim = this, attacker = attacker
};
OnDeathEvent?.Invoke(this, e2);
if (e2.cancel == true)
{
return;
} // return if the event has been cancelled by any subscriber
}
// Update health
GetAttribute(Attributes.HEALTH).Modify(-e.damage);
// Send indicator
Color indicatorColor = Color.gray * Color.gray;
if (hadImmunity)
{
indicatorColor = Color.red;
}
if (hadWeakness)
{
indicatorColor = Color.white;
}
if (hadResistance)
{
indicatorColor = Color.yellow;
}
if (hitPoint == null)
{
UIMaster.SendFloatingIndicator(this.transform.position + this.transform.rotation * center, e.damage.ToString("#.0"), indicatorColor);
}
else
{
UIMaster.SendFloatingIndicator(hitPoint, e.damage.ToString("0.0"), indicatorColor);
}
}
public IEnumerator OnStun(float stunDuration)
{
if (status.stunned || cannotBeStunned)
{
yield break;
}
if (stunDuration == 0.0f)
{
stunDuration = defaultStun;
}
// HACK: stunDuration of < 0 means "force a stun of this amount"
if (stunDuration < 0.0f)
{
stunDuration *= -1.0f;
}
else
{
stunDuration -= stunResistance;
if (stunDuration <= 0.0f)
{
stunDuration = 0.5f; //yield break;
}
// tell the Director to maintain the bloodlust meter
var fakeData = new DamageEvent();
fakeData.damage = 20;
var director = GameObject.FindGameObjectWithTag("Director");
if (director != null)
{
director.SendMessage("OnDamageDealt", fakeData);
}
}
var trailEffect = Instantiate(
Resources.Load("Effects/effect_stun") as GameObject, Vector3.zero, Quaternion.identity
) as GameObject;
trailEffect.transform.parent = transform;
trailEffect.transform.localPosition = Vector3.zero;
if (stunDuration >= 1.0f)
{
animated.animation["bjorn_die"].speed = 1;
animated.animation.Play("bjorn_die");
//animated.parent.SendMessage("DoEffect", stunDuration);
}
// stop all active processes
gameObject.BroadcastMessage("OnDisable");
StopCoroutine("doSwing");
if (activeTelegraph != null)
{
activeTelegraph.gameObject.SetActive(false);
//activeTelegraphCircle.gameObject.SetActive(false);
}
this.status.stunned = true;
yield return(new WaitForSeconds(stunDuration));
Destroy(trailEffect);
if (stunDuration >= 1.0f)
{
// get up
animated.animation["bjorn_die"].normalizedTime = 1.0f;
animated.animation["bjorn_die"].speed = -1;
animated.animation.Play("bjorn_die");
yield return(new WaitForSeconds(0.5f));
}
gameObject.BroadcastMessage("OnEnable");
this.status.stunned = false;
// have to reset other statuses as well
// I really shouldn't have to do this...
this.status.Reset();
}
private void OnDamaged(DamageEvent evt)
{
health = PlayerInputComponent.health;
Debug.Log("Health: " + health.ToString());
}
/*void OnSetPlayer(int playerNum)
* {
* humanPlayer = playerNum;
*
* }*/
void OnShotHit(DamageEvent data)
{
// we send damagedealt in Dude now ... that might not be a good idea
//Director.GetSingleton().SendMessage("OnDamageDealt", data);
}
public void OnCollideObject(WorldObject target)
{
if (!PhysicsObj.is_active())
{
return;
}
//Console.WriteLine($"Projectile.OnCollideObject - {WorldObject.Name} ({WorldObject.Guid}) -> {target.Name} ({target.Guid})");
if (ProjectileTarget == null || ProjectileTarget != target)
{
//Console.WriteLine("Unintended projectile target! (should be " + ProjectileTarget.Guid.Full.ToString("X8") + " - " + ProjectileTarget.Name + ")");
OnCollideEnvironment();
return;
}
// take damage
var sourceCreature = ProjectileSource as Creature;
var sourcePlayer = ProjectileSource as Player;
var targetCreature = target as Creature;
DamageEvent damageEvent = null;
if (targetCreature != null)
{
if (sourcePlayer != null)
{
// player damage monster or player
damageEvent = sourcePlayer.DamageTarget(targetCreature, WorldObject);
if (damageEvent != null && damageEvent.HasDamage)
{
WorldObject.EnqueueBroadcast(new GameMessageSound(WorldObject.Guid, Sound.Collision, 1.0f));
}
}
else if (sourceCreature != null && sourceCreature.AttackTarget != null)
{
var targetPlayer = sourceCreature.AttackTarget as Player;
damageEvent = DamageEvent.CalculateDamage(sourceCreature, targetCreature, WorldObject);
if (targetPlayer != null)
{
// monster damage player
if (damageEvent.HasDamage)
{
targetPlayer.TakeDamage(sourceCreature, damageEvent);
// blood splatter?
if (damageEvent.ShieldMod != 1.0f)
{
var shieldSkill = targetPlayer.GetCreatureSkill(Skill.Shield);
Proficiency.OnSuccessUse(targetPlayer, shieldSkill, shieldSkill.Current); // ??
}
}
else
{
targetPlayer.OnEvade(sourceCreature, CombatType.Missile);
}
}
else
{
// monster damage pet
if (damageEvent.HasDamage)
{
targetCreature.TakeDamage(sourceCreature, damageEvent.DamageType, damageEvent.Damage);
// blood splatter?
}
}
}
// handle target procs
if (damageEvent != null && damageEvent.HasDamage)
{
sourceCreature?.TryProcEquippedItems(targetCreature, false);
}
}
WorldObject.CurrentLandblock?.RemoveWorldObject(WorldObject.Guid, showError: !PhysicsObj.entering_world);
PhysicsObj.set_active(false);
WorldObject.HitMsg = true;
}
public override void OnHit(OmniObject player, OmniObject hitPlayer, Vector2 vel,Vector2 pos,int location)
{
if (hitPlayer is DamageableObject)
{
DamageableObject dmged = hitPlayer as DamageableObject;
if (dmged.stun > 0)
return;
else
{
dmged.stun = stunTime;
}
}
if (vel.magnitude < 0.7f)
return;
if (location >= 0)
{
if (player is DamageableObject)
{
if (((DamageableObject)player).isProjectile)
{
DamageableObject pl = ((DamageableObject)player);
Vector2 b1 = pos;
Vector2 b2 = hitPlayer.boundsPos + new Vector2(hitPlayer.skeleton[location].bounds.x * hitPlayer.item.Size, hitPlayer.skeleton[location].bounds.y * hitPlayer.item.Size);
//b1.x += player.item.Size / 2f;
//b2.x += hitPlayer.item.Size / 2f;
//b1.y += player.item.Size / 2f;
//b2.y += hitPlayer.item.Size / 2f;
Vector2 offset = pos;
/*
Quaternion rot = Quaternion.AngleAxis(hitPlayer.skeleton[location].rotation, Vector3.forward);
Matrix4x4 tr = hitPlayer.skeleton[location].tr;
Matrix4x4 skelmove = Matrix4x4.TRS(hitPlayer.skeleton[location].rotationPoint, Quaternion.identity, Vector3.one);
Matrix4x4 skelrot = Matrix4x4.TRS(Vector3.zero, rot, Vector3.one);
tr *= skelmove;
tr *= skelrot;
tr *= skelmove.inverse;
offset = tr.MultiplyPoint(offset);
*/
//offset /= hitPlayer.item.Size;
pl.mountedTo = hitPlayer;
pl.mountPos = offset;
pl.mountPosFlipped = offset;
pl.mountPosFlipped.x = pl.item.Size-offset.x;
pl.mountRot = player.rotation - hitPlayer.skeleton[location].rotation;
//Debug.Log(pl.mountRot);
//float a = ;
if (hitPlayer.skeleton[location].rotation >= 0)
{
//pl.mountPos.x += 1 * (hitPlayer.item.Size / player.item.Size);
}
//pl.mountPos.x -= Mathf.Cos(a);
//pl.mountPos.y -= Mathf.Sin(a);
//pl.mountRotOffset = player.rotation - hitPlayer.skeleton[location].rotation;
pl.mountLoc = location;
mountObject o = new mountObject();
o.obj = player;
o.location = location;
hitPlayer.mountObjects.Add(o);
}
}
}
DamageEvent e = new DamageEvent(OmniWorld.tick, hitPlayer, player, this, vel);
OmniEvents.AddEvent(e);
}
void Handle(DamageEvent e)
{
constraint.ForEachGameObject((egoComponent, transform, powerUpComponent, spriteRenderer, collider) => {
powerUpComponent.powerUpTimerTimeElapsed = -1;
});
}
public void ModifyDispatchedEvent(DamageEvent damageEvent)
{
damageEvent.DamageAmount += DamageDealt;
}
