9
3

Combat.cpp 69 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006
  1. /*
  2. EQ2Emulator: Everquest II Server Emulator
  3. Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net)
  4. This file is part of EQ2Emulator.
  5. EQ2Emulator is free software: you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation, either version 3 of the License, or
  8. (at your option) any later version.
  9. EQ2Emulator is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU General Public License for more details.
  13. You should have received a copy of the GNU General Public License
  14. along with EQ2Emulator. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. #include "Combat.h"
  17. #include "client.h"
  18. #include "../common/ConfigReader.h"
  19. #include "classes.h"
  20. #include "../common/debug.h"
  21. #include "../common/Log.h"
  22. #include "zoneserver.h"
  23. #include "Skills.h"
  24. #include "classes.h"
  25. #include "World.h"
  26. #include "LuaInterface.h"
  27. #include "Rules/Rules.h"
  28. #include "SpellProcess.h"
  29. #include "World.h"
  30. #include <math.h>
  31. extern Classes classes;
  32. extern ConfigReader configReader;
  33. extern MasterSkillList master_skill_list;
  34. extern RuleManager rule_manager;
  35. extern LuaInterface* lua_interface;
  36. extern World world;
  37. /* ******************************************************************************
  38. DamageSpawn() - Damage equation
  39. MeleeAttack() - Melee auto attacks
  40. RangeAttack() - Range auto attacks
  41. DetermineHit() - ToHit chance as well as defender parry / dodge / block / riposte
  42. CheckInterruptSpell() - Interrupt equations
  43. No mitigation equations yet
  44. ****************************************************************************** */
  45. /* New Combat code */
  46. bool Entity::PrimaryWeaponReady() {
  47. //Can only be ready if no ranged timer
  48. if (GetPrimaryLastAttackTime() == 0 || (Timer::GetCurrentTime2() >= (GetPrimaryLastAttackTime() + GetPrimaryAttackDelay()))) {
  49. if (GetRangeLastAttackTime() == 0 || Timer::GetCurrentTime2() >= (GetRangeLastAttackTime() + GetRangeAttackDelay()))
  50. return true;
  51. }
  52. return false;
  53. }
  54. bool Entity::SecondaryWeaponReady() {
  55. //Can only be ready if no ranged timer
  56. // if(IsDualWield() && (GetPrimaryLastAttackTime()
  57. if (IsDualWield() && (GetSecondaryLastAttackTime() == 0 || (Timer::GetCurrentTime2() >= (GetSecondaryLastAttackTime() + GetSecondaryAttackDelay())))) {
  58. if(GetRangeLastAttackTime() == 0 || Timer::GetCurrentTime2() >= (GetRangeLastAttackTime() + GetRangeAttackDelay()))
  59. return true;
  60. }
  61. return false;
  62. }
  63. bool Entity::RangeWeaponReady() {
  64. //Ranged can only be ready if no other attack timers are active
  65. if(GetRangeLastAttackTime() == 0 || (Timer::GetCurrentTime2() >= (GetRangeLastAttackTime() + GetRangeAttackDelay()))) {
  66. if((GetPrimaryLastAttackTime() == 0 || (Timer::GetCurrentTime2() >= (GetPrimaryLastAttackTime() + GetPrimaryAttackDelay()))) && (GetSecondaryLastAttackTime() == 0 || Timer::GetCurrentTime2() >= (GetSecondaryLastAttackTime() + GetSecondaryAttackDelay()))){
  67. if(!IsPlayer() || ((Player*)this)->GetRangeAttack()) {
  68. return true;
  69. }
  70. }
  71. }
  72. return false;
  73. }
  74. bool Entity::AttackAllowed(Entity* target, float distance, bool range_attack) {
  75. Entity* attacker = this;
  76. Client* client = 0;
  77. if(!target || IsMezzedOrStunned() || IsDazed()) {
  78. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: no target, mezzed, stunned or dazed");
  79. return false;
  80. }
  81. if (IsPlayer())
  82. client = ((Player*)this)->GetClient();
  83. if (IsPet())
  84. attacker = ((NPC*)this)->GetOwner();
  85. if (target->IsNPC() && ((NPC*)target)->IsPet()){
  86. if (((NPC*)target)->GetOwner())
  87. target = ((NPC*)target)->GetOwner();
  88. }
  89. if((IsBot() || (client || (attacker && (attacker->IsPlayer() || attacker->IsBot())))) && !target->IsPlayer() && !target->GetAttackable()) {
  90. return false;
  91. }
  92. if (attacker == target) {
  93. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: attacker tried to attack himself or his pet.");
  94. return false;
  95. }
  96. if (IsPlayer() && target->GetAttackable() == 0) {
  97. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: target is not attackable");
  98. return false;
  99. }
  100. if (IsPlayer() && target->IsBot()) {
  101. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: players are not allowed to attack bots");
  102. return false;
  103. }
  104. if(rule_manager.GetGlobalRule(R_Combat, LockedEncounterNoAttack)->GetBool()) {
  105. if(target->IsNPC() && (target->GetLockedNoLoot() == ENCOUNTER_STATE_LOCKED || target->GetLockedNoLoot() == ENCOUNTER_STATE_OVERMATCHED) &&
  106. !attacker->IsEngagedBySpawnID(target->GetID())) {
  107. return false;
  108. }
  109. else if(IsNPC() && (GetLockedNoLoot() == ENCOUNTER_STATE_LOCKED || GetLockedNoLoot() == ENCOUNTER_STATE_OVERMATCHED) &&
  110. !target->IsEngagedBySpawnID(GetID())) {
  111. return false;
  112. }
  113. }
  114. if (attacker->IsPlayer() && target->IsPlayer())
  115. {
  116. bool pvp_allowed = rule_manager.GetGlobalRule(R_PVP, AllowPVP)->GetBool();
  117. if (!pvp_allowed) {
  118. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: pvp is not allowed");
  119. return false;
  120. }
  121. else
  122. {
  123. sint32 pvpLevelRange = rule_manager.GetGlobalRule(R_PVP, LevelRange)->GetSInt32();
  124. int32 attackerLevel = attacker->GetLevel();
  125. int32 defenderLevel = target->GetLevel();
  126. if ((sint32)abs((sint32)attackerLevel - (sint32)defenderLevel) > pvpLevelRange)
  127. {
  128. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: pvp range of %i exceeded abs(%i-%i).", pvpLevelRange, attackerLevel, defenderLevel);
  129. return false;
  130. }
  131. }
  132. }
  133. if (target->GetHP() <= 0) {
  134. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: target is dead");
  135. return false;
  136. }
  137. if(range_attack && distance != 0) {
  138. Item* weapon = 0;
  139. Item* ammo = 0;
  140. if(attacker->IsPlayer()) {
  141. weapon = ((Player*)attacker)->GetEquipmentList()->GetItem(EQ2_RANGE_SLOT);
  142. ammo = GetAmmoFromSlot(true, true);
  143. }
  144. if(weapon && weapon->IsRanged() && ammo && ammo->IsAmmo() && ammo->IsThrown()) {
  145. // Distance is less then min weapon range
  146. if(distance < weapon->ranged_info->range_low) {
  147. if (client)
  148. client->SimpleMessage(CHANNEL_GENERAL_COMBAT, "Your target is too close! Move back!");
  149. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: range attack, target to close");
  150. return false;
  151. }
  152. // Distance is greater then max weapon range
  153. if (distance > (weapon->ranged_info->range_high + ammo->thrown_info->range)) {
  154. if (client)
  155. client->SimpleMessage(CHANNEL_GENERAL_COMBAT, "Your target is too far away! Move closer!");
  156. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: range attack, target is to far");
  157. return false;
  158. }
  159. }
  160. }
  161. else if (distance != 0) {
  162. if(distance >= rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat()) {
  163. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Failed to attack: distance is beyond melee range");
  164. return false;
  165. }
  166. }
  167. if((target->IsPrivateSpawn() && !target->AllowedAccess(this)) || (IsPrivateSpawn() && AllowedAccess(target))) {
  168. LogWrite(COMBAT__DEBUG, 3, "AttackAllowed", "Access to spawn disallowed.");
  169. return false;
  170. }
  171. return true;
  172. }
  173. Item* Entity::GetAmmoFromSlot(bool is_ammo, bool is_thrown) {
  174. Item* ammo = GetEquipmentList()->GetItem(EQ2_AMMO_SLOT);
  175. if(ammo && ammo->IsBag() && IsPlayer()) {
  176. Item* ammo_bag = ammo;
  177. vector<Item*>* items = ((Player*)this)->GetPlayerItemList()->GetItemsInBag(ammo_bag);
  178. vector<Item*>::iterator itr;
  179. int16 i = 0;
  180. Item* tmp_bag_item = 0;
  181. for (itr = items->begin(); itr != items->end(); itr++) {
  182. tmp_bag_item = *itr;
  183. if (tmp_bag_item) {
  184. if(is_ammo && !tmp_bag_item->IsAmmo())
  185. continue;
  186. if(is_thrown && !tmp_bag_item->IsThrown())
  187. continue;
  188. ammo = tmp_bag_item;
  189. break;
  190. }
  191. }
  192. }
  193. if(ammo && is_ammo && !ammo->IsAmmo())
  194. ammo = nullptr;
  195. if(ammo && is_thrown && !ammo->IsThrown())
  196. ammo = nullptr;
  197. return ammo;
  198. }
  199. void Entity::MeleeAttack(Spawn* victim, float distance, bool primary, bool multi_attack) {
  200. if(!victim)
  201. return;
  202. int8 damage_type = 0;
  203. int32 min_damage = 0;
  204. int32 max_damage = 0;
  205. if(primary) {
  206. damage_type = GetPrimaryWeaponType();
  207. min_damage = GetPrimaryWeaponMinDamage();
  208. max_damage = GetPrimaryWeaponMaxDamage();
  209. }
  210. else {
  211. damage_type = GetSecondaryWeaponType();
  212. min_damage = GetSecondaryWeaponMinDamage();
  213. max_damage = GetSecondaryWeaponMaxDamage();
  214. }
  215. if (IsStealthed() || IsInvis())
  216. CancelAllStealth();
  217. int8 hit_result = DetermineHit(victim, DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE, damage_type, 0, false);
  218. if(victim->IsEntity()) {
  219. CheckEncounterState((Entity*)victim);
  220. }
  221. if(hit_result == DAMAGE_PACKET_RESULT_SUCCESSFUL){
  222. /*if(GetAdventureClass() == MONK){
  223. max_damage*=3;
  224. crit_chance = GetLevel()/4+5;
  225. }
  226. else if(GetAdventureClass() == BRUISER){
  227. min_damage = GetLevel();
  228. max_damage*=3;
  229. crit_chance = GetLevel()/3+5;
  230. }
  231. if(rand()%100 <=crit_chance){
  232. max_damage*= 2;
  233. DamageSpawn((Entity*)victim, DAMAGE_PACKET_TYPE_SIMPLE_CRIT_DMG, damage_type, min_damage, max_damage, 0);
  234. }
  235. else*/
  236. DamageSpawn((Entity*)victim, DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE, damage_type, min_damage, max_damage, 0);
  237. if (!multi_attack) {
  238. CheckProcs(PROC_TYPE_OFFENSIVE, victim);
  239. CheckProcs(PROC_TYPE_PHYSICAL_OFFENSIVE, victim);
  240. }
  241. }
  242. else{
  243. GetZone()->SendDamagePacket(this, victim, DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE, hit_result, damage_type, 0, 0);
  244. if(hit_result == DAMAGE_PACKET_RESULT_RIPOSTE && victim->IsEntity())
  245. ((Entity*)victim)->MeleeAttack(this, distance, true);
  246. }
  247. //Multi Attack roll
  248. if(!multi_attack){
  249. float multi_attack = info_struct.get_multi_attack();
  250. if(multi_attack > 0){
  251. float chance = multi_attack;
  252. if (multi_attack > 100){
  253. int8 automatic_multi = (int8)floor((float)(multi_attack / 100));
  254. chance = (multi_attack - (floor((float) ((multi_attack / 100) * 100))));
  255. while(automatic_multi > 0){
  256. MeleeAttack(victim, 100, primary, true);
  257. automatic_multi--;
  258. }
  259. }
  260. if (MakeRandomFloat(0, 100) <= chance)
  261. MeleeAttack(victim, 100, primary, true);
  262. }
  263. }
  264. //Apply attack speed mods
  265. if(!multi_attack)
  266. SetAttackDelay(primary);
  267. if(victim->IsNPC() && victim->EngagedInCombat() == false) {
  268. ((NPC*)victim)->AddHate(this, 50);
  269. }
  270. if (victim->IsEntity() && victim->GetHP() > 0 && ((Entity*)victim)->HasPet()) {
  271. Entity* pet = 0;
  272. bool AddHate = false;
  273. if (victim->IsPlayer()) {
  274. if (((Player*)victim)->GetInfoStruct()->get_pet_behavior() & 1)
  275. AddHate = true;
  276. }
  277. else
  278. AddHate = true;
  279. if (AddHate) {
  280. pet = ((Entity*)victim)->GetPet();
  281. if (pet)
  282. pet->AddHate(this, 1);
  283. pet = ((Entity*)victim)->GetCharmedPet();
  284. if (pet)
  285. pet->AddHate(this, 1);
  286. }
  287. }
  288. }
  289. void Entity::RangeAttack(Spawn* victim, float distance, Item* weapon, Item* ammo, bool multi_attack) {
  290. if(!victim)
  291. return;
  292. if(weapon && weapon->IsRanged() && ammo && ammo->IsAmmo() && ammo->IsThrown()) {
  293. if(weapon->ranged_info->range_low <= distance && (weapon->ranged_info->range_high + ammo->thrown_info->range) >= distance) {
  294. int8 hit_result = DetermineHit(victim, DAMAGE_PACKET_TYPE_RANGE_DAMAGE, ammo->thrown_info->damage_type, ammo->thrown_info->hit_bonus, false);
  295. if(hit_result == DAMAGE_PACKET_RESULT_SUCCESSFUL) {
  296. DamageSpawn((Entity*)victim, DAMAGE_PACKET_TYPE_RANGE_DAMAGE, ammo->thrown_info->damage_type, weapon->ranged_info->weapon_info.damage_low3, weapon->ranged_info->weapon_info.damage_high3+ammo->thrown_info->damage_modifier, 0);
  297. if (!multi_attack) {
  298. CheckProcs(PROC_TYPE_OFFENSIVE, victim);
  299. CheckProcs(PROC_TYPE_PHYSICAL_OFFENSIVE, victim);
  300. }
  301. }
  302. else
  303. GetZone()->SendDamagePacket(this, victim, DAMAGE_PACKET_TYPE_RANGE_DAMAGE, hit_result, ammo->thrown_info->damage_type, 0, 0);
  304. // If is a player subtract ammo
  305. if (IsPlayer()) {
  306. if (ammo->details.count > 1) {
  307. ammo->details.count -= 1;
  308. ammo->save_needed = true;
  309. }
  310. else {
  311. if(ammo->details.inv_slot_id >= 6) {
  312. ((Player*)this)->equipment_list.RemoveItem(ammo->details.slot_id, false);
  313. ((Player*)this)->item_list.DestroyItem(ammo->details.index);
  314. }
  315. else {
  316. ((Player*)this)->equipment_list.RemoveItem(ammo->details.slot_id, true);
  317. }
  318. }
  319. Client* client = ((Player*)this)->GetClient();
  320. if(client) {
  321. EQ2Packet* outapp = ((Player*)this)->GetEquipmentList()->serialize(client->GetVersion(), (Player*)this);
  322. if(outapp)
  323. client->QueuePacket(outapp);
  324. if(ammo->details.inv_slot_id > 6) {
  325. EQ2Packet* outapp = client->GetPlayer()->SendInventoryUpdate(client->GetVersion());
  326. if (outapp)
  327. client->QueuePacket(outapp);
  328. }
  329. }
  330. }
  331. if(victim->IsNPC() && victim->EngagedInCombat() == false) {
  332. ((NPC*)victim)->AddHate(this, 50);
  333. }
  334. if (victim->IsEntity() && victim->GetHP() > 0 && ((Entity*)victim)->HasPet()) {
  335. Entity* pet = 0;
  336. bool AddHate = false;
  337. if (victim->IsPlayer()) {
  338. if (((Player*)victim)->GetInfoStruct()->get_pet_behavior() & 1)
  339. AddHate = true;
  340. }
  341. else
  342. AddHate = true;
  343. if (AddHate) {
  344. pet = ((Entity*)victim)->GetPet();
  345. if (pet)
  346. pet->AddHate(this, 1);
  347. pet = ((Entity*)victim)->GetCharmedPet();
  348. if (pet)
  349. pet->AddHate(this, 1);
  350. }
  351. }
  352. // Check Ranged attack proc
  353. CheckProcs(PROC_TYPE_RANGED_ATTACK, victim);
  354. // Check Ranged defence proc
  355. if (victim->IsEntity())
  356. ((Entity*)victim)->CheckProcs(PROC_TYPE_RANGED_DEFENSE, this);
  357. SetRangeLastAttackTime(Timer::GetCurrentTime2());
  358. }
  359. }
  360. //Multi Attack roll
  361. if(!multi_attack){
  362. float multi_attack = info_struct.get_multi_attack();
  363. if(multi_attack > 0){
  364. float chance = multi_attack;
  365. if (multi_attack > 100){
  366. int8 automatic_multi = (int8)floor((float)(multi_attack / 100));
  367. chance = (multi_attack - (floor((float)(multi_attack / 100) * 100)));
  368. while(automatic_multi > 0){
  369. RangeAttack(victim, 100, weapon, ammo, true);
  370. automatic_multi--;
  371. }
  372. }
  373. if (MakeRandomFloat(0, 100) <= chance)
  374. RangeAttack(victim, 100, weapon, ammo, true);
  375. }
  376. }
  377. //Apply attack speed mods
  378. if(!multi_attack)
  379. SetAttackDelay(false, true);
  380. }
  381. bool Entity::SpellAttack(Spawn* victim, float distance, LuaSpell* luaspell, int8 damage_type, int32 low_damage, int32 high_damage, int8 crit_mod, bool no_calcs, int8 override_packet_type, bool take_power){
  382. if(!victim || !luaspell || !luaspell->spell)
  383. return false;
  384. Spell* spell = luaspell->spell;
  385. Skill* skill = nullptr;
  386. int8 packet_type = DAMAGE_PACKET_TYPE_SPELL_DAMAGE;
  387. if(override_packet_type) {
  388. packet_type = override_packet_type;
  389. }
  390. int8 hit_result = 0;
  391. bool is_tick = false; // if spell is already active, this is a tick
  392. if (GetZone()->GetSpellProcess()->GetActiveSpells()->count(luaspell)){
  393. hit_result = DAMAGE_PACKET_RESULT_SUCCESSFUL;
  394. is_tick = true;
  395. }
  396. else if(spell->GetSpellData()->type == SPELL_BOOK_TYPE_COMBAT_ART)
  397. hit_result = DetermineHit(victim, packet_type, damage_type, 0, false, luaspell);
  398. else
  399. hit_result = DetermineHit(victim, packet_type, damage_type, 0, true, luaspell);
  400. if(victim->IsEntity()) {
  401. CheckEncounterState((Entity*)victim);
  402. }
  403. bool successful_hit = true;
  404. if(hit_result == DAMAGE_PACKET_RESULT_SUCCESSFUL) {
  405. luaspell->last_spellattack_hit = true;
  406. //If this spell is a tick and has already crit, force the tick to crit
  407. if(is_tick){
  408. if(luaspell->crit)
  409. crit_mod = 1;
  410. else
  411. crit_mod = 2;
  412. }
  413. DamageSpawn((Entity*)victim, packet_type, damage_type, low_damage, high_damage, spell->GetName(), crit_mod, is_tick, no_calcs, false, take_power, luaspell);
  414. CheckProcs(PROC_TYPE_OFFENSIVE, victim);
  415. CheckProcs(PROC_TYPE_MAGICAL_OFFENSIVE, victim);
  416. if(spell->GetSpellData()->success_message.length() > 0){
  417. Client* client = nullptr;
  418. if(IsPlayer())
  419. client = ((Player*)this)->GetClient();
  420. if(client){
  421. string success_message = spell->GetSpellData()->success_message;
  422. if(success_message.find("%t") < 0xFFFFFFFF)
  423. success_message.replace(success_message.find("%t"), 2, victim->GetName());
  424. client->Message(CHANNEL_YOU_CAST, success_message.c_str());
  425. //commented out the following line as it was causing a duplicate message EmemJR 5/4/2019
  426. //GetZone()->SendDamagePacket(this, victim, DAMAGE_PACKET_TYPE_SPELL_DAMAGE, hit_result, damage_type, 0, spell->GetName());
  427. }
  428. }
  429. if(spell->GetSpellData()->effect_message.length() > 0){
  430. string effect_message = spell->GetSpellData()->effect_message;
  431. if(effect_message.find("%t") < 0xFFFFFFFF)
  432. effect_message.replace(effect_message.find("%t"), 2, victim->GetName());
  433. GetZone()->SimpleMessage(CHANNEL_SPELLS, effect_message.c_str(), victim, 50);
  434. }
  435. }
  436. else {
  437. successful_hit = false;
  438. if(hit_result == DAMAGE_PACKET_RESULT_RESIST)
  439. luaspell->resisted = true;
  440. if(victim->IsNPC())
  441. ((NPC*)victim)->AddHate(this, 5);
  442. luaspell->last_spellattack_hit = false;
  443. GetZone()->SendDamagePacket(this, victim, DAMAGE_PACKET_TYPE_SPELL_DAMAGE, hit_result, damage_type, 0, spell->GetName());
  444. }
  445. if(EngagedInCombat() == false)
  446. {
  447. LogWrite(MISC__TODO, 1, "TODO", "//It would probably be better to add a column to the spells table for 'starts autoattack'\nfile: %s, func: %s, Line: %i", __FILE__, __FUNCTION__, __LINE__);
  448. int8 class1_ = GetInfoStruct()->get_class1();
  449. if(class1_ == COMMONER ||
  450. class1_ == FIGHTER ||
  451. class1_ == WARRIOR ||
  452. class1_ == GUARDIAN ||
  453. class1_ == BERSERKER ||
  454. class1_ == BRAWLER ||
  455. class1_ == MONK ||
  456. class1_ == BRUISER ||
  457. class1_ == CRUSADER ||
  458. class1_ == SHADOWKNIGHT ||
  459. class1_ == PALADIN ||
  460. class1_ == SCOUT ||
  461. class1_ == ROGUE ||
  462. class1_ == SWASHBUCKLER ||
  463. class1_ == BRIGAND ||
  464. class1_ == BARD ||
  465. class1_ == TROUBADOR ||
  466. class1_ == DIRGE ||
  467. class1_ == PREDATOR ||
  468. class1_ == RANGER ||
  469. class1_ == ASSASSIN ||
  470. class1_ == ANIMALIST ||
  471. class1_ == BEASTLORD ||
  472. class1_ == SHAPER ||
  473. class1_ == CHANNELER) //note: it would probably be better to add a column to the spells table for "starts autoattack".
  474. {
  475. if (victim->IsNPC())
  476. ((NPC*)victim)->AddHate(this, 5);
  477. else {
  478. Client* client = 0;
  479. if(IsPlayer())
  480. client = ((Player*)this)->GetClient();
  481. if(client) {
  482. client->GetPlayer()->InCombat(true, client->GetPlayer()->GetRangeAttack());
  483. }
  484. InCombat(true);
  485. }
  486. }
  487. }
  488. if (victim->IsEntity() && victim->GetHP() > 0 && ((Entity*)victim)->HasPet()) {
  489. Entity* pet = 0;
  490. bool AddHate = false;
  491. if (victim->IsPlayer()) {
  492. if (((Player*)victim)->GetInfoStruct()->get_pet_behavior() & 1)
  493. AddHate = true;
  494. }
  495. else
  496. AddHate = true;
  497. if (AddHate) {
  498. pet = ((Entity*)victim)->GetPet();
  499. if (pet)
  500. pet->AddHate(this, 1);
  501. pet = ((Entity*)victim)->GetCharmedPet();
  502. if (pet)
  503. pet->AddHate(this, 1);
  504. }
  505. }
  506. return successful_hit;
  507. }
  508. bool Entity::ProcAttack(Spawn* victim, int8 damage_type, int32 low_damage, int32 high_damage, string name, string success_msg, string effect_msg) {
  509. int8 hit_result = DetermineHit(victim, DAMAGE_PACKET_TYPE_SPELL_DAMAGE, damage_type, 0, true);
  510. if (hit_result == DAMAGE_PACKET_RESULT_SUCCESSFUL) {
  511. DamageSpawn((Entity*)victim, DAMAGE_PACKET_TYPE_SPELL_DAMAGE, damage_type, low_damage, high_damage, name.c_str());
  512. if (success_msg.length() > 0) {
  513. Client* client = 0;
  514. if(IsPlayer())
  515. client = ((Player*)this)->GetClient();
  516. if(client) {
  517. if(success_msg.find("%t") < 0xFFFFFFFF)
  518. success_msg.replace(success_msg.find("%t"), 2, victim->GetName());
  519. client->Message(CHANNEL_YOU_CAST, success_msg.c_str());
  520. }
  521. }
  522. if (effect_msg.length() > 0) {
  523. if(effect_msg.find("%t") < 0xFFFFFFFF)
  524. effect_msg.replace(effect_msg.find("%t"), 2, victim->GetName());
  525. GetZone()->SimpleMessage(CHANNEL_SPELLS, effect_msg.c_str(), victim, 50);
  526. }
  527. }
  528. else {
  529. if(victim->IsNPC())
  530. ((NPC*)victim)->AddHate(this, 5);
  531. GetZone()->SendDamagePacket(this, victim, DAMAGE_PACKET_TYPE_SPELL_DAMAGE, hit_result, damage_type, 0, name.c_str());
  532. }
  533. if (victim->IsEntity() && victim->GetHP() > 0 && ((Entity*)victim)->HasPet()) {
  534. Entity* pet = 0;
  535. bool AddHate = false;
  536. if (victim->IsPlayer()) {
  537. if (((Player*)victim)->GetInfoStruct()->get_pet_behavior() & 1)
  538. AddHate = true;
  539. }
  540. else
  541. AddHate = true;
  542. if (AddHate) {
  543. pet = ((Entity*)victim)->GetPet();
  544. if (pet)
  545. pet->AddHate(this, 1);
  546. pet = ((Entity*)victim)->GetCharmedPet();
  547. if (pet)
  548. pet->AddHate(this, 1);
  549. }
  550. }
  551. return true;
  552. }
  553. // this is used exclusively by LUA, heal_type is forced lower case via boost::lower(heal_type); in the LUA Functions used by this
  554. bool Entity::SpellHeal(Spawn* target, float distance, LuaSpell* luaspell, string heal_type, int32 low_heal, int32 high_heal, int8 crit_mod, bool no_calcs, string custom_spell_name){
  555. if(!target || !luaspell || !luaspell->spell || (target->IsPrivateSpawn() && !target->AllowedAccess(this)))
  556. return false;
  557. if (!target->Alive())
  558. return false;
  559. if (target->GetHP() == target->GetTotalHP())
  560. return true;
  561. int32 heal_amt = 0;
  562. bool crit = false;
  563. if(high_heal < low_heal)
  564. high_heal = low_heal;
  565. if(high_heal == low_heal)
  566. heal_amt = high_heal;
  567. else
  568. heal_amt = MakeRandomInt(low_heal, high_heal);
  569. if(!no_calcs){
  570. // if spell is already active, this is a tick
  571. bool is_tick = GetZone()->GetSpellProcess()->GetActiveSpells()->count(luaspell);
  572. //if is a tick and the spell has crit, force crit, else disable
  573. if(is_tick){
  574. if(luaspell->crit)
  575. crit_mod = 1;
  576. else
  577. crit_mod = 2;
  578. }
  579. if (heal_amt > 0){
  580. if(target->IsEntity())
  581. heal_amt = (int32)CalculateHealAmount((Entity*)target, (sint32)heal_amt, crit_mod, &crit);
  582. else
  583. heal_amt = (int32)CalculateHealAmount(nullptr, (sint32)heal_amt, crit_mod, &crit);
  584. }
  585. }
  586. int16 type = 0;
  587. if (heal_type == "heal") {
  588. if(crit)
  589. type = HEAL_PACKET_TYPE_CRIT_HEAL;
  590. else
  591. type = HEAL_PACKET_TYPE_SIMPLE_HEAL;
  592. //apply heal
  593. if (target->GetHP() + (sint32)heal_amt > target->GetTotalHP())
  594. heal_amt = target->GetTotalHP() - target->GetHP();
  595. target->SetHP(target->GetHP() + heal_amt);
  596. /*
  597. if (target->GetHP() + (sint32)heal_amt > target->GetTotalHP())
  598. target->SetHP(target->GetTotalHP());
  599. else
  600. target->SetHP(target->GetHP() + heal_amt);
  601. */
  602. }
  603. else if (heal_type == "power"){
  604. if(crit)
  605. type = HEAL_PACKET_TYPE_CRIT_MANA;
  606. else
  607. type = HEAL_PACKET_TYPE_SIMPLE_MANA;
  608. //give power
  609. if (target->GetPower() + (sint32)heal_amt > target->GetTotalPower())
  610. heal_amt = target->GetTotalPower() - target->GetPower();
  611. target->SetPower(GetPower() + heal_amt);
  612. /*
  613. if (target->GetPower() + (sint32)heal_amt > target->GetTotalPower())
  614. target->SetPower(target->GetTotalPower());
  615. else
  616. target->SetPower(GetPower() + heal_amt);
  617. */
  618. }
  619. /*else if (heal_type == "Savagery"){
  620. if(crit)
  621. type = HEAL_PACKET_TYPE_CRIT_SAVAGERY;
  622. else
  623. type = HEAL_PACKET_TYPE_SAVAGERY;
  624. }
  625. else if (heal_type == "Repair"){
  626. if(crit)
  627. type = HEAL_PACKET_TYPE_CRIT_REPAIR;
  628. else
  629. type = HEAL_PACKET_TYPE_REPAIR;
  630. }*/
  631. else{ //default to heal if type cannot be determined
  632. if(crit)
  633. type = HEAL_PACKET_TYPE_CRIT_HEAL;
  634. else
  635. type = HEAL_PACKET_TYPE_SIMPLE_HEAL;
  636. if (target->GetHP() + (sint32)heal_amt > target->GetTotalHP())
  637. heal_amt = target->GetTotalHP() - target->GetHP();
  638. target->SetHP(target->GetHP() + heal_amt);
  639. /*
  640. if (target->GetHP() + (sint32)heal_amt > target->GetTotalHP())
  641. target->SetHP(target->GetTotalHP());
  642. else
  643. target->SetHP(target->GetHP() + heal_amt);
  644. */
  645. }
  646. target->GetZone()->TriggerCharSheetTimer();
  647. if (heal_amt > 0)
  648. GetZone()->SendHealPacket(this, target, type, heal_amt, custom_spell_name.length() > 0 ? (char*)custom_spell_name.c_str() : luaspell->spell->GetName());
  649. CheckProcs(PROC_TYPE_HEALING, target);
  650. CheckProcs(PROC_TYPE_BENEFICIAL, target);
  651. if (target->IsEntity()) {
  652. int32 hate_amt = heal_amt / 2;
  653. set<int32>::iterator itr;
  654. ((Entity*)target)->MHatedBy.lock();
  655. set<int32> hatedByCopy(((Entity*)target)->HatedBy);
  656. ((Entity*)target)->MHatedBy.unlock();
  657. for (itr = hatedByCopy.begin(); itr != hatedByCopy.end(); itr++) {
  658. Spawn* spawn = GetZone()->GetSpawnByID(*itr);
  659. if (spawn && spawn->IsEntity() && target != this) {
  660. CheckEncounterState((Entity*)spawn);
  661. ((Entity*)spawn)->AddHate(this, hate_amt);
  662. }
  663. }
  664. }
  665. return true;
  666. }
  667. int8 Entity::DetermineHit(Spawn* victim, int8 type, int8 damage_type, float ToHitBonus, bool is_caster_spell, LuaSpell* lua_spell){
  668. if(lua_spell) {
  669. lua_spell->is_damage_spell = true;
  670. }
  671. if(!victim) {
  672. return DAMAGE_PACKET_RESULT_MISS;
  673. }
  674. if(victim->GetInvulnerable()) {
  675. return DAMAGE_PACKET_RESULT_INVULNERABLE;
  676. }
  677. bool behind = false;
  678. // move this above the if statement to assure skill-ups on successful damage return
  679. Skill* skill = GetSkillByWeaponType(type, damage_type, true);
  680. // Monk added with Brawler to 360 degree support per KoS Prima Official eGuide Fighter: Monk, pg 138, denoted '360-Degree Avoidance!'
  681. if(!victim->IsEntity() || (!is_caster_spell && victim->GetAdventureClass() != BRAWLER && victim->GetAdventureClass() != MONK && (behind = BehindTarget(victim)))) {
  682. return DAMAGE_PACKET_RESULT_SUCCESSFUL;
  683. }
  684. float bonus = ToHitBonus;
  685. float skillAddedByWeapon = 0.0f;
  686. if(skill)
  687. {
  688. int16 skillID = master_item_list.GetItemStatIDByName(skill->name.data);
  689. if(skillID != 0xFFFFFFFF)
  690. {
  691. MStats.lock();
  692. skillAddedByWeapon = stats[skillID];
  693. if(!is_caster_spell) {
  694. float item_stat_weapon_skill = stats[ITEM_STAT_WEAPON_SKILLS];
  695. skillAddedByWeapon += item_stat_weapon_skill;
  696. }
  697. MStats.unlock();
  698. float max_bonus_skill = GetRuleSkillMaxBonus();
  699. if(skillAddedByWeapon > max_bonus_skill) {
  700. skillAddedByWeapon = max_bonus_skill;
  701. }
  702. }
  703. }
  704. if (skill)
  705. bonus += (skill->current_val+skillAddedByWeapon) / 25;
  706. if(is_caster_spell && lua_spell) {
  707. if(lua_spell->spell->GetSpellData()->resistibility > 0)
  708. bonus -= (1.0f - lua_spell->spell->GetSpellData()->resistibility)*100.0f;
  709. LogWrite(COMBAT__DEBUG, 9, "Combat", "SpellResist: resistibility %f, bonus %f", lua_spell->spell->GetSpellData()->resistibility, bonus);
  710. // Here we take into account Subjugation, Disruption and Ordination (debuffs)
  711. if(lua_spell->spell->GetSpellData()->mastery_skill) {
  712. int32 master_skill_reduce = rule_manager.GetGlobalRule(R_Spells, MasterSkillReduceSpellResist)->GetInt32();
  713. if(master_skill_reduce < 1)
  714. master_skill_reduce = 25;
  715. if(IsPlayer() && lua_spell->spell->GetSpellData()->spell_book_type == SPELL_BOOK_TYPE_TRADESKILL &&
  716. !((Player*)this)->GetSkills()->HasSkill(lua_spell->spell->GetSpellData()->mastery_skill)) {
  717. ((Player*)this)->AddSkill(lua_spell->spell->GetSpellData()->mastery_skill, 1, ((Player*)this)->GetLevel() * 5, true);
  718. }
  719. Skill* master_skill = GetSkillByID(lua_spell->spell->GetSpellData()->mastery_skill, true);
  720. if(master_skill && (lua_spell->spell->GetSpellData()->spell_book_type == SPELL_BOOK_TYPE_TRADESKILL ||
  721. ((master_skill->name.data == "Subjugation" || master_skill->name.data == "Disruption" || master_skill->name.data == "Ordination" || master_skill->name.data == "Aggression")))) {
  722. float item_stat_bonus = 0.0f;
  723. int32 item_stat = master_item_list.GetItemStatIDByName(::ToLower(master_skill->name.data));
  724. if(item_stat != 0xFFFFFFFF) {
  725. item_stat_bonus = GetStat(item_stat);
  726. }
  727. bonus += (master_skill->current_val + item_stat_bonus) / master_skill_reduce;
  728. LogWrite(COMBAT__DEBUG, 9, "Combat", "SpellResistMasterySkill: skill %u, stat bonus %f, mastery skill reduce %u, bonus %f", master_skill->current_val, item_stat_bonus, master_skill_reduce, bonus);
  729. }
  730. }
  731. }
  732. if (victim->IsEntity())
  733. bonus -= ((Entity*)victim)->GetDamageTypeResistPercentage(damage_type);
  734. LogWrite(COMBAT__DEBUG, 9, "Combat", "DamageResistPercent: type %u, bonus %f", damage_type, bonus);
  735. Entity* entity_victim = (Entity*)victim;
  736. float chance = 80 + bonus; //80% base chance that the victim will get hit (plus bonus)
  737. sint16 roll_chance = 100;
  738. if(is_caster_spell) {
  739. chance += CalculateLevelStatBonus(GetWis());
  740. }
  741. if(skill)
  742. roll_chance -= skill->current_val / 10;
  743. LogWrite(COMBAT__DEBUG, 9, "Combat", "Chance: fchance %f, roll_chance %i", chance, roll_chance);
  744. if(!is_caster_spell){ // melee or range attack
  745. skill = GetSkillByName("Offense", true); //add this skill for NPCs
  746. if(skill)
  747. roll_chance -= skill->current_val / 25;
  748. if(entity_victim->IsImmune(IMMUNITY_TYPE_RIPOSTE))
  749. return DAMAGE_PACKET_RESULT_RIPOSTE;
  750. // Avoidance Instructions: https://forums.daybreakgames.com/eq2/index.php?threads/avoidance-faq.482979/
  751. /*Parry: reads as parry in the avoidance tooltip, increased by items with +parry on them
  752. Caps at 70%. For plate tanks, works in the front quadrant only, for brawlers this is 360 degrees.
  753. A small % of parries will be ripostes, which not only avoid the attack but also damage your attacker
  754. */
  755. skill = entity_victim->GetSkillByName("Parry", true);
  756. if(skill){
  757. float parryChance = entity_victim->GetInfoStruct()->get_parry();
  758. float chanceValue = (100.0f - parryChance);
  759. if(chanceValue < 10.0f) { // min default per https://eq2.fandom.com/wiki/Update:29
  760. chanceValue = 10.0f; // this becomes 5.0f at EoF
  761. }
  762. if(rand()%roll_chance >= chanceValue){ //successful parry
  763. /* You may only riposte things in the front quadrant.
  764. Riposte is based off of parry: a certain % of parries turn into ripostes.
  765. */
  766. if(!behind && victim->InFrontSpawn((Spawn*)this, victim->GetX(), victim->GetZ())) { // if the attacker is not behind the victim, and the victim is facing the attacker (in front of spawn) then we can riposte
  767. float riposteChanceValue = parryChance / 7.0f; // Riposte is based off of parry: a certain % of parries turn into ripostes. Unknown what the value is divided by, 7 to make it 10% even.
  768. if(rand()%100 <= riposteChanceValue) {
  769. entity_victim->CheckProcs(PROC_TYPE_RIPOSTE, this);
  770. return DAMAGE_PACKET_RESULT_RIPOSTE;
  771. }
  772. }
  773. entity_victim->CheckProcs(PROC_TYPE_PARRY, this);
  774. return DAMAGE_PACKET_RESULT_PARRY;
  775. }
  776. }
  777. skill = nullptr;
  778. float blockChance = 0.0f;
  779. if(victim->GetAdventureClass() == BRAWLER)
  780. skill = entity_victim->GetSkillByName("Deflection", true);
  781. blockChance = entity_victim->GetInfoStruct()->get_block();
  782. if(blockChance > 0.0f)
  783. {
  784. blockChance += (blockChance*(entity_victim->GetInfoStruct()->get_block_chance()/100.0f));
  785. float chanceValue = (100.0f - blockChance);
  786. \
  787. if(chanceValue < 30.0f) { // min default per https://eq2.fandom.com/wiki/Update:29
  788. chanceValue = 30.0f; // this becomes 25.0f at EoF
  789. }
  790. /* Non-brawlers may only block things in the front quadrant.
  791. Riposte is based off of parry: a certain % of parries turn into ripostes.
  792. */
  793. float rnd = rand()%roll_chance;
  794. if(rnd >= chanceValue){ //successful block
  795. if((victim->GetAdventureClass() == BRAWLER || victim->GetAdventureClass() == MONK) || (!behind && victim->InFrontSpawn((Spawn*)this, victim->GetX(), victim->GetZ()))) { // if the attacker is not behind the victim, and the victim is facing the attacker (in front of spawn) then we can block
  796. entity_victim->CheckProcs(PROC_TYPE_BLOCK, this);
  797. return (victim->GetAdventureClass() == BRAWLER) ? DAMAGE_PACKET_RESULT_DEFLECT : DAMAGE_PACKET_RESULT_BLOCK;
  798. }
  799. }
  800. }
  801. skill = entity_victim->GetSkillByName("Defense", true);
  802. // calculated in Entity::CalculateBonuses
  803. float dodgeChance = entity_victim->GetInfoStruct()->get_avoidance_base();
  804. if(dodgeChance > 0.0f)
  805. {
  806. float chanceValue = (100.0f - dodgeChance);
  807. float rnd = rand()%roll_chance;
  808. if(rnd >= chanceValue){ //successful dodge
  809. entity_victim->CheckProcs(PROC_TYPE_EVADE, this);
  810. return DAMAGE_PACKET_RESULT_DODGE;//successfully dodged
  811. }
  812. }
  813. if(rand() % roll_chance >= chance)
  814. return DAMAGE_PACKET_RESULT_MISS; //successfully avoided
  815. }
  816. else{
  817. float focus_skill_with_bonus = entity_victim->CalculateSkillWithBonus("Spell Avoidance", ITEM_STAT_SPELL_AVOIDANCE, true);
  818. int16 effective_level = entity_victim->GetInfoStruct()->get_effective_level() != 0 ? entity_victim->GetInfoStruct()->get_effective_level() : entity_victim->GetLevel();
  819. focus_skill_with_bonus += entity_victim->CalculateLevelStatBonus(entity_victim->GetWis());
  820. chance -= ((focus_skill_with_bonus)/10);
  821. LogWrite(COMBAT__DEBUG, 9, "Combat", "SpellAvoidChance: fchance %f, focus with skill bonus %f", chance, focus_skill_with_bonus);
  822. if(rand()%roll_chance >= chance) {
  823. return DAMAGE_PACKET_RESULT_RESIST; //successfully resisted
  824. }
  825. }
  826. return DAMAGE_PACKET_RESULT_SUCCESSFUL;
  827. }
  828. float Entity::GetDamageTypeResistPercentage(int8 damage_type) {
  829. float ret = 1;
  830. switch(damage_type) {
  831. case DAMAGE_PACKET_DAMAGE_TYPE_CRUSH:
  832. case DAMAGE_PACKET_DAMAGE_TYPE_PIERCE:
  833. case DAMAGE_PACKET_DAMAGE_TYPE_SLASH: {
  834. Skill* skill = GetSkillByName("Defense", true);
  835. if(skill)
  836. ret += skill->current_val / 25;
  837. if(IsNPC())
  838. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Crush/Pierce/Slash (%i)", damage_type, ret);
  839. break;
  840. }
  841. case DAMAGE_PACKET_DAMAGE_TYPE_HEAT: {
  842. ret += GetInfoStruct()->get_heat() / 50;
  843. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Heat (%i), Amt: %.2f", damage_type, ret);
  844. break;
  845. }
  846. case DAMAGE_PACKET_DAMAGE_TYPE_COLD: {
  847. ret += GetInfoStruct()->get_cold() / 50;
  848. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Cold (%i), Amt: %.2f", damage_type, ret);
  849. break;
  850. }
  851. case DAMAGE_PACKET_DAMAGE_TYPE_MAGIC: {
  852. ret += GetInfoStruct()->get_magic() / 50;
  853. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Magic (%i), Amt: %.2f", damage_type, ret);
  854. break;
  855. }
  856. case DAMAGE_PACKET_DAMAGE_TYPE_MENTAL: {
  857. ret += GetInfoStruct()->get_mental() / 50;
  858. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Mental (%i), Amt: %.2f", damage_type, ret);
  859. break;
  860. }
  861. case DAMAGE_PACKET_DAMAGE_TYPE_DIVINE: {
  862. ret += GetInfoStruct()->get_divine() / 50;
  863. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Divine (%i), Amt: %.2f", damage_type, ret);
  864. break;
  865. }
  866. case DAMAGE_PACKET_DAMAGE_TYPE_DISEASE: {
  867. ret += GetInfoStruct()->get_disease() / 50;
  868. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Disease (%i), Amt: %.2f", damage_type, ret);
  869. break;
  870. }
  871. case DAMAGE_PACKET_DAMAGE_TYPE_POISON: {
  872. ret += GetInfoStruct()->get_poison() / 50;
  873. LogWrite(COMBAT__DEBUG, 3, "Combat", "DamageType: Poison (%i), Amt: %.2f", damage_type, ret);
  874. break;
  875. }
  876. case DAMAGE_PACKET_DAMAGE_TYPE_FOCUS: {
  877. ret = 0.0f;
  878. break;
  879. }
  880. }
  881. return ret;
  882. }
  883. Skill* Entity::GetSkillByWeaponType(int8 type, int8 damage_type, bool update) {
  884. if(type == DAMAGE_PACKET_TYPE_RANGE_DAMAGE) {
  885. return GetSkillByName("Ranged", update);
  886. }
  887. switch(damage_type) {
  888. case DAMAGE_PACKET_DAMAGE_TYPE_SLASH: // slash
  889. return GetSkillByName("Slashing", update);
  890. case DAMAGE_PACKET_DAMAGE_TYPE_CRUSH: // crush
  891. return GetSkillByName("Crushing", update);
  892. case DAMAGE_PACKET_DAMAGE_TYPE_PIERCE: // pierce
  893. return GetSkillByName("Piercing", update);
  894. case DAMAGE_PACKET_DAMAGE_TYPE_HEAT:
  895. case DAMAGE_PACKET_DAMAGE_TYPE_COLD:
  896. case DAMAGE_PACKET_DAMAGE_TYPE_MAGIC:
  897. case DAMAGE_PACKET_DAMAGE_TYPE_MENTAL:
  898. case DAMAGE_PACKET_DAMAGE_TYPE_DIVINE:
  899. case DAMAGE_PACKET_DAMAGE_TYPE_DISEASE:
  900. case DAMAGE_PACKET_DAMAGE_TYPE_POISON:
  901. return GetSkillByName("Disruption", update);
  902. case DAMAGE_PACKET_DAMAGE_TYPE_FOCUS:
  903. return GetSkillByName("Focus", update);
  904. }
  905. return 0;
  906. }
  907. bool Entity::DamageSpawn(Entity* victim, int8 type, int8 damage_type, int32 low_damage, int32 high_damage, const char* spell_name, int8 crit_mod, bool is_tick, bool no_calcs, bool ignore_attacker, bool take_power, LuaSpell* spell) {
  908. if(spell) {
  909. spell->is_damage_spell = true;
  910. }
  911. bool has_damaged = false;
  912. if(!victim || !victim->Alive() || victim->GetHP() == 0)
  913. return false;
  914. int8 hit_result = 0;
  915. int16 blow_type = 0;
  916. sint32 damage = 0;
  917. sint32 damage_before_crit = 0;
  918. bool crit = false;
  919. if(low_damage > high_damage)
  920. high_damage = low_damage;
  921. if(low_damage == high_damage)
  922. damage = low_damage;
  923. else
  924. damage = MakeRandomInt(low_damage, high_damage);
  925. if(!no_calcs) {
  926. //this can be simplified by taking out the / 2, but I wanted the damage to be more consistent
  927. //damage = (rand()%((int)(high_damage/2-low_damage/2) + low_damage/2)) + (rand()%((int)(high_damage/2-low_damage/2) + low_damage/2));
  928. //damage = (rand()%((int)(high_damage-low_damage) + low_damage)) + (rand()%((int)(high_damage-low_damage) + low_damage));
  929. //DPS mod is only applied to auto attacks
  930. if (type == DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE || type == DAMAGE_PACKET_TYPE_RANGE_DAMAGE) {
  931. if(info_struct.get_dps_multiplier() != 0.0f) {
  932. damage *= (info_struct.get_dps_multiplier());
  933. }
  934. }
  935. //Potency and ability mod is only applied to spells/CAs
  936. else {
  937. damage = CalculateDamageAmount(victim, damage, type, damage_type, spell);
  938. }
  939. if(!crit_mod || crit_mod == 1){
  940. //force crit if crit_mod == 1
  941. if(crit_mod == 1)
  942. crit = true;
  943. // Crit Roll
  944. else {
  945. victim->MStats.lock();
  946. float chance = max((float)0, (info_struct.get_crit_chance() - victim->stats[ITEM_STAT_CRITAVOIDANCE]));
  947. victim->MStats.unlock();
  948. if (MakeRandomFloat(0, 100) <= chance)
  949. crit = true;
  950. }
  951. if(crit){
  952. damage_before_crit = damage;
  953. //Apply total crit multiplier with crit bonus
  954. if(info_struct.get_crit_bonus() > 0)
  955. damage *= (1.3 + (info_struct.get_crit_bonus() / 100));
  956. else
  957. damage *= 1.3;
  958. // Change packet type to crit
  959. if (type == DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE)
  960. type = DAMAGE_PACKET_TYPE_SIMPLE_CRIT_DMG;
  961. else if (type == DAMAGE_PACKET_TYPE_SPELL_DAMAGE)
  962. type = DAMAGE_PACKET_TYPE_SPELL_CRIT_DMG;
  963. }
  964. }
  965. if(type == DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE || type == DAMAGE_PACKET_TYPE_SIMPLE_CRIT_DMG || type == DAMAGE_PACKET_TYPE_RANGE_DAMAGE) {
  966. int16 effective_level_attacker = GetInfoStruct()->get_effective_level() != 0 ? GetInfoStruct()->get_effective_level() : GetLevel();
  967. float mit_percentage = CalculateMitigation(type, damage_type, effective_level_attacker, (IsPlayer() && victim->IsPlayer()));
  968. sint32 damage_to_reduce = (damage * mit_percentage);
  969. if(damage_to_reduce > damage)
  970. damage = 0;
  971. else
  972. damage -= damage_to_reduce;
  973. // if we reduce damage back below crit level then its no longer a crit, but we don't go below base damage
  974. if(type == DAMAGE_PACKET_TYPE_SIMPLE_CRIT_DMG && damage <= damage_before_crit) {
  975. damage = damage_before_crit;
  976. type = DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE;
  977. }
  978. }
  979. }
  980. bool useWards = false;
  981. if(damage <= 0){
  982. hit_result = DAMAGE_PACKET_RESULT_NO_DAMAGE;
  983. damage = 0;
  984. if(victim->IsNPC() && victim->GetHP() > 0)
  985. ((Entity*)victim)->AddHate(this, damage);
  986. }
  987. else{
  988. hit_result = DAMAGE_PACKET_RESULT_SUCCESSFUL;
  989. sint32 return_damage = 0;
  990. if(GetZone()->CallSpawnScript(victim, SPAWN_SCRIPT_HEALTHCHANGED, this, 0, false, damage, &return_damage) && return_damage != 0)
  991. {
  992. // anything not 0 (no return) becomes considered 'immune' to the damage
  993. if(return_damage < 0) {
  994. damage = 0;
  995. hit_result = DAMAGE_PACKET_RESULT_NO_DAMAGE;
  996. }
  997. else if(return_damage != 0) {
  998. // otherwise we use what was given back to us (either less or greater)
  999. damage = return_damage;
  1000. }
  1001. }
  1002. if(victim->IsNPC() && victim->GetHP() > 0)
  1003. ((Entity*)victim)->AddHate(this, damage);
  1004. if(damage) {
  1005. int32 prevDmg = damage;
  1006. damage = victim->CheckWards(this, damage, damage_type);
  1007. if (damage < (sint64)prevDmg)
  1008. useWards = true;
  1009. if(damage > 0 && spell) {
  1010. has_damaged = true;
  1011. spell->has_damaged = true;
  1012. }
  1013. if(take_power) {
  1014. sint32 curPower = victim->GetPower();
  1015. if(curPower < damage)
  1016. curPower = 0;
  1017. else
  1018. curPower -= damage;
  1019. victim->SetPower(curPower);
  1020. }
  1021. else {
  1022. victim->TakeDamage(damage);
  1023. }
  1024. victim->CheckProcs(PROC_TYPE_DAMAGED, this);
  1025. if (IsPlayer()) {
  1026. switch (damage_type) {
  1027. case DAMAGE_PACKET_DAMAGE_TYPE_SLASH:
  1028. case DAMAGE_PACKET_DAMAGE_TYPE_CRUSH:
  1029. case DAMAGE_PACKET_DAMAGE_TYPE_PIERCE:
  1030. if (((Player*)this)->GetPlayerStatisticValue(STAT_PLAYER_HIGHEST_MELEE_HIT) < damage)
  1031. ((Player*)this)->UpdatePlayerStatistic(STAT_PLAYER_HIGHEST_MELEE_HIT, damage, true);
  1032. victim->CheckProcs(PROC_TYPE_DAMAGED_MELEE, this);
  1033. break;
  1034. case DAMAGE_PACKET_DAMAGE_TYPE_HEAT:
  1035. case DAMAGE_PACKET_DAMAGE_TYPE_COLD:
  1036. case DAMAGE_PACKET_DAMAGE_TYPE_MAGIC:
  1037. case DAMAGE_PACKET_DAMAGE_TYPE_MENTAL:
  1038. case DAMAGE_PACKET_DAMAGE_TYPE_DIVINE:
  1039. case DAMAGE_PACKET_DAMAGE_TYPE_DISEASE:
  1040. case DAMAGE_PACKET_DAMAGE_TYPE_POISON:
  1041. if (((Player*)this)->GetPlayerStatisticValue(STAT_PLAYER_HIGHEST_MAGIC_HIT) < damage)
  1042. ((Player*)this)->UpdatePlayerStatistic(STAT_PLAYER_HIGHEST_MAGIC_HIT, damage, true);
  1043. victim->CheckProcs(PROC_TYPE_DAMAGED_MAGIC, this);
  1044. break;
  1045. }
  1046. }
  1047. }
  1048. }
  1049. Entity* attacker = nullptr;
  1050. if(!ignore_attacker)
  1051. attacker = this;
  1052. if (damage > 0) {
  1053. GetZone()->SendDamagePacket(attacker, victim, type, hit_result, damage_type, damage, spell_name);
  1054. if (IsStealthed() || IsInvis())
  1055. CancelAllStealth();
  1056. if (victim->IsEntity())
  1057. ((Entity*)victim)->CheckInterruptSpell(this);
  1058. }
  1059. else if (useWards)
  1060. {
  1061. GetZone()->SendDamagePacket(attacker, victim, DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE, DAMAGE_PACKET_RESULT_NO_DAMAGE, damage_type, 0, spell_name);
  1062. }
  1063. if (victim->GetHP() <= 0)
  1064. KillSpawn(victim, type, damage_type, blow_type);
  1065. else {
  1066. victim->CheckProcs(PROC_TYPE_DEFENSIVE, this);
  1067. if (spell_name)
  1068. victim->CheckProcs(PROC_TYPE_MAGICAL_DEFENSIVE, this);
  1069. else
  1070. victim->CheckProcs(PROC_TYPE_PHYSICAL_DEFENSIVE, this);
  1071. }
  1072. if(spell)
  1073. spell->crit = crit;
  1074. return has_damaged;
  1075. }
  1076. float Entity::CalculateMitigation(int8 type, int8 damage_type, int16 effective_level_attacker, bool for_pvp) {
  1077. int16 effective_level_victim = GetInfoStruct()->get_effective_level() != 0 ? GetInfoStruct()->get_effective_level() : GetLevel();
  1078. if(effective_level_attacker < 1 && effective_level_victim)
  1079. effective_level_attacker = effective_level_victim;
  1080. else
  1081. effective_level_attacker = 1;
  1082. int32 effective_mit_cap = effective_level_victim * rule_manager.GetGlobalRule(R_Combat, EffectiveMitigationCapLevel)->GetInt32();
  1083. float max_mit = (float)GetInfoStruct()->get_max_mitigation();
  1084. if(max_mit == 0.0f)
  1085. max_mit = effective_level_victim * 100.0f;
  1086. int32 mit_to_use = 0;
  1087. switch(type) {
  1088. case DAMAGE_PACKET_TYPE_SIMPLE_DAMAGE:
  1089. case DAMAGE_PACKET_TYPE_RANGE_DAMAGE:
  1090. mit_to_use = GetInfoStruct()->get_cur_mitigation();
  1091. break;
  1092. case DAMAGE_PACKET_TYPE_SIMPLE_CRIT_DMG:
  1093. // since critical mitigation is a percentage we will reverse the mit value so we can add skill from specific types of weapons
  1094. mit_to_use = (int32)((float)GetInfoStruct()->get_max_mitigation() * (float)(GetInfoStruct()->get_critical_mitigation()/100.0f));
  1095. break;
  1096. }
  1097. switch(damage_type) {
  1098. case DAMAGE_PACKET_DAMAGE_TYPE_SLASH:
  1099. mit_to_use += GetInfoStruct()->get_mitigation_skill1(); // slash
  1100. break;
  1101. case DAMAGE_PACKET_DAMAGE_TYPE_PIERCE:
  1102. mit_to_use += GetInfoStruct()->get_mitigation_skill2(); // pierce
  1103. break;
  1104. case DAMAGE_PACKET_DAMAGE_TYPE_CRUSH:
  1105. mit_to_use += GetInfoStruct()->get_mitigation_skill3(); // crush
  1106. break;
  1107. case DAMAGE_PACKET_DAMAGE_TYPE_FOCUS:
  1108. return 0.0f; // focus cannot be mitigated, just break out of this now
  1109. break;
  1110. default:
  1111. // do nothing
  1112. break;
  1113. }
  1114. if(for_pvp) {
  1115. mit_to_use += effective_level_victim * rule_manager.GetGlobalRule(R_Combat, MitigationLevelEffectivenessMax)->GetInt32();
  1116. }
  1117. if(mit_to_use > effective_mit_cap) {
  1118. mit_to_use = effective_mit_cap;
  1119. }
  1120. float level_diff = ((float)effective_level_victim / (float)effective_level_attacker);
  1121. if(level_diff > rule_manager.GetGlobalRule(R_Combat, MitigationLevelEffectivenessMax)->GetFloat()) {
  1122. level_diff = rule_manager.GetGlobalRule(R_Combat, MitigationLevelEffectivenessMax)->GetFloat();
  1123. }
  1124. else if(level_diff < rule_manager.GetGlobalRule(R_Combat, MitigationLevelEffectivenessMax)->GetFloat()) {
  1125. level_diff = rule_manager.GetGlobalRule(R_Combat, MitigationLevelEffectivenessMin)->GetFloat();
  1126. }
  1127. float mit_percentage = ((float)mit_to_use / max_mit) * level_diff;
  1128. if(!for_pvp && mit_percentage > rule_manager.GetGlobalRule(R_Combat, MaxMitigationAllowed)->GetFloat()) {
  1129. mit_percentage = rule_manager.GetGlobalRule(R_Combat, MaxMitigationAllowed)->GetFloat();
  1130. }
  1131. else if(for_pvp && mit_percentage > rule_manager.GetGlobalRule(R_Combat, MaxMitigationAllowedPVP)->GetFloat()) {
  1132. mit_percentage = rule_manager.GetGlobalRule(R_Combat, MaxMitigationAllowedPVP)->GetFloat();
  1133. }
  1134. return mit_percentage;
  1135. }
  1136. void Entity::AddHate(Entity* attacker, sint32 hate) {
  1137. if(!attacker || GetHP() <= 0 || attacker->GetHP() <= 0)
  1138. return;
  1139. // If a players pet and protect self is off
  1140. if (IsPet() && ((NPC*)this)->GetOwner() && ((NPC*)this)->GetOwner()->IsPlayer() && ((((Player*)((NPC*)this)->GetOwner())->GetInfoStruct()->get_pet_behavior() & 2) == 0))
  1141. return;
  1142. hate = attacker->CalculateHateAmount(this, hate);
  1143. if (IsNPC() && ((NPC*)this)->Brain()) {
  1144. LogWrite(COMBAT__DEBUG, 3, "Combat", "Add NPC_AI Hate: Victim '%s', Attacker '%s', Hate: %i", GetName(), attacker->GetName(), hate);
  1145. ((NPC*)this)->Brain()->AddHate(attacker, hate);
  1146. int8 loot_state = ((NPC*)this)->GetLockedNoLoot();
  1147. // if encounter size is 0 then add the attacker to the encounter
  1148. if ((loot_state != ENCOUNTER_STATE_AVAILABLE && loot_state != ENCOUNTER_STATE_BROKEN && ((NPC*)this)->Brain()->GetEncounterSize() == 0)) {
  1149. ((NPC*)this)->Brain()->AddToEncounter(attacker);
  1150. AddTargetToEncounter(attacker);
  1151. }
  1152. }
  1153. if (attacker->GetThreatTransfer() && hate > 0) {
  1154. Spawn* transfer_target = (Entity*)GetZone()->GetSpawnByID(attacker->GetThreatTransfer()->Target);
  1155. if (transfer_target && transfer_target->IsEntity()) {
  1156. sint32 transfered_hate = hate * (attacker->GetThreatTransfer()->Amount / 100);
  1157. hate -= transfered_hate;
  1158. this->AddHate((Entity*)transfer_target, transfered_hate);
  1159. }
  1160. }
  1161. // If pet is adding hate add some to the pets owner as well
  1162. if (attacker->IsNPC() && ((NPC*)attacker)->IsPet())
  1163. AddHate(((NPC*)attacker)->GetOwner(), 1);
  1164. // If player and player has a pet and protect master is set add hate to the pet
  1165. if (IsPlayer() && HasPet() && (((Player*)this)->GetInfoStruct()->get_pet_behavior() & 1)) {
  1166. // If we have a combat pet add hate to it
  1167. if (((Player*)this)->GetPet())
  1168. AddHate(((Player*)this)->GetPet(), 1);
  1169. if (((Player*)this)->GetCharmedPet())
  1170. AddHate(((Player*)this)->GetCharmedPet(), 1);
  1171. }
  1172. // If this spawn has a spawn group then add the attacker to the hate list of the other
  1173. // group members if not already in their list
  1174. if (HasSpawnGroup()) {
  1175. vector<Spawn*>* group = GetSpawnGroup();
  1176. vector<Spawn*>::iterator itr;
  1177. for (itr = group->begin(); itr != group->end(); itr++) {
  1178. if (!(*itr)->IsNPC())
  1179. continue;
  1180. NPC* spawn = (NPC*)(*itr);
  1181. if (spawn->Brain()->GetHate(attacker) == 0)
  1182. spawn->Brain()->AddHate(attacker, 1);
  1183. }
  1184. safe_delete(group);
  1185. }
  1186. }
  1187. bool Entity::CheckFizzleSpell(LuaSpell* spell) {
  1188. if(!spell || !rule_manager.GetGlobalRule(R_Spells, EnableFizzleSpells)->GetInt8()
  1189. || spell->spell->GetSpellData()->can_fizzle == false)
  1190. return false;
  1191. float fizzleMaxSkill = rule_manager.GetGlobalRule(R_Spells, FizzleMaxSkill)->GetFloat();
  1192. float baseFizzle = rule_manager.GetGlobalRule(R_Spells, DefaultFizzleChance)->GetFloat()/100.0f; // 10%
  1193. float skillObtained = rule_manager.GetGlobalRule(R_Spells, FizzleDefaultSkill)->GetFloat(); // default of .2f so we don't go over the threshold if no skill
  1194. Skill* skill = GetSkillByID(spell->spell->GetSpellData()->mastery_skill, false);
  1195. if(skill && spell->spell->GetSpellData()->min_class_skill_req > 0)
  1196. {
  1197. float skillObtained = skill->current_val / spell->spell->GetSpellData()->min_class_skill_req;
  1198. if(skillObtained > fizzleMaxSkill) // 120% over the skill value
  1199. {
  1200. skillObtained = fizzleMaxSkill;
  1201. }
  1202. baseFizzle = (fizzleMaxSkill - skillObtained) * baseFizzle;
  1203. float totalSuccessChance = 1.0f - baseFizzle;
  1204. float randResult = MakeRandomFloat(0.0f, 1.0f);
  1205. if(randResult > totalSuccessChance)
  1206. return true;
  1207. }
  1208. return false;
  1209. }
  1210. bool Entity::CheckInterruptSpell(Entity* attacker) {
  1211. if(!IsCasting())
  1212. return false;
  1213. Spell* spell = GetZone()->GetSpell(this);
  1214. if(!spell || spell->GetSpellData()->interruptable == 0)
  1215. return false;
  1216. if(GetInfoStruct()->get_no_interrupt())
  1217. return false;
  1218. //originally base of 30 percent chance to continue casting if attacked
  1219. //modified to 50% and added global rule, 30% was too small at starting levels
  1220. int8 percent = rule_manager.GetGlobalRule(R_Spells, NoInterruptBaseChance)->GetInt32();
  1221. float focus_skill_with_bonus = CalculateSkillWithBonus("Focus", ITEM_STAT_FOCUS, true);
  1222. percent += ((1 + focus_skill_with_bonus)/6);
  1223. if(MakeRandomInt(1, 100) > percent) {
  1224. LogWrite(COMBAT__DEBUG, 0, "Combat", "'%s' interrupted spell for '%s': %i%%", attacker->GetName(), GetName(), percent);
  1225. GetZone()->Interrupted(this, attacker, SPELL_ERROR_INTERRUPTED);
  1226. return true;
  1227. }
  1228. LogWrite(COMBAT__DEBUG, 0, "Combat", "'%s' failed to interrupt spell for '%s': %i%%", attacker->GetName(), GetName(), percent);
  1229. return false;
  1230. }
  1231. void Entity::KillSpawn(Spawn* dead, int8 type, int8 damage_type, int16 kill_blow_type) {
  1232. if(!dead)
  1233. return;
  1234. if (IsPlayer()) {
  1235. Client* client = ((Player*)this)->GetClient();
  1236. if(client) {
  1237. PacketStruct* packet = configReader.getStruct("WS_EnterCombat", client->GetVersion());
  1238. if (packet) {
  1239. client->QueuePacket(packet->serialize());
  1240. }
  1241. safe_delete(packet);
  1242. }
  1243. ((Player*)this)->InCombat(false);
  1244. }
  1245. if (IsPlayer() && dead->IsEntity())
  1246. GetZone()->GetSpellProcess()->KillHOBySpawnID(dead->GetID());
  1247. /* just for sake of not knowing if we are in a read lock, write lock, or no lock
  1248. ** say spawnlist is locked (DismissPet arg 3 true), which means RemoveSpawn will remove the id from the spawn_list outside of the potential lock
  1249. */
  1250. if (dead->IsPet() && ((NPC*)dead)->GetOwner())
  1251. ((NPC*)dead)->GetOwner()->DismissPet((NPC*)dead, true, true);
  1252. else if (dead->IsEntity()) {
  1253. // remove all pets for this entity
  1254. ((Entity*)dead)->DismissAllPets(false, true);
  1255. }
  1256. if (IsCasting())
  1257. GetZone()->Interrupted(this, dead, SPELL_ERROR_NOT_ALIVE);
  1258. LogWrite(COMBAT__DEBUG, 3, "Combat", "Killing '%s'", dead->GetName());
  1259. // Kill movement for the dead npc so the corpse doesn't move
  1260. GetZone()->movementMgr->StopNavigation((Entity*)dead);
  1261. dead->ClearRunningLocations();
  1262. dead->CalculateRunningLocation(true);
  1263. GetZone()->KillSpawn(true, dead, this, true, type, damage_type, kill_blow_type);
  1264. }
  1265. void Entity::HandleDeathExperienceDebt(Spawn* killer)
  1266. {
  1267. if(!IsPlayer())
  1268. return;
  1269. float ruleDebt = 0.0f;
  1270. if(killer && killer->IsPlayer())
  1271. ruleDebt = rule_manager.GetGlobalRule(R_Combat, PVPDeathExperienceDebt)->GetFloat()/100.0f;
  1272. else
  1273. ruleDebt = rule_manager.GetGlobalRule(R_Combat, DeathExperienceDebt)->GetFloat()/100.0f;
  1274. if(ruleDebt > 0.0f)
  1275. {
  1276. bool groupDebt = rule_manager.GetGlobalRule(R_Combat, GroupExperienceDebt)->GetBool();
  1277. if(groupDebt && ((Player*)this)->GetGroupMemberInfo())
  1278. {
  1279. world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__);
  1280. PlayerGroup* group = world.GetGroupManager()->GetGroup(((Player*)this)->GetGroupMemberInfo()->group_id);
  1281. if (group)
  1282. {
  1283. group->MGroupMembers.readlock(__FUNCTION__, __LINE__);
  1284. deque<GroupMemberInfo*>* members = group->GetMembers();
  1285. int32 size = members->size();
  1286. float xpDebtPerMember = ruleDebt/(float)size;
  1287. deque<GroupMemberInfo*>::iterator itr;
  1288. for (itr = members->begin(); itr != members->end(); itr++) {
  1289. GroupMemberInfo* gmi = *itr;
  1290. if (gmi->client && gmi->client->GetPlayer()) {
  1291. gmi->client->GetPlayer()->GetInfoStruct()->set_xp_debt(gmi->client->GetPlayer()->GetInfoStruct()->get_xp_debt()+xpDebtPerMember);
  1292. gmi->client->GetPlayer()->SetCharSheetChanged(true);
  1293. }
  1294. }
  1295. group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__);
  1296. }
  1297. world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__);
  1298. }
  1299. else
  1300. {
  1301. ((Player*)this)->GetInfoStruct()->set_xp_debt(((Player*)this)->GetInfoStruct()->get_xp_debt()+ruleDebt);
  1302. ((Player*)this)->SetCharSheetChanged(true);
  1303. }
  1304. }
  1305. }
  1306. void Entity::ProcessCombat() {
  1307. // This is a virtual function so when a NPC calls this it will use the NPC::ProcessCombat() version
  1308. // and a player will use the Player::ProcessCombat() version, leave this function blank.
  1309. }
  1310. void NPC::ProcessCombat() {
  1311. MBrain.writelock(__FUNCTION__, __LINE__);
  1312. // Check to see if it is time to call the AI again
  1313. if (m_brain && GetHP() > 0 && Timer::GetCurrentTime2() >= (m_brain->LastTick() + m_brain->Tick())) {
  1314. // Probably never want to use the following log, will spam the console for every NPC in a zone 4 times a second
  1315. //LogWrite(NPC_AI__DEBUG, 9, "NPC_AI", "%s is thinking...", GetName());
  1316. m_brain->Think();
  1317. // Set the time for when the brain was last called
  1318. m_brain->SetLastTick(Timer::GetCurrentTime2());
  1319. }
  1320. MBrain.releasewritelock(__FUNCTION__, __LINE__);
  1321. }
  1322. void Player::ProcessCombat() {
  1323. // if not in combat OR casting a spell OR dazed OR feared return out
  1324. if (!EngagedInCombat() || IsCasting() || IsDazed() || IsFeared())
  1325. return;
  1326. //If no target delete combat_target and return out
  1327. Spawn* Target = GetZone()->GetSpawnByID(target);
  1328. if (!Target) {
  1329. combat_target = 0;
  1330. if (target > 0) {
  1331. SetTarget(0);
  1332. }
  1333. return;
  1334. }
  1335. // If is not an entity return out
  1336. if (!Target->IsEntity())
  1337. return;
  1338. // Reset combat target
  1339. combat_target = 0;
  1340. if (Target->HasTarget()) {
  1341. if (Target->IsPlayer() || (Target->IsNPC() && Target->IsPet() && ((NPC*)Target)->GetOwner() && ((NPC*)Target)->GetOwner()->IsPlayer())){
  1342. Spawn* secondary_target = Target->GetTarget();
  1343. if (secondary_target->IsNPC() && secondary_target->appearance.attackable) {
  1344. if (!secondary_target->IsPet() || (secondary_target->IsPet() && ((NPC*)secondary_target)->GetOwner() && ((NPC*)secondary_target)->GetOwner()->IsNPC())) {
  1345. combat_target = secondary_target;
  1346. }
  1347. }
  1348. }
  1349. }
  1350. // If combat_target wasn't set in the above if set it to the original target
  1351. if (!combat_target)
  1352. combat_target = Target;
  1353. // this if may not be required as at the min combat_target will be Target, which we already check at the begining
  1354. if(!combat_target)
  1355. return;
  1356. float distance = 0;
  1357. distance = GetDistance(combat_target);
  1358. // Check to see if we are doing ranged auto attacks if not check to see if we are in melee range
  1359. if (GetRangeAttack()) {
  1360. // We are doing ranged auto attacks
  1361. //check to see if we can attack the target AND the ranged weapon is ready
  1362. if(AttackAllowed((Entity*)combat_target, distance, true) && RangeWeaponReady()) {
  1363. Item* weapon = 0;
  1364. Item* ammo = 0;
  1365. // Get the currently equiped weapon and ammo for the ranged attack
  1366. weapon = GetEquipmentList()->GetItem(EQ2_RANGE_SLOT);
  1367. ammo = GetAmmoFromSlot(true, true);
  1368. LogWrite(COMBAT__DEBUG, 1, "Combat", "Weapon '%s', Ammo '%s'", ( weapon )? weapon->name.c_str() : "None", ( ammo ) ? ammo->name.c_str() : "None");
  1369. // If weapon and ammo are both valid perform the ranged attack else send a message to the client
  1370. if(weapon && ammo) {
  1371. LogWrite(COMBAT__DEBUG, 1, "Combat", "Weapon: Primary, Fighter: '%s', Target: '%s', Distance: %.2f", GetName(), combat_target->GetName(), distance);
  1372. RangeAttack(combat_target, distance, weapon, ammo);
  1373. }
  1374. else {
  1375. Client* client = ((Player*)this)->GetClient();
  1376. if (client) {
  1377. // Need to get messages from live, made these up so the player knows what is wrong in game if weapon or ammo are not valid
  1378. if (!ammo)
  1379. client->SimpleMessage(CHANNEL_COLOR_YELLOW, "Out of ammo.");
  1380. if (!weapon)
  1381. client->SimpleMessage(CHANNEL_COLOR_YELLOW, "No ranged weapon found.");
  1382. }
  1383. }
  1384. }
  1385. }
  1386. else if(distance <= rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat()) {
  1387. // We are doing melee auto attacks and are within range
  1388. // Check to see if we can attack the target
  1389. if(AttackAllowed((Entity*)combat_target)) {
  1390. // Check to see if the primary melee weapon is ready
  1391. if(PrimaryWeaponReady()) {
  1392. // Set the time of the last melee attack with the primary weapon and perform the melee attack with primary weapon
  1393. SetPrimaryLastAttackTime(Timer::GetCurrentTime2());
  1394. MeleeAttack(combat_target, distance, true);
  1395. }
  1396. // Check to see if the secondary weapon is ready
  1397. if(SecondaryWeaponReady()) {
  1398. // set the time of the last melee attack with the secondary weapon and perform the melee attack with the secondary weapon
  1399. SetSecondaryLastAttackTime(Timer::GetCurrentTime2());
  1400. MeleeAttack(combat_target, distance, false);
  1401. }
  1402. }
  1403. }
  1404. }
  1405. void Entity::SetAttackDelay(bool primary, bool ranged) {
  1406. float mod = CalculateAttackSpeedMod();
  1407. bool dual_wield = IsDualWield();
  1408. //Note: Capping all attack speed increases at 125% normal speed (from function CalculateAttackSpeedMod())
  1409. //Add 33% longer delay if dual wielding
  1410. if(dual_wield && ! ranged) {
  1411. if(primary)
  1412. SetPrimaryAttackDelay((GetPrimaryWeaponDelay() * 1.33) / mod);
  1413. else
  1414. SetSecondaryAttackDelay((GetSecondaryWeaponDelay() * 1.33) / mod);
  1415. }
  1416. else {
  1417. if(primary)
  1418. SetPrimaryAttackDelay(GetPrimaryWeaponDelay() / mod);
  1419. else if(ranged)
  1420. SetRangeAttackDelay(GetRangeWeaponDelay() / mod);
  1421. else
  1422. SetSecondaryAttackDelay(GetSecondaryWeaponDelay() / mod);
  1423. }
  1424. }
  1425. float Entity::CalculateAttackSpeedMod(){
  1426. float aspeed = info_struct.get_attackspeed();
  1427. if(aspeed > 0) {
  1428. if (aspeed <= 100)
  1429. return (aspeed / 100 + 1);
  1430. else if (aspeed <= 200)
  1431. return 2.25;
  1432. }
  1433. return 1;
  1434. }
  1435. void Entity::AddProc(int8 type, float chance, Item* item, LuaSpell* spell, int8 damage_type, int8 hp_ratio, bool below_health, bool target_health, bool extended_version) {
  1436. if (type == 0) {
  1437. LogWrite(COMBAT__ERROR, 0, "Proc", "Entity::AddProc called with an invalid type.");
  1438. return;
  1439. }
  1440. if (!item && !spell) {
  1441. LogWrite(COMBAT__ERROR, 0, "Proc", "Entity::AddProc must have a valid item or spell.");
  1442. return;
  1443. }
  1444. MProcList.writelock(__FUNCTION__, __LINE__);
  1445. Proc* proc = new Proc();
  1446. proc->chance = chance;
  1447. proc->item = item;
  1448. proc->spell = spell;
  1449. if(spell) {
  1450. spell->has_proc = true;
  1451. }
  1452. if(spell && spell->spell) {
  1453. proc->spellid = spell->spell->GetSpellID();
  1454. }
  1455. proc->health_ratio = hp_ratio;
  1456. proc->below_health = below_health;
  1457. proc->damage_type = damage_type;
  1458. proc->target_health = target_health;
  1459. proc->extended_version = extended_version;
  1460. m_procList[type].push_back(proc);
  1461. MProcList.releasewritelock(__FUNCTION__, __LINE__);
  1462. }
  1463. void Entity::RemoveProc(Item* item, LuaSpell* spell) {
  1464. if (!item && !spell) {
  1465. LogWrite(COMBAT__ERROR, 0, "Proc", "Entity::RemoveProc must have a valid item or spell.");
  1466. return;
  1467. }
  1468. MProcList.writelock(__FUNCTION__, __LINE__);
  1469. map<int8, vector<Proc*> >::iterator proc_itr;
  1470. vector<Proc*>::iterator itr;
  1471. for (proc_itr = m_procList.begin(); proc_itr != m_procList.end(); proc_itr++) {
  1472. itr = proc_itr->second.begin();
  1473. while (itr != proc_itr->second.end()) {
  1474. Proc* proc = *itr;
  1475. if ((item && proc->item == item) || (spell && proc->spell == spell)) {
  1476. itr = proc_itr->second.erase(itr);
  1477. safe_delete(proc);
  1478. }
  1479. else
  1480. itr++;
  1481. }
  1482. }
  1483. MProcList.releasewritelock(__FUNCTION__, __LINE__);
  1484. }
  1485. bool Entity::CastProc(Proc* proc, int8 type, Spawn* target) {
  1486. lua_State* state = 0;
  1487. bool item_proc = false;
  1488. int8 num_args = 3;
  1489. Mutex* mutex = 0;
  1490. if (proc->spell) {
  1491. state = proc->spell->state;
  1492. }
  1493. else if (proc->item) {
  1494. state = lua_interface->GetItemScript(proc->item->GetItemScript(), true, true);
  1495. item_proc = true;
  1496. }
  1497. if (!state) {
  1498. LogWrite(COMBAT__ERROR, 0, "Proc", "No valid lua_State* found");
  1499. return false;
  1500. }
  1501. if(item_proc) {
  1502. mutex = lua_interface->GetItemScriptMutex(proc->item->GetItemScript());
  1503. }
  1504. if(mutex)
  1505. mutex->readlock(__FUNCTION__, __LINE__);
  1506. if(proc->extended_version) {
  1507. lua_getglobal(state, "proc_ext");
  1508. }
  1509. else {
  1510. lua_getglobal(state, "proc");
  1511. }
  1512. if (lua_isfunction(state, lua_gettop(state))) {
  1513. if (item_proc) {
  1514. num_args++;
  1515. lua_interface->SetItemValue(state, proc->item);
  1516. }
  1517. lua_interface->SetSpawnValue(state, this);
  1518. lua_interface->SetSpawnValue(state, target);
  1519. lua_interface->SetInt32Value(state, type);
  1520. if(proc->extended_version) {
  1521. lua_interface->SetInt32Value(state, proc->damage_type);
  1522. }
  1523. /*
  1524. Add spell data from db in case of a spell proc here...
  1525. */
  1526. if (!item_proc) {
  1527. // Append spell data to the param list
  1528. vector<LUAData*>* data = proc->spell->spell->GetLUAData();
  1529. for(int32 i = 0; i < data->size(); i++) {
  1530. switch(data->at(i)->type) {
  1531. case 0:{
  1532. lua_interface->SetSInt32Value(proc->spell->state, data->at(i)->int_value);
  1533. break;
  1534. }
  1535. case 1:{
  1536. lua_interface->SetFloatValue(proc->spell->state, data->at(i)->float_value);
  1537. break;
  1538. }
  1539. case 2:{
  1540. lua_interface->SetBooleanValue(proc->spell->state, data->at(i)->bool_value);
  1541. break;
  1542. }
  1543. case 3:{
  1544. lua_interface->SetStringValue(proc->spell->state, data->at(i)->string_value.c_str());
  1545. break;
  1546. }
  1547. default:{
  1548. LogWrite(SPELL__ERROR, 0, "Spell", "Error: Unknown LUA Type '%i' in Entity::CastProc for Spell '%s'", (int)data->at(i)->type, proc->spell->spell->GetName());
  1549. return false;
  1550. }
  1551. }
  1552. num_args++;
  1553. }
  1554. }
  1555. if (lua_pcall(state, num_args, 0, 0) != 0) {
  1556. LogWrite(COMBAT__ERROR, 0, "Proc", "Unable to call the proc function for spell %i tier %i", proc->spell->spell->GetSpellID(), proc->spell->spell->GetSpellTier());
  1557. lua_pop(state, 1);
  1558. if(mutex)
  1559. mutex->releasereadlock(__FUNCTION__, __LINE__);
  1560. if(item_proc)
  1561. lua_interface->UseItemScript(proc->item->GetItemScript(), state, false);
  1562. return false;
  1563. }
  1564. }
  1565. lua_interface->ResetFunctionStack(state);
  1566. if(mutex)
  1567. mutex->releasereadlock(__FUNCTION__);
  1568. if(item_proc)
  1569. lua_interface->UseItemScript(proc->item->GetItemScript(), state, false);
  1570. return true;
  1571. }
  1572. void Entity::CheckProcs(int8 type, Spawn* target) {
  1573. if (type == 0) {
  1574. LogWrite(COMBAT__ERROR, 0, "Proc", "Entity::CheckProcs called with an invalid type.");
  1575. return;
  1576. }
  1577. vector<Proc*> tmpList;
  1578. MProcList.readlock(__FUNCTION__, __LINE__);
  1579. for (int8 i = 0; i < m_procList[type].size(); i++) {
  1580. // roll per proc, not overall
  1581. float roll = MakeRandomFloat(0, 100);
  1582. Proc* proc = m_procList[type].at(i);
  1583. if (roll <= proc->chance &&
  1584. ((!proc->extended_version || proc->health_ratio == 0) ||
  1585. (proc->below_health && !proc->target_health && proc->health_ratio < (int8)GetIntHPRatio()) ||
  1586. (!proc->below_health && !proc->target_health && proc->health_ratio >= (int8)GetIntHPRatio()) ||
  1587. (target && proc->below_health && proc->target_health && proc->health_ratio < (int8)target->GetIntHPRatio()) ||
  1588. (target && !proc->below_health && proc->target_health && proc->health_ratio >= (int8)target->GetIntHPRatio()))
  1589. )
  1590. {
  1591. Proc* tmpProc = new Proc();
  1592. tmpProc->chance = proc->chance;
  1593. tmpProc->item = proc->item;
  1594. tmpProc->spell = proc->spell;
  1595. tmpProc->spellid = proc->spellid;
  1596. tmpProc->damage_type = proc->damage_type;
  1597. tmpProc->health_ratio = proc->health_ratio;
  1598. tmpProc->below_health = proc->below_health;
  1599. tmpProc->target_health = proc->target_health;
  1600. tmpProc->extended_version = proc->extended_version;
  1601. tmpList.push_back(tmpProc);
  1602. }
  1603. }
  1604. MProcList.releasereadlock(__FUNCTION__, __LINE__);
  1605. vector<Proc*>::iterator proc_itr;
  1606. for (proc_itr = tmpList.begin(); proc_itr != tmpList.end();) {
  1607. Proc* tmpProc = *proc_itr;
  1608. CastProc(tmpProc, type, target);
  1609. proc_itr++;
  1610. safe_delete(tmpProc);
  1611. }
  1612. }
  1613. void Entity::ClearProcs() {
  1614. MProcList.writelock(__FUNCTION__, __LINE__);
  1615. map<int8, vector<Proc*> >::iterator proc_itr;
  1616. vector<Proc*>::iterator itr;
  1617. for (proc_itr = m_procList.begin(); proc_itr != m_procList.end(); proc_itr++) {
  1618. itr = proc_itr->second.begin();
  1619. while (itr != proc_itr->second.end()) {
  1620. safe_delete(*itr);
  1621. itr = proc_itr->second.erase(itr);
  1622. }
  1623. proc_itr->second.clear();
  1624. }
  1625. m_procList.clear();
  1626. MProcList.releasewritelock(__FUNCTION__, __LINE__);
  1627. }
  1628. sint32 Entity::CalculateHateAmount(Spawn* target, sint32 amt) {
  1629. amt = CalculateFormulaByStat(amt, ITEM_STAT_TAUNT_AMOUNT);
  1630. amt = CalculateFormulaByStat(amt, ITEM_STAT_TAUNT_AND_COMBAT_ART_DAMAGE);
  1631. amt = CalculateFormulaByStat(amt, ITEM_STAT_ABILITY_MODIFIER);
  1632. return amt;
  1633. }
  1634. sint32 Entity::CalculateHealAmount(Spawn* target, sint32 amt, int8 crit_mod, bool* crit, bool skip_crit_mod) {
  1635. amt = CalculateFormulaByStat(amt, ITEM_STAT_HEAL_AMOUNT);
  1636. amt = CalculateFormulaByStat(amt, ITEM_STAT_SPELL_AND_HEAL);
  1637. //Potency Mod
  1638. amt = CalculateFormulaByStat(amt, ITEM_STAT_POTENCY);
  1639. //Ability Mod
  1640. amt += (int32)min((int32)GetInfoStruct()->get_ability_modifier(), (int32)(amt / 2));
  1641. if(!skip_crit_mod){
  1642. if(!crit_mod || crit_mod == 1){
  1643. if(crit_mod == 1)
  1644. *crit = true;
  1645. else if(!*crit) {
  1646. // Crit Roll
  1647. float chance = (float)max((float)0, (float)GetInfoStruct()->get_crit_chance());
  1648. *crit = (MakeRandomFloat(0, 100) <= chance);
  1649. }
  1650. if(*crit){
  1651. //Apply total crit multiplier with crit bonus
  1652. amt *= ((GetInfoStruct()->get_crit_bonus() / 100) + 1.3);
  1653. }
  1654. }
  1655. }
  1656. return amt;
  1657. }
  1658. sint32 Entity::CalculateDamageAmount(Spawn* target, sint32 damage, int8 base_type, int8 damage_type, LuaSpell* spell) {
  1659. return CalculateDamageAmount(target, damage, base_type, damage_type, (spell && spell->spell) ? spell->spell->GetSpellData()->target_type : 0);
  1660. }
  1661. sint32 Entity::CalculateDamageAmount(Spawn* target, sint32 damage, int8 base_type, int8 damage_type, int8 target_type) {
  1662. if(damage_type == DAMAGE_PACKET_DAMAGE_TYPE_FOCUS) {
  1663. return damage; // cannot avoid focus damage
  1664. }
  1665. // only spells may add spell damage item stat
  1666. if(damage_type >= DAMAGE_PACKET_DAMAGE_TYPE_HEAT && damage_type <= DAMAGE_PACKET_DAMAGE_TYPE_POISON)
  1667. {
  1668. // https://forums.daybreakgames.com/eq2/index.php?threads/potency-and-ability-mod-what.4316/
  1669. // Spell damage model assuming 100% crit chance:
  1670. // (Spell base damage * Base damage modifier * Int bonus * Skill bonus * Potency + Ability modifier) * Crit bonus * Spell double attack
  1671. /** Spell base damage: Get all master spells
  1672. Base damage modifier: Very very rare. Available from Wizard aa Wisdom line(Brainstorm). Get it, cherish it.
  1673. Int bonus: Past 1200 or so int, you will get a 10% increase in spell damage per 30% increase in int. Look at int tooltip to see the numerical value.
  1674. Skill bonus: Past skill cap, 100 points skill is worth 2% increase in minimum spell damage, which translates to 1% overall increase. Looks at the skill that the spell uses, for wizards mostly disruption. Cap is 6.5*level.
  1675. Potency: A straight damage modifier, the more you can get the better. No practical cap.
  1676. Ability modifier: A straight damage modifier. Limited to 50% of the spell base damage, but for a wizard this usually has little consequence. However note that this is not affected by Potency.
  1677. Crit bonus: A straight damage modifier, the more you can get the better. No practical cap. Wizards got 50% intrinsic Crit Bonus that does not show up in the stat window, just add 50 to stat value for calculations.
  1678. Spell double cast: A straight damage modifier, the more you can get the better. You won't be able to get very much of this.
  1679. Makes the spell cast twice with some limitations.
  1680. **/
  1681. damage = damage + damage * CalculateLevelStatBonus(GetInt()); // lvl 70 * 1200 int = 84000, log10f(84000) = 4.924 / 50.0f = 0.09848
  1682. damage = CalculateFormulaByStat(damage, ITEM_STAT_SPELL_DAMAGE);
  1683. }
  1684. if(base_type == DAMAGE_PACKET_TYPE_SPELL_DAMAGE) {
  1685. damage = CalculateFormulaByStat(damage, ITEM_STAT_SPELL_AND_COMBAT_ART_DAMAGE);
  1686. if(target && target->IsEntity() && damage > 0) {
  1687. int16 effective_level_attacker = GetInfoStruct()->get_effective_level() != 0 ? GetInfoStruct()->get_effective_level() : GetLevel();
  1688. float resistBase = ((Entity*)target)->GetDamageTypeResistPercentage(damage_type);
  1689. if(resistBase > 1.0f) {
  1690. float dmgReduction = ((Entity*)target)->CalculateSpellDamageReduction((float)damage, resistBase - 1.0f, effective_level_attacker);
  1691. float newDamage = static_cast<float>(damage) - dmgReduction;
  1692. if(newDamage < 0.0f)
  1693. newDamage = 0.0f;
  1694. damage = static_cast<sint32>(std::floor(newDamage));
  1695. }
  1696. }
  1697. }
  1698. // combat abilities only bonus
  1699. if(damage_type <= DAMAGE_PACKET_DAMAGE_TYPE_PIERCE) {
  1700. damage = CalculateFormulaByStat(damage, ITEM_STAT_TAUNT_AND_COMBAT_ART_DAMAGE);
  1701. }
  1702. // Potency mod
  1703. damage = CalculateFormulaByStat(damage, ITEM_STAT_POTENCY);
  1704. int32 modifier = 2;
  1705. if(target_type == SPELL_TARGET_GROUP_AE || target_type == SPELL_TARGET_RAID_AE || target_type == SPELL_TARGET_OTHER_GROUP_AE)
  1706. {
  1707. modifier = 3;
  1708. }
  1709. // Ability mod can only give up to half of damage after potency
  1710. int32 mod = (int32)min(info_struct.get_ability_modifier(), (float)(damage / modifier));
  1711. damage += mod;
  1712. return damage;
  1713. }
  1714. sint32 Entity::CalculateFormulaByStat(sint32 value, int16 stat) {
  1715. sint32 outValue = value;
  1716. MStats.lock();
  1717. std::map<int16, float>::iterator itr = stats.find(stat);
  1718. if(itr != stats.end())
  1719. outValue = (sint32)((float)value * ((itr->second / 100.0f) + 1.0f));
  1720. MStats.unlock();
  1721. return outValue;
  1722. }
  1723. int32 Entity::CalculateFormulaByStat(int32 value, int16 stat) {
  1724. int32 outValue = value;
  1725. MStats.lock();
  1726. std::map<int16, float>::iterator itr = stats.find(stat);
  1727. if(itr != stats.end())
  1728. outValue = (int32)((float)value * ((itr->second / 100.0f) + 1.0f));
  1729. MStats.unlock();
  1730. return outValue;
  1731. }
  1732. int32 Entity::CalculateFormulaBonus(int32 value, float percent_bonus) {
  1733. return (int32)((float)value * ((percent_bonus / 100.0f) + 1.0f));
  1734. }
  1735. float Entity::CalculateSpellDamageReduction(float spellDamage, float resistancePercentage, int16 attackerLevel) {
  1736. int16 effective_level = GetInfoStruct()->get_effective_level() != 0 ? GetInfoStruct()->get_effective_level() : GetLevel();
  1737. float levelDifference = std::abs(effective_level - attackerLevel);
  1738. float logFactor = 1.0f / (1.0f + 0.1f * levelDifference); // Adjust the factor for smoother reduction
  1739. // Calculate the actual damage reduction based on resistance percentage, logarithmic factor, and maximum reduction
  1740. float reducedDamage = spellDamage * (1.0f - resistancePercentage) * logFactor * GetInfoStruct()->get_max_spell_reduction();
  1741. return reducedDamage;
  1742. }