API tools faq
paste
Advertisement
WIXXZI

Untitled

WIXXZI
Mar 17th, 2023
46
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.13 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp
  2. index c3adb55..c2f6f0b 100644
  3. --- a/src/server/game/Entities/Player/Player.cpp
  4. +++ b/src/server/game/Entities/Player/Player.cpp
  5. @@ -173,6 +173,8 @@ uint32 const MAX_MONEY_AMOUNT = static_cast<uint32>(std::numeric_limits<int32>::
  6.  
  7. Player::Player(WorldSession* session): Unit(true)
  8. {
  9. + // 1557 HasteCap
  10. + hasteMod = 2.1059f;
  11. m_speakTime = 0;
  12. m_speakCount = 0;
  13.  
  14. @@ -1141,10 +1143,10 @@ void Player::Update(uint32 p_time)
  15. m_swingErrorMsg = 0; // reset swing error state
  16.  
  17. // prevent base and off attack in same time, delay attack at 0.2 sec
  18. - if (haveOffhandWeapon())
  19. + /*if (haveOffhandWeapon())
  20. if (getAttackTimer(OFF_ATTACK) < ATTACK_DISPLAY_DELAY)
  21. setAttackTimer(OFF_ATTACK, ATTACK_DISPLAY_DELAY);
  22. -
  23. + */
  24. // do attack
  25. AttackerStateUpdate(victim, BASE_ATTACK);
  26. resetAttackTimer(BASE_ATTACK);
  27. @@ -1160,9 +1162,9 @@ void Player::Update(uint32 p_time)
  28. else
  29. {
  30. // prevent base and off attack in same time, delay attack at 0.2 sec
  31. - if (getAttackTimer(BASE_ATTACK) < ATTACK_DISPLAY_DELAY)
  32. + /*if (getAttackTimer(BASE_ATTACK) < ATTACK_DISPLAY_DELAY)
  33. setAttackTimer(BASE_ATTACK, ATTACK_DISPLAY_DELAY);
  34. -
  35. + */
  36. // do attack
  37. AttackerStateUpdate(victim, OFF_ATTACK);
  38. resetAttackTimer(OFF_ATTACK);
  39. @@ -5468,7 +5470,7 @@ float Player::OCTRegenMPPerSpirit() const
  40. return regen;
  41. }
  42.  
  43. -void Player::ApplyRatingMod(CombatRating combatRating, int32 value, bool apply)
  44. +/*void Player::ApplyRatingMod(CombatRating combatRating, int32 value, bool apply)
  45. {
  46. float oldRating = m_baseRatingValue[combatRating];
  47. m_baseRatingValue[combatRating] += (apply ? value : -value);
  48. @@ -5498,6 +5500,72 @@ void Player::ApplyRatingMod(CombatRating combatRating, int32 value, bool apply)
  49. }
  50.  
  51. UpdateRating(combatRating);
  52. +}*/
  53. +
  54. +void Player::SetAttackTime(WeaponAttackType att, uint32 val) {
  55. + switch (att) {
  56. + case BASE_ATTACK:
  57. + ApplyHasteMod(m_baseRatingValue[CR_HASTE_MELEE], BASE_ATTACK, CR_HASTE_MELEE, val);
  58. + break;
  59. +
  60. + case OFF_ATTACK:
  61. + ApplyHasteMod(m_baseRatingValue[CR_HASTE_MELEE], OFF_ATTACK, CR_HASTE_MELEE, val);
  62. + break;
  63. + case RANGED_ATTACK:
  64. + ApplyHasteMod(m_baseRatingValue[CR_HASTE_RANGED], RANGED_ATTACK, CR_HASTE_RANGED, val);
  65. + break;
  66. +
  67. + default:
  68. + SetFloatValue(UNIT_FIELD_BASEATTACKTIME + att, val * m_modAttackSpeedPct[att]);
  69. + }
  70. +}
  71. +
  72. +void Player::ApplyHasteMod(int16 val, uint32 att, CombatRating cr, float speed) {
  73. + float atkSpd = speed * ((100.0f - ((val / 32.789989f) * hasteMod)) / 100.0f);
  74. + if (atkSpd < 0) atkSpd = 0;
  75. + SetFloatValue(UNIT_FIELD_BASEATTACKTIME + att, atkSpd);
  76. +}
  77. +
  78. +// This function had to be completely replaced.
  79. +void Player::ApplyRatingMod(CombatRating cr, int32 value, bool apply)
  80. +{
  81. + m_baseRatingValue[cr] += (apply ? value : -value);
  82. + // explicit affected values
  83. + switch (cr)
  84. + {
  85. + case CR_HASTE_MELEE:
  86. + {
  87. + Item* mainhand = m_items[EQUIPMENT_SLOT_MAINHAND];
  88. + Item* offhand = m_items[EQUIPMENT_SLOT_OFFHAND];
  89. + float speed1 = mainhand ? (float)mainhand->GetTemplate()->Delay : 2000.0f;
  90. + float speed2 = offhand ? (float)offhand->GetTemplate()->Delay : 2000.0f;
  91. +
  92. + ApplyHasteMod(m_baseRatingValue[cr], BASE_ATTACK, cr, speed1);
  93. + ApplyHasteMod(m_baseRatingValue[cr], OFF_ATTACK, cr, speed2);
  94. +
  95. + float RatingChange = value / value;
  96. + (RatingChange = 0) ? ApplyAttackTimePercentMod(BASE_ATTACK, RatingChange, false) : ApplyAttackTimePercentMod(BASE_ATTACK, -RatingChange, true);
  97. + (RatingChange = 0) ? ApplyAttackTimePercentMod(OFF_ATTACK, RatingChange, false) : ApplyAttackTimePercentMod(OFF_ATTACK, -RatingChange, true);
  98. + break;
  99. + }
  100. + case CR_HASTE_RANGED:
  101. + {
  102. + Item* ranged = m_items[EQUIPMENT_SLOT_RANGED];
  103. + float speed = ranged ? (float)ranged->GetTemplate()->Delay : 2000.0f;
  104. + ApplyHasteMod(m_baseRatingValue[cr], RANGED_ATTACK, cr, speed);
  105. + float RatingChange = value / value;
  106. + (RatingChange = 0) ? ApplyAttackTimePercentMod(RANGED_ATTACK, RatingChange, false) : ApplyAttackTimePercentMod(RANGED_ATTACK, -RatingChange, true);
  107. + break;
  108. + }
  109. + case CR_HASTE_SPELL:
  110. + {
  111. + ApplyHasteMod(m_baseRatingValue[cr], CR_HASTE_SPELL - 1, cr, 1.0f);
  112. + }
  113. + default:
  114. + break;
  115. + }
  116. +
  117. + UpdateRating(cr);
  118. }
  119.  
  120. void Player::UpdateRating(CombatRating cr)
  121. diff --git a/src/server/game/Entities/Player/Player.h b/src/server/game/Entities/Player/Player.h
  122. index 4e2f674..94d2b8a 100644
  123. --- a/src/server/game/Entities/Player/Player.h
  124. +++ b/src/server/game/Entities/Player/Player.h
  125. @@ -2496,6 +2496,13 @@ class TC_GAME_API Player : public Unit, public GridObject<Player>
  126. uint32 manaBeforeDuel;
  127.  
  128. WorldLocation _corpseLocation;
  129. +
  130. + float hasteMod;
  131. + public:
  132. + float GetHasteMod() const { return hasteMod; }
  133. + void SetHasteMod(float val) { hasteMod = val; }
  134. + void ApplyHasteMod(int16 val, uint32 att, CombatRating cr, float speed);
  135. + void SetAttackTime(WeaponAttackType att, uint32 val);
  136. };
  137.  
  138. TC_GAME_API void AddItemsSetItem(Player* player, Item* item);
  139. diff --git a/src/server/game/Entities/Unit/StatSystem.cpp b/src/server/game/Entities/Unit/StatSystem.cpp
  140. index 0458f14..e279d2b 100644
  141. --- a/src/server/game/Entities/Unit/StatSystem.cpp
  142. +++ b/src/server/game/Entities/Unit/StatSystem.cpp
  143. @@ -531,64 +531,64 @@ void Player::CalculateMinMaxDamage(WeaponAttackType attType, bool normalized, bo
  144. }
  145.  
  146. UnitMods unitMod;
  147. + Item* Weapon = NULL;
  148.  
  149. switch (attType)
  150. {
  151. - case BASE_ATTACK:
  152. - default:
  153. - unitMod = UNIT_MOD_DAMAGE_MAINHAND;
  154. - break;
  155. - case OFF_ATTACK:
  156. - unitMod = UNIT_MOD_DAMAGE_OFFHAND;
  157. - break;
  158. - case RANGED_ATTACK:
  159. - unitMod = UNIT_MOD_DAMAGE_RANGED;
  160. - break;
  161. + case BASE_ATTACK:
  162. + default:
  163. + Weapon = m_items[EQUIPMENT_SLOT_MAINHAND];
  164. + unitMod = UNIT_MOD_DAMAGE_MAINHAND;
  165. + break;
  166. + case OFF_ATTACK:
  167. + Weapon = m_items[EQUIPMENT_SLOT_OFFHAND];
  168. + unitMod = UNIT_MOD_DAMAGE_OFFHAND;
  169. + break;
  170. + case RANGED_ATTACK:
  171. + Weapon = m_items[EQUIPMENT_SLOT_RANGED];
  172. + unitMod = UNIT_MOD_DAMAGE_RANGED;
  173. + break;
  174. }
  175.  
  176. - float const attackPowerMod = std::max(GetAPMultiplier(attType, normalized), 0.25f);
  177. -
  178. - float baseValue = GetFlatModifierValue(unitMod, BASE_VALUE);
  179. - baseValue += GetTotalAttackPowerValue(attType) / 14.0f * attackPowerMod;
  180. -
  181. - float basePct = GetPctModifierValue(unitMod, BASE_PCT);
  182. - float totalValue = GetFlatModifierValue(unitMod, TOTAL_VALUE);
  183. - float totalPct = addTotalPct ? GetPctModifierValue(unitMod, TOTAL_PCT) : 1.0f;
  184. + float wep_speed = (!Weapon) ? 2200.00f : Weapon->GetTemplate()->Delay;
  185. + float base_value = GetFlatModifierValue(unitMod, BASE_VALUE) + GetTotalAttackPowerValue(attType) / 14.0f * (wep_speed / 1000.00f);
  186. + float att_speed = GetAPMultiplier(attType, normalized);
  187. + float base_pct = GetPctModifierValue(unitMod, BASE_PCT);
  188. + float total_value = GetFlatModifierValue(unitMod, TOTAL_VALUE);
  189. + float total_pct = addTotalPct ? GetPctModifierValue(unitMod, TOTAL_PCT) : 1.0f;
  190.  
  191. - float weaponMinDamage = GetWeaponDamageRange(attType, MINDAMAGE);
  192. - float weaponMaxDamage = GetWeaponDamageRange(attType, MAXDAMAGE);
  193. + float weapon_mindamage = GetWeaponDamageRange(attType, MINDAMAGE);
  194. + float weapon_maxdamage = GetWeaponDamageRange(attType, MAXDAMAGE);
  195.  
  196. - // check if player is druid and in cat or bear forms
  197. - if (IsInFeralForm())
  198. + if (IsInFeralForm()) //check if player is druid and in cat or bear forms
  199. {
  200. uint8 lvl = GetLevel();
  201. if (lvl > 60)
  202. lvl = 60;
  203.  
  204. - weaponMinDamage = lvl * 0.85f * attackPowerMod;
  205. - weaponMaxDamage = lvl * 1.25f * attackPowerMod;
  206. + weapon_mindamage = lvl * 3.0f * wep_speed / 1000; //fix druid damage dalton
  207. + weapon_maxdamage = lvl * 5.0f * wep_speed / 1000;
  208. }
  209. - else if (!CanUseAttackType(attType)) // check if player not in form but still can't use (disarm case)
  210. + else if (!CanUseAttackType(attType)) //check if player not in form but still can't use (disarm case)
  211. {
  212. - // cannot use ranged/off attack, set values to 0
  213. + //cannot use ranged/off attack, set values to 0
  214. if (attType != BASE_ATTACK)
  215. {
  216. - minDamage = 0.f;
  217. - maxDamage = 0.f;
  218. + minDamage = 0;
  219. + maxDamage = 0;
  220. return;
  221. }
  222. -
  223. - weaponMinDamage = BASE_MINDAMAGE;
  224. - weaponMaxDamage = BASE_MAXDAMAGE;
  225. + weapon_mindamage = BASE_MINDAMAGE;
  226. + weapon_maxdamage = BASE_MAXDAMAGE;
  227. }
  228. - else if (attType == RANGED_ATTACK) // add ammo DPS to ranged primary damage
  229. + else if (attType == RANGED_ATTACK) //add ammo DPS to ranged damage
  230. {
  231. - weaponMinDamage += GetAmmoDPS() * attackPowerMod;
  232. - weaponMaxDamage += GetAmmoDPS() * attackPowerMod;
  233. + weapon_mindamage += GetAmmoDPS() * att_speed;
  234. + weapon_maxdamage += GetAmmoDPS() * att_speed;
  235. }
  236.  
  237. - minDamage = ((weaponMinDamage + baseValue) * basePct + totalValue) * totalPct;
  238. - maxDamage = ((weaponMaxDamage + baseValue) * basePct + totalValue) * totalPct;
  239. + minDamage = ((base_value + weapon_mindamage) * base_pct + total_value) * total_pct;
  240. + maxDamage = ((base_value + weapon_maxdamage) * base_pct + total_value) * total_pct;
  241. }
  242.  
  243. void Player::UpdateDefenseBonusesMod()
  244.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!