Inna/CypherCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated to 8.2.0.31429 (scripts disabled atm, they still need updated)

Browse Source 
Code Port from TrinityCore https://github.com/TrinityCore/TrinityCore
Casc from WoW-Tools https://github.com/WoW-Tools/CASCExplorer
This commit is contained in:
hondacrx
2019-08-14 11:20:42 -04:00
parent e4d500f4b5
commit 125e3b3ac7
232 changed files with 12268 additions and 14670 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Game/Entities/StatSystem.cs
+159 -162
View File
@@ -183,12 +183,18 @@ namespace Game.Entities
public void ApplyStatBuffMod(Stats stat, float val, bool apply)
{
ApplyModSignedFloatValue((val > 0 ? UnitFields.PosStat + (int)stat : UnitFields.NegStat + (int)stat), val, apply);
MathFunctions.ApplyPercentModFloatVar(ref (val > 0 ? ref m_floatStatPosBuff[(int)stat] : ref m_floatStatNegBuff[(int)stat]), val, apply);
UpdateStatBuffModForClient(stat);
}
public void ApplyStatPercentBuffMod(Stats stat, float val, bool apply)
{
ApplyPercentModFloatValue(UnitFields.PosStat + (int)stat, val, apply);
ApplyPercentModFloatValue(UnitFields.NegStat + (int)stat, val, apply);
MathFunctions.ApplyPercentModFloatVar(ref m_floatStatPosBuff[(int)stat], val, apply);
MathFunctions.ApplyPercentModFloatVar(ref m_floatStatNegBuff[(int)stat], val, apply);
}
void UpdateStatBuffModForClient(Stats stat)
{
SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.StatPosBuff, (int)stat), (int)m_floatStatPosBuff[(int)stat]);
SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.StatNegBuff, (int)stat), (int)m_floatStatNegBuff[(int)stat]);
}
public virtual bool UpdateStats(Stats stat) { return false; }
@@ -219,16 +225,16 @@ namespace Game.Entities
{
case WeaponAttackType.BaseAttack:
default:
SetStatFloatValue(UnitFields.MinDamage, minDamage);
SetStatFloatValue(UnitFields.MaxDamage, maxDamage);
SetUpdateFieldStatValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MinDamage), minDamage);
SetUpdateFieldStatValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MaxDamage), maxDamage);
break;
case WeaponAttackType.OffAttack:
SetStatFloatValue(UnitFields.MinOffHandDamage, minDamage);
SetStatFloatValue(UnitFields.MaxOffHandDamage, maxDamage);
SetUpdateFieldStatValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MinOffHandDamage), minDamage);
SetUpdateFieldStatValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MaxOffHandDamage), maxDamage);
break;
case WeaponAttackType.RangedAttack:
SetStatFloatValue(UnitFields.MinRangedDamage, minDamage);
SetStatFloatValue(UnitFields.MaxRangedDamage, maxDamage);
SetUpdateFieldStatValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MinRangedDamage), minDamage);
SetUpdateFieldStatValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MaxRangedDamage), maxDamage);
break;
}
}
@@ -245,26 +251,10 @@ namespace Game.Entities
}
//Stats
public float GetStat(Stats stat)
{
return GetUInt32Value(UnitFields.Stat + (int)stat);
}
public void SetCreateStat(Stats stat, float val)
{
CreateStats[(int)stat] = val;
}
public void SetStat(Stats stat, int val)
{
SetStatInt32Value(UnitFields.Stat + (int)stat, val);
}
public void SetCreateMana(uint val)
{
SetUInt32Value(UnitFields.BaseMana, val);
}
public uint GetCreateMana()
{
return GetUInt32Value(UnitFields.BaseMana);
}
public float GetStat(Stats stat) { return m_unitData.Stats[(int)stat]; }
public void SetStat(Stats stat, int val) { SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.Stats, (int)stat), val); }
public uint GetCreateMana() { return m_unitData.BaseMana; }
public void SetCreateMana(uint val) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.BaseMana), val); }
public uint GetArmor()
{
return (uint)(GetResistance(SpellSchools.Normal) + GetBonusResistanceMod(SpellSchools.Normal));
@@ -274,13 +264,23 @@ namespace Game.Entities
SetResistance(SpellSchools.Normal, val);
SetBonusResistanceMod(SpellSchools.Normal, bonusVal);
}
public float GetCreateStat(Stats stat)
{
return CreateStats[(int)stat];
}
public void SetCreateStat(Stats stat, float val)
{
CreateStats[(int)stat] = val;
}
public float GetPosStat(Stats stat) { return m_unitData.StatPosBuff[(int)stat]; }
public float GetNegStat(Stats stat) { return m_unitData.StatNegBuff[(int)stat]; }
public int GetResistance(SpellSchools school)
{
return GetInt32Value(UnitFields.Resistances + (int)school);
return m_unitData.Resistances[(int)school];
}
public int GetBonusResistanceMod(SpellSchools school)
{
return GetInt32Value(UnitFields.BonusResistanceMods + (int)school);
return m_unitData.BonusResistanceMods[(int)school];
}
public int GetResistance(SpellSchoolMask mask)
{
@@ -295,25 +295,22 @@ namespace Game.Entities
// resist value will never be negative here
return resist.HasValue ? resist.Value : 0;
}
public void SetResistance(SpellSchools school, int val)
{
SetStatInt32Value(UnitFields.Resistances + (int)school, val);
}
public void SetBonusResistanceMod(SpellSchools school, int val)
{
SetStatInt32Value(UnitFields.BonusResistanceMods + (int)school, val);
}
public void SetResistance(SpellSchools school, int val) { SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.Resistances, (int)school), val); }
public void SetBonusResistanceMod(SpellSchools school, int val) { SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.BonusResistanceMods, (int)school), val); }
public void SetModCastingSpeed(float castingSpeed) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.ModCastingSpeed), castingSpeed); }
public void SetModSpellHaste(float spellHaste) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.ModSpellHaste), spellHaste); }
public void SetModHaste(float haste) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.ModHaste), haste); }
public void SetModRangedHaste(float rangedHaste) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.ModRangedHaste), rangedHaste); }
public void SetModHasteRegen(float hasteRegen) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.ModHasteRegen), hasteRegen); }
public void SetModTimeRate(float timeRate) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.ModTimeRate), timeRate); }
public float GetCreateStat(Stats stat)
{
return CreateStats[(int)stat];
}
public void InitStatBuffMods()
{
for (var i = Stats.Strength; i < Stats.Max; ++i)
for (var stat = Stats.Strength; stat < Stats.Max; ++stat)
{
SetFloatValue(UnitFields.PosStat + (int)i, 0);
SetFloatValue(UnitFields.NegStat + (int)i, 0);
m_floatStatPosBuff[(int)stat] = 0.0f;
m_floatStatNegBuff[(int)stat] = 0.0f;
UpdateStatBuffModForClient(stat);
}
}
@@ -341,16 +338,10 @@ namespace Game.Entities
return value;
}
//Health
public uint GetCreateHealth() { return GetUInt32Value(UnitFields.BaseHealth); }
public ulong GetHealth() { return GetUInt64Value(UnitFields.Health); }
public ulong GetMaxHealth() { return GetUInt64Value(UnitFields.MaxHealth); }
public float GetHealthPct() { return GetMaxHealth() != 0 ? 100.0f * GetHealth() / GetMaxHealth() : 0.0f; }
public void SetCreateHealth(uint val)
{
SetUInt32Value(UnitFields.BaseHealth, val);
}
//Health
public uint GetCreateHealth() { return m_unitData.BaseHealth; }
public void SetCreateHealth(uint val) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.BaseHealth), val); }
public ulong GetHealth() { return m_unitData.Health; }
public void SetHealth(ulong val)
{
if (getDeathState() == DeathState.JustDied)
@@ -364,7 +355,7 @@ namespace Game.Entities
val = maxHealth;
}
SetUInt64Value(UnitFields.Health, val);
SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.Health), val);
// group update
Player player = ToPlayer();
@@ -380,13 +371,14 @@ namespace Game.Entities
pet.SetGroupUpdateFlag(GroupUpdatePetFlags.CurHp);
}
}
public ulong GetMaxHealth() { return m_unitData.MaxHealth; }
public void SetMaxHealth(ulong val)
{
if (val == 0)
val = 1;
ulong health = GetHealth();
SetUInt64Value(UnitFields.MaxHealth, val);
SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MaxHealth), val);
// group update
if (IsTypeId(TypeId.Player))
@@ -404,6 +396,7 @@ namespace Game.Entities
if (val < health)
SetHealth(val);
}
public float GetHealthPct() { return GetMaxHealth() != 0 ? 100.0f * GetHealth() / GetMaxHealth() : 0.0f; }
public void SetFullHealth() { SetHealth(GetMaxHealth()); }
public bool IsFullHealth() { return GetHealth() == GetMaxHealth(); }
@@ -419,21 +412,19 @@ namespace Game.Entities
public virtual float GetArmorMultiplierForTarget(WorldObject target) { return 1.0f; }
//Powers
public PowerType GetPowerType()
{
return (PowerType)GetUInt32Value(UnitFields.DisplayPower);
}
public PowerType GetPowerType() { return (PowerType)(byte)m_unitData.DisplayPower; }
public void SetPowerType(PowerType powerType)
{
if (GetPowerType() == powerType)
return;
SetUInt32Value(UnitFields.DisplayPower, (uint)powerType);
SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.DisplayPower), (byte)powerType);
if (IsTypeId(TypeId.Player))
Player thisPlayer = ToPlayer();
if (thisPlayer != null)
{
if (ToPlayer().GetGroup())
ToPlayer().SetGroupUpdateFlag(GroupUpdateFlags.PowerType);
if (thisPlayer.GetGroup())
thisPlayer.SetGroupUpdateFlag(GroupUpdateFlags.PowerType);
}
/*else if (IsPet()) TODO 6.x
{
@@ -461,6 +452,8 @@ namespace Game.Entities
break;
}
}
public void SetOverrideDisplayPowerId(uint powerDisplayId) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.OverrideDisplayPowerID), powerDisplayId); }
public void SetMaxPower(PowerType powerType, int val)
{
uint powerIndex = GetPowerIndex(powerType);
@@ -468,7 +461,7 @@ namespace Game.Entities
return;
int cur_power = GetPower(powerType);
SetInt32Value(UnitFields.MaxPower + (int)powerIndex, val);
SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.MaxPower, (int)powerIndex), (uint)val);
// group update
if (IsTypeId(TypeId.Player))
@@ -496,7 +489,7 @@ namespace Game.Entities
if (maxPower < val)
val = maxPower;
SetInt32Value(UnitFields.Power + (int)powerIndex, val);
SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.Power, (int)powerIndex), val);
if (IsInWorld)
{
@@ -527,7 +520,7 @@ namespace Game.Entities
if (powerIndex == (int)PowerType.Max || powerIndex >= (int)PowerType.MaxPerClass)
return 0;
return GetInt32Value(UnitFields.Power + (int)powerIndex);
return m_unitData.Power[(int)powerIndex];
}
public int GetMaxPower(PowerType powerType)
{
@@ -535,7 +528,7 @@ namespace Game.Entities
if (powerIndex == (int)PowerType.Max || powerIndex >= (int)PowerType.MaxPerClass)
return 0;
return GetInt32Value(UnitFields.MaxPower + (int)powerIndex);
return (int)(uint)m_unitData.MaxPower[(int)powerIndex];
}
public int GetCreatePowers(PowerType powerType)
{
@@ -597,6 +590,15 @@ namespace Game.Entities
return MathFunctions.CalculatePct(damage, percent);
}
public void SetAttackPower(int attackPower) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.AttackPower), attackPower); }
public void SetAttackPowerModPos(int attackPowerMod) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.AttackPowerModPos), attackPowerMod); }
public void SetAttackPowerModNeg(int attackPowerMod) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.AttackPowerModNeg), attackPowerMod); }
public void SetAttackPowerMultiplier(float attackPowerMult) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.AttackPowerMultiplier), attackPowerMult); }
public void SetRangedAttackPower(int attackPower) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.RangedAttackPower), attackPower); }
public void SetRangedAttackPowerModPos(int attackPowerMod) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.RangedAttackPowerModPos), attackPowerMod); }
public void SetRangedAttackPowerModNeg(int attackPowerMod) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.RangedAttackPowerModNeg), attackPowerMod); }
public void SetRangedAttackPowerMultiplier(float attackPowerMult) { SetUpdateFieldValue(m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.RangedAttackPowerMultiplier), attackPowerMult); }
//Chances
float MeleeSpellMissChance(Unit victim, WeaponAttackType attType, uint spellId)
{
@@ -635,18 +637,19 @@ namespace Game.Entities
float GetUnitCriticalChance(WeaponAttackType attackType, Unit victim)
{
float chance = 0.0f;
if (IsTypeId(TypeId.Player))
Player thisPlayer = ToPlayer();
if (thisPlayer != null)
{
switch (attackType)
{
case WeaponAttackType.BaseAttack:
chance = GetFloatValue(ActivePlayerFields.CritPercentage);
chance = thisPlayer.m_activePlayerData.CritPercentage;
break;
case WeaponAttackType.OffAttack:
chance = GetFloatValue(ActivePlayerFields.OffhandCritPercentage);
chance = thisPlayer.m_activePlayerData.OffhandCritPercentage;
break;
case WeaponAttackType.RangedAttack:
chance = GetFloatValue(ActivePlayerFields.RangedCritPercentage);
chance = thisPlayer.m_activePlayerData.RangedCritPercentage;
break;
}
}
@@ -684,8 +687,9 @@ namespace Game.Entities
float chance = 0.0f;
float levelBonus = 0.0f;
if (victim.IsTypeId(TypeId.Player))
chance = victim.GetFloatValue(ActivePlayerFields.DodgePercentage);
Player playerVictim = victim.ToPlayer();
if (playerVictim)
chance = playerVictim.m_activePlayerData.DodgePercentage;
else
{
if (!victim.IsTotem())
@@ -729,7 +733,7 @@ namespace Game.Entities
tmpitem = playerVictim.GetWeaponForAttack(WeaponAttackType.OffAttack, true);
if (tmpitem)
chance = playerVictim.GetFloatValue(ActivePlayerFields.ParryPercentage);
chance = playerVictim.m_activePlayerData.ParryPercentage;
}
}
else
@@ -777,7 +781,7 @@ namespace Game.Entities
{
Item tmpitem = playerVictim.GetUseableItemByPos(InventorySlots.Bag0, EquipmentSlot.OffHand);
if (tmpitem && !tmpitem.IsBroken() && tmpitem.GetTemplate().GetInventoryType() == InventoryType.Shield)
chance = playerVictim.GetFloatValue(ActivePlayerFields.BlockPercentage);
chance = playerVictim.m_activePlayerData.BlockPercentage;
}
}
else
@@ -796,7 +800,7 @@ namespace Game.Entities
return Math.Max(chance, 0.0f);
}
int GetMechanicResistChance(SpellInfo spellInfo)
public int GetMechanicResistChance(SpellInfo spellInfo)
{
if (spellInfo == null)
return 0;
@@ -817,6 +821,9 @@ namespace Game.Entities
}
return Math.Max(resistMech, 0);
}
public void ApplyModPowerCostModifier(SpellSchools school, int mod, bool apply) { ApplyModUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.PowerCostModifier, (int)school), mod, apply); }
public void ApplyModPowerCostMultiplier(SpellSchools school, float pct, bool apply) { ApplyModUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.PowerCostMultiplier, (int)school), pct, apply); }
}
public partial class Player
@@ -925,7 +932,14 @@ namespace Game.Entities
UpdateArmor();
}
void RecalculateRating(CombatRating cr) { ApplyRatingMod(cr, 0, true); }
public void ApplyModTargetResistance(int mod, bool apply) { ApplyModUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModTargetResistance), mod, apply); }
public void ApplyModTargetPhysicalResistance(int mod, bool apply) { ApplyModUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModTargetPhysicalResistance), mod, apply); }
public void RecalculateRating(CombatRating cr) { ApplyRatingMod(cr, 0, true); }
public void ApplyModDamageDonePos(SpellSchools school, int mod, bool apply) { ApplyModUpdateFieldValue(ref m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModDamageDonePos, (int)school), mod, apply); }
public void ApplyModDamageDoneNeg(SpellSchools school, int mod, bool apply) { ApplyModUpdateFieldValue(ref m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModDamageDoneNeg, (int)school), mod, apply); }
public void ApplyModDamageDonePercent(SpellSchools school, float pct, bool apply) { ApplyPercentModUpdateFieldValue(ref m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModDamageDonePercent, (int)school), pct, apply); }
public void ApplyRatingMod(CombatRating combatRating, int value, bool apply)
{
@@ -989,7 +1003,7 @@ namespace Game.Entities
max_damage = ((baseValue + weaponMaxDamage) * basePct + totalValue) * totalPct * versaDmgMod;
}
void UpdateAllCritPercentages()
public void UpdateAllCritPercentages()
{
float value = 5.0f;
@@ -1004,7 +1018,7 @@ namespace Game.Entities
public void UpdateManaRegen()
{
int manaIndex = (int)GetPowerIndex(PowerType.Mana);
uint manaIndex = GetPowerIndex(PowerType.Mana);
if (manaIndex == (int)PowerType.Max)
return;
@@ -1021,8 +1035,8 @@ namespace Game.Entities
// Apply PCT bonus from SPELL_AURA_MOD_MANA_REGEN_PCT
base_regen *= GetTotalAuraMultiplierByMiscValue(AuraType.ModManaRegenPct, (int)PowerType.Mana);
SetFloatValue(UnitFields.PowerRegenInterruptedFlatModifier + manaIndex, base_regen);
SetFloatValue(UnitFields.PowerRegenFlatModifier + manaIndex, base_regen);
SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.PowerRegenFlatModifier, (int)manaIndex), base_regen);
SetUpdateFieldValue(ref m_values.ModifyValue(m_unitData).ModifyValue(m_unitData.PowerRegenInterruptedFlatModifier, (int)manaIndex), base_regen);
}
public void UpdateSpellDamageAndHealingBonus()
@@ -1030,18 +1044,19 @@ namespace Game.Entities
// Magic damage modifiers implemented in Unit.SpellDamageBonusDone
// This information for client side use only
// Get healing bonus for all schools
SetStatInt32Value(ActivePlayerFields.ModHealingDonePos, (int)SpellBaseHealingBonusDone(SpellSchoolMask.All));
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModHealingDonePos), (int)SpellBaseHealingBonusDone(SpellSchoolMask.All));
// Get damage bonus for all schools
var modDamageAuras = GetAuraEffectsByType(AuraType.ModDamageDone);
for (var i = SpellSchools.Holy; i < SpellSchools.Max; ++i)
for (int i = (int)SpellSchools.Holy; i < (int)SpellSchools.Max; ++i)
{
SetInt32Value(ActivePlayerFields.ModDamageDoneNeg + (int)i, modDamageAuras.Aggregate(0, (negativeMod, aurEff) =>
SetUpdateFieldValue(ref m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModDamageDoneNeg, i), modDamageAuras.Aggregate(0, (negativeMod, aurEff) =>
{
if (aurEff.GetAmount() < 0 && Convert.ToBoolean(aurEff.GetMiscValue() & (1 << (int)i)))
if (aurEff.GetAmount() < 0 && Convert.ToBoolean(aurEff.GetMiscValue() & (1 << i)))
negativeMod += aurEff.GetAmount();
return negativeMod;
}));
SetStatInt32Value(ActivePlayerFields.ModDamageDonePos + (int)i, SpellBaseDamageBonusDone((SpellSchoolMask)(1 << (int)i)) - GetInt32Value(ActivePlayerFields.ModDamageDoneNeg + (int)i));
SetUpdateFieldStatValue(ref m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModDamageDonePos, i),
(SpellBaseDamageBonusDone((SpellSchoolMask)(1 << i)) - m_activePlayerData.ModDamageDoneNeg[i]));
}
if (HasAuraType(AuraType.OverrideAttackPowerBySpPct))
@@ -1060,17 +1075,6 @@ namespace Game.Entities
var entry = CliDB.ChrClassesStorage.LookupByKey(GetClass());
UnitMods unitMod = ranged ? UnitMods.AttackPowerRanged : UnitMods.AttackPower;
UnitFields index = UnitFields.AttackPower;
UnitFields index_mod = UnitFields.AttackPowerModPos;
UnitFields index_mult = UnitFields.AttackPowerMultiplier;
if (ranged)
{
index = UnitFields.RangedAttackPower;
index_mod = UnitFields.RangedAttackPowerModPos;
index_mult = UnitFields.RangedAttackPowerMultiplier;
}
if (!HasAuraType(AuraType.OverrideAttackPowerBySpPct))
{
if (!ranged)
@@ -1090,11 +1094,11 @@ namespace Game.Entities
}
else
{
int minSpellPower = GetInt32Value(ActivePlayerFields.ModHealingDonePos);
int minSpellPower = m_activePlayerData.ModHealingDonePos;
for (var i = SpellSchools.Holy; i < SpellSchools.Max; ++i)
minSpellPower = Math.Min(minSpellPower, GetInt32Value(ActivePlayerFields.ModDamageDonePos + (int)i));
minSpellPower = Math.Min(minSpellPower, m_activePlayerData.ModDamageDonePos[(int)i]);
val2 = MathFunctions.CalculatePct(minSpellPower, GetFloatValue(ActivePlayerFields.OverrideApBySpellPowerPercent));
val2 = MathFunctions.CalculatePct(minSpellPower, m_activePlayerData.OverrideAPBySpellPowerPercent);
}
SetModifierValue(unitMod, UnitModifierType.BaseValue, val2);
@@ -1112,9 +1116,18 @@ namespace Game.Entities
attPowerMod += (int)(GetArmor() / iter.GetAmount());
}
SetUInt32Value(index, (uint)base_attPower); //UNIT_FIELD_(RANGED)_ATTACK_POWER field
SetUInt32Value(index_mod, (uint)attPowerMod); //UNIT_FIELD_(RANGED)_ATTACK_POWER_MOD_POS field
SetFloatValue(index_mult, attPowerMultiplier); //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field
if (ranged)
{
SetRangedAttackPower((int)base_attPower);
SetRangedAttackPowerModPos((int)attPowerMod);
SetRangedAttackPowerMultiplier(attPowerMultiplier);
}
else
{
SetAttackPower((int)base_attPower);
SetAttackPowerModPos((int)attPowerMod);
SetAttackPowerMultiplier(attPowerMultiplier);
}
Pet pet = GetPet(); //update pet's AP
Guardian guardian = GetGuardianPet();
@@ -1220,8 +1233,8 @@ namespace Game.Entities
if (amount < 0)
amount = 0;
uint oldRating = GetUInt32Value(ActivePlayerFields.CombatRating + (int)cr);
SetUInt32Value(ActivePlayerFields.CombatRating + (int)cr, (uint)amount);
uint oldRating = m_activePlayerData.CombatRatings[(int)cr];
SetUpdateFieldValue(ref m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.CombatRatings, (int)cr), (uint)amount);
bool affectStats = CanModifyStats();
@@ -1320,15 +1333,15 @@ namespace Game.Entities
{
if (!CanUseMastery())
{
SetFloatValue(ActivePlayerFields.Mastery, 0.0f);
SetUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.Mastery), 0.0f);
return;
}
float value = GetTotalAuraModifier(AuraType.Mastery);
value += GetRatingBonusValue(CombatRating.Mastery);
SetFloatValue(ActivePlayerFields.Mastery, value);
SetUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.Mastery), value);
ChrSpecializationRecord chrSpec = CliDB.ChrSpecializationStorage.LookupByKey(GetUInt32Value(PlayerFields.CurrentSpecId));
ChrSpecializationRecord chrSpec = CliDB.ChrSpecializationStorage.LookupByKey(GetPrimarySpecialization());
if (chrSpec == null)
return;
@@ -1354,8 +1367,8 @@ namespace Game.Entities
public void UpdateVersatilityDamageDone()
{
// No proof that CR_VERSATILITY_DAMAGE_DONE is allways = PLAYER_VERSATILITY
SetUInt32Value(ActivePlayerFields.Versatility, GetUInt32Value(ActivePlayerFields.CombatRating + (int)CombatRating.VersatilityDamageDone));
// No proof that CR_VERSATILITY_DAMAGE_DONE is allways = ActivePlayerData::Versatility
SetUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.Versatility), (int)m_activePlayerData.CombatRatings[(int)CombatRating.VersatilityDamageDone]);
if (GetClass() == Class.Hunter)
UpdateDamagePhysical(WeaponAttackType.RangedAttack);
@@ -1372,13 +1385,13 @@ namespace Game.Entities
foreach (AuraEffect auraEffect in GetAuraEffectsByType(AuraType.ModHealingDonePercent))
MathFunctions.AddPct(ref value, auraEffect.GetAmount());
SetStatFloatValue(ActivePlayerFields.ModHealingDonePct, value);
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModHealingDonePercent), value);
}
void UpdateArmorPenetration(int amount)
{
// Store Rating Value
SetInt32Value(ActivePlayerFields.CombatRating + (int)CombatRating.ArmorPenetration, amount);
SetUpdateFieldValue(ref m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.CombatRatings, (int)CombatRating.ArmorPenetration), (uint)amount);
}
public void UpdateParryPercentage()
{
@@ -1413,10 +1426,8 @@ namespace Game.Entities
if (WorldConfig.GetBoolValue(WorldCfg.StatsLimitsEnable))
value = value > WorldConfig.GetFloatValue(WorldCfg.StatsLimitsParry) ? WorldConfig.GetFloatValue(WorldCfg.StatsLimitsParry) : value;
value = value < 0.0f ? 0.0f : value;
}
SetFloatValue(ActivePlayerFields.ParryPercentage, value);
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ParryPercentage), value);
}
public void UpdateDodgePercentage()
@@ -1450,8 +1461,7 @@ namespace Game.Entities
if (WorldConfig.GetBoolValue(WorldCfg.StatsLimitsEnable))
value = value > WorldConfig.GetFloatValue(WorldCfg.StatsLimitsDodge) ? WorldConfig.GetFloatValue(WorldCfg.StatsLimitsDodge) : value;
value = value < 0.0f ? 0.0f : value;
SetStatFloatValue(ActivePlayerFields.DodgePercentage, value);
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.DodgePercentage), value);
}
public void UpdateBlockPercentage()
{
@@ -1468,47 +1478,35 @@ namespace Game.Entities
if (WorldConfig.GetBoolValue(WorldCfg.StatsLimitsEnable))
value = value > WorldConfig.GetFloatValue(WorldCfg.StatsLimitsBlock) ? WorldConfig.GetFloatValue(WorldCfg.StatsLimitsBlock) : value;
value = value < 0.0f ? 0.0f : value;
}
SetFloatValue(ActivePlayerFields.BlockPercentage, value);
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.BlockPercentage), value);
}
public void UpdateCritPercentage(WeaponAttackType attType)
{
BaseModGroup modGroup;
ActivePlayerFields index;
CombatRating cr;
float applyCritLimit(float value)
{
if (WorldConfig.GetBoolValue(WorldCfg.StatsLimitsEnable))
value = value > WorldConfig.GetFloatValue(WorldCfg.StatsLimitsCrit) ? WorldConfig.GetFloatValue(WorldCfg.StatsLimitsCrit) : value;
return value;
}
switch (attType)
{
case WeaponAttackType.OffAttack:
modGroup = BaseModGroup.OffhandCritPercentage;
index = ActivePlayerFields.OffhandCritPercentage;
cr = CombatRating.CritMelee;
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.OffhandCritPercentage),
applyCritLimit(GetTotalPercentageModValue(BaseModGroup.OffhandCritPercentage) + GetRatingBonusValue(CombatRating.CritMelee)));
break;
case WeaponAttackType.RangedAttack:
modGroup = BaseModGroup.RangedCritPercentage;
index = ActivePlayerFields.RangedCritPercentage;
cr = CombatRating.CritRanged;
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.RangedCritPercentage),
applyCritLimit(GetTotalPercentageModValue(BaseModGroup.RangedCritPercentage) + GetRatingBonusValue(CombatRating.CritRanged)));
break;
case WeaponAttackType.BaseAttack:
default:
modGroup = BaseModGroup.CritPercentage;
index = ActivePlayerFields.CritPercentage;
cr = CombatRating.CritMelee;
SetUpdateFieldStatValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.CritPercentage),
applyCritLimit(GetTotalPercentageModValue(BaseModGroup.CritPercentage) + GetRatingBonusValue(CombatRating.CritMelee)));
break;
}
float value = GetTotalPercentageModValue(modGroup) + GetRatingBonusValue(cr);
// Modify crit from weapon skill and maximized defense skill of same level victim difference
value += (GetMaxSkillValueForLevel() - GetMaxSkillValueForLevel()) * 0.04f;
if (WorldConfig.GetBoolValue(WorldCfg.StatsLimitsEnable))
value = value > WorldConfig.GetFloatValue(WorldCfg.StatsLimitsCrit) ? WorldConfig.GetFloatValue(WorldCfg.StatsLimitsCrit) : value;
value = value < 0.0f ? 0.0f : value;
SetFloatValue(index, value);
}
public void UpdateExpertise(WeaponAttackType attack)
@@ -1528,10 +1526,10 @@ namespace Game.Entities
switch (attack)
{
case WeaponAttackType.BaseAttack:
SetInt32Value(ActivePlayerFields.Expertise, expertise);
SetUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.MainhandExpertise), expertise);
break;
case WeaponAttackType.OffAttack:
SetInt32Value(ActivePlayerFields.OffhandExpertise, expertise);
SetUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.OffhandExpertise), expertise);
break;
default: break;
}
@@ -1623,7 +1621,7 @@ namespace Game.Entities
crit += GetRatingBonusValue(CombatRating.CritSpell);
// Store crit value
SetFloatValue(ActivePlayerFields.SpellCritPercentage1, crit);
SetUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.SpellCritPercentage), crit);
}
public void UpdateMeleeHitChances()
@@ -1688,7 +1686,7 @@ namespace Game.Entities
public void ApplySpellPenetrationBonus(int amount, bool apply)
{
ApplyModInt32Value(ActivePlayerFields.ModTargetResistance, -amount, apply);
ApplyModTargetResistance(-amount, apply);
m_spellPenetrationItemMod += apply ? amount : -amount;
}
@@ -1711,9 +1709,9 @@ namespace Game.Entities
apply = _ModifyUInt32(apply, ref m_baseSpellPower, ref amount);
// For speed just update for client
ApplyModUInt32Value(ActivePlayerFields.ModHealingDonePos, amount, apply);
for (int i = (int)SpellSchools.Holy; i < (int)SpellSchools.Max; ++i)
ApplyModUInt32Value(ActivePlayerFields.ModDamageDonePos + i, amount, apply);
ApplyModUpdateFieldValue(m_values.ModifyValue(m_activePlayerData).ModifyValue(m_activePlayerData.ModHealingDonePos), amount, apply);
for (SpellSchools spellSchool = SpellSchools.Holy; spellSchool < SpellSchools.Max; ++spellSchool)
ApplyModDamageDonePos(spellSchool, amount, apply);
if (HasAuraType(AuraType.OverrideAttackPowerBySpPct))
{
@@ -1826,20 +1824,19 @@ namespace Game.Entities
{
UnitMods unitMod = ranged ? UnitMods.AttackPowerRanged : UnitMods.AttackPower;
UnitFields index = UnitFields.AttackPower;
UnitFields index_mult = UnitFields.AttackPowerMultiplier;
float baseAttackPower = GetModifierValue(unitMod, UnitModifierType.BaseValue) * GetModifierValue(unitMod, UnitModifierType.BasePCT);
float attackPowerMultiplier = GetModifierValue(unitMod, UnitModifierType.TotalPCT) - 1.0f;
if (ranged)
{
index = UnitFields.RangedAttackPower;
index_mult = UnitFields.RangedAttackPowerMultiplier;
SetRangedAttackPower((int)baseAttackPower);
SetRangedAttackPowerMultiplier(attackPowerMultiplier);
}
else
{
SetAttackPower((int)baseAttackPower);
SetAttackPowerMultiplier(attackPowerMultiplier);
}
float base_attPower = GetModifierValue(unitMod, UnitModifierType.BaseValue) * GetModifierValue(unitMod, UnitModifierType.BasePCT);
float attPowerMultiplier = GetModifierValue(unitMod, UnitModifierType.TotalPCT) - 1.0f;
SetInt32Value(index, (int)base_attPower); //UNIT_FIELD_(RANGED)_ATTACK_POWER field
SetFloatValue(index_mult, attPowerMultiplier); //UNIT_FIELD_(RANGED)_ATTACK_POWER_MULTIPLIER field
//automatically update weapon damage after attack power modification
if (ranged)