mirror of
https://github.com/EQEmu/Server.git
synced 2025-12-13 14:41:28 +00:00
804 lines
22 KiB
C++
804 lines
22 KiB
C++
#include "../common/rulesys.h"
|
|
#include "../common/global_define.h"
|
|
#include "../common/eqemu_logsys.h"
|
|
|
|
#include "mob.h"
|
|
#include "elixir.h"
|
|
#include "zone.h"
|
|
#include "groups.h"
|
|
|
|
extern Zone* zone;
|
|
|
|
// ElixirCastSpell determines if a spell can be casted by Mob.
|
|
// If 0 is returned, spell is valid and no target changing is required
|
|
// If a negative value is returned, an error occured. See elixir.h ELIXIR_ prefix const error lookup of reasons
|
|
// If 1 is returned, outMob is set to the suggested mob entity
|
|
int8 Mob::ElixirCastSpellCheck(uint16 spellID, Mob *outMob)
|
|
{
|
|
int manaCurrent = GetMana();
|
|
int manaMax = GetMaxMana();
|
|
int hpCurrent = GetHP();
|
|
int hpMax = GetMaxHP();
|
|
int endCurrent = GetEndurance();
|
|
int endMax = GetMaxEndurance();
|
|
|
|
int healPercent = 90;
|
|
if (IsMerc()) healPercent = RuleI(Mercs, MercsElixirHealPercent);
|
|
#ifdef BOTS
|
|
if (IsBot()) healPercent = RuleI(Bots, BotsElixirHealPercent);
|
|
#endif
|
|
if (healPercent < 1) healPercent = 1;
|
|
if (healPercent > 99) healPercent = 99;
|
|
|
|
int aeMinimum = 3;
|
|
if (IsMerc()) aeMinimum = RuleI(Mercs, MercsElixirAEMinimum);
|
|
#ifdef BOTS
|
|
if (IsBot()) aeMinimum = RuleI(Bots, BotsElixirAEMinimum);
|
|
#endif
|
|
if (aeMinimum < 1) aeMinimum = 1;
|
|
if (aeMinimum > 99) aeMinimum = 99;
|
|
|
|
if (IsCorpse()) return ELIXIR_CANNOT_CAST_BAD_STATE;
|
|
|
|
bool isHeal = false;
|
|
bool isDebuff = false;
|
|
bool isBuff = false;
|
|
bool isLifetap = false;
|
|
bool isMana = false;
|
|
bool isCharm = false;
|
|
bool isSnare = false;
|
|
bool isSow = false;
|
|
bool isTaunt = false;
|
|
bool isSingleTargetSpell = false;
|
|
bool isPetSummon = false;
|
|
bool isTransport = false;
|
|
bool isGroupSpell = false;
|
|
bool isBardSong = false;
|
|
bool isMez = false;
|
|
bool isLull = false;
|
|
long stunDuration = 0;
|
|
long damageAmount = 0;
|
|
long healAmount = 0;
|
|
|
|
int skillID;
|
|
|
|
bodyType targetBodyType = BT_NoTarget2;
|
|
|
|
const SPDat_Spell_Struct &spDat = spells[spellID];
|
|
|
|
int spellgroup = spDat.type_description_id;
|
|
uint32 ticks = spDat.buff_duration;
|
|
int targets = spDat.aoe_max_targets;
|
|
SpellTargetType targettype = spDat.target_type;
|
|
EQ::skills::SkillType skill = spDat.skill;
|
|
uint16 recourseID = spDat.recourse_link;
|
|
int category = spDat.spell_category;
|
|
int subcategory = spDat.effect_description_id;
|
|
|
|
uint32 buffCount;
|
|
Group *grp = GetGroup();
|
|
Raid *raid = GetRaid();
|
|
|
|
for (int i = 0; i < EFFECT_COUNT; i++) {
|
|
if (IsBlankSpellEffect(spellID, i)) continue;
|
|
|
|
int attr = spDat.effect_id[i];
|
|
int base = spDat.base_value[i];
|
|
int base2 = spDat.limit_value[i];
|
|
int max = spDat.max_value[i];
|
|
int calc = spDat.formula[i];
|
|
|
|
if (attr == SE_CurrentHP) { //0
|
|
if (max > 0) { //Heal / HoT
|
|
if (ticks < 5 && base > 0) { //regen
|
|
isHeal = true;
|
|
healAmount = base;
|
|
}
|
|
if (ticks > 0) {
|
|
isBuff = true;
|
|
}
|
|
if (category == 114) { //taps like touch of zlandicar
|
|
isLifetap = true;
|
|
}
|
|
}
|
|
if (base < 0 && damageAmount == 0) {
|
|
damageAmount = -base;
|
|
}
|
|
if (max < 0) { //Nuke / DoT
|
|
damageAmount = -max;
|
|
}
|
|
}
|
|
|
|
if (attr == SE_ArmorClass || // 1 ac
|
|
attr == SE_ATK || //2 attack
|
|
attr == SE_STR || //4 str
|
|
attr == SE_DEX || //5 dex
|
|
attr == SE_AGI || //6 agi
|
|
attr == SE_STA || //7 sta
|
|
attr == SE_INT || //8 int
|
|
attr == SE_WIS //9 wis
|
|
) {
|
|
if (base > 0) { //+stat
|
|
isBuff = true;
|
|
}
|
|
if (base < 0) { //-stat
|
|
isDebuff = true;
|
|
}
|
|
}
|
|
|
|
if (attr == SE_MovementSpeed) { //3
|
|
if (base > 0) { //+Movement
|
|
isBuff = true;
|
|
isSow = true;
|
|
}
|
|
if (base < 0) { //-Movement
|
|
isDebuff = true;
|
|
isSnare = true;
|
|
}
|
|
}
|
|
|
|
if (attr == SE_CHA) { //10 CHA
|
|
if (base > 0 && base < 254) { //+CHA
|
|
isBuff = true;
|
|
}
|
|
if (base < 0) { //-CHA
|
|
isDebuff = true;
|
|
}
|
|
}
|
|
|
|
if (attr == SE_AttackSpeed) { //11 attackspeed
|
|
if (base > 0) { //+Haste
|
|
isBuff = true;
|
|
}
|
|
if (base < 0) { //-Haste
|
|
isDebuff = true;
|
|
}
|
|
}
|
|
|
|
if (attr == SE_CurrentMana) { //15 Mana
|
|
isMana = true;
|
|
}
|
|
if (attr == SE_Lull) { // pacify (lull)
|
|
isLull = true;
|
|
}
|
|
if (attr == SE_Stun) { //21 stun
|
|
stunDuration = base2;
|
|
if (targettype == ST_AEClientV1 || targettype == ST_AECaster) { // 2 or
|
|
isSingleTargetSpell = true; //hack to make ae stuns work
|
|
}
|
|
}
|
|
if (attr == SE_Charm) { //23 charm
|
|
isCharm = true;
|
|
}
|
|
|
|
if (attr == SE_Gate) { //26 Gate
|
|
isTransport = true;
|
|
}
|
|
|
|
if (attr == SE_ChangeFrenzyRad) { //30 frenzy radius reduction (lull)
|
|
isLull = true;
|
|
}
|
|
|
|
if (attr == SE_Mez) { //31 Mesmerization
|
|
isMez = true;
|
|
}
|
|
|
|
if (attr == SE_SummonPet) { //33 Summon Elemental Pet
|
|
isPetSummon = true;
|
|
}
|
|
|
|
if (attr == SE_NecPet) { //71 Summon Skeleton Pet
|
|
isPetSummon = true;
|
|
}
|
|
|
|
if (attr == SE_Teleport) { //83 Transport
|
|
isTransport = true;
|
|
}
|
|
|
|
if (attr == SE_Harmony) { //86 reaction radius reduction (lull)
|
|
isLull = true;
|
|
}
|
|
if (attr == SE_Succor) { //88 Evac
|
|
isTransport = true;
|
|
}
|
|
|
|
if (attr == SE_Familiar) { //108 Summon Familiar
|
|
isPetSummon = true;
|
|
}
|
|
|
|
if (attr == SE_Hate) { //192 taunt
|
|
isTaunt = true;
|
|
}
|
|
|
|
if (attr == SE_SkillAttack) { //193 skill attack
|
|
skillID = spDat.skill;
|
|
}
|
|
}
|
|
|
|
if (subcategory == 43 && ticks < 10) { //Health
|
|
isHeal = true;
|
|
}
|
|
|
|
if (category == 126) { //Taps
|
|
if (subcategory == 43) { //Health
|
|
isLifetap = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
//TODO TargetTypes:
|
|
case 40: return "AE PC v2";
|
|
case 25: return "AE Summoned";
|
|
case 24: return "AE Undead";
|
|
case 20: return "Targetted AE Tap";
|
|
case 8: return "Targetted AE";
|
|
case 2: return "AE PC v1";
|
|
case 1: return "Line of Sight";
|
|
*/
|
|
|
|
|
|
if (targettype == ST_Group) { // 41 Group v2
|
|
isGroupSpell = true;
|
|
}
|
|
if (targettype == ST_GroupTeleport) { //3 Group v1
|
|
isGroupSpell = true;
|
|
}
|
|
|
|
if (isGroupSpell && IsBardSong(spellID)) {
|
|
isBardSong = true;
|
|
}
|
|
|
|
if (targettype == ST_Target) { //5 Single
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (GetTarget()) {
|
|
targetBodyType = target->bodytype;
|
|
}
|
|
|
|
if (targettype == ST_Animal) { //9 Animal
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Undead) { //10 Undead
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Summoned) { //11 Summoned
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Tap) { //13 Lifetap
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Pet) { //14 Pet
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Corpse) { //15 Corpse
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Plant) { //16 Plant
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Giant) { //17 Uber Giants
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (targettype == ST_Dragon) { //18 Uber Dragons
|
|
isSingleTargetSpell = true;
|
|
}
|
|
|
|
if (spDat.mana > 0 && manaCurrent < GetActSpellCost(spellID, spDat.mana)) return ELIXIR_NOT_ENOUGH_MANA;
|
|
if (spDat.endurance_cost > 0 && endCurrent < spDat.endurance_cost) return ELIXIR_NOT_ENOUGH_ENDURANCE;
|
|
|
|
if (isLull) return ELIXIR_LULL_IGNORED;
|
|
if (isMez) return ELIXIR_MEZ_IGNORED;
|
|
if (isCharm) return ELIXIR_CHARM_IGNORED;
|
|
|
|
if (targettype == ST_Animal) { //16 Animal
|
|
if (target == nullptr) return ELIXIR_NO_TARGET;
|
|
if (targetBodyType != BT_Animal) return ELIXIR_INVALID_TARGET_BODYTYPE;
|
|
}
|
|
|
|
if (targettype == ST_Undead ) { //10 Undead
|
|
if (target == nullptr) return ELIXIR_NO_TARGET;
|
|
if (targetBodyType != BT_Undead) return ELIXIR_INVALID_TARGET_BODYTYPE;
|
|
}
|
|
|
|
if (targettype == ST_Summoned) { //11 Summoned
|
|
if (target == nullptr) return ELIXIR_NO_TARGET;
|
|
if (targetBodyType != BT_Summoned) return ELIXIR_INVALID_TARGET_BODYTYPE;
|
|
}
|
|
|
|
if (targettype == ST_Plant) { //Plant
|
|
if (target == nullptr) return ELIXIR_NO_TARGET;
|
|
if (targetBodyType != BT_Plant) return ELIXIR_INVALID_TARGET_BODYTYPE;
|
|
}
|
|
|
|
if (isTransport) return ELIXIR_TRANSPORT_IGNORED;
|
|
|
|
if (spDat.npc_no_los == 0 && target && isSingleTargetSpell && CheckLosFN(target)) return ELIXIR_NOT_LINE_OF_SIGHT;
|
|
|
|
for (int i = 0; i < 4; i++) { // Reagent check
|
|
if (spDat.component[i] == 0) continue;
|
|
if (spDat.component_count[i] == -1) continue;
|
|
if (IsMerc()) continue; //mercs don't have inventory nor require reagents
|
|
#ifdef BOTS
|
|
if (IsBot()) continue; //bots don't have inventory nor require reagents
|
|
#endif
|
|
return ELIXIR_COMPONENT_REQUIRED;
|
|
//TODO: teach elixir how to check inventory for component in cases it's a client calling this function
|
|
}
|
|
|
|
//TODO: CasterRequirement logic
|
|
//DWORD ReqID = pSpell->CasterRequirementID;
|
|
//if (ReqID == 518 && SpawnPctHPs(pChar->pSpawn) > 89) return "not < 90% hp";
|
|
|
|
|
|
if (skillID == EQ::skills::SkillBackstab) { // 8 backstab
|
|
if (!target) {
|
|
return ELIXIR_NO_TARGET;
|
|
}
|
|
if (!BehindMob(target)) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
if (!IsWithinSpellRange(target, spDat.range, spellID)) {
|
|
return ELIXIR_OUT_OF_RANGE;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (recourseID > 0) { //recourse buff attached
|
|
const SPDat_Spell_Struct &spDatRecourse = spells[recourseID];
|
|
if (spDatRecourse.buff_duration > 0) {
|
|
buffCount = GetMaxTotalSlots();
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.ticsremaining < 2) continue;
|
|
if (buff.spellid == recourseID) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, recourseID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ticks > 0 && !IsBeneficialSpell(spellID) && targettype == ST_Target) { // debuff
|
|
if (!target) {
|
|
return ELIXIR_NO_TARGET;
|
|
}
|
|
|
|
buffCount = target->GetMaxTotalSlots();
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = target->buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.ticsremaining < 2) continue;
|
|
if (buff.spellid == spellID) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (spDat.zone_type == 1 && !zone->CanCastOutdoor()) {
|
|
return ELIXIR_ZONETYPE_FAIL;
|
|
}
|
|
|
|
//TODO: zone_type 2 check (can't cast outdoors indoor only)
|
|
|
|
if (IsEffectInSpell(spellID, SE_Levitate) && !zone->CanLevitate()) {
|
|
return ELIXIR_ZONETYPE_FAIL;
|
|
}
|
|
|
|
if (!spDat.can_cast_in_combat) {
|
|
if (IsEngaged()) return ELIXIR_CANNOT_USE_IN_COMBAT;
|
|
buffCount = target->GetMaxTotalSlots();
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = target->buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (IsDetrimentalSpell(buff.spellid) && buff.ticsremaining > 0 && !DetrimentalSpellAllowsRest(buff.spellid)) {
|
|
return ELIXIR_CANNOT_USE_IN_COMBAT;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IsDisciplineBuff(spellID)) {
|
|
buffCount = GetMaxTotalSlots();
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.ticsremaining < 2) continue;
|
|
if (buff.spellid == spellID) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isPetSummon && HasPet()) return ELIXIR_ALREADY_HAVE_PET;
|
|
|
|
|
|
if (targettype == ST_Pet && isHeal) {
|
|
if (!HasPet()) {
|
|
return ELIXIR_NO_PET;
|
|
}
|
|
if (GetPet()->GetHPRatio() <= healPercent) {
|
|
return 0;
|
|
}
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
if (isBuff && targettype == ST_Pet && IsBeneficialSpell(spellID)) {
|
|
if (!HasPet()) {
|
|
return ELIXIR_NO_PET;
|
|
}
|
|
|
|
buffCount = GetPet()->GetMaxTotalSlots();
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = GetPet()->buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.ticsremaining < 2) continue;
|
|
if (buff.spellid == spellID) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
return ELIXIR_ALREADY_HAVE_BUFF;
|
|
}
|
|
if (!IsWithinSpellRange(GetPet(), spDat.range, spellID)) {
|
|
return ELIXIR_OUT_OF_RANGE;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (isMana && targettype == ST_Self && ticks <= 0 && !isPetSummon) { // self only regen, like harvest, canni
|
|
if (stunDuration > 0 && IsEngaged()) {
|
|
return ELIXIR_CANNOT_USE_IN_COMBAT;
|
|
}
|
|
|
|
if (GetManaRatio() > 50) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (isLifetap && GetHPRatio() <= healPercent) {
|
|
//TODO: check if it's a group recourse lifetap regen so necros can bond heal group
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
|
|
if (isGroupSpell && isHeal && ticks == 0) { //self/group instant heals
|
|
int groupHealCount = 0;
|
|
|
|
float sqDistance = spDat.aoe_range * spDat.aoe_range;
|
|
for (int i = 0; i < MAX_GROUP_MEMBERS; i++) {
|
|
if (!grp) break;
|
|
if (!grp->members[i]) continue;
|
|
if (grp->members[i]->GetHPRatio() > healPercent) continue;
|
|
if (sqDistance > 0 && DistanceSquaredNoZ(target->GetPosition(), grp->members[i]->GetPosition()) > sqDistance) continue;
|
|
groupHealCount++;
|
|
}
|
|
|
|
if (groupHealCount < aeMinimum) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
if ((targettype == ST_Self || isGroupSpell) && IsBeneficialSpell(spellID)) { //self/group beneficial spell
|
|
if (IsEngaged() && !isBardSong) {
|
|
return ELIXIR_CANNOT_USE_IN_COMBAT;
|
|
}
|
|
|
|
if (ticks > 0) {
|
|
bool isBuffNeeded = true;
|
|
|
|
buffCount = GetMaxTotalSlots();
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.ticsremaining < 2) continue;
|
|
if (buff.spellid == spellID) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
}
|
|
if (isBuffNeeded) return 0;
|
|
if (!isGroupSpell) return ELIXIR_NOT_NEEDED;
|
|
|
|
isBuffNeeded = true;
|
|
for (int i = 0; i < MAX_GROUP_MEMBERS; i++) {
|
|
|
|
if (!grp) break;
|
|
if (!grp->members[i]) continue;
|
|
buffCount = grp->members[i]->GetMaxTotalSlots();
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.ticsremaining < 2) continue;
|
|
if (buff.spellid == spellID) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
}
|
|
if (!isBuffNeeded) continue;
|
|
outMob = grp->members[i];
|
|
return 1;
|
|
}
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (targettype == ST_Target || IsBeneficialSpell(spellID)) { //single target beneficial spell
|
|
if (isHeal) { //heal logic
|
|
int healIDPercent = 100;
|
|
// figure out who is lowest HP party member
|
|
if (GetHPRatio() <= healPercent) {
|
|
if (ticks == 0) { // instant heal, just apply
|
|
outMob = this;
|
|
healIDPercent = GetHPRatio();
|
|
} else { // it's a heal buff, check if player already has it
|
|
bool isBuffNeeded = true;
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.spellid == spellID) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
}
|
|
if (isBuffNeeded) {
|
|
outMob = this;
|
|
healIDPercent = GetHPRatio();
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < MAX_GROUP_MEMBERS; i++) {
|
|
if (!grp) break;
|
|
if (!grp->members[i]) continue;
|
|
if (grp->members[i]->GetHPRatio() > healPercent) continue;
|
|
if (grp->members[i]->GetHPRatio() > healIDPercent) continue;
|
|
if (!IsWithinSpellRange(grp->members[i], spDat.range, spellID)) continue;
|
|
|
|
if (ticks == 0) { // instant heal, just apply
|
|
outMob = grp->members[i];
|
|
healIDPercent = grp->members[i]->GetHPRatio();
|
|
} else { // it's a heal buff, check if player already has it
|
|
bool isBuffNeeded = true;
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = grp->members[i]->buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.spellid == spellID) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
// TODO: Immune Check
|
|
}
|
|
if (isBuffNeeded) {
|
|
outMob = grp->members[i];
|
|
healIDPercent = GetHPRatio();
|
|
}
|
|
}
|
|
}
|
|
if (!outMob) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
// TODO: add exceptions for combat buffs situation
|
|
bool isCombatBuff = false;
|
|
|
|
if (IsEngaged() && !isCombatBuff) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
// for the time being, any beneficial non-heal single target spells without a duration are skipped
|
|
// later, we need to add in things like necro mana flow, etc
|
|
if (ticks == 0) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
// always self buff first
|
|
bool isBuffNeeded = true;
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.spellid == spellID) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
// TODO: Immune Check
|
|
}
|
|
if (isBuffNeeded) {
|
|
if (target && target->GetID() == GetID()) {
|
|
return 0;
|
|
}
|
|
outMob = this;
|
|
return 1;
|
|
}
|
|
|
|
for (int i = 0; i < MAX_GROUP_MEMBERS; i++) {
|
|
if (!grp) break;
|
|
if (!grp->members[i]) continue;
|
|
if (!IsWithinSpellRange(grp->members[i], spDat.range, spellID)) continue;
|
|
|
|
bool isBuffNeeded = true;
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = grp->members[i]->buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.spellid == spellID) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
isBuffNeeded = false;
|
|
break;
|
|
}
|
|
// TODO: Immune Check
|
|
}
|
|
if (isBuffNeeded) {
|
|
if (target && target->GetID() == grp->members[i]->GetID()) {
|
|
return 0;
|
|
}
|
|
outMob = grp->members[i];
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
if (damageAmount > 0 && (targettype == ST_AEClientV1 || targettype == ST_AreaClientOnly || targettype == ST_AECaster)) { // PB AE DD
|
|
int targetCount = 0;
|
|
float sqDistance = spDat.aoe_range * spDat.aoe_range;
|
|
auto hates = GetHateList();
|
|
auto iter = hates.begin();
|
|
for (auto iter : hates) {
|
|
if (sqDistance > 0 && DistanceSquaredNoZ(GetPosition(), iter->entity_on_hatelist->GetPosition()) > sqDistance) continue;
|
|
targetCount++;
|
|
}
|
|
if (targetCount < aeMinimum) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
if (damageAmount > 0 && (targettype == ST_TargetAETap || targettype == ST_AETarget)) { // Target AE DD
|
|
if (!target) {
|
|
return ELIXIR_NO_TARGET;
|
|
}
|
|
if (!IsWithinSpellRange(target, spDat.range, spellID)) {
|
|
return ELIXIR_OUT_OF_RANGE;
|
|
}
|
|
|
|
int targetCount = 0;
|
|
float sqDistance = spDat.aoe_range * spDat.aoe_range;
|
|
auto hates = GetHateList();
|
|
auto iter = hates.begin();
|
|
for (auto iter : hates) {
|
|
if (sqDistance > 0 && DistanceSquaredNoZ(target->GetPosition(), iter->entity_on_hatelist->GetPosition()) > sqDistance) continue;
|
|
targetCount++;
|
|
}
|
|
if (targetCount < aeMinimum) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
if (targettype == ST_Target || !IsBeneficialSpell(spellID)) { // single target detrimental spell
|
|
if (!hate_list.IsEntOnHateList(target)) {
|
|
return ELIXIR_NO_TARGET;
|
|
}
|
|
|
|
if (target->GetHPRatio() <= 0) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
if (!IsWithinSpellRange(GetPet(), spDat.range, spellID)) {
|
|
return ELIXIR_OUT_OF_RANGE;
|
|
}
|
|
|
|
if (target->IsMezzed()) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
if (!IsAttackAllowed(target)) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
|
|
if (ticks == 0) {
|
|
if (!target) {
|
|
return ELIXIR_NO_TARGET;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
for (uint32 i = 0; i < buffCount; i++) {
|
|
auto buff = target->buffs[i];
|
|
if (buff.spellid == SPELL_UNKNOWN) continue;
|
|
if (spells[buff.spellid].buff_duration_formula == DF_Permanent) continue;
|
|
if (buff.spellid == spellID) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
int stackResult = CheckStackConflict(buff.spellid, buff.casterlevel, spellID, GetLevel(), entity_list.GetMobID(buff.casterid), this, i);
|
|
if (stackResult == -1) {
|
|
return ELIXIR_NOT_NEEDED;
|
|
}
|
|
// TODO: Immune Check
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
return ELIXIR_UNHANDLED_SPELL;
|
|
}
|
|
|
|
/*
|
|
for (int i = 0; i < MAX_RAID_MEMBERS; i++) {
|
|
if (!raid) break;
|
|
if (!raid->members[i]) continue;
|
|
if (!raid->members[i].member) continue;
|
|
//raid->members[i].GroupNumber == gid
|
|
}
|
|
*/ |