/** * MaNGOS is a full featured server for World of Warcraft, supporting * the following clients: 1.12.x, 2.4.3, 3.3.5a, 4.3.4a and 5.4.8 * * Copyright (C) 2005-2018 MaNGOS project * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * World of Warcraft, and all World of Warcraft or Warcraft art, images, * and lore are copyrighted by Blizzard Entertainment, Inc. */ #ifndef MANGOS_H_SPELL #define MANGOS_H_SPELL #include "Common.h" #include "GridDefines.h" #include "SharedDefines.h" #include "DBCEnums.h" #include "ObjectGuid.h" #include "LootMgr.h" #include "Unit.h" #include "Player.h" class WorldSession; class WorldPacket; class DynamicObj; class Item; class GameObject; class Group; class Aura; enum SpellCastFlags { CAST_FLAG_NONE = 0x00000000, CAST_FLAG_HIDDEN_COMBATLOG = 0x00000001, // hide in combat log? CAST_FLAG_UNKNOWN2 = 0x00000002, CAST_FLAG_UNKNOWN3 = 0x00000004, CAST_FLAG_UNKNOWN4 = 0x00000008, CAST_FLAG_UNKNOWN5 = 0x00000010, CAST_FLAG_AMMO = 0x00000020, // Projectiles visual CAST_FLAG_UNKNOWN7 = 0x00000040, // !0x41 mask used to call CGTradeSkillInfo::DoRecast CAST_FLAG_UNKNOWN8 = 0x00000080, CAST_FLAG_UNKNOWN9 = 0x00000100, }; enum SpellNotifyPushType { PUSH_IN_FRONT, PUSH_IN_FRONT_90, PUSH_IN_FRONT_15, PUSH_IN_BACK, PUSH_SELF_CENTER, PUSH_DEST_CENTER, PUSH_TARGET_CENTER }; bool IsQuestTameSpell(uint32 spellId); namespace MaNGOS { struct SpellNotifierPlayer; struct SpellNotifierCreatureAndPlayer; } class SpellCastTargets; struct SpellCastTargetsReader { explicit SpellCastTargetsReader(SpellCastTargets& _targets, Unit* _caster) : targets(_targets), caster(_caster) {} SpellCastTargets& targets; Unit* caster; }; class SpellCastTargets { public: SpellCastTargets(); ~SpellCastTargets(); void read(ByteBuffer& data, Unit* caster); void write(ByteBuffer& data) const; SpellCastTargetsReader ReadForCaster(Unit* caster) { return SpellCastTargetsReader(*this, caster); } SpellCastTargets& operator=(const SpellCastTargets& target) { m_unitTarget = target.m_unitTarget; m_itemTarget = target.m_itemTarget; m_GOTarget = target.m_GOTarget; m_unitTargetGUID = target.m_unitTargetGUID; m_GOTargetGUID = target.m_GOTargetGUID; m_CorpseTargetGUID = target.m_CorpseTargetGUID; m_itemTargetGUID = target.m_itemTargetGUID; m_itemTargetEntry = target.m_itemTargetEntry; m_srcX = target.m_srcX; m_srcY = target.m_srcY; m_srcZ = target.m_srcZ; m_destX = target.m_destX; m_destY = target.m_destY; m_destZ = target.m_destZ; m_strTarget = target.m_strTarget; m_targetMask = target.m_targetMask; return *this; } void setUnitTarget(Unit* target); ObjectGuid getUnitTargetGuid() const { return m_unitTargetGUID; } Unit* getUnitTarget() const { return m_unitTarget; } void setDestination(float x, float y, float z); void setSource(float x, float y, float z); void getDestination(float& x, float& y, float& z) const { x = m_destX; y = m_destY; z = m_destZ; } void getSource(float& x, float& y, float& z) const { x = m_srcX; y = m_srcY, z = m_srcZ; } void setGOTarget(GameObject* target); ObjectGuid getGOTargetGuid() const { return m_GOTargetGUID; } GameObject* getGOTarget() const { return m_GOTarget; } void setCorpseTarget(Corpse* corpse); ObjectGuid getCorpseTargetGuid() const { return m_CorpseTargetGUID; } void setItemTarget(Item* item); ObjectGuid getItemTargetGuid() const { return m_itemTargetGUID; } Item* getItemTarget() const { return m_itemTarget; } uint32 getItemTargetEntry() const { return m_itemTargetEntry; } void setTradeItemTarget(Player* caster); void updateTradeSlotItem() { if (m_itemTarget && (m_targetMask & TARGET_FLAG_TRADE_ITEM)) { m_itemTargetGUID = m_itemTarget->GetObjectGuid(); m_itemTargetEntry = m_itemTarget->GetEntry(); } } bool IsEmpty() const { return !m_GOTargetGUID && !m_unitTargetGUID && !m_itemTarget && !m_CorpseTargetGUID; } void Update(Unit* caster); float m_srcX, m_srcY, m_srcZ; float m_destX, m_destY, m_destZ; std::string m_strTarget; uint16 m_targetMask; private: // objects (can be used at spell creating and after Update at casting Unit* m_unitTarget; GameObject* m_GOTarget; Item* m_itemTarget; // object GUID/etc, can be used always ObjectGuid m_unitTargetGUID; ObjectGuid m_GOTargetGUID; ObjectGuid m_CorpseTargetGUID; ObjectGuid m_itemTargetGUID; uint32 m_itemTargetEntry; }; inline ByteBuffer& operator<< (ByteBuffer& buf, SpellCastTargets const& targets) { targets.write(buf); return buf; } inline ByteBuffer& operator>> (ByteBuffer& buf, SpellCastTargetsReader const& targets) { targets.targets.read(buf, targets.caster); return buf; } enum SpellState { SPELL_STATE_CREATED = 0, // just created SPELL_STATE_PREPARING = 1, // cast time delay period, non channeled spell SPELL_STATE_CASTING = 2, // channeled time period spell casting state SPELL_STATE_FINISHED = 3, // cast finished to success or fail SPELL_STATE_DELAYED = 4 // spell casted but need time to hit target(s) }; enum SpellTargets { SPELL_TARGETS_HOSTILE, SPELL_TARGETS_NOT_FRIENDLY, SPELL_TARGETS_NOT_HOSTILE, SPELL_TARGETS_FRIENDLY, SPELL_TARGETS_AOE_DAMAGE, SPELL_TARGETS_ALL }; typedef std::multimap SpellTargetTimeMap; class Spell { friend struct MaNGOS::SpellNotifierPlayer; friend struct MaNGOS::SpellNotifierCreatureAndPlayer; friend void Unit::SetCurrentCastedSpell(Spell* pSpell); public: void EffectEmpty(SpellEffectIndex eff_idx); void EffectNULL(SpellEffectIndex eff_idx); void EffectUnused(SpellEffectIndex eff_idx); void EffectDistract(SpellEffectIndex eff_idx); void EffectPull(SpellEffectIndex eff_idx); void EffectSchoolDMG(SpellEffectIndex eff_idx); void EffectEnvironmentalDMG(SpellEffectIndex eff_idx); void EffectInstaKill(SpellEffectIndex eff_idx); void EffectDummy(SpellEffectIndex eff_idx); void EffectTeleportUnits(SpellEffectIndex eff_idx); void EffectApplyAura(SpellEffectIndex eff_idx); void EffectSendEvent(SpellEffectIndex eff_idx); void EffectPowerBurn(SpellEffectIndex eff_idx); void EffectPowerDrain(SpellEffectIndex eff_idx); void EffectHeal(SpellEffectIndex eff_idx); void EffectBind(SpellEffectIndex eff_idx); void EffectHealthLeech(SpellEffectIndex eff_idx); void EffectQuestComplete(SpellEffectIndex eff_idx); void EffectCreateItem(SpellEffectIndex eff_idx); void EffectPersistentAA(SpellEffectIndex eff_idx); void EffectEnergize(SpellEffectIndex eff_idx); void EffectOpenLock(SpellEffectIndex eff_idx); void EffectSummonChangeItem(SpellEffectIndex eff_idx); void EffectProficiency(SpellEffectIndex eff_idx); void EffectApplyAreaAura(SpellEffectIndex eff_idx); void EffectSummon(SpellEffectIndex eff_idx); void EffectLearnSpell(SpellEffectIndex eff_idx); void EffectDispel(SpellEffectIndex eff_idx); void EffectDualWield(SpellEffectIndex eff_idx); void EffectPickPocket(SpellEffectIndex eff_idx); void EffectAddFarsight(SpellEffectIndex eff_idx); void EffectSummonPossessed(SpellEffectIndex eff_idx); void EffectSummonWild(SpellEffectIndex eff_idx); void EffectSummonGuardian(SpellEffectIndex eff_idx); void EffectHealMechanical(SpellEffectIndex eff_idx); void EffectTeleUnitsFaceCaster(SpellEffectIndex eff_idx); void EffectLearnSkill(SpellEffectIndex eff_idx); void EffectAddHonor(SpellEffectIndex eff_idx); void EffectTradeSkill(SpellEffectIndex eff_idx); void EffectEnchantItemPerm(SpellEffectIndex eff_idx); void EffectEnchantItemTmp(SpellEffectIndex eff_idx); void EffectTameCreature(SpellEffectIndex eff_idx); void EffectSummonPet(SpellEffectIndex eff_idx); void EffectLearnPetSpell(SpellEffectIndex eff_idx); void EffectWeaponDmg(SpellEffectIndex eff_idx); void EffectTriggerSpell(SpellEffectIndex eff_idx); void EffectTriggerMissileSpell(SpellEffectIndex eff_idx); void EffectThreat(SpellEffectIndex eff_idx); void EffectHealMaxHealth(SpellEffectIndex eff_idx); void EffectInterruptCast(SpellEffectIndex eff_idx); void EffectSummonObjectWild(SpellEffectIndex eff_idx); void EffectScriptEffect(SpellEffectIndex eff_idx); void EffectSanctuary(SpellEffectIndex eff_idx); void EffectAddComboPoints(SpellEffectIndex eff_idx); void EffectDuel(SpellEffectIndex eff_idx); void EffectStuck(SpellEffectIndex eff_idx); void EffectSummonPlayer(SpellEffectIndex eff_idx); void EffectActivateObject(SpellEffectIndex eff_idx); void EffectSummonTotem(SpellEffectIndex eff_idx); void EffectEnchantHeldItem(SpellEffectIndex eff_idx); void EffectSummonObject(SpellEffectIndex eff_idx); void EffectResurrect(SpellEffectIndex eff_idx); void EffectParry(SpellEffectIndex eff_idx); void EffectBlock(SpellEffectIndex eff_idx); void EffectLeapForward(SpellEffectIndex eff_idx); void EffectTransmitted(SpellEffectIndex eff_idx); void EffectDisEnchant(SpellEffectIndex eff_idx); void EffectInebriate(SpellEffectIndex eff_idx); void EffectFeedPet(SpellEffectIndex eff_idx); void EffectDismissPet(SpellEffectIndex eff_idx); void EffectReputation(SpellEffectIndex eff_idx); void EffectSelfResurrect(SpellEffectIndex eff_idx); void EffectSkinning(SpellEffectIndex eff_idx); void EffectCharge(SpellEffectIndex eff_idx); void EffectSendTaxi(SpellEffectIndex eff_idx); void EffectSummonCritter(SpellEffectIndex eff_idx); void EffectKnockBack(SpellEffectIndex eff_idx); void EffectPlayerPull(SpellEffectIndex eff_idx); void EffectDispelMechanic(SpellEffectIndex eff_idx); void EffectSummonDeadPet(SpellEffectIndex eff_idx); void EffectDestroyAllTotems(SpellEffectIndex eff_idx); void EffectDurabilityDamage(SpellEffectIndex eff_idx); void EffectSkill(SpellEffectIndex eff_idx); void EffectTaunt(SpellEffectIndex eff_idx); void EffectDurabilityDamagePCT(SpellEffectIndex eff_idx); void EffectModifyThreatPercent(SpellEffectIndex eff_idx); void EffectResurrectNew(SpellEffectIndex eff_idx); void EffectAddExtraAttacks(SpellEffectIndex eff_idx); void EffectSpiritHeal(SpellEffectIndex eff_idx); void EffectSkinPlayerCorpse(SpellEffectIndex eff_idx); void EffectSummonDemon(SpellEffectIndex eff_idx); void EffectPlayMusic(SpellEffectIndex eff_idx); Spell(Unit* caster, SpellEntry const* info, bool triggered, ObjectGuid originalCasterGUID = ObjectGuid(), SpellEntry const* triggeredBy = NULL); ~Spell(); void prepare(SpellCastTargets const* targets, Aura* triggeredByAura = NULL); void cancel(); void update(uint32 difftime); void cast(bool skipCheck = false); void finish(bool ok = true); void TakePower(); void TakeAmmo(); void TakeReagents(); void TakeCastItem(); SpellCastResult CheckCast(bool strict); SpellCastResult CheckPetCast(Unit* target); // handlers void handle_immediate(); uint64 handle_delayed(uint64 t_offset); // handler helpers void _handle_immediate_phase(); void _handle_finish_phase(); SpellCastResult CheckItems(); SpellCastResult CheckRange(bool strict); SpellCastResult CheckPower(); SpellCastResult CheckCasterAuras() const; int32 CalculateDamage(SpellEffectIndex i, Unit* target) { return m_caster->CalculateSpellDamage(target, m_spellInfo, i, &m_currentBasePoints[i]); } static uint32 CalculatePowerCost(SpellEntry const* spellInfo, Unit* caster, Spell const* spell = NULL, Item* castItem = NULL); bool HaveTargetsForEffect(SpellEffectIndex effect) const; void Delayed(); void DelayedChannel(); uint32 getState() const { return m_spellState; } void setState(uint32 state) { m_spellState = state; } void DoCreateItem(SpellEffectIndex eff_idx, uint32 itemtype); void WriteSpellGoTargets(WorldPacket* data); void WriteAmmoToPacket(WorldPacket* data); template WorldObject* FindCorpseUsing(); bool CheckTarget(Unit* target, SpellEffectIndex eff); bool CanAutoCast(Unit* target); static void SendCastResult(Player* caster, SpellEntry const* spellInfo, SpellCastResult result); void SendCastResult(SpellCastResult result); void SendSpellStart(); void SendSpellGo(); void SendSpellCooldown(); void SendLogExecute(); void SendInterrupted(SpellCastResult result); void SendChannelUpdate(uint32 time); void SendChannelStart(uint32 duration); void SendResurrectRequest(Player* target); void HandleEffects(Unit* pUnitTarget, Item* pItemTarget, GameObject* pGOTarget, SpellEffectIndex i, float DamageMultiplier = 1.0); void HandleThreatSpells(); // void HandleAddAura(Unit* Target); SpellEntry const* m_spellInfo; SpellEntry const* m_triggeredBySpellInfo; int32 m_currentBasePoints[MAX_EFFECT_INDEX]; // cache SpellEntry::CalculateSimpleValue and use for set custom base points Item* m_CastItem; SpellCastTargets m_targets; int32 GetCastTime() const { return m_casttime; } uint32 GetCastedTime() { return m_timer; } bool IsAutoRepeat() const { return m_autoRepeat; } void SetAutoRepeat(bool rep) { m_autoRepeat = rep; } void ReSetTimer() { m_timer = m_casttime > 0 ? m_casttime : 0; } bool IsNextMeleeSwingSpell() const { return m_spellInfo->HasAttribute(SPELL_ATTR_ON_NEXT_SWING_1) || m_spellInfo->HasAttribute(SPELL_ATTR_ON_NEXT_SWING_2); } bool IsRangedSpell() const { return m_spellInfo->HasAttribute(SPELL_ATTR_RANGED); } bool IsChannelActive() const { return m_caster->GetUInt32Value(UNIT_CHANNEL_SPELL) != 0; } bool IsMeleeAttackResetSpell() const { return !m_IsTriggeredSpell && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_AUTOATTACK); } bool IsRangedAttackResetSpell() const { return !m_IsTriggeredSpell && IsRangedSpell() && (m_spellInfo->InterruptFlags & SPELL_INTERRUPT_FLAG_AUTOATTACK); } bool IsDeletable() const { return !m_referencedFromCurrentSpell && !m_executedCurrently; } void SetReferencedFromCurrent(bool yes) { m_referencedFromCurrentSpell = yes; } void SetExecutedCurrently(bool yes) { m_executedCurrently = yes; } uint64 GetDelayStart() const { return m_delayStart; } void SetDelayStart(uint64 m_time) { m_delayStart = m_time; } uint64 GetDelayMoment() const { return m_delayMoment; } bool IsNeedSendToClient() const; // use for hide spell cast for client in case when cast not have client side affect (animation or log entries) bool IsTriggeredSpellWithRedundentCastTime() const; // use for ignore some spell data for triggered spells like cast time, some triggered spells have redundent copy data from main spell for client use purpose CurrentSpellTypes GetCurrentContainer(); // caster types: // formal spell caster, in game source of spell affects cast Unit* GetCaster() const { return m_caster; } // real source of cast affects, explicit caster, or DoT/HoT applier, or GO owner, or wild GO itself. Can be NULL WorldObject* GetAffectiveCasterObject() const; // limited version returning NULL in cases wild gameobject caster object, need for Aura (auras currently not support non-Unit caster) Unit* GetAffectiveCaster() const { return m_originalCasterGUID ? m_originalCaster : m_caster; } // m_originalCasterGUID can store GO guid, and in this case this is visual caster WorldObject* GetCastingObject() const; uint32 GetPowerCost() const { return m_powerCost; } void UpdatePointers(); // must be used at call Spell code after time delay (non triggered spell cast/update spell call/etc) bool CheckTargetCreatureType(Unit* target) const; void AddTriggeredSpell(SpellEntry const* spellInfo) { m_TriggerSpells.push_back(spellInfo); } void AddPrecastSpell(SpellEntry const* spellInfo) { m_preCastSpells.push_back(spellInfo); } void AddTriggeredSpell(uint32 spellId); void AddPrecastSpell(uint32 spellId); void CastPreCastSpells(Unit* target); void CastTriggerSpells(); void CleanupTargetList(); void ClearCastItem(); typedef std::list UnitList; void SetSelfContainer(Spell** pCurrentContainer) { m_selfContainer = pCurrentContainer; } Spell** GetSelfContainer() { return m_selfContainer; } protected: bool HasGlobalCooldown(); void TriggerGlobalCooldown(); void CancelGlobalCooldown(); void SendLoot(ObjectGuid guid, LootType loottype, LockType lockType); bool IgnoreItemRequirements() const; // some item use spells have unexpected reagent data void UpdateOriginalCasterPointer(); Unit* m_caster; ObjectGuid m_originalCasterGUID; // real source of cast (aura caster/etc), used for spell targets selection // e.g. damage around area spell trigered by victim aura and da,age emeies of aura caster Unit* m_originalCaster; // cached pointer for m_originalCaster, updated at Spell::UpdatePointers() Spell** m_selfContainer; // pointer to our spell container (if applicable) // Spell data SpellSchoolMask m_spellSchoolMask; // Spell school (can be overwrite for some spells (wand shoot for example) WeaponAttackType m_attackType; // For weapon based attack uint32 m_powerCost; // Calculated spell cost initialized only in Spell::prepare int32 m_casttime; // Calculated spell cast time initialized only in Spell::prepare int32 m_duration; bool m_canReflect; // can reflect this spell? bool m_autoRepeat; uint8 m_delayAtDamageCount; int32 GetNextDelayAtDamageMsTime() { return m_delayAtDamageCount < 5 ? 1000 - (m_delayAtDamageCount++) * 200 : 200; } // Delayed spells system uint64 m_delayStart; // time of spell delay start, filled by event handler, zero = just started uint64 m_delayMoment; // moment of next delay call, used internally bool m_immediateHandled; // were immediate actions handled? (used by delayed spells only) // These vars are used in both delayed spell system and modified immediate spell system bool m_referencedFromCurrentSpell; // mark as references to prevent deleted and access by dead pointers bool m_executedCurrently; // mark as executed to prevent deleted and access by dead pointers bool m_needSpellLog; // need to send spell log? uint8 m_applyMultiplierMask; // by effect: damage multiplier needed? float m_damageMultipliers[3]; // by effect: damage multiplier // Current targets, to be used in SpellEffects (MUST BE USED ONLY IN SPELL EFFECTS) Unit* unitTarget; Item* itemTarget; GameObject* gameObjTarget; SpellAuraHolder* m_spellAuraHolder; // spell aura holder for current target, created only if spell has aura applying effect int32 damage; // this is set in Spell Hit, but used in Apply Aura handler DiminishingLevels m_diminishLevel; DiminishingGroup m_diminishGroup; // ------------------------------------------- GameObject* focusObject; // Damage and healing in effects need just calculate int32 m_damage; // Damage in effects count here int32 m_healing; // Healing in effects count here int32 m_healthLeech; // Health leech in effects for all targets count here //****************************************** // Spell trigger system //****************************************** bool m_canTrigger; // Can start trigger (m_IsTriggeredSpell can`t use for this) uint8 m_negativeEffectMask; // Use for avoid sent negative spell procs for additional positive effects only targets uint32 m_procAttacker; // Attacker trigger flags uint32 m_procVictim; // Victim trigger flags void prepareDataForTriggerSystem(); //***************************************** // Spell target filling //***************************************** void FillTargetMap(); void SetTargetMap(SpellEffectIndex effIndex, uint32 targetMode, UnitList& targetUnitMap); void FillAreaTargets(UnitList& targetUnitMap, float radius, SpellNotifyPushType pushType, SpellTargets spellTargets, WorldObject* originalCaster = NULL); void FillRaidOrPartyTargets(UnitList& targetUnitMap, Unit* member, float radius, bool raid, bool withPets, bool withcaster); // Returns GUID either of the 1st target from the implicit target list, or of explicit one (selected victim) ObjectGuid GetPrefilledOrUnitTargetGuid(SpellEffectIndex effIndex) const; void GetSpellRangeAndRadius(SpellEffectIndex effIndex, float& radius, uint32& EffectChainTarget, uint32& unMaxTargets) const; //***************************************** // Spell target subsystem //***************************************** // Targets store structures and data struct TargetInfo { ObjectGuid targetGUID; uint64 timeDelay; uint32 HitInfo; uint32 damage; SpellMissInfo missCondition: 8; SpellMissInfo reflectResult: 8; uint8 effectMask: 8; bool processed: 1; }; uint8 m_needAliveTargetMask; // Mask req. alive targets struct GOTargetInfo { ObjectGuid targetGUID; uint64 timeDelay; uint8 effectMask: 8; bool processed: 1; }; struct ItemTargetInfo { Item* item; uint8 effectMask; }; typedef std::list TargetList; typedef std::list GOTargetList; typedef std::list ItemTargetList; TargetList m_UniqueTargetInfo; GOTargetList m_UniqueGOTargetInfo; ItemTargetList m_UniqueItemInfo; void AddUnitTarget(Unit* target, SpellEffectIndex effIndex); void AddUnitTarget(ObjectGuid unitGuid, SpellEffectIndex effIndex); void AddGOTarget(GameObject* target, SpellEffectIndex effIndex); void AddGOTarget(ObjectGuid goGuid, SpellEffectIndex effIndex); void AddItemTarget(Item* target, SpellEffectIndex effIndex); void DoAllEffectOnTarget(TargetInfo* target); void HandleDelayedSpellLaunch(TargetInfo* target); void InitializeDamageMultipliers(); void ResetEffectDamageAndHeal(); void DoSpellHitOnUnit(Unit* unit, uint32 effectMask, bool isReflected = false); void DoAllEffectOnTarget(GOTargetInfo* target); void DoAllEffectOnTarget(ItemTargetInfo* target); bool IsAliveUnitPresentInTargetList(); SpellCastResult CanOpenLock(SpellEffectIndex effIndex, uint32 lockid, SkillType& skillid, int32& reqSkillValue, int32& skillValue); SpellCastResult CanTameUnit(bool isGM = false); // ------------------------------------------- // List For Triggered Spells typedef std::list SpellInfoList; SpellInfoList m_TriggerSpells; // casted by caster to same targets settings in m_targets at success finish of current spell SpellInfoList m_preCastSpells; // casted by caster to each target at spell hit before spell effects apply uint32 m_spellState; uint32 m_timer; float m_castPositionX; float m_castPositionY; float m_castPositionZ; float m_castOrientation; bool m_IsTriggeredSpell; // if need this can be replaced by Aura copy // we can't store original aura link to prevent access to deleted auras // and in same time need aura data and after aura deleting. SpellEntry const* m_triggeredByAuraSpell; }; enum ReplenishType { REPLENISH_UNDEFINED = 0, REPLENISH_HEALTH = 20, REPLENISH_MANA = 21, REPLENISH_RAGE = 22 }; namespace MaNGOS { struct SpellNotifierPlayer // Currently unused. When put to use this one requires handling for source-location (smilar to below) { Spell::UnitList& i_data; Spell& i_spell; const uint32& i_index; float i_radius; WorldObject* i_originalCaster; SpellNotifierPlayer(Spell& spell, Spell::UnitList& data, const uint32& i, float radius) : i_data(data), i_spell(spell), i_index(i), i_radius(radius) { i_originalCaster = i_spell.GetAffectiveCasterObject(); } void Visit(PlayerMapType& m) { if (!i_originalCaster) { return; } for (PlayerMapType::iterator itr = m.begin(); itr != m.end(); ++itr) { Player* pPlayer = itr->getSource(); if (!pPlayer->IsAlive() || pPlayer->IsTaxiFlying()) { continue; } if (i_originalCaster->IsFriendlyTo(pPlayer)) { continue; } if (pPlayer->IsWithinDist3d(i_spell.m_targets.m_destX, i_spell.m_targets.m_destY, i_spell.m_targets.m_destZ, i_radius)) { i_data.push_back(pPlayer); } } } template void Visit(GridRefManager&) {} }; struct SpellNotifierCreatureAndPlayer { Spell::UnitList* i_data; Spell& i_spell; SpellNotifyPushType i_push_type; float i_radius; SpellTargets i_TargetType; WorldObject* i_originalCaster; WorldObject* i_castingObject; bool i_playerControlled; float i_centerX; float i_centerY; float i_centerZ; float GetCenterX() const { return i_centerX; } float GetCenterY() const { return i_centerY; } SpellNotifierCreatureAndPlayer(Spell& spell, Spell::UnitList& data, float radius, SpellNotifyPushType type, SpellTargets TargetType = SPELL_TARGETS_NOT_FRIENDLY, WorldObject* originalCaster = NULL) : i_data(&data), i_spell(spell), i_push_type(type), i_radius(radius), i_TargetType(TargetType), i_originalCaster(originalCaster), i_castingObject(i_spell.GetCastingObject()) { if (!i_originalCaster) { i_originalCaster = i_spell.GetAffectiveCasterObject(); } i_playerControlled = i_originalCaster ? i_originalCaster->IsControlledByPlayer() : false; switch (i_push_type) { case PUSH_IN_FRONT: case PUSH_IN_FRONT_90: case PUSH_IN_FRONT_15: case PUSH_IN_BACK: case PUSH_SELF_CENTER: if (i_castingObject) { i_centerX = i_castingObject->GetPositionX(); i_centerY = i_castingObject->GetPositionY(); } break; case PUSH_DEST_CENTER: if (i_spell.m_targets.m_targetMask & TARGET_FLAG_SOURCE_LOCATION) { i_spell.m_targets.getSource(i_centerX, i_centerY, i_centerZ); } else { i_spell.m_targets.getDestination(i_centerX, i_centerY, i_centerZ); } break; case PUSH_TARGET_CENTER: if (Unit* target = i_spell.m_targets.getUnitTarget()) { i_centerX = target->GetPositionX(); i_centerY = target->GetPositionY(); } break; default: sLog.outError("SpellNotifierCreatureAndPlayer: unsupported PUSH_* case %u.", i_push_type); } } template inline void Visit(GridRefManager& m) { MANGOS_ASSERT(i_data); if (!i_originalCaster || !i_castingObject) { return; } for (typename GridRefManager::iterator itr = m.begin(); itr != m.end(); ++itr) { // GM OFF Spell must pass the checks. bool gmSpell = (i_spell.m_spellInfo->Id == 1509); // there are still more spells which can be casted on dead, but // they are no AOE and don't have such a nice SPELL_ATTR flag if (!gmSpell) { if ((i_TargetType != SPELL_TARGETS_ALL && !itr->getSource()->IsTargetableForAttack(i_spell.m_spellInfo->HasAttribute(SPELL_ATTR_EX3_CAST_ON_DEAD))) // mostly phase check || !itr->getSource()->IsInMap(i_originalCaster)) { continue; } switch (i_TargetType) { case SPELL_TARGETS_HOSTILE: if (!i_originalCaster->IsHostileTo(itr->getSource())) { continue; } break; case SPELL_TARGETS_NOT_FRIENDLY: if (i_originalCaster->IsFriendlyTo(itr->getSource())) { continue; } break; case SPELL_TARGETS_NOT_HOSTILE: if (i_originalCaster->IsHostileTo(itr->getSource())) { continue; } break; case SPELL_TARGETS_FRIENDLY: if (!i_originalCaster->IsFriendlyTo(itr->getSource())) { continue; } break; case SPELL_TARGETS_AOE_DAMAGE: { if (itr->getSource()->GetTypeId() == TYPEID_UNIT && ((Creature*)itr->getSource())->IsTotem()) { continue; } if (i_playerControlled) { if (i_originalCaster->IsFriendlyTo(itr->getSource())) { continue; } } else { if (!i_originalCaster->IsHostileTo(itr->getSource())) { continue; } } } break; case SPELL_TARGETS_ALL: break; default: continue; } } // we don't need to check InMap here, it's already done some lines above switch (i_push_type) { case PUSH_IN_FRONT: if (i_castingObject->IsInFront((Unit*)(itr->getSource()), i_radius, 2 * M_PI_F / 3)) { i_data->push_back(itr->getSource()); } break; case PUSH_IN_FRONT_90: if (i_castingObject->IsInFront((Unit*)(itr->getSource()), i_radius, M_PI_F / 2)) { i_data->push_back(itr->getSource()); } break; case PUSH_IN_FRONT_15: if (i_castingObject->IsInFront((Unit*)(itr->getSource()), i_radius, M_PI_F / 12)) { i_data->push_back(itr->getSource()); } break; case PUSH_IN_BACK: if (i_castingObject->IsInBack((Unit*)(itr->getSource()), i_radius, 2 * M_PI_F / 3)) { i_data->push_back(itr->getSource()); } break; case PUSH_SELF_CENTER: if (i_castingObject->IsWithinDist((Unit*)(itr->getSource()), i_radius)) { i_data->push_back(itr->getSource()); } break; case PUSH_DEST_CENTER: if (itr->getSource()->IsWithinDist3d(i_centerX, i_centerY, i_centerZ, i_radius)) { i_data->push_back(itr->getSource()); } break; case PUSH_TARGET_CENTER: if (i_spell.m_targets.getUnitTarget() && i_spell.m_targets.getUnitTarget()->IsWithinDist((Unit*)(itr->getSource()), i_radius)) { i_data->push_back(itr->getSource()); } break; } } } #ifdef WIN32 template<> inline void Visit(CorpseMapType&) {} template<> inline void Visit(GameObjectMapType&) {} template<> inline void Visit(DynamicObjectMapType&) {} template<> inline void Visit(CameraMapType&) {} #endif }; #ifndef WIN32 template<> inline void SpellNotifierCreatureAndPlayer::Visit(CorpseMapType&) {} template<> inline void SpellNotifierCreatureAndPlayer::Visit(GameObjectMapType&) {} template<> inline void SpellNotifierCreatureAndPlayer::Visit(DynamicObjectMapType&) {} template<> inline void SpellNotifierCreatureAndPlayer::Visit(CameraMapType&) {} #endif } typedef void(Spell::*pEffect)(SpellEffectIndex eff_idx); class SpellEvent : public BasicEvent { public: SpellEvent(Spell* spell); virtual ~SpellEvent(); virtual bool Execute(uint64 e_time, uint32 p_time) override; virtual void Abort(uint64 e_time) override; virtual bool IsDeletable() const override; protected: Spell* m_Spell; }; #endif