void WorldSession::HandlePetStopAttack(WorldPacket & recv_data)
{
uint64 petGuid;
recv_data >> petGuid;
// used also for charmed creature/player
Unit* pet = ObjectAccessor::GetUnit(*GetPlayer(), petGuid);
if(!pet)
{
sLog.outError("pet %u doesn't exist.", uint32(GUID_LOPART(petGuid)));
return;
}
if(pet != GetPlayer()->GetPet() && pet != GetPlayer()->GetCharm())
{
sLog.outError("%u isn't pet or charm of player %s.", uint32(GUID_LOPART(petGuid)), GetPlayer()->GetName());
return;
}
if(!pet->isAlive())
return;
pet->AttackStop();
pet->StopMoving();
pet->GetMotionMaster()->Clear();
}
void RotateMovementGenerator::Initialize(Unit& owner)
{
if (owner.HasUnitState(UNIT_STAT_MOVE))
owner.StopMoving();
if (owner.getVictim())
owner.SetInFront(owner.getVictim());
owner.AddUnitState(UNIT_STAT_ROTATING);
}
void RotateMovementGenerator::Initialize(Unit& owner)
{
if (!owner.IsStopped())
owner.StopMoving();
if (owner.getVictim())
owner.SetInFront(owner.getVictim());
owner.AddUnitState(UNIT_STATE_ROTATING);
owner.AttackStop();
}
void FlyOrLandMovementGenerator::Initialize(Unit& unit)
{
if (unit.hasUnitState(UNIT_STAT_CAN_NOT_REACT | UNIT_STAT_NOT_MOVE))
return;
unit.StopMoving();
float x, y, z;
GetDestination(x, y, z);
unit.addUnitState(UNIT_STAT_ROAMING | UNIT_STAT_ROAMING_MOVE);
Movement::MoveSplineInit init(unit);
init.SetFly();
init.MoveTo(x, y, z, false);
init.Launch();
}
CanCastResult CreatureAI::DoCastSpellIfCan(Unit* pTarget, uint32 uiSpell, uint32 uiCastFlags, ObjectGuid uiOriginalCasterGUID)
{
Unit* pCaster = m_creature;
if (uiCastFlags & CAST_FORCE_TARGET_SELF)
pCaster = pTarget;
// Allowed to cast only if not casting (unless we interrupt ourself) or if spell is triggered
if (!pCaster->IsNonMeleeSpellCasted(false) || (uiCastFlags & (CAST_TRIGGERED | CAST_INTERRUPT_PREVIOUS)))
{
if (const SpellEntry* pSpell = sSpellStore.LookupEntry(uiSpell))
{
// If cast flag CAST_AURA_NOT_PRESENT is active, check if target already has aura on them
if (uiCastFlags & CAST_AURA_NOT_PRESENT)
{
if (pTarget->HasAura(uiSpell))
return CAST_FAIL_TARGET_AURA;
}
// Check if cannot cast spell
if (!(uiCastFlags & (CAST_FORCE_TARGET_SELF | CAST_FORCE_CAST)))
{
CanCastResult castResult = CanCastSpell(pTarget, pSpell, !!(uiCastFlags & CAST_TRIGGERED));
if (castResult != CAST_OK)
return castResult;
}
// Interrupt any previous spell
if (uiCastFlags & CAST_INTERRUPT_PREVIOUS && pCaster->IsNonMeleeSpellCasted(false))
pCaster->InterruptNonMeleeSpells(false);
// Creature should always stop before it will cast a new spell (logic applies to combat movement only)
if (pCaster->isInCombat())
pCaster->StopMoving();
pCaster->CastSpell(pTarget, pSpell, !!(uiCastFlags & CAST_TRIGGERED), nullptr, nullptr, uiOriginalCasterGUID);
return CAST_OK;
}
else
{
sLog.outErrorDb("DoCastSpellIfCan by creature entry %u attempt to cast spell %u but spell does not exist.", m_creature->GetEntry(), uiSpell);
return CAST_FAIL_OTHER;
}
}
else
return CAST_FAIL_IS_CASTING;
}
void FlyOrLandMovementGenerator::Initialize(Unit& unit)
{
if (unit.hasUnitState(UNIT_STAT_CAN_NOT_REACT | UNIT_STAT_NOT_MOVE))
return;
if (!unit.IsStopped())
unit.StopMoving();
float x, y, z;
GetDestination(x, y, z);
unit.addUnitState(UNIT_STAT_ROAMING | UNIT_STAT_ROAMING_MOVE);
Movement::MoveSplineInit init(unit);
init.SetFly();
init.SetAnimation((m_liftOff ? Movement::FlyToGround : Movement::ToGround));
init.MoveTo(x, y, z, false);
init.Launch();
}
void AssistanceMovementGenerator::Initialize(Unit& unit)
{
if (unit.hasUnitState(UNIT_STAT_CAN_NOT_REACT | UNIT_STAT_NOT_MOVE))
{ return; }
if (!unit.IsStopped())
{ unit.StopMoving(); }
unit.addUnitState(UNIT_STAT_ROAMING | UNIT_STAT_ROAMING_MOVE);
Movement::MoveSplineInit init(unit);
init.MoveTo(i_x, i_y, i_z, m_generatePath);
//Slow down the mob that is running for assistance
//TODO: There are different speeds for the different mobs, isn't there?
//That should probably be taken into account here
init.SetWalk(true);
init.Launch();
}
void WorldSession::HandlePetAction(WorldPacket& recv_data)
{
ObjectGuid petGuid;
uint32 data;
ObjectGuid targetGuid;
recv_data >> petGuid;
recv_data >> data;
recv_data >> targetGuid;
uint32 spellid = UNIT_ACTION_BUTTON_ACTION(data);
uint8 flag = UNIT_ACTION_BUTTON_TYPE(data); // delete = 0x07 CastSpell = C1
DETAIL_LOG("HandlePetAction: %s flag is %u, spellid is %u, target %s.", petGuid.GetString().c_str(), uint32(flag), spellid, targetGuid.GetString().c_str());
// used also for charmed creature/player
Unit* petUnit = _player->GetMap()->GetUnit(petGuid);
if (!petUnit)
{
sLog.outError("HandlePetAction: %s not exist.", petGuid.GetString().c_str());
return;
}
if (_player->GetObjectGuid() != petUnit->GetMasterGuid())
{
sLog.outError("HandlePetAction: %s isn't controlled by %s.", petGuid.GetString().c_str(), _player->GetGuidStr().c_str());
return;
}
if (!petUnit->isAlive())
return;
CharmInfo* charmInfo = petUnit->GetCharmInfo();
if (!charmInfo)
{
sLog.outError("WorldSession::HandlePetAction: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", petUnit->GetGUIDLow(), petUnit->GetTypeId());
return;
}
Pet* pet = nullptr;
Creature* creature = nullptr;
if (petUnit->GetTypeId() == TYPEID_UNIT)
{
creature = static_cast<Creature*>(petUnit);
if (creature->IsPet())
{
pet = static_cast<Pet*>(petUnit);
if (pet->GetModeFlags() & PET_MODE_DISABLE_ACTIONS)
return;
}
}
if (!pet)
{
if (petUnit->hasUnitState(UNIT_STAT_POSSESSED))
{
// possess case
if (flag != uint8(ACT_COMMAND))
{
sLog.outError("PetHAndler: unknown PET flag Action %i and spellid %i. For possessed %s", uint32(flag), spellid, petUnit->GetGuidStr().c_str());
return;
}
switch (spellid)
{
case COMMAND_STAY:
case COMMAND_FOLLOW:
charmInfo->SetCommandState(CommandStates(spellid));
break;
case COMMAND_ATTACK:
{
Unit* targetUnit = targetGuid ? _player->GetMap()->GetUnit(targetGuid) : nullptr;
if (targetUnit && targetUnit != petUnit && petUnit->CanAttack(targetUnit))
{
// This is true if pet has no target or has target but targets differs.
if (petUnit->getVictim() != targetUnit)
petUnit->Attack(targetUnit, true);
}
break;
}
case COMMAND_DISMISS:
_player->BreakCharmOutgoing(petUnit);
break;
default:
sLog.outError("PetHandler: Not allowed action %i and spellid %i. Pet %s owner is %s", uint32(flag), spellid, petUnit->GetGuidStr().c_str(), _player->GetGuidStr().c_str());
break;
}
}
if (!petUnit->HasCharmer())
return;
}
switch (flag)
{
case ACT_COMMAND: // 0x07
switch (spellid)
{
case COMMAND_STAY: // flat=1792 // STAY
{
if (!petUnit->hasUnitState(UNIT_STAT_POSSESSED))
{
petUnit->StopMoving();
petUnit->GetMotionMaster()->Clear();
}
petUnit->AttackStop(true, true);
charmInfo->SetCommandState(COMMAND_STAY);
break;
}
case COMMAND_FOLLOW: // spellid=1792 // FOLLOW
{
if (!petUnit->hasUnitState(UNIT_STAT_POSSESSED))
{
petUnit->StopMoving();
petUnit->GetMotionMaster()->Clear();
charmInfo->SetIsRetreating(true);
}
petUnit->AttackStop(true, true);
charmInfo->SetCommandState(COMMAND_FOLLOW);
break;
}
case COMMAND_ATTACK: // spellid=1792 // ATTACK
{
charmInfo->SetIsRetreating();
charmInfo->SetSpellOpener();
Unit* targetUnit = targetGuid ? _player->GetMap()->GetUnit(targetGuid) : nullptr;
if (targetUnit && targetUnit != petUnit && petUnit->CanAttack(targetUnit) && targetUnit->isInAccessablePlaceFor((Creature*)petUnit))
{
// This is true if pet has no target or has target but targets differs.
if (petUnit->getVictim() != targetUnit)
{
petUnit->AttackStop();
if (!petUnit->hasUnitState(UNIT_STAT_POSSESSED))
{
petUnit->GetMotionMaster()->Clear();
petUnit->AI()->AttackStart(targetUnit);
if (pet)
{
// 10% chance to play special warlock pet attack talk, else growl
if (pet->getPetType() == SUMMON_PET && roll_chance_i(10))
pet->SendPetTalk((uint32)PET_TALK_ATTACK);
pet->SendPetAIReaction();
}
}
else
petUnit->Attack(targetUnit, true);
}
}
break;
}
case COMMAND_DISMISS: // dismiss permanent pet, remove temporary pet, uncharm unit
{
if (pet)
{
pet->PlayDismissSound();
// No action for Hunter pets, Hunters must use their Dismiss Pet spell
if (pet->getPetType() != HUNTER_PET)
pet->ForcedDespawn();
}
else
{
// dismissing a summoned pet is like killing them (this prevents returning a soulshard...)
if (creature && creature->IsTemporarySummon())
creature->ForcedDespawn();
else
_player->BreakCharmOutgoing(petUnit);
}
charmInfo->SetStayPosition();
break;
}
default:
sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
}
break;
case ACT_REACTION: // 0x6
switch (spellid)
{
case REACT_PASSIVE: // passive
{
petUnit->AttackStop(true, true);
charmInfo->SetSpellOpener();
}
case REACT_DEFENSIVE: // recovery
case REACT_AGGRESSIVE: // activete
{
petUnit->AI()->SetReactState(ReactStates(spellid));
break;
}
}
break;
case ACT_DISABLED: // 0x81 spell (disabled), ignore
case ACT_PASSIVE: // 0x01
case ACT_ENABLED: // 0xC1 spell
{
charmInfo->SetIsRetreating();
charmInfo->SetSpellOpener();
Unit* unit_target = targetGuid ? _player->GetMap()->GetUnit(targetGuid) : nullptr;
// do not cast unknown spells
SpellEntry const* spellInfo = sSpellTemplate.LookupEntry<SpellEntry>(spellid);
if (!spellInfo)
{
sLog.outError("WORLD: unknown PET spell id %i", spellid);
return;
}
// do not cast not learned spells
if (IsPassiveSpell(spellInfo) || !petUnit->HasSpell(spellid))
return;
if (!petUnit->IsSpellReady(*spellInfo))
return;
for (unsigned int i : spellInfo->EffectImplicitTargetA)
{
if (i == TARGET_ENUM_UNITS_ENEMY_AOE_AT_SRC_LOC
|| i == TARGET_ENUM_UNITS_ENEMY_AOE_AT_DEST_LOC
|| i == TARGET_ENUM_UNITS_ENEMY_AOE_AT_DYNOBJ_LOC)
return;
}
petUnit->clearUnitState(UNIT_STAT_MOVING);
uint32 flags = TRIGGERED_NONE;
if (!petUnit->hasUnitState(UNIT_STAT_POSSESSED))
flags |= TRIGGERED_PET_CAST;
Spell* spell = new Spell(petUnit, spellInfo, flags);
SpellCastResult result = spell->CheckPetCast(unit_target);
const SpellRangeEntry* sRange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex);
if (unit_target && !(petUnit->IsWithinDistInMap(unit_target, sRange->maxRange) && petUnit->IsWithinLOSInMap(unit_target))
&& petUnit->CanAttackNow(unit_target))
{
charmInfo->SetSpellOpener(spellid, sRange->minRange, sRange->maxRange);
spell->finish(false);
delete spell;
petUnit->AttackStop();
if (!petUnit->hasUnitState(UNIT_STAT_POSSESSED))
{
petUnit->GetMotionMaster()->Clear();
petUnit->AI()->AttackStart(unit_target);
// 10% chance to play special warlock pet attack talk, else growl
if (pet && pet->getPetType() == SUMMON_PET && pet != unit_target && roll_chance_i(10))
petUnit->SendPetTalk((uint32)PET_TALK_ATTACK);
petUnit->SendPetAIReaction();
}
else
petUnit->Attack(unit_target, true);
return;
}
// auto turn to target unless possessed
if (result == SPELL_FAILED_UNIT_NOT_INFRONT && !petUnit->hasUnitState(UNIT_STAT_POSSESSED))
{
if (unit_target)
{
petUnit->SetInFront(unit_target);
if (unit_target->GetTypeId() == TYPEID_PLAYER)
petUnit->SendCreateUpdateToPlayer((Player*)unit_target);
}
else if (Unit* unit_target2 = spell->m_targets.getUnitTarget())
{
petUnit->SetInFront(unit_target2);
if (unit_target2->GetTypeId() == TYPEID_PLAYER)
petUnit->SendCreateUpdateToPlayer((Player*)unit_target2);
}
if (Unit* powner = petUnit->GetMaster())
if (powner->GetTypeId() == TYPEID_PLAYER)
petUnit->SendCreateUpdateToPlayer((Player*)powner);
result = SPELL_CAST_OK;
}
if (result == SPELL_CAST_OK)
{
charmInfo->SetSpellOpener();
spell->SpellStart(&(spell->m_targets));
}
else
{
if (creature && creature->IsSpellReady(*spellInfo))
GetPlayer()->SendClearCooldown(spellid, petUnit);
charmInfo->SetSpellOpener();
spell->finish(false);
delete spell;
}
break;
}
default:
sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
}
}
CanCastResult UnitAI::DoCastSpellIfCan(Unit* target, uint32 spellId, uint32 castFlags, ObjectGuid originalCasterGUID) const
{
Unit* caster = m_unit;
if (target)
{
if (castFlags & CAST_SWITCH_CASTER_TARGET)
std::swap(caster, target);
if (castFlags & CAST_FORCE_TARGET_SELF)
caster = target;
}
else if (castFlags & (CAST_FORCE_TARGET_SELF | CAST_SWITCH_CASTER_TARGET))
return CAST_FAIL_OTHER;
// Allowed to cast only if not casting (unless we interrupt ourself) or if spell is triggered
if (!caster->IsNonMeleeSpellCasted(false) || (castFlags & (CAST_TRIGGERED | CAST_INTERRUPT_PREVIOUS)))
{
if (const SpellEntry* spellInfo = sSpellTemplate.LookupEntry<SpellEntry>(spellId))
{
// If cast flag CAST_AURA_NOT_PRESENT is active, check if target already has aura on them
if (castFlags & CAST_AURA_NOT_PRESENT)
{
if (!target)
{
if (caster->HasAura(spellId))
return CAST_FAIL_TARGET_AURA;
}
else if (target->HasAura(spellId))
return CAST_FAIL_TARGET_AURA;
}
// Check if cannot cast spell
if (!(castFlags & (CAST_FORCE_TARGET_SELF | CAST_FORCE_CAST)))
{
CanCastResult castResult = CanCastSpell(target, spellInfo, (castFlags & CAST_TRIGGERED) != 0);
if (castResult != CAST_OK)
return castResult;
}
// Interrupt any previous spell
if (castFlags & CAST_INTERRUPT_PREVIOUS && caster->IsNonMeleeSpellCasted(false))
caster->InterruptNonMeleeSpells(false);
// Creature should always stop before it will cast a non-instant spell
if (GetSpellCastTime(spellInfo) || (IsChanneledSpell(spellInfo) && spellInfo->ChannelInterruptFlags & CHANNEL_FLAG_MOVEMENT))
caster->StopMoving();
// Creature should interrupt any current melee spell
caster->InterruptSpell(CURRENT_MELEE_SPELL);
// Creature should stop wielding weapon while casting
// caster->SetSheath(SHEATH_STATE_UNARMED);
uint32 flags = (castFlags & CAST_TRIGGERED ? TRIGGERED_OLD_TRIGGERED : TRIGGERED_NONE) | (castFlags & CAST_IGNORE_UNSELECTABLE_TARGET ? TRIGGERED_IGNORE_UNSELECTABLE_FLAG : TRIGGERED_NONE);
if (flags == TRIGGERED_NONE)
flags |= TRIGGERED_NORMAL_COMBAT_CAST;
caster->CastSpell(target, spellInfo, flags, nullptr, nullptr, originalCasterGUID);
return CAST_OK;
}
sLog.outErrorDb("DoCastSpellIfCan by %s attempt to cast spell %u but spell does not exist.", m_unit->GetObjectGuid().GetString().c_str(), spellId);
return CAST_FAIL_OTHER;
}
return CAST_FAIL_IS_CASTING;
}
void
IdleMovementGenerator::Reset(Unit& owner)
{
if (owner.hasUnitState(UNIT_STAT_MOVE))
owner.StopMoving();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if (StormCount)
{
Unit* pTarget = Unit::GetUnit(*me, CloudGUID);
if (!pTarget || !pTarget->IsAlive())
{
EnterEvadeMode();
return;
}
else if (Unit* Cyclone = Unit::GetUnit(*me, CycloneGUID))
Cyclone->CastSpell(pTarget, 25160, true); // keep casting or...
if (StormSequenceTimer <= diff)
HandleStormSequence(pTarget);
else
StormSequenceTimer -= diff;
return;
}
if (Enrage_Timer <= diff)
{
me->MonsterYell(SAY_ONENRAGE, LANG_UNIVERSAL, 0);
DoPlaySoundToSet(me, SOUND_ONENRAGE);
DoCast(me, SPELL_BERSERK, true);
Enrage_Timer = (diff - Enrage_Timer) + 600000;
}
else
Enrage_Timer -= diff;
if (StaticDisruption_Timer <= diff)
{
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
if (!pTarget) pTarget = me->GetVictim();
TargetGUID = pTarget->GetGUID();
DoCast(pTarget, SPELL_STATIC_DISRUPTION, false);
me->SetInFront(me->GetVictim());
StaticDisruption_Timer = (diff - StaticDisruption_Timer) + (10 + rand() % 8) * 1000; // < 20s
/*if (float dist = me->IsWithinDist3d(pTarget->GetPositionX(), pTarget->GetPositionY(), pTarget->GetPositionZ(), 5.0f) dist = 5.0f;
SDisruptAOEVisual_Timer = 1000 + floor(dist / 30 * 1000.0f);*/
}
else
StaticDisruption_Timer -= diff;
if (GustOfWind_Timer <= diff)
{
Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 1);
if (!pTarget) pTarget = me->GetVictim();
DoCast(pTarget, SPELL_GUST_OF_WIND);
GustOfWind_Timer = (diff - GustOfWind_Timer) + (20 + rand() % 10) * 1000; //20 to 30 seconds(bosskillers)
}
else
GustOfWind_Timer -= diff;
if (CallLighting_Timer <= diff)
{
DoCastVictim( SPELL_CALL_LIGHTNING);
CallLighting_Timer = (diff - CallLighting_Timer) + (12 + rand() % 5) * 1000; //totaly random timer. can't find any info on this
}
else
CallLighting_Timer -= diff;
if (!isRaining && ElectricalStorm_Timer < 8000 + urand(0, 5000))
{
SetWeather(WEATHER_STATE_HEAVY_RAIN, 0.9999f);
isRaining = true;
}
if (ElectricalStorm_Timer <= diff)
{
Unit* pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true);
if (!pTarget)
{
EnterEvadeMode();
return;
}
pTarget->CastSpell(pTarget, SPELL_ELECTRICAL_STORM_VISUAL, true);//cloud visual
DoCast(pTarget, SPELL_ELECTRICAL_STORM, false);//storm cyclon + visual
float x, y, z;
pTarget->GetPosition(x, y, z);
pTarget->SetLevitate(true);
Movement::MoveSplineInit init(*me);
init.MoveTo(x, y, me->GetPositionZ() + 15.0f, true);
init.Launch();
Unit* Cloud = me->SummonTrigger(x, y, me->GetPositionZ() + 16, 0, 15000);
if (Cloud)
{
CloudGUID = Cloud->GetGUID();
Cloud->SetLevitate(true);
Cloud->StopMoving();
Cloud->SetObjectScale(1.0f);
Cloud->setFaction(35);
Cloud->SetMaxHealth(9999999);
Cloud->SetHealth(9999999);
Cloud->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
ElectricalStorm_Timer = (diff - ElectricalStorm_Timer) + 60000; //60 seconds (bosskillers)
StormCount = 1;
StormSequenceTimer = 0;
}
else
ElectricalStorm_Timer -= diff;
if (SummonEagles_Timer <= diff)
{
if (urand(0, 1))
{
me->MonsterYell(SAY_ONSUMMON2, LANG_UNIVERSAL, 0);
DoPlaySoundToSet(me, SOUND_ONSUMMON1);
}
else
{
me->MonsterYell(SAY_ONSUMMON2, LANG_UNIVERSAL, 0);
DoPlaySoundToSet(me, SOUND_ONSUMMON2);
}
float x, y, z;
me->GetPosition(x, y, z);
for (uint8 i = 0; i < 8; ++i)
{
if (!Unit::GetUnit(*me, BirdGUIDs[i])) // they despawn on death
{
if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
{
x = pTarget->GetPositionX() + irand(-10, 10);
y = pTarget->GetPositionY() + irand(-10, 10);
z = pTarget->GetPositionZ() + urand(16, 20);
if (z > 95)
z = 95 - urand(0, 5);
}
if (Creature* pCreature = me->SummonCreature(MOB_SOARING_EAGLE, x, y, z, 0, TEMPSUMMON_CORPSE_DESPAWN, 0))
{
pCreature->AddThreat(me->GetVictim(), 1.0f);
pCreature->AI()->AttackStart(me->GetVictim());
BirdGUIDs[i] = pCreature->GetGUID();
}
}
}
SummonEagles_Timer = (diff - SummonEagles_Timer) + 999999;
}
else
SummonEagles_Timer -= diff;
DoMeleeAttackIfReady();
}
/// Remove control and such modifiers to a passenger if they were added
void VehicleInfo::RemoveSeatMods(Unit* passenger, uint32 seatFlags)
{
Unit* pVehicle = (Unit*)m_owner;
if (seatFlags & SEAT_FLAG_NOT_SELECTABLE)
passenger->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
// ToDo: reset passenger model id for SEAT_FLAG_HIDE_PASSENGER?
if (passenger->GetTypeId() == TYPEID_PLAYER)
{
Player* pPlayer = (Player*)passenger;
// group update
if (pPlayer->GetGroup())
pPlayer->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_VEHICLE_SEAT);
if (seatFlags & SEAT_FLAG_CAN_CONTROL)
{
pPlayer->SetCharm(nullptr);
pVehicle->SetCharmer(nullptr);
pPlayer->UpdateClientControl(pVehicle, false);
pPlayer->SetMover(nullptr);
pVehicle->StopMoving(true);
pVehicle->GetMotionMaster()->Clear();
pVehicle->clearUnitState(UNIT_STAT_POSSESSED);
pVehicle->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_POSSESSED);
pVehicle->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
// must be called after movement control unapplying
pPlayer->GetCamera().ResetView();
if (pVehicle->GetTypeId() == TYPEID_UNIT)
{
// reset vehicle faction
((Creature*)pVehicle)->ClearTemporaryFaction();
// Reset react state
if (!(GetVehicleEntry()->m_flags & VEHICLE_FLAG_PASSIVE))
pVehicle->AI()->SetReactState(REACT_AGGRESSIVE);
}
}
if (seatFlags & SEAT_FLAG_CAN_CAST)
pPlayer->RemovePetActionBar();
}
else if (passenger->GetTypeId() == TYPEID_UNIT)
{
if (seatFlags & SEAT_FLAG_CAN_CONTROL)
{
passenger->SetCharm(nullptr);
pVehicle->SetCharmer(nullptr);
}
// Reinitialize movement
if (((Creature*)passenger)->AI())
((Creature*)passenger)->AI()->SetCombatMovement(true, true);
if (!passenger->getVictim())
passenger->GetMotionMaster()->Initialize();
}
}
void WorldSession::HandlePetAction(WorldPacket& recv_data)
{
ObjectGuid petGuid;
uint32 data;
ObjectGuid targetGuid;
float x, y, z;
recv_data >> petGuid;
recv_data >> data;
recv_data >> targetGuid;
recv_data >> x >> y >> z;
uint32 spellid = UNIT_ACTION_BUTTON_ACTION(data);
uint8 flag = UNIT_ACTION_BUTTON_TYPE(data); // delete = 0x07 CastSpell = C1
DETAIL_LOG("HandlePetAction: %s flag is %u, spellid is %u, target %s.", petGuid.GetString().c_str(), uint32(flag), spellid, targetGuid.GetString().c_str());
// used also for charmed creature/player
Unit* pet = _player->GetMap()->GetUnit(petGuid);
if (!pet)
{
sLog.outError("HandlePetAction: %s not exist.", petGuid.GetString().c_str());
return;
}
if (_player->GetObjectGuid() != pet->GetCharmerOrOwnerGuid())
{
sLog.outError("HandlePetAction: %s isn't controlled by %s.", petGuid.GetString().c_str(), _player->GetGuidStr().c_str());
return;
}
if (!pet->isAlive())
return;
if (pet->GetTypeId() == TYPEID_PLAYER && pet->GetCharmer()->GetTypeId() == TYPEID_PLAYER)
{
// controller player cannot use controlled player's spells
if (flag != (ACT_COMMAND || ACT_REACTION))
return;
}
else if (((Creature*)pet)->IsPet())
{
// pet can have action bar disabled
if (((Pet*)pet)->GetModeFlags() & PET_MODE_DISABLE_ACTIONS)
return;
}
CharmInfo* charmInfo = pet->GetCharmInfo();
if (!charmInfo)
{
sLog.outError("WorldSession::HandlePetAction: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), pet->GetTypeId());
return;
}
switch (flag)
{
case ACT_COMMAND: // 0x07
switch (spellid)
{
case COMMAND_STAY: // flat=1792 // STAY
{
pet->StopMoving();
pet->AttackStop(true, true);
pet->GetMotionMaster()->Clear();
((Pet*)pet)->SetStayPosition(true);
((Pet*)pet)->SetIsRetreating();
((Pet*)pet)->SetSpellOpener();
charmInfo->SetCommandState(COMMAND_STAY);
break;
}
case COMMAND_FOLLOW: // spellid=1792 // FOLLOW
{
pet->StopMoving();
pet->AttackStop(true, true);
pet->GetMotionMaster()->Clear();
((Pet*)pet)->SetStayPosition();
((Pet*)pet)->SetIsRetreating(true);
((Pet*)pet)->SetSpellOpener();
charmInfo->SetCommandState(COMMAND_FOLLOW);
break;
}
case COMMAND_ATTACK: // spellid=1792 // ATTACK
{
((Pet*)pet)->SetIsRetreating();
((Pet*)pet)->SetSpellOpener();
Unit* targetUnit = targetGuid ? _player->GetMap()->GetUnit(targetGuid) : nullptr;
if (targetUnit && targetUnit != pet && targetUnit->isTargetableForAttack() && targetUnit->isInAccessablePlaceFor((Creature*)pet))
{
_player->SetInCombatState(true, targetUnit);
// This is true if pet has no target or has target but targets differs.
if (pet->getVictim() != targetUnit)
{
pet->AttackStop();
pet->GetMotionMaster()->Clear();
if (((Creature*)pet)->AI())
{
((Creature*)pet)->AI()->AttackStart(targetUnit);
// 10% chance to play special warlock pet attack talk, else growl
if (((Creature*)pet)->IsPet() && ((Pet*)pet)->getPetType() == SUMMON_PET && roll_chance_i(10))
pet->SendPetTalk((uint32)PET_TALK_ATTACK);
pet->SendPetAIReaction();
}
else
pet->Attack(targetUnit, true);
}
}
break;
}
case COMMAND_ABANDON: // abandon (hunter pet) or dismiss (summoned pet)
{
Creature* petC = (Creature*)pet;
if (petC->IsPet())
{
Pet* p = (Pet*)petC;
if (p->getPetType() == HUNTER_PET)
p->Unsummon(PET_SAVE_AS_DELETED, _player);
else
// dismissing a summoned pet is like killing them (this prevents returning a soulshard...)
p->SetDeathState(CORPSE);
}
else // charmed
_player->Uncharm();
if (petC->IsTemporarySummon()) // special case when pet was temporary summon through DoSummonPossesed
{
petC->ForcedDespawn();
return;
}
((Pet*)pet)->SetStayPosition();
break;
}
default:
sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
}
break;
case ACT_REACTION: // 0x6
switch (spellid)
{
case REACT_PASSIVE: // passive
{
pet->AttackStop(true, true);
((Pet*)pet)->SetSpellOpener();
}
case REACT_DEFENSIVE: // recovery
case REACT_AGGRESSIVE: // activete
{
charmInfo->SetReactState(ReactStates(spellid));
break;
}
}
break;
case ACT_DISABLED: // 0x81 spell (disabled), ignore
case ACT_PASSIVE: // 0x01
case ACT_ENABLED: // 0xC1 spell
{
((Pet*)pet)->SetIsRetreating();
((Pet*)pet)->SetSpellOpener();
Unit* unit_target = targetGuid ? _player->GetMap()->GetUnit(targetGuid) : nullptr;
// do not cast unknown spells
SpellEntry const* spellInfo = sSpellStore.LookupEntry(spellid);
if (!spellInfo)
{
sLog.outError("WORLD: unknown PET spell id %i", spellid);
return;
}
if (pet->GetCharmInfo() && pet->GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(spellInfo))
return;
for (int i = 0; i < MAX_EFFECT_INDEX; ++i)
{
SpellEffectEntry const* spellEffect = spellInfo->GetSpellEffect(SpellEffectIndex(i));
if (!spellEffect)
continue;
if (spellEffect->EffectImplicitTargetA == TARGET_ALL_ENEMY_IN_AREA
|| spellEffect->EffectImplicitTargetA == TARGET_ALL_ENEMY_IN_AREA_INSTANT
|| spellEffect->EffectImplicitTargetA == TARGET_ALL_ENEMY_IN_AREA_CHANNELED)
return;
}
// do not cast not learned spells
if (!pet->HasSpell(spellid) || IsPassiveSpell(spellInfo))
return;
pet->clearUnitState(UNIT_STAT_MOVING);
Spell* spell = new Spell(pet, spellInfo, false);
SpellCastResult result = spell->CheckPetCast(unit_target);
const SpellRangeEntry* sRange = sSpellRangeStore.LookupEntry(spellInfo->rangeIndex);
if (unit_target && !(pet->IsWithinDistInMap(unit_target, sRange->maxRange) && pet->IsWithinLOSInMap(unit_target))
&& !(GetPlayer()->IsFriendlyTo(unit_target) || pet->HasAuraType(SPELL_AURA_MOD_POSSESS)))
{
((Pet*)pet)->SetSpellOpener(spellid, sRange->minRange, sRange->maxRange);
spell->finish(false);
delete spell;
pet->AttackStop();
pet->GetMotionMaster()->Clear();
((Creature*)pet)->AI()->AttackStart(unit_target);
// 10% chance to play special warlock pet attack talk, else growl
if (((Creature*)pet)->IsPet() && ((Pet*)pet)->getPetType() == SUMMON_PET && pet != unit_target && roll_chance_i(10))
pet->SendPetTalk((uint32)PET_TALK_ATTACK);
pet->SendPetAIReaction();
return;
}
// auto turn to target unless possessed
if (result == SPELL_FAILED_UNIT_NOT_INFRONT && !pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
{
if (unit_target)
{
pet->SetInFront(unit_target);
if (unit_target->GetTypeId() == TYPEID_PLAYER)
pet->SendCreateUpdateToPlayer((Player*)unit_target);
}
else if (Unit* unit_target2 = spell->m_targets.getUnitTarget())
{
pet->SetInFront(unit_target2);
if (unit_target2->GetTypeId() == TYPEID_PLAYER)
pet->SendCreateUpdateToPlayer((Player*)unit_target2);
}
if (Unit* powner = pet->GetCharmerOrOwner())
if (powner->GetTypeId() == TYPEID_PLAYER)
pet->SendCreateUpdateToPlayer((Player*)powner);
result = SPELL_CAST_OK;
}
if (result == SPELL_CAST_OK)
{
((Creature*)pet)->AddCreatureSpellCooldown(spellid);
unit_target = spell->m_targets.getUnitTarget();
if (unit_target && !GetPlayer()->IsFriendlyTo(unit_target) && !pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
{
// This is true if pet has no target or has target but targets differs.
if (pet->getVictim() != unit_target)
{
pet->AttackStop();
pet->GetMotionMaster()->Clear();
_player->SetInCombatState(true, unit_target);
if (((Creature*)pet)->AI())
{
((Creature*)pet)->AI()->AttackStart(unit_target);
// 10% chance to play special warlock pet attack talk, else growl
if (((Creature*)pet)->IsPet() && ((Pet*)pet)->getPetType() == SUMMON_PET && pet != unit_target && roll_chance_i(10))
pet->SendPetTalk((uint32)PET_TALK_ATTACK);
pet->SendPetAIReaction();
}
else
pet->Attack(unit_target, true);
}
}
((Pet*)pet)->SetSpellOpener();
spell->SpellStart(&(spell->m_targets));
}
else
{
if (pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
Spell::SendCastResult(GetPlayer(), spellInfo, 0, result);
else
{
Unit* owner = pet->GetCharmerOrOwner();
if (owner && owner->GetTypeId() == TYPEID_PLAYER)
Spell::SendCastResult((Player*)owner, spellInfo, 0, result, true);
}
if (!((Creature*)pet)->HasSpellCooldown(spellid))
GetPlayer()->SendClearCooldown(spellid, pet);
((Pet*)pet)->SetSpellOpener();
spell->finish(false);
delete spell;
}
break;
}
default:
sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (!m_bFirstPlanar && !m_bIsRegularMode && m_creature->GetHealthPercent() < 50.0f)
{
m_bFirstPlanar = true;
Events.ScheduleEvent(EVENT_PLANAR_SHIFT, 0);
}
if (!m_bSecondPlanar && !m_bIsRegularMode && m_creature->GetHealthPercent() < 25.0f)
{
m_bSecondPlanar = true;
Events.ScheduleEvent(EVENT_PLANAR_SHIFT, 0);
}
if (m_creature->GetDistance2d(m_creature->getVictim()) > 35.0f && !m_bIsMove)
{
m_bIsMove = true;
SetCombatMovement(m_bIsMove);
if (Unit* pTarget = m_creature->getVictim())
m_creature->GetMotionMaster()->MoveChase(pTarget);
}
if (m_creature->GetDistance2d(m_creature->getVictim()) < 20.0f && m_bIsMove)
{
m_bIsMove = false;
SetCombatMovement(m_bIsMove);
m_creature->GetMotionMaster()->Clear(false);
m_creature->GetMotionMaster()->MoveIdle();
m_creature->StopMoving();
}
Events.Update(uiDiff);
while (uint32 uiEventId = Events.ExecuteEvent())
switch (uiEventId)
{
case EVENT_DRAKE_COLOR_CHECK:
CheckDrakeColors();
break;
case EVENT_ARCANE_BARRAGE:
DoCast(m_creature->getVictim(), m_bIsRegularMode ? SPELL_ARCANE_BARRAGE_N : SPELL_ARCANE_BARRAGE_H);
break;
case EVENT_ARCANE_VOLLEY:
DoCast(m_creature->getVictim(), m_bIsRegularMode ? SPELL_ARCANE_VOLLEY_N : SPELL_ARCANE_VOLLEY_H);
break;
case EVENT_PLANAR_SHIFT:
m_creature->MonsterTextEmote(EMOTE_PLANAR_SHIFT, m_creature, true);
Events.DelayEvents(18*IN_MILLISECONDS);
m_creature->InterruptNonMeleeSpells(false);
DoCast(m_creature, SPELL_PLANAR_SHIFT, false);
Events.ScheduleEvent(EVENT_ENRAGED_ASSAULT, 19*IN_MILLISECONDS);
Events.ScheduleEvent(EVENT_PLANAR_ANOMALITIES, 2*IN_MILLISECONDS);
break;
case EVENT_ENRAGED_ASSAULT:
DoCast(m_creature, SPELL_ENRAGED_ASSAULT, true);
break;
case EVENT_PLANAR_ANOMALITIES:
DoCast(m_creature, SPELL_PLANAR_ANOMALIES, true);
break;
case EVENT_SUMMON_DRAKES:
if (SummonMgr.GetSummonCount(NPC_DRAGON) > MAX_DRAGON_COUNT)
break;
for (int i = 0 ; i < 3 ; i++)
{
//DoCast(m_creature, SPELL_SUMMON_DRAKE, true); // summoned @ ground position
Unit* pSumm = SummonMgr.SummonCreature(NPC_DRAGON, m_creature->GetPositionX() - 5 + urand(0, 10), m_creature->GetPositionY() - 5 + urand(0, 10),
m_creature->GetPositionZ() - 5 + urand(0, 10), 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
if (Unit* pPlayer = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM_PLAYER, 0))
{
if (pPlayer->GetVehicle())
if (Unit* pDrake = pPlayer->GetVehicle()->GetBase())
{
pSumm->AddThreat(pDrake, 10000.0f);
pSumm->GetMotionMaster()->MoveIdle();
pSumm->StopMoving();
pSumm->GetMotionMaster()->MoveChase(pDrake, 20.0f);
}
}
}
break;
default:
break;
}
DoMeleeAttackIfReady();
}
// StopMoving is needed to make unit stop if its last movement generator expires
// But it should not be sent otherwise there are many redundent packets
void IdleMovementGenerator::Initialize(Unit& owner)
{
if (owner.HasUnitState(UNIT_STATE_MOVE))
owner.StopMoving();
}
void IdleMovementGenerator::Reset(Unit& owner)
{
if (!owner.IsStopped())
owner.StopMoving();
}
void UpdateAI(uint32 diff) override
{
if (!UpdateVictim())
return;
events.Update(diff);
while (uint32 eventId = events.ExecuteEvent())
{
switch (eventId)
{
case EVENT_STATIC_DISRUPTION:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target)
target = me->GetVictim();
if (target)
{
TargetGUID = target->GetGUID();
DoCast(target, SPELL_STATIC_DISRUPTION, false);
me->SetInFront(me->GetVictim());
}
/*if (float dist = me->IsWithinDist3d(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 5.0f) dist = 5.0f;
SDisruptAOEVisual_Timer = 1000 + floor(dist / 30 * 1000.0f);*/
events.ScheduleEvent(EVENT_STATIC_DISRUPTION, urand(10000, 18000));
break;
}
case EVENT_GUST_OF_WIND:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (!target)
target = me->GetVictim();
if (target)
DoCast(target, SPELL_GUST_OF_WIND);
events.ScheduleEvent(EVENT_GUST_OF_WIND, urand(20000, 30000));
break;
}
case EVENT_CALL_LIGHTNING:
DoCastVictim(SPELL_CALL_LIGHTNING);
events.ScheduleEvent(EVENT_CALL_LIGHTNING, urand(12000, 17000)); // totaly random timer. can't find any info on this
break;
case EVENT_ELECTRICAL_STORM:
{
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true);
if (!target)
{
EnterEvadeMode();
return;
}
target->CastSpell(target, 44007, true); // cloud visual
DoCast(target, SPELL_ELECTRICAL_STORM, false); // storm cyclon + visual
float x, y, z;
target->GetPosition(x, y, z);
/// @todo: fix it in correct way, that causes player to can fly until logout
/*
if (target)
{
target->SetDisableGravity(true);
target->MonsterMoveWithSpeed(x, y, me->GetPositionZ()+15, 0);
}
*/
Unit* Cloud = me->SummonTrigger(x, y, me->GetPositionZ()+16, 0, 15000);
if (Cloud)
{
CloudGUID = Cloud->GetGUID();
Cloud->SetDisableGravity(true);
Cloud->StopMoving();
Cloud->SetObjectScale(1.0f);
Cloud->setFaction(35);
Cloud->SetMaxHealth(9999999);
Cloud->SetHealth(9999999);
Cloud->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
StormCount = 1;
events.ScheduleEvent(EVENT_ELECTRICAL_STORM, 60000); // 60 seconds(bosskillers)
events.ScheduleEvent(EVENT_RAIN, urand(47000, 52000));
break;
}
case EVENT_RAIN:
if (!isRaining)
{
SetWeather(WEATHER_STATE_HEAVY_RAIN, 0.9999f);
isRaining = true;
}
else
events.ScheduleEvent(EVENT_RAIN, 1000);
break;
case EVENT_STORM_SEQUENCE:
{
Unit* target = ObjectAccessor::GetUnit(*me, CloudGUID);
if (!target || !target->IsAlive())
{
EnterEvadeMode();
return;
}
else if (Unit* Cyclone = ObjectAccessor::GetUnit(*me, CycloneGUID))
Cyclone->CastSpell(target, SPELL_SAND_STORM, true); // keep casting or...
HandleStormSequence(target);
break;
}
case EVENT_SUMMON_EAGLES:
Talk(SAY_SUMMON);
float x, y, z;
me->GetPosition(x, y, z);
for (uint8 i = 0; i < 8; ++i)
{
Unit* bird = ObjectAccessor::GetUnit(*me, BirdGUIDs[i]);
if (!bird) //they despawned on die
{
if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
{
x = target->GetPositionX() + irand(-10, 10);
y = target->GetPositionY() + irand(-10, 10);
z = target->GetPositionZ() + urand(16, 20);
if (z > 95)
z = 95.0f - urand(0, 5);
}
Creature* creature = me->SummonCreature(NPC_SOARING_EAGLE, x, y, z, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
if (creature)
{
creature->AddThreat(me->GetVictim(), 1.0f);
creature->AI()->AttackStart(me->GetVictim());
BirdGUIDs[i] = creature->GetGUID();
}
}
}
break;
case EVENT_ENRAGE:
Talk(SAY_ENRAGE);
DoCast(me, SPELL_BERSERK, true);
events.ScheduleEvent(EVENT_ENRAGE, 600000);
break;
default:
break;
}
}
DoMeleeAttackIfReady();
}
void UpdateAI(const uint32 diff)
{
if (!UpdateVictim())
return;
if(StormCount)
{
Unit* target = Unit::GetUnit(*m_creature, CloudGUID);
if(!target || !target->isAlive())
{
EnterEvadeMode();
return;
}
else if(Unit* Cyclone = Unit::GetUnit(*m_creature, CycloneGUID))
Cyclone->CastSpell(target, 25160, true); // keep casting or...
if(StormSequenceTimer < diff) {
HandleStormSequence(target);
}else StormSequenceTimer -= diff;
return;
}
if (Enrage_Timer < diff) {
DoYell(SAY_ONENRAGE, LANG_UNIVERSAL, NULL);
DoPlaySoundToSet(m_creature, SOUND_ONENRAGE);
m_creature->CastSpell(m_creature, SPELL_BERSERK, true);
Enrage_Timer = 600000;
}else Enrage_Timer -= diff;
if (StaticDisruption_Timer < diff) {
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1);
if(!target) target = m_creature->getVictim();
TargetGUID = target->GetGUID();
m_creature->CastSpell(target, SPELL_STATIC_DISRUPTION, false);
m_creature->SetInFront(m_creature->getVictim());
StaticDisruption_Timer = (10+rand()%8)*1000; // < 20s
/*if(float dist = m_creature->IsWithinDist3d(target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 5.0f) dist = 5.0f;
SDisruptAOEVisual_Timer = 1000 + floor(dist / 30 * 1000.0f);*/
}else StaticDisruption_Timer -= diff;
if (GustOfWind_Timer < diff) {
Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 1);
if(!target) target = m_creature->getVictim();
DoCast(target, SPELL_GUST_OF_WIND);
GustOfWind_Timer = (20+rand()%10)*1000; //20 to 30 seconds(bosskillers)
} else GustOfWind_Timer -= diff;
if (CallLighting_Timer < diff) {
DoCast(m_creature->getVictim(), SPELL_CALL_LIGHTNING);
CallLighting_Timer = (12 + rand()%5)*1000; //totaly random timer. can't find any info on this
} else CallLighting_Timer -= diff;
if (!isRaining && ElectricalStorm_Timer < 8000 + rand()%5000) {
SetWeather(WEATHER_STATE_HEAVY_RAIN, 0.9999f);
isRaining = true;
}
if (ElectricalStorm_Timer < diff) {
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0, 50, true);
if(!target)
{
EnterEvadeMode();
return;
}
target->CastSpell(target, 44007, true);//cloud visual
m_creature->CastSpell(target, SPELL_ELECTRICAL_STORM, false);//storm cyclon + visual
float x,y,z;
target->GetPosition(x,y,z);
if (target)
{
target->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING);
target->SendMonsterMove(x,y,m_creature->GetPositionZ()+15,0);
}
Unit *Cloud = m_creature->SummonTrigger(x, y, m_creature->GetPositionZ()+16, 0, 15000);
if(Cloud)
{
CloudGUID = Cloud->GetGUID();
Cloud->SetUnitMovementFlags(MOVEMENTFLAG_LEVITATING);
Cloud->StopMoving();
Cloud->SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
Cloud->setFaction(35);
Cloud->SetMaxHealth(9999999);
Cloud->SetHealth(9999999);
Cloud->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
}
ElectricalStorm_Timer = 60000; //60 seconds(bosskillers)
StormCount = 1;
StormSequenceTimer = 0;
} else ElectricalStorm_Timer -= diff;
if (SummonEagles_Timer < diff)
{
DoYell(SAY_ONSUMMON, LANG_UNIVERSAL, NULL);
DoPlaySoundToSet(m_creature, SOUND_ONSUMMON);
float x, y, z;
m_creature->GetPosition(x, y, z);
for (uint8 i = 0; i < 8; i++)
{
Unit* bird = Unit::GetUnit(*m_creature,BirdGUIDs[i]);
if(!bird)//they despawned on die
{
if(Unit* target = SelectUnit(SELECT_TARGET_RANDOM, 0))
{
x = target->GetPositionX() + 10 - rand()%20;
y = target->GetPositionY() + 10 - rand()%20;
z = target->GetPositionZ() + 6 + rand()%5 + 10;
if(z > 95) z = 95 - rand()%5;
}
Creature *pCreature = m_creature->SummonCreature(MOB_SOARING_EAGLE, x, y, z, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
if (pCreature)
{
pCreature->AddThreat(m_creature->getVictim(), 1.0f);
pCreature->AI()->AttackStart(m_creature->getVictim());
BirdGUIDs[i] = pCreature->GetGUID();
}
}
}
SummonEagles_Timer = 999999;
} else SummonEagles_Timer -= diff;
DoMeleeAttackIfReady();
}
CanCastResult CreatureAI::DoCastSpellIfCan(Unit* pTarget, uint32 uiSpell, uint32 uiCastFlags, ObjectGuid uiOriginalCasterGUID) const
{
Unit* pCaster = m_unit;
if (!pTarget)
return CAST_FAIL_OTHER;
if (uiCastFlags & CAST_SWITCH_CASTER_TARGET)
std::swap(pCaster, pTarget);
if (uiCastFlags & CAST_FORCE_TARGET_SELF)
pCaster = pTarget;
// Allowed to cast only if not casting (unless we interrupt ourself) or if spell is triggered
if (!pCaster->IsNonMeleeSpellCasted(false) || (uiCastFlags & (CAST_TRIGGERED | CAST_INTERRUPT_PREVIOUS)))
{
if (const SpellEntry* pSpell = sSpellTemplate.LookupEntry<SpellEntry>(uiSpell))
{
// If cast flag CAST_AURA_NOT_PRESENT is active, check if target already has aura on them
if (uiCastFlags & CAST_AURA_NOT_PRESENT)
{
if (pTarget->HasAura(uiSpell))
return CAST_FAIL_TARGET_AURA;
}
// Check if cannot cast spell
if (!(uiCastFlags & (CAST_FORCE_TARGET_SELF | CAST_FORCE_CAST)))
{
CanCastResult castResult = CanCastSpell(pTarget, pSpell, !!(uiCastFlags & CAST_TRIGGERED));
if (castResult != CAST_OK)
return castResult;
}
// Interrupt any previous spell
if (uiCastFlags & CAST_INTERRUPT_PREVIOUS && pCaster->IsNonMeleeSpellCasted(false))
pCaster->InterruptNonMeleeSpells(false);
// Creature should always stop before it will cast a non-instant spell
if (GetSpellCastTime(pSpell))
pCaster->StopMoving();
// Creature should interrupt any current melee spell
pCaster->InterruptSpell(CURRENT_MELEE_SPELL);
// Creature should stop wielding weapon while casting
pCaster->SetSheath(SHEATH_STATE_UNARMED);
uint32 flags = (uiCastFlags & CAST_TRIGGERED ? TRIGGERED_OLD_TRIGGERED : TRIGGERED_NONE) | (uiCastFlags & CAST_IGNORE_UNSELECTABLE_TARGET ? TRIGGERED_IGNORE_UNSELECTABLE_FLAG : TRIGGERED_NONE);
pCaster->CastSpell(pTarget, pSpell, flags, nullptr, nullptr, uiOriginalCasterGUID);
return CAST_OK;
}
else
{
sLog.outErrorDb("DoCastSpellIfCan by %s attempt to cast spell %u but spell does not exist.", m_unit->GetObjectGuid().GetString().c_str(), uiSpell);
return CAST_FAIL_OTHER;
}
}
else
return CAST_FAIL_IS_CASTING;
}
void WorldSession::HandlePetAction( WorldPacket & recv_data )
{
ObjectGuid petGuid;
uint32 data;
ObjectGuid targetGuid;
recv_data >> petGuid;
recv_data >> data;
recv_data >> targetGuid;
uint32 spellid = UNIT_ACTION_BUTTON_ACTION(data);
uint8 flag = UNIT_ACTION_BUTTON_TYPE(data); //delete = 0x07 CastSpell = C1
DETAIL_LOG("HandlePetAction: %s flag is %u, spellid is %u, target %s.", petGuid.GetString().c_str(), uint32(flag), spellid, targetGuid.GetString().c_str());
// used also for charmed creature/player
Unit* pet = _player->GetMap()->GetUnit(petGuid);
if (!pet)
{
sLog.outError("HandlePetAction: %s not exist.", petGuid.GetString().c_str());
return;
}
if (GetPlayer()->GetObjectGuid() != pet->GetCharmerOrOwnerGuid())
{
sLog.outError("HandlePetAction: %s isn't controlled by %s.", petGuid.GetString().c_str(), GetPlayer()->GetGuidStr().c_str());
return;
}
if (!pet->isAlive())
return;
if (pet->GetTypeId() == TYPEID_PLAYER)
{
// controller player can only do melee attack
if (!(flag == ACT_COMMAND && spellid == COMMAND_ATTACK))
return;
}
else if (((Creature*)pet)->IsPet())
{
// pet can have action bar disabled
if(((Pet*)pet)->GetModeFlags() & PET_MODE_DISABLE_ACTIONS)
return;
}
CharmInfo *charmInfo = pet->GetCharmInfo();
if(!charmInfo)
{
sLog.outError("WorldSession::HandlePetAction: object (GUID: %u TypeId: %u) is considered pet-like but doesn't have a charminfo!", pet->GetGUIDLow(), pet->GetTypeId());
return;
}
switch(flag)
{
case ACT_COMMAND: //0x07
switch(spellid)
{
case COMMAND_STAY: //flat=1792 //STAY
pet->StopMoving();
pet->GetMotionMaster()->Clear(false);
pet->GetMotionMaster()->MoveIdle();
charmInfo->SetCommandState( COMMAND_STAY );
break;
case COMMAND_FOLLOW: //spellid=1792 //FOLLOW
pet->AttackStop();
pet->GetMotionMaster()->MoveFollow(_player,PET_FOLLOW_DIST,PET_FOLLOW_ANGLE);
charmInfo->SetCommandState( COMMAND_FOLLOW );
break;
case COMMAND_ATTACK: //spellid=1792 //ATTACK
{
Unit *TargetUnit = _player->GetMap()->GetUnit(targetGuid);
if(!TargetUnit)
return;
// not let attack friendly units.
if(GetPlayer()->IsFriendlyTo(TargetUnit))
return;
// Not let attack through obstructions
if(!pet->IsWithinLOSInMap(TargetUnit))
return;
// This is true if pet has no target or has target but targets differs.
if(pet->getVictim() != TargetUnit)
{
if (pet->getVictim())
pet->AttackStop();
if (pet->hasUnitState(UNIT_STAT_CONTROLLED))
{
pet->Attack(TargetUnit, true);
pet->SendPetAIReaction();
}
else
{
pet->GetMotionMaster()->Clear();
if (((Creature*)pet)->AI())
((Creature*)pet)->AI()->AttackStart(TargetUnit);
// 10% chance to play special pet attack talk, else growl
if(((Creature*)pet)->IsPet() && ((Pet*)pet)->getPetType() == SUMMON_PET && pet != TargetUnit && roll_chance_i(10))
pet->SendPetTalk((uint32)PET_TALK_ATTACK);
else
{
// 90% chance for pet and 100% chance for charmed creature
pet->SendPetAIReaction();
}
}
}
break;
}
case COMMAND_ABANDON: // abandon (hunter pet) or dismiss (summoned pet)
if(((Creature*)pet)->IsPet())
{
Pet* p = (Pet*)pet;
if(p->getPetType() == HUNTER_PET)
p->Unsummon(PET_SAVE_AS_DELETED, _player);
else
//dismissing a summoned pet is like killing them (this prevents returning a soulshard...)
p->SetDeathState(CORPSE);
}
else // charmed
_player->Uncharm();
break;
default:
sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
}
break;
case ACT_REACTION: // 0x6
switch(spellid)
{
case REACT_PASSIVE: //passive
case REACT_DEFENSIVE: //recovery
case REACT_AGGRESSIVE: //activete
charmInfo->SetReactState( ReactStates(spellid) );
break;
}
break;
case ACT_DISABLED: // 0x81 spell (disabled), ignore
case ACT_PASSIVE: // 0x01
case ACT_ENABLED: // 0xC1 spell
{
Unit* unit_target = NULL;
if (!targetGuid.IsEmpty())
unit_target = _player->GetMap()->GetUnit(targetGuid);
// do not cast unknown spells
SpellEntry const *spellInfo = sSpellStore.LookupEntry(spellid );
if (!spellInfo)
{
sLog.outError("WORLD: unknown PET spell id %i", spellid);
return;
}
if (pet->GetCharmInfo() && pet->GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(spellInfo))
return;
for(int i = 0; i < MAX_EFFECT_INDEX;++i)
{
if(spellInfo->EffectImplicitTargetA[i] == TARGET_ALL_ENEMY_IN_AREA || spellInfo->EffectImplicitTargetA[i] == TARGET_ALL_ENEMY_IN_AREA_INSTANT || spellInfo->EffectImplicitTargetA[i] == TARGET_ALL_ENEMY_IN_AREA_CHANNELED)
return;
}
// do not cast not learned spells
if(!pet->HasSpell(spellid) || IsPassiveSpell(spellInfo))
return;
pet->clearUnitState(UNIT_STAT_MOVING);
Spell *spell = new Spell(pet, spellInfo, false);
SpellCastResult result = spell->CheckPetCast(unit_target);
//auto turn to target unless possessed
if(result == SPELL_FAILED_UNIT_NOT_INFRONT && !pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
{
if(unit_target)
{
pet->SetInFront(unit_target);
if (unit_target->GetTypeId() == TYPEID_PLAYER)
pet->SendCreateUpdateToPlayer( (Player*)unit_target );
}
else if(Unit *unit_target2 = spell->m_targets.getUnitTarget())
{
pet->SetInFront(unit_target2);
if (unit_target2->GetTypeId() == TYPEID_PLAYER)
pet->SendCreateUpdateToPlayer( (Player*)unit_target2 );
}
if (Unit* powner = pet->GetCharmerOrOwner())
if(powner->GetTypeId() == TYPEID_PLAYER)
pet->SendCreateUpdateToPlayer((Player*)powner);
result = SPELL_CAST_OK;
}
if(result == SPELL_CAST_OK)
{
((Creature*)pet)->AddCreatureSpellCooldown(spellid);
unit_target = spell->m_targets.getUnitTarget();
//10% chance to play special pet attack talk, else growl
//actually this only seems to happen on special spells, fire shield for imp, torment for voidwalker, but it's stupid to check every spell
if(((Creature*)pet)->IsPet() && (((Pet*)pet)->getPetType() == SUMMON_PET) && (pet != unit_target) && (urand(0, 100) < 10))
pet->SendPetTalk((uint32)PET_TALK_SPECIAL_SPELL);
else
{
pet->SendPetAIReaction();
}
if( unit_target && !GetPlayer()->IsFriendlyTo(unit_target) && !pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
{
// This is true if pet has no target or has target but targets differs.
if (pet->getVictim() != unit_target)
{
if (pet->getVictim())
pet->AttackStop();
pet->GetMotionMaster()->Clear();
if (((Creature*)pet)->AI())
((Creature*)pet)->AI()->AttackStart(unit_target);
}
}
spell->prepare(&(spell->m_targets));
}
else
{
if(pet->HasAuraType(SPELL_AURA_MOD_POSSESS))
Spell::SendCastResult(GetPlayer(),spellInfo,0,result);
else
pet->SendPetCastFail(spellid, result);
if (!((Creature*)pet)->HasSpellCooldown(spellid))
GetPlayer()->SendClearCooldown(spellid, pet);
spell->finish(false);
delete spell;
}
break;
}
default:
sLog.outError("WORLD: unknown PET flag Action %i and spellid %i.", uint32(flag), spellid);
}
}
/// Add control and such modifiers to a passenger if required
void VehicleInfo::ApplySeatMods(Unit* passenger, uint32 seatFlags)
{
Unit* pVehicle = (Unit*)m_owner; // Vehicles are alawys Unit
if (seatFlags & SEAT_FLAG_NOT_SELECTABLE)
passenger->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
// ToDo: change passenger model id for SEAT_FLAG_HIDE_PASSENGER?
if (passenger->GetTypeId() == TYPEID_PLAYER)
{
Player* pPlayer = (Player*)passenger;
// group update
if (pPlayer->GetGroup())
pPlayer->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_VEHICLE_SEAT);
if (seatFlags & SEAT_FLAG_CAN_CONTROL)
{
pPlayer->GetCamera().SetView(pVehicle);
pPlayer->SetCharm(pVehicle);
pVehicle->SetCharmer(pPlayer);
pVehicle->GetMotionMaster()->Clear();
pVehicle->GetMotionMaster()->MoveIdle();
pVehicle->StopMoving(true);
pVehicle->addUnitState(UNIT_STAT_POSSESSED);
pVehicle->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_POSSESSED);
pVehicle->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED);
pPlayer->UpdateClientControl(pVehicle, true);
pPlayer->SetMover(pVehicle);
// Unconfirmed - default speed handling
if (pVehicle->GetTypeId() == TYPEID_UNIT)
{
if (!pPlayer->IsWalking() && pVehicle->IsWalking())
{
((Creature*)pVehicle)->SetWalk(false, true);
}
else if (pPlayer->IsWalking() && !pVehicle->IsWalking())
{
((Creature*)pVehicle)->SetWalk(true, true);
}
// set vehicle faction as per the controller faction
((Creature*)pVehicle)->SetFactionTemporary(pPlayer->getFaction(), TEMPFACTION_NONE);
// set vehicle react state to passive; player will control the vehicle
pVehicle->AI()->SetReactState(REACT_PASSIVE);
}
}
if (seatFlags & SEAT_FLAG_CAN_CAST)
{
CharmInfo* charmInfo = pVehicle->InitCharmInfo(pVehicle);
charmInfo->InitVehicleCreateSpells();
pPlayer->PossessSpellInitialize();
}
}
else if (passenger->GetTypeId() == TYPEID_UNIT)
{
if (seatFlags & SEAT_FLAG_CAN_CONTROL)
{
passenger->SetCharm(pVehicle);
pVehicle->SetCharmer(passenger);
// Change vehicle react state; ToDo: also change the vehicle faction?
if (pVehicle->GetTypeId() == TYPEID_UNIT)
pVehicle->AI()->SetReactState(passenger->AI()->GetReactState());
}
((Creature*)passenger)->AI()->SetCombatMovement(false);
// Not entirely sure how this must be handled in relation to CONTROL
// But in any way this at least would require some changes in the movement system most likely
passenger->GetMotionMaster()->Clear(false, true);
passenger->GetMotionMaster()->MoveIdle();
}
}
