public void TakeDamage(float damageTaken, GameObject damageGiver)
{
if (invulnerable)
{
return;
}
StartCoroutine(IFrames());
currHealth -= damageTaken;
SoundsManager.instance.PlayClip(SoundsManager.Sound.PlayerDamaged);
DamageTaken?.Invoke();
if (currHealth <= 0f)
{
Destroy();
}
else
{
Knockback kB = GetComponent <Knockback>();
if (kB != null)
{
StartCoroutine(kB.KnockBack(damageGiver.gameObject.transform));
GetComponent <PlayerMovement>().ChangeState(PlayerState.Stagger);
}
}
}
public void TakeDamage(DamageArgs args)
{
DamageArgs pointDamageArgs = new DamageArgs(args.Origin, args.Dealer, 1);
health.TakeDamage(pointDamageArgs);
DamageTaken?.Invoke(this, pointDamageArgs);
}
public void ApplyDamage(ProjectileInfo projectileInfo, Unit unit)
{
if (unit.IsAlive && projectileInfo.Sender != unit)
{
unit.Stats.CurrentHealth.Value -= projectileInfo.Damage;
DamageTaken?.Invoke(unit);
}
}
public void Clicked()
{
if (CombatManager.instance.Enemy.CurrentHP == 0)
{
CombatManager.instance.Enemy = monsterController.SpawnMonster();
printEnemyStuff();
killChain += 1;
}
damageTaken = CombatManager.instance.CalculateDamage();
}
public void TakeDamage(int damage)
{
_currHealth = Mathf.Clamp(_currHealth - Mathf.Abs(damage), 0, _maxHealth);
DamageTaken?.Invoke();
Debug.Log("Took " + damage + " damage: " + _currHealth);
if (_currHealth <= 0 && !_isDead)
{
Died?.Invoke();
_isDead = true;
}
}
public void Reset()
{
Creatures.Clear();
Targets.Clear();
DamageDone.Clear();
DamageTaken.Clear();
Deads.Clear();
CombatCreatureGuid.Reset();
CombatDamageDoneGuid.Reset();
CombatDamageTakenGuid.Reset();
CombatDeadGuid.Reset();
}
public void TakeDamage(byte amount)
{
var newHP = HP - amount;
DamageTaken?.Invoke(this, amount);
if (newHP > 0)
{
HP = (byte)newHP;
}
else
{
Died?.Invoke(this, true);
}
}
public void TakeDamage(int health)
{
if (health < 0)
{
throw new Exception("Vitals.TakeDamage used to heal! Use Vitals.HealDamage instead.");
}
currentHealth -= health;
DamageTaken?.Invoke();
if (isDead)
{
_playerLives.Die();
}
}
public void ApplyDamage(int damage)
{
if (!IsAlive)
{
return;
}
_livesRemaining -= damage;
DamageTaken?.Invoke(_livesRemaining);
if (_livesRemaining <= 0)
{
GameEventsHandler.Instance.CountPlayerDeath();
Died?.Invoke();
}
}
public void Update(int targetGuid, int targetHealthPercent)
{
Update(targetGuid, targetHealthPercent, Targets);
if (CombatCreatureGuid.Updated(reader))
{
Update(CombatCreatureGuid.Value, 100f, Creatures);
}
if (CombatDamageTakenGuid.Updated(reader))
{
Update(CombatDamageTakenGuid.Value, 100f, DamageTaken);
}
if (CombatDamageDoneGuid.Updated(reader))
{
Update(CombatDamageDoneGuid.Value, 100f, DamageDone);
}
if (CombatDeadGuid.Updated(reader))
{
Update(CombatDeadGuid.Value, 0, Creatures);
Update(CombatDeadGuid.Value, 0, Deads);
if (DamageTaken.Exists(x => x.Guid == CombatDeadGuid.Value))
{
Update(CombatDeadGuid.Value, 0, DamageTaken);
}
if (DamageDone.Exists(x => x.Guid == CombatDeadGuid.Value))
{
Update(CombatDeadGuid.Value, 0, DamageDone);
}
if (Targets.Exists(x => x.Guid == CombatDeadGuid.Value))
{
Update(CombatDeadGuid.Value, 0, Targets);
}
if (Targets.Exists(x => x.Guid == CombatDeadGuid.Value) &&
(DamageDone.Exists(x => x.Guid == CombatDeadGuid.Value) || DamageTaken.Exists(x => x.Guid == CombatDeadGuid.Value)))
{
KillCredit?.Invoke(this, EventArgs.Empty);
}
}
}
public void takeDamage(Damage damage)
{
if ((this.Group & damage.Attacks) != 0)
{
this.Amount -= damage.Amount;
if (DamageTaken != null)
{
DamageTaken.Invoke(this);
}
if (this.Amount <= 0)
{
if (Dead != null)
{
Dead.Invoke(this);
}
}
}
}
private void TakeDamage(GameObject damager)
{
DamageTaken?.Invoke(this.gameObject, damager);
switch (damager.gameObject.tag)
{
case "Enemy":
health -= damager.GetComponent <EnemyController>().data.damage;
break;
case "Obstacle":
health -= damager.GetComponent <ObstacleController>().data.damage;
break;
}
if (health < 1)
{
Destroy(this.gameObject);
// Die();
}
}
public DamageTaken CalculateDamage()
{
DamageTaken damageTaken = CalculateEnemyDamageTaken();
if (damageTaken.EnemyDamageTaken >= Enemy.CurrentHP)
{
// Enemy was killed
Enemy.CurrentHP = 0;
GameManager.instance.Player.CurrentExperience += Enemy.ExperienceToAward;
// Player gained a level
if (GameManager.instance.Player.CurrentExperience >= GameManager.instance.Player.MaxExperience)
{
double diffExperience = GameManager.instance.Player.CurrentExperience - GameManager.instance.Player.MaxExperience;
GameManager.instance.Player.CurrentExperience = diffExperience;
GameManager.instance.Player.LevelUp();
}
// Player doesn't take damage
return(damageTaken);
}
else
{
Enemy.CurrentHP -= damageTaken.EnemyDamageTaken;
}
damageTaken = CalculatePlayerDamageTaken(damageTaken);
if (damageTaken.PlayerDamageTaken >= GameManager.instance.Player.CurrentHP)
{
//Player was killed
GameManager.instance.Player.CurrentHP = 0;
GameManager.instance.Player.CurrentExperience -= Math.Round(GameManager.instance.Player.CurrentExperience * .1);
SceneManager.LoadScene("Death");
}
else
{
GameManager.instance.Player.CurrentHP -= damageTaken.PlayerDamageTaken;
}
return(damageTaken);
}
int IComparable <BProtoObjectVeterancy> .CompareTo(BProtoObjectVeterancy other)
{
if (XP != other.XP)
{
return(XP.CompareTo(other.XP));
}
if (Damage != other.Damage)
{
return(Damage.CompareTo(other.Damage));
}
if (Velocity != other.Velocity)
{
return(Velocity.CompareTo(other.Velocity));
}
if (Accuracy != other.Accuracy)
{
return(Accuracy.CompareTo(other.Accuracy));
}
if (WorkRate != other.WorkRate)
{
return(WorkRate.CompareTo(other.WorkRate));
}
if (WeaponRange != other.WeaponRange)
{
return(WeaponRange.CompareTo(other.WeaponRange));
}
if (DamageTaken != other.DamageTaken)
{
return(DamageTaken.CompareTo(other.DamageTaken));
}
return(0);
}
public bool DoDamage(MyDamageInformation dmg)
{
if (dmg.Type == MyDamageType.Bullet || dmg.Type == MyDamageType.Bolt)
{
var parentSwitcher = Entity.Hierarchy.Parent?.Container?.Get <IRailSwitch>();
if (parentSwitcher != null)
{
if (MyMultiplayerModApi.Static.IsServer)
{
parentSwitcher.Switch();
}
(parentSwitcher as RailSwitchExternalComponent)?.FlagAnimationWarp();
return(true);
}
}
if (!DamageParent(dmg))
{
return(false);
}
DamageTaken?.Invoke(dmg);
return(true);
}
public override void Draw(SpriteBatch spriteBatch)
{
#if debug
RectClass.DrawBorder(Game1.pixel, spriteBatch, BoundingBox, 1, Color.Red, Color.Gray * 0.3f);
//spriteBatch.DrawString(Game1.debugFont, damagePosition.ToString(), new Vector2(100, 100), Color.Black);
#endif
#region Zombie draw
if (alive)
{
#region Healthbar draw
spriteBatch.Draw(Game1.HealthBar, new Rectangle((int)HealthBarPosition.X, (int)HealthBarPosition.Y, ZombieHealthBarWidthBackground, Game1.HealthBar.Height), Color.Black);
spriteBatch.Draw(Game1.HealthBar, new Rectangle((int)HealthBarPosition.X, (int)HealthBarPosition.Y, ZombieHealthBarWidth, Game1.HealthBar.Height), Color.Red);
#endregion
spriteBatch.Draw(texture, bloodPosition, hitSourceRectangle, color, rotation, new Vector2(90, 40), scale, SpriteEffects.None, 0f);
spriteBatch.Draw(texture, new Rectangle((int)this.position.X, (int)this.position.Y, (int)(WIDTH * scale), (int)(HEIGHT * scale)), sourceRectangle, Color.White, rotation, origin, SpriteEffects.None, 0f);
if (displayingDamagePoints && Game1.ScreenSize.Contains((int)damagePosition.X, (int)damagePosition.Y))
{
spriteBatch.DrawString(Game1.debugFont, DamageTaken.ToString(), this.DamagePosition, Color.Black, 0f, Vector2.Zero, 1.0f, SpriteEffects.None, 0f);
}
}
else if (!alive)
{
int Dwidth = 120;
int Dheight = 80;
Vector2 Dorgin = new Vector2(Dwidth / 2, Dheight / 2);
spriteBatch.Draw(Game1.SSZombieDeathAnmation, new Rectangle((int)this.position.X, (int)this.position.Y, (int)(Dwidth * scale), (int)(Dheight * scale)),
new Rectangle(DeathFrame * Dwidth, 0, Dwidth, Dheight),
Color.White,
rotation,
Dorgin,
SpriteEffects.None,
0f);
}
#endregion
}
public void Register(DamageTaken callBack)
{
damageTaken += callBack;
}
private void DoDamageTaken(int value)
{
DamageTaken?.Invoke(this, new DamageTakenEventArgs(value));
}
// Start is called before the first frame update
void Start()
{
theDialogBox = FindObjectOfType <DialogBoxManager>();
dmg = FindObjectOfType <DamageTaken>();
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues = new Dictionary <string, string>();
int levelDifference = TargetLevel - CharacterLevel;
float baseMiss = StatConversion.WHITE_MISS_CHANCE_CAP[levelDifference] - BasicStats.PhysicalHit;
float baseDodge = StatConversion.WHITE_DODGE_CHANCE_CAP[levelDifference] - StatConversion.GetDodgeParryReducFromExpertise(BasicStats.Expertise);
float baseParry = StatConversion.WHITE_PARRY_CHANCE_CAP[levelDifference] - StatConversion.GetDodgeParryReducFromExpertise(BasicStats.Expertise);
float capMiss = (float)Math.Ceiling(baseMiss * StatConversion.RATING_PER_PHYSICALHIT);
float capDodge = (float)Math.Ceiling(baseDodge * 400f * StatConversion.RATING_PER_EXPERTISE);
float capParry = (float)Math.Ceiling(baseParry * 400f * StatConversion.RATING_PER_EXPERTISE);
string tipMiss = string.Empty;
if (BasicStats.HitRating > capMiss)
{
tipMiss = string.Format("*Over the cap by {0} Hit Rating", BasicStats.HitRating - capMiss);
}
else if (BasicStats.HitRating < capMiss)
{
tipMiss = string.Format("*Under the cap by {0} Hit Rating", capMiss - BasicStats.HitRating);
}
else
{
tipMiss = "*Exactly at the cap";
}
string tipDodgeParry = string.Empty;
if (BasicStats.ExpertiseRating > capDodge)
{
tipDodgeParry = string.Format("*Over the dodge cap by {0} Expertise Rating\r\n", BasicStats.ExpertiseRating - capDodge);
}
else if (BasicStats.ExpertiseRating < capDodge)
{
tipDodgeParry = string.Format("*Under the dodge cap by {0} Expertise Rating\r\n", capDodge - BasicStats.ExpertiseRating);
}
else
{
tipDodgeParry = "*Exactly at the dodge cap";
}
if (BasicStats.ExpertiseRating > capParry)
{
tipDodgeParry += string.Format("Over the parry cap by {0} Expertise Rating", BasicStats.ExpertiseRating - capParry);
}
else if (BasicStats.ExpertiseRating < capParry)
{
tipDodgeParry += string.Format("Under the parry cap by {0} Expertise Rating", capParry - BasicStats.ExpertiseRating);
}
else
{
tipDodgeParry += "Exactly at the parry cap";
}
int armorCap = (int)Math.Ceiling(6502.5f * TargetLevel - 474502.5f);
float levelDifferenceAvoidance = 0.002f * levelDifference;
float targetCritReduction = StatConversion.NPC_LEVEL_CRIT_MOD[levelDifference];
/*int defToCap = 0, resToCap = 0;
* if (CritReduction < targetCritReduction)
* {
* //while (((float)Math.Floor((BasicStats.DefenseRating + defToCap) / (123f / 52f)) * 0.04f)
* //+ BasicStats.Resilience / (2050f / 52f) + BasicStats.CritChanceReduction < targetCritReduction)
* // defToCap++;
* //while (((float)Math.Floor(BasicStats.DefenseRating / (123f / 52f)) * 0.04f)
* //+ (BasicStats.Resilience + resToCap) / (2050f / 52f) + BasicStats.CritChanceReduction < targetCritReduction)
* // resToCap++;
* while (((float)Math.Floor(StatConversion.GetDefenseFromRating(BasicStats.DefenseRating + defToCap)) * 0.0004f)
+ StatConversion.GetCritReductionFromResilience(BasicStats.Resilience)
+ BasicStats.CritChanceReduction < targetCritReduction)
+ defToCap++;
+ while (((float)Math.Floor(StatConversion.GetDefenseFromRating(BasicStats.DefenseRating)) * 0.0004f)
+ StatConversion.GetCritReductionFromResilience(BasicStats.Resilience + resToCap)
+ BasicStats.CritChanceReduction < targetCritReduction)
+ resToCap++;
+ }
+ else if (CritReduction > targetCritReduction)
+ {
+ //while (((float)Math.Floor((BasicStats.DefenseRating + defToCap) / (123f / 52f)) * 0.04f)
+ //+ BasicStats.Resilience / (2050f / 52f) + BasicStats.CritChanceReduction > targetCritReduction)
+ // defToCap--;
+ //while (((float)Math.Floor(BasicStats.DefenseRating / (123f / 52f)) * 0.04f)
+ //+ (BasicStats.Resilience + resToCap) / (2050f / 52f) + BasicStats.CritChanceReduction > targetCritReduction)
+ // resToCap--;
+
+ while (((float)Math.Floor(StatConversion.GetDefenseFromRating(BasicStats.DefenseRating + defToCap)) * 0.0004f)
+ StatConversion.GetCritReductionFromResilience(BasicStats.Resilience) + BasicStats.CritChanceReduction > targetCritReduction)
+ defToCap--;
+ while (((float)Math.Floor(StatConversion.GetDefenseFromRating(BasicStats.DefenseRating)) * 0.0004f)
+ StatConversion.GetCritReductionFromResilience(BasicStats.Resilience + resToCap) + BasicStats.CritChanceReduction > targetCritReduction)
+ resToCap--;
+ defToCap++;
+ resToCap++;
+ }*/
// Changed to not just give a resist rating, but a breakdown of the resulting resist values in the tooltip
string tipResist = string.Empty;
tipResist = StatConversion.GetResistanceTableString(TargetLevel, CharacterLevel, BasicStats.NatureResistance, 0);
dictValues.Add("Nature Resist", BasicStats.NatureResistance.ToString() + "*" + tipResist);
tipResist = StatConversion.GetResistanceTableString(TargetLevel, CharacterLevel, BasicStats.ArcaneResistance, 0);
dictValues.Add("Arcane Resist", BasicStats.ArcaneResistance.ToString() + "*" + tipResist);
tipResist = StatConversion.GetResistanceTableString(TargetLevel, CharacterLevel, BasicStats.FrostResistance, 0);
dictValues.Add("Frost Resist", BasicStats.FrostResistance.ToString() + "*" + tipResist);
tipResist = StatConversion.GetResistanceTableString(TargetLevel, CharacterLevel, BasicStats.FireResistance, 0);
dictValues.Add("Fire Resist", BasicStats.FireResistance.ToString() + "*" + tipResist);
tipResist = StatConversion.GetResistanceTableString(TargetLevel, CharacterLevel, BasicStats.ShadowResistance, 0);
dictValues.Add("Shadow Resist", BasicStats.ShadowResistance.ToString() + "*" + tipResist);
dictValues.Add("Health", BasicStats.Health.ToString());
dictValues.Add("Agility", BasicStats.Agility.ToString());
dictValues.Add("Armor", BasicStats.Armor.ToString());
dictValues.Add("Stamina", BasicStats.Stamina.ToString());
dictValues.Add("Dodge Rating", BasicStats.DodgeRating.ToString());
dictValues.Add("Mastery", string.Format("{0}*{1} Mastery Rating",
StatConversion.GetMasteryFromRating(BasicStats.MasteryRating) + 8f,
BasicStats.MasteryRating.ToString()));
dictValues.Add("Resilience", BasicStats.Resilience.ToString());
dictValues.Add("Dodge", Dodge.ToString("0.000%"));
dictValues.Add("Miss", Miss.ToString("0.000%"));
if (BasicStats.Armor == armorCap)
{
dictValues.Add("Armor Damage Reduction", DamageReductionFromArmor.ToString("0.000%")
+ string.Format("*Exactly at the armor cap against level {0} mobs.", TargetLevel));
}
else if (BasicStats.Armor > armorCap)
{
dictValues.Add("Armor Damage Reduction", DamageReductionFromArmor.ToString("0.000%")
+ string.Format("*Over the armor cap by {0} armor.", BasicStats.Armor - armorCap));
}
else
{
dictValues.Add("Armor Damage Reduction", DamageReductionFromArmor.ToString("0.000%")
+ string.Format("*Short of the armor cap by {0} armor.", armorCap - BasicStats.Armor));
}
dictValues.Add("Total Damage Reduction", TotalConstantDamageReduction.ToString("0.000%"));
dictValues.Add("Avoidance PreDR", AvoidancePreDR.ToString("0.000%"));
dictValues.Add("Avoidance PostDR", AvoidancePostDR.ToString("0.000%"));
dictValues.Add("Total Mitigation", TotalMitigation.ToString("0.000%"));
dictValues.Add("Damage Taken", DamageTaken.ToString("0.000%"));
dictValues.Add("Savage Defense", string.Format(
"{0} ~ {1}*{0} chance to absorb incoming hit\r\n{1} absorbed per hit\r\n{2} of incoming damage absorbed",
SavageDefenseChance.ToString("0.000%"), SavageDefenseValue, SavageDefensePercent.ToString("0.000%")));
dictValues.Add("Chance to be Crit", ((0.05f + levelDifferenceAvoidance) - CritReduction).ToString("0.000%"));
dictValues.Add("Overall Points", OverallPoints.ToString());
dictValues.Add("Mitigation Points", MitigationPoints.ToString());
dictValues.Add("Survival Points", string.Format("{0}*{1} Before Soft Cap", SurvivabilityPoints.ToString(), SurvivalPointsRaw.ToString()));
dictValues.Add("Threat Points", ThreatPoints.ToString());
dictValues["Nature Survival"] = NatureSurvivalPoints.ToString();
dictValues["Frost Survival"] = FrostSurvivalPoints.ToString();
dictValues["Fire Survival"] = FireSurvivalPoints.ToString();
dictValues["Shadow Survival"] = ShadowSurvivalPoints.ToString();
dictValues["Arcane Survival"] = ArcaneSurvivalPoints.ToString();
dictValues["Strength"] = BasicStats.Strength.ToString();
dictValues["Attack Power"] = string.Format("{0}*{1} with Vengeance", (BasicStats.AttackPower - AverageVengeanceAP), BasicStats.AttackPower);
dictValues["Average Vengeance AP"] = AverageVengeanceAP.ToString("N1");
dictValues["Crit Rating"] = BasicStats.CritRating.ToString();
dictValues["Hit Rating"] = BasicStats.HitRating.ToString() + tipMiss;
dictValues["Expertise Rating"] = BasicStats.ExpertiseRating.ToString() + tipDodgeParry;
dictValues["Haste Rating"] = string.Format("{0}*{1}sec Attack Speed", BasicStats.HasteRating, AttackSpeed.ToString("0.000"));
//dictValues["Armor Penetration Rating"] = BasicStats.ArmorPenetrationRating.ToString();
dictValues["Avoided Attacks"] = String.Format("{0}*{1} Missed\r\n{2} Dodged\r\n{3} Parried",
AvoidedAttacks.ToString("0.000%"), MissedAttacks.ToString("0.000%"),
DodgedAttacks.ToString("0.000%"), ParriedAttacks.ToString("0.000%"));
dictValues["Highest DPS Rotation"] = HighestDPSRotation.Name;
dictValues["Highest TPS Rotation"] = HighestTPSRotation.Name;
dictValues["Swipe Rotation"] = "";
dictValues["Custom Rotation"] = "";
//string rotationFormat = "{0} DPS, {1} TPS*{2}";
//dictValues["Highest DPS Rotation"] = String.Format(rotationFormat, Math.Round(HighestDPSRotation.DPS), Math.Round(HighestDPSRotation.TPS), GetRotationTooltip(HighestDPSRotation.Name));
//dictValues["Highest TPS Rotation"] = String.Format(rotationFormat, Math.Round(HighestTPSRotation.DPS), Math.Round(HighestTPSRotation.TPS), GetRotationTooltip(HighestTPSRotation.Name));
//dictValues["Swipe Rotation"] = String.Format(rotationFormat, Math.Round(SwipeRotation.DPS), Math.Round(SwipeRotation.TPS), GetRotationTooltip(SwipeRotation.Name));
//dictValues["Custom Rotation"] = String.Format(rotationFormat, Math.Round(CustomRotation.DPS), Math.Round(CustomRotation.TPS), GetRotationTooltip(CustomRotation.Name));
dictValues["Melee"] = Abilities.MeleeStats.ToString();
dictValues["Maul"] = Abilities.MaulStats.ToString();
dictValues["Mangle"] = Abilities.MangleStats.ToString();
dictValues["Lacerate"] = Abilities.LacerateStats.ToString();
dictValues["Pulverize"] = Abilities.PulverizeStats.ToString();
dictValues["Swipe"] = Abilities.SwipeStats.ToString();
dictValues["Thrash"] = Abilities.ThrashStats.ToString();
dictValues["Faerie Fire"] = Abilities.FaerieFireStats.ToString();
dictValues["Thorns"] = Abilities.ThornsStats.ToString();
//string attackFormat = "{0} Dmg, {1} Threat*Per Hit: {0} Damage, {1} Threat\r\nPer Average Swing: {2} Damage, {3} Threat";
//string attackFormatWithRage = attackFormat + "\r\nThreat Per Rage: {4}\r\nDamage Per Rage: {5}";
//dictValues["Melee"] = String.Format(attackFormat, MeleeDamageRaw, MeleeThreatRaw, MeleeDamageAverage, MeleeThreatAverage);
//dictValues["Maul"] = String.Format(attackFormatWithRage, MaulDamageRaw, MaulThreatRaw, MaulDamageAverage, MaulThreatAverage, MaulTPR, MaulDPR);
//dictValues["Mangle"] = String.Format(attackFormatWithRage, MangleDamageRaw, MangleThreatRaw, MangleDamageAverage, MangleThreatAverage, MangleTPR, MangleDPR);
//dictValues["Swipe"] = String.Format(attackFormatWithRage, SwipeDamageRaw, SwipeThreatRaw, SwipeDamageAverage, SwipeThreatAverage, SwipeTPR, SwipeDPR);
//dictValues["Faerie Fire"] = String.Format(attackFormat, FaerieFireDamageRaw, FaerieFireThreatRaw, FaerieFireDamageAverage, FaerieFireThreatAverage);
//dictValues["Lacerate"] = String.Format(attackFormatWithRage, LacerateDamageRaw, LacerateThreatRaw, LacerateDamageAverage, LacerateThreatAverage, LacerateTPR, LacerateDPR);
//dictValues["Lacerate DoT Tick"] = String.Format(attackFormat, LacerateDotDamageRaw, LacerateDotThreatRaw, LacerateDotDamageAverage, LacerateDotThreatAverage).Replace("Swing", "Tick");
return(dictValues);
}
public void ReceivedDamage()
{
DamageTaken.IncreaseValue(1);
}
public void UnRegister(DamageTaken callBack)
{
damageTaken -= callBack;
}
public void TakeDamage(DamageArgs args)
{
UpdateHealth(args.Origin, args.Dealer, -args.Damage);
DamageTaken?.Invoke(this, args);
}
private void OnDamageTaken(GameObject source, int amount)
{
DamageTaken?.Invoke(source, amount);
}
public void AddDamageInstance(PSO2DamageInstance instance)
{
if (instance.TargetId == ID)
{
//we took damage from instance.SourceId
_receivedDamageInstances.Add(instance);
DamageTaken.AddDamage(instance);
if (!_attackInfoList.ContainsKey("Damage Taken"))
{
_attackInfoList.Add("Damage Taken", new AttackInfo("Damage Taken", 0));
}
_attackInfoList["Damage Taken"].AddDamageInstance(instance);
}
else if (instance.SourceId == ID)
{
//we dealt damage to instance.TargetId
if (instance.IsAISDamage)
{
AISDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.AIS))
{
AddAttackInfo(instance);
}
}
else if (instance.IsDarkBlastDamage)
{
DarkBlastDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.DarkBlast))
{
AddAttackInfo(instance);
}
}
else if (instance.IsZanverseDamage)
{
ZanverseDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.Zanverse))
{
AddAttackInfo(instance);
}
}
else if (instance.IsHeroFinishDamage)
{
HeroTimeFinishDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.HTF))
{
AddAttackInfo(instance);
}
}
else if (instance.IsPhotonDamage)
{
PhotonDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.PWP))
{
AddAttackInfo(instance);
}
}
else if (instance.IsRideroidDamage)
{
RideroidDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.Ride))
{
AddAttackInfo(instance);
}
}
else if (instance.IsLaconiumDamage)
{
LaconiumDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.LSW))
{
AddAttackInfo(instance);
}
}
else if (instance.IsElementalDamage)
{
ElementDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.Elem))
{
AddAttackInfo(instance);
}
}
else
{
BasicDamage.AddDamage(instance);
if (trackersToSum.HasFlag(PSO2DamageTrackers.Basic))
{
AddAttackInfo(instance);
}
}
_damageInstances.Add(instance);
if (instance.IsZanverseDamage) //only update ZV max hit if ZV is not separated
{
if (trackersToSum.HasFlag(PSO2DamageTrackers.Zanverse))
{
UpdateMaxHit(instance);
}
}
else
{
UpdateMaxHit(instance);
}
}
}
private DamageTaken CalculatePlayerDamageTaken(DamageTaken damageTaken)
{
damageTaken.PlayerDamageTaken = Enemy.CalculateDamage();
return(damageTaken);
}
public void TakeDamage(DamageArgs args) => DamageTaken?.Invoke(this, args);
public void OnDamageTaken(float value = 0)
{
DamageTaken?.Invoke(value);
}
void Start()
{
dmg = FindObjectOfType <DamageTaken>();
}
public override Dictionary <string, string> GetCharacterDisplayCalculationValues()
{
Dictionary <string, string> dictValues = new Dictionary <string, string>();
int armorCap = (int)Math.Ceiling((1402.5f * TargetLevel) - 66502.5f);
float levelDifference = 0.2f * (TargetLevel - 70);
float targetCritReduction = 5f + levelDifference;
float currentCritReduction = ((float)Math.Floor(
(BasicStats.DefenseRating * WarriorConversions.DefenseRatingToDefense + BasicStats.Defense)) *
WarriorConversions.DefenseToCritReduction) +
(BasicStats.Resilience * WarriorConversions.ResilienceRatingToCritReduction);
int defToCap = 0, resToCap = 0;
if (currentCritReduction < targetCritReduction)
{
while ((((float)Math.Floor(
((BasicStats.DefenseRating + defToCap) * WarriorConversions.DefenseRatingToDefense + BasicStats.Defense)) *
WarriorConversions.DefenseToCritReduction) +
(BasicStats.Resilience * WarriorConversions.ResilienceRatingToCritReduction)) < targetCritReduction)
{
defToCap++;
}
while ((((float)Math.Floor(
(BasicStats.DefenseRating * WarriorConversions.DefenseRatingToDefense + BasicStats.Defense)) *
WarriorConversions.DefenseToCritReduction) +
((BasicStats.Resilience + resToCap) * WarriorConversions.ResilienceRatingToCritReduction)) < targetCritReduction)
{
resToCap++;
}
}
else if (currentCritReduction > targetCritReduction)
{
while ((((float)Math.Floor(
((BasicStats.DefenseRating + defToCap) * WarriorConversions.DefenseRatingToDefense + BasicStats.Defense)) *
WarriorConversions.DefenseToCritReduction) +
(BasicStats.Resilience * WarriorConversions.ResilienceRatingToCritReduction)) > targetCritReduction)
{
defToCap--;
}
while ((((float)Math.Floor(
(BasicStats.DefenseRating * WarriorConversions.DefenseRatingToDefense + BasicStats.Defense)) *
WarriorConversions.DefenseToCritReduction) +
((BasicStats.Resilience + resToCap) * WarriorConversions.ResilienceRatingToCritReduction)) > targetCritReduction)
{
resToCap--;
}
defToCap++;
resToCap++;
}
dictValues.Add("Health", BasicStats.Health.ToString());
dictValues.Add("Strength", BasicStats.Strength.ToString());
dictValues.Add("Agility", BasicStats.Agility.ToString());
dictValues.Add("Stamina", BasicStats.Stamina.ToString());
dictValues.Add("Armor", BasicStats.Armor.ToString());
dictValues.Add("Defense", Defense.ToString() +
string.Format("*Defense Rating {0}", BasicStats.DefenseRating));
dictValues.Add("Dodge", Dodge.ToString() +
string.Format("%*Dodge Rating {0}", BasicStats.DodgeRating));
dictValues.Add("Parry", Parry.ToString() +
string.Format("%*Parry Rating {0}", BasicStats.ParryRating));
if (BlockOverCap > 0f)
{
dictValues.Add("Block", (Block + BlockOverCap).ToString()
+ string.Format("%*Block Rating {0}. Over the crush cap by {1}% block", BasicStats.BlockRating, BlockOverCap));
}
else
{
dictValues.Add("Block", Block.ToString()
+ string.Format("%*Block Rating {0}", BasicStats.BlockRating));
}
dictValues.Add("Miss", Miss.ToString() + "%");
dictValues.Add("Resilience", BasicStats.Resilience.ToString() +
string.Format(@"*Reduces periodic damage and chance to be critically hit by {0}%.
Reduces the effect of mana-drains and the damage of critical strikes by {1}%.",
BasicStats.Resilience * WarriorConversions.ResilienceRatingToCritReduction,
BasicStats.Resilience * WarriorConversions.ResilienceRatingToCritReduction * 2));
dictValues.Add("Block Value", BlockValue.ToString());
#region Offensive Stats
dictValues["Attack Power"] = BasicStats.AttackPower.ToString();
dictValues["Hit"] = (BasicStats.HitRating * WarriorConversions.HitRatingToHit +
BasicStats.Hit).ToString() +
string.Format("%*Hit Rating {0}", BasicStats.HitRating);
dictValues["Expertise"] = (Math.Round(BasicStats.ExpertiseRating * WarriorConversions.ExpertiseRatingToExpertise +
BasicStats.Expertise)).ToString() +
string.Format(@"*Expertise Rating {0}
Reduces chance to be dodged or parried by {1}%.", BasicStats.ExpertiseRating,
Math.Round((BasicStats.ExpertiseRating * WarriorConversions.ExpertiseRatingToExpertise +
BasicStats.Expertise) * WarriorConversions.ExpertiseToDodgeParryReduction));
dictValues["Haste"] = (BasicStats.HasteRating * WarriorConversions.HasteRatingToHaste).ToString() +
string.Format("%*Haste Rating {0}", BasicStats.HasteRating);
dictValues["Armor Penetration"] = BasicStats.ArmorPenetration.ToString();
dictValues["Crit"] = Crit.ToString() +
string.Format("%*Crit Rating {0}", BasicStats.CritRating);
dictValues["Weapon Damage"] = BasicStats.WeaponDamage.ToString();
dictValues.Add("Missed Attacks", AvoidedAttacks.ToString() +
string.Format(@"%*Out of 100 attacks:
Attacks Missed: {0}%
Attacks Dodged: {1}%
Attacks Parried: {2}%", MissedAttacks, DodgedAttacks, ParriedAttacks));
dictValues.Add("Limited Threat", (LimitedThreat / ThreatScale).ToString() +
string.Format(@"*White TPS: {0}
Shield Slam TPS: {1}
Revenge TPS: {2}
Devastate TPS: {3}
Windfury TPS: {4}", WhiteThreat, ShieldSlamThreat, RevengeThreat, DevastateThreat, WindfuryThreat));
dictValues.Add("Unlimited Threat", (UnlimitedThreat / ThreatScale).ToString() +
string.Format(@"*Heroic Strike TPS: {0}
Shield Slam TPS: {1}
Revenge TPS: {2}
Devastate TPS: {3}
Windfury TPS: {4}", HeroicStrikeThreat, ShieldSlamThreat, RevengeThreat, DevastateThreat, WindfuryThreat));
#endregion
dictValues["Nature Resist"] = (BasicStats.NatureResistance + BasicStats.AllResist).ToString();
dictValues["Arcane Resist"] = (BasicStats.ArcaneResistance + BasicStats.AllResist).ToString();
dictValues["Frost Resist"] = (BasicStats.FrostResistance + BasicStats.AllResist).ToString();
dictValues["Fire Resist"] = (BasicStats.FireResistance + BasicStats.AllResist).ToString();
dictValues["Shadow Resist"] = (BasicStats.ShadowResistance + BasicStats.AllResist).ToString();
if (BasicStats.Armor == armorCap)
{
dictValues.Add("Mitigation", Mitigation.ToString()
+ string.Format("%*Exactly at the armor cap against level {0} mobs.", TargetLevel));
}
else if (BasicStats.Armor > armorCap)
{
dictValues.Add("Mitigation", Mitigation.ToString()
+ string.Format("%*Over the armor cap by {0} armor.", BasicStats.Armor - armorCap));
}
else
{
dictValues.Add("Mitigation", Mitigation.ToString()
+ string.Format("%*Short of the armor cap by {0} armor.", armorCap - BasicStats.Armor));
}
dictValues.Add("Avoidance", DodgePlusMissPlusParry.ToString() + "%");
dictValues.Add("Avoidance + Block", DodgePlusMissPlusParryPlusBlock.ToString() + "%");
dictValues.Add("Total Mitigation", TotalMitigation.ToString() + "%");
dictValues.Add("Damage Taken", DamageTaken.ToString() + "%");
if (defToCap == 0 && resToCap == 0)
{
dictValues.Add("Chance to be Crit", ((5f + levelDifference) - CritReduction).ToString()
+ "%*Exactly enough defense rating/resilience to be uncrittable by bosses.");
}
else if (defToCap + resToCap > 0)
{
dictValues.Add("Chance to be Crit", ((5f + levelDifference) - CritReduction).ToString()
+ string.Format("%*CRITTABLE! Short by {0} defense rating ({1} defense) or {2} resilience to be uncrittable by bosses.",
defToCap, defToCap * WarriorConversions.DefenseRatingToDefense, resToCap));
}
else
{
dictValues.Add("Chance to be Crit", ((5f + levelDifference) - CritReduction).ToString()
+ string.Format("%*Uncrittable by bosses. {0} defense rating ({1} defense) or {2} resilience over the crit cap.",
-defToCap, -defToCap * WarriorConversions.DefenseRatingToDefense, -resToCap));
}
dictValues.Add("Chance Crushed", CrushChance.ToString() + "%");
dictValues.Add("Overall Points", OverallPoints.ToString());
dictValues.Add("Mitigation Points", MitigationPoints.ToString());
dictValues.Add("Survival Points", SurvivalPoints.ToString());
dictValues.Add("Threat Points", ThreatPoints.ToString());
dictValues["Nature Survival"] = NatureSurvivalPoints.ToString();
dictValues["Frost Survival"] = FrostSurvivalPoints.ToString();
dictValues["Fire Survival"] = FireSurvivalPoints.ToString();
dictValues["Shadow Survival"] = ShadowSurvivalPoints.ToString();
dictValues["Arcane Survival"] = ArcaneSurvivalPoints.ToString();
return(dictValues);
}
