public static uint XPGain(Player player, Unit u, bool isBattleGround = false)
{
Creature creature = u.ToCreature();
uint gain = 0;
if (!creature || creature.CanGiveExperience())
{
float xpMod = 1.0f;
gain = BaseGain(player.getLevel(), u.getLevel());
if (gain != 0 && creature)
{
// Players get only 10% xp for killing creatures of lower expansion levels than himself
if ((creature.GetCreatureTemplate().HealthScalingExpansion < (int)GetExpansionForLevel(player.getLevel())))
{
gain = (uint)Math.Round(gain / 10.0f);
}
if (creature.isElite())
{
// Elites in instances have a 2.75x XP bonus instead of the regular 2x world bonus.
if (u.GetMap().IsDungeon())
{
xpMod *= 2.75f;
}
else
{
xpMod *= 2.0f;
}
}
xpMod *= creature.GetCreatureTemplate().ModExperience;
}
xpMod *= isBattleGround ? WorldConfig.GetFloatValue(WorldCfg.RateXpBgKill) : WorldConfig.GetFloatValue(WorldCfg.RateXpKill);
if (creature && creature.m_PlayerDamageReq != 0) // if players dealt less than 50% of the damage and were credited anyway (due to CREATURE_FLAG_EXTRA_NO_PLAYER_DAMAGE_REQ), scale XP gained appropriately (linear scaling)
{
xpMod *= 1.0f - 2.0f * creature.m_PlayerDamageReq / creature.GetMaxHealth();
}
gain = (uint)(gain * xpMod);
}
Global.ScriptMgr.OnGainCalculation(gain, player, u);
return(gain);
}
public static void ForAllControlled(Unit unit, Action <Unit> func)
{
foreach (Unit controlled in unit.m_Controlled)
{
if (controlled.GetTypeId() != TypeId.Player)
{
func(controlled);
}
}
for (byte i = 0; i < SharedConst.MaxSummonSlot; ++i)
{
if (!unit.m_SummonSlot[i].IsEmpty())
{
Creature summon = unit.GetMap().GetCreature(unit.m_SummonSlot[i]);
if (summon)
{
func(summon);
}
}
}
}
void HandleMovementOpcode(ClientOpcodes opcode, MovementInfo movementInfo)
{
Unit mover = GetPlayer().m_unitMovedByMe;
Player plrMover = mover.ToPlayer();
if (plrMover && plrMover.IsBeingTeleported())
{
return;
}
GetPlayer().ValidateMovementInfo(movementInfo);
if (movementInfo.Guid != mover.GetGUID())
{
Log.outError(LogFilter.Network, "HandleMovementOpcodes: guid error");
return;
}
if (!movementInfo.Pos.IsPositionValid())
{
Log.outError(LogFilter.Network, "HandleMovementOpcodes: Invalid Position");
return;
}
// stop some emotes at player move
if (plrMover && (plrMover.GetEmoteState() != 0))
{
plrMover.SetEmoteState(Emote.OneshotNone);
}
//handle special cases
if (!movementInfo.transport.guid.IsEmpty())
{
// We were teleported, skip packets that were broadcast before teleport
if (movementInfo.Pos.GetExactDist2d(mover) > MapConst.SizeofGrids)
{
return;
}
if (Math.Abs(movementInfo.transport.pos.GetPositionX()) > 75f || Math.Abs(movementInfo.transport.pos.GetPositionY()) > 75f || Math.Abs(movementInfo.transport.pos.GetPositionZ()) > 75f)
{
return;
}
if (!GridDefines.IsValidMapCoord(movementInfo.Pos.posX + movementInfo.transport.pos.posX, movementInfo.Pos.posY + movementInfo.transport.pos.posY,
movementInfo.Pos.posZ + movementInfo.transport.pos.posZ, movementInfo.Pos.Orientation + movementInfo.transport.pos.Orientation))
{
return;
}
if (plrMover)
{
if (!plrMover.GetTransport())
{
Transport transport = plrMover.GetMap().GetTransport(movementInfo.transport.guid);
if (transport)
{
transport.AddPassenger(plrMover);
}
}
else if (plrMover.GetTransport().GetGUID() != movementInfo.transport.guid)
{
plrMover.GetTransport().RemovePassenger(plrMover);
Transport transport = plrMover.GetMap().GetTransport(movementInfo.transport.guid);
if (transport)
{
transport.AddPassenger(plrMover);
}
else
{
movementInfo.ResetTransport();
}
}
}
if (!mover.GetTransport() && !mover.GetVehicle())
{
GameObject go = mover.GetMap().GetGameObject(movementInfo.transport.guid);
if (!go || go.GetGoType() != GameObjectTypes.Transport)
{
movementInfo.transport.Reset();
}
}
}
else if (plrMover && plrMover.GetTransport()) // if we were on a transport, leave
{
plrMover.GetTransport().RemovePassenger(plrMover);
}
// fall damage generation (ignore in flight case that can be triggered also at lags in moment teleportation to another map).
if (opcode == ClientOpcodes.MoveFallLand && plrMover && !plrMover.IsInFlight())
{
plrMover.HandleFall(movementInfo);
}
// interrupt parachutes upon falling or landing in water
if (opcode == ClientOpcodes.MoveFallLand || opcode == ClientOpcodes.MoveStartSwim)
{
mover.RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags.Landing); // Parachutes
}
if (plrMover && movementInfo.HasMovementFlag(MovementFlag.Swimming) != plrMover.IsInWater())
{
// now client not include swimming flag in case jumping under water
plrMover.SetInWater(!plrMover.IsInWater() || plrMover.GetMap().IsUnderWater(plrMover.GetPhaseShift(), movementInfo.Pos.posX, movementInfo.Pos.posY, movementInfo.Pos.posZ));
}
uint mstime = GameTime.GetGameTimeMS();
if (m_clientTimeDelay == 0)
{
m_clientTimeDelay = mstime - movementInfo.Time;
}
movementInfo.Time = movementInfo.Time + m_clientTimeDelay;
movementInfo.Guid = mover.GetGUID();
mover.m_movementInfo = movementInfo;
// Some vehicles allow the passenger to turn by himself
Vehicle vehicle = mover.GetVehicle();
if (vehicle)
{
VehicleSeatRecord seat = vehicle.GetSeatForPassenger(mover);
if (seat != null)
{
if (seat.HasSeatFlag(VehicleSeatFlags.AllowTurning))
{
if (movementInfo.Pos.GetOrientation() != mover.GetOrientation())
{
mover.SetOrientation(movementInfo.Pos.GetOrientation());
mover.RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags.Turning);
}
}
}
return;
}
mover.UpdatePosition(movementInfo.Pos);
MoveUpdate moveUpdate = new MoveUpdate();
moveUpdate.Status = mover.m_movementInfo;
mover.SendMessageToSet(moveUpdate, GetPlayer());
if (plrMover) // nothing is charmed, or player charmed
{
if (plrMover.IsSitState() && movementInfo.HasMovementFlag(MovementFlag.MaskMoving | MovementFlag.MaskTurning))
{
plrMover.SetStandState(UnitStandStateType.Stand);
}
plrMover.UpdateFallInformationIfNeed(movementInfo, opcode);
if (movementInfo.Pos.posZ < plrMover.GetMap().GetMinHeight(plrMover.GetPhaseShift(), movementInfo.Pos.GetPositionX(), movementInfo.Pos.GetPositionY()))
{
if (!(plrMover.GetBattleground() && plrMover.GetBattleground().HandlePlayerUnderMap(GetPlayer())))
{
// NOTE: this is actually called many times while falling
// even after the player has been teleported away
// @todo discard movement packets after the player is rooted
if (plrMover.IsAlive())
{
plrMover.AddPlayerFlag(PlayerFlags.IsOutOfBounds);
plrMover.EnvironmentalDamage(EnviromentalDamage.FallToVoid, (uint)GetPlayer().GetMaxHealth());
// player can be alive if GM/etc
// change the death state to CORPSE to prevent the death timer from
// starting in the next player update
if (plrMover.IsAlive())
{
plrMover.KillPlayer();
}
}
}
}
else
{
plrMover.RemovePlayerFlag(PlayerFlags.IsOutOfBounds);
}
if (opcode == ClientOpcodes.MoveJump)
{
plrMover.RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags.Jump, 605); // Mind Control
plrMover.ProcSkillsAndAuras(null, ProcFlags.Jump, ProcFlags.None, ProcFlagsSpellType.MaskAll, ProcFlagsSpellPhase.None, ProcFlagsHit.None, null, null, null);
}
}
}
void HandleCancelChanneling(CancelChannelling cancelChanneling)
{
// ignore for remote control state (for player case)
Unit mover = _player.GetUnitBeingMoved();
if (mover != _player && mover.IsTypeId(TypeId.Player))
{
return;
}
var spellInfo = Global.SpellMgr.GetSpellInfo((uint)cancelChanneling.ChannelSpell, mover.GetMap().GetDifficultyID());
if (spellInfo == null)
{
return;
}
// not allow remove spells with attr SPELL_ATTR0_CANT_CANCEL
if (spellInfo.HasAttribute(SpellAttr0.CantCancel))
{
return;
}
var spell = mover.GetCurrentSpell(CurrentSpellTypes.Channeled);
if (spell == null || spell.GetSpellInfo().Id != spellInfo.Id)
{
return;
}
mover.InterruptSpell(CurrentSpellTypes.Channeled);
}
void HandleCastSpell(CastSpell cast)
{
// ignore for remote control state (for player case)
Unit mover = GetPlayer().GetUnitBeingMoved();
if (mover != GetPlayer() && mover.IsTypeId(TypeId.Player))
{
return;
}
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(cast.Cast.SpellID, mover.GetMap().GetDifficultyID());
if (spellInfo == null)
{
Log.outError(LogFilter.Network, "WORLD: unknown spell id {0}", cast.Cast.SpellID);
return;
}
if (spellInfo.IsPassive())
{
return;
}
Unit caster = mover;
if (caster.IsTypeId(TypeId.Unit) && !caster.ToCreature().HasSpell(spellInfo.Id))
{
// If the vehicle creature does not have the spell but it allows the passenger to cast own spells
// change caster to player and let him cast
if (!GetPlayer().IsOnVehicle(caster) || spellInfo.CheckVehicle(GetPlayer()) != SpellCastResult.SpellCastOk)
{
return;
}
caster = GetPlayer();
}
TriggerCastFlags triggerFlag = TriggerCastFlags.None;
// client provided targets
SpellCastTargets targets = new(caster, cast.Cast);
// check known spell or raid marker spell (which not requires player to know it)
if (caster.IsTypeId(TypeId.Player) && !caster.ToPlayer().HasActiveSpell(spellInfo.Id) && !spellInfo.HasEffect(SpellEffectName.ChangeRaidMarker) && !spellInfo.HasAttribute(SpellAttr8.RaidMarker))
{
bool allow = false;
// allow casting of unknown spells for special lock cases
GameObject go = targets.GetGOTarget();
if (go != null)
{
if (go.GetSpellForLock(caster.ToPlayer()) == spellInfo)
{
allow = true;
}
}
// allow casting of spells triggered by clientside periodic trigger auras
if (caster.HasAuraTypeWithTriggerSpell(AuraType.PeriodicTriggerSpellFromClient, spellInfo.Id))
{
allow = true;
triggerFlag = TriggerCastFlags.FullMask;
}
if (!allow)
{
return;
}
}
// Check possible spell cast overrides
spellInfo = caster.GetCastSpellInfo(spellInfo);
// can't use our own spells when we're in possession of another unit,
if (GetPlayer().IsPossessing())
{
return;
}
// Client is resending autoshot cast opcode when other spell is cast during shoot rotation
// Skip it to prevent "interrupt" message
// Also check targets! target may have changed and we need to interrupt current spell
if (spellInfo.IsAutoRepeatRangedSpell())
{
Spell autoRepeatSpell = caster.GetCurrentSpell(CurrentSpellTypes.AutoRepeat);
if (autoRepeatSpell != null)
{
if (autoRepeatSpell.m_spellInfo == spellInfo && autoRepeatSpell.m_targets.GetUnitTargetGUID() == targets.GetUnitTargetGUID())
{
return;
}
}
}
// auto-selection buff level base at target level (in spellInfo)
if (targets.GetUnitTarget() != null)
{
SpellInfo actualSpellInfo = spellInfo.GetAuraRankForLevel(targets.GetUnitTarget().GetLevelForTarget(caster));
// if rank not found then function return NULL but in explicit cast case original spell can be casted and later failed with appropriate error message
if (actualSpellInfo != null)
{
spellInfo = actualSpellInfo;
}
}
if (cast.Cast.MoveUpdate.HasValue)
{
HandleMovementOpcode(ClientOpcodes.MoveStop, cast.Cast.MoveUpdate.Value);
}
Spell spell = new(caster, spellInfo, triggerFlag);
SpellPrepare spellPrepare = new();
spellPrepare.ClientCastID = cast.Cast.CastID;
spellPrepare.ServerCastID = spell.m_castId;
SendPacket(spellPrepare);
spell.m_fromClient = true;
spell.m_misc.Data0 = cast.Cast.Misc[0];
spell.m_misc.Data1 = cast.Cast.Misc[1];
spell.Prepare(targets);
}
void HandlePetCastSpell(PetCastSpell petCastSpell)
{
Unit caster = Global.ObjAccessor.GetUnit(GetPlayer(), petCastSpell.PetGUID);
if (!caster)
{
Log.outError(LogFilter.Network, "WorldSession.HandlePetCastSpell: Caster {0} not found.", petCastSpell.PetGUID.ToString());
return;
}
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(petCastSpell.Cast.SpellID, caster.GetMap().GetDifficultyID());
if (spellInfo == null)
{
Log.outError(LogFilter.Network, "WorldSession.HandlePetCastSpell: unknown spell id {0} tried to cast by {1}", petCastSpell.Cast.SpellID, petCastSpell.PetGUID.ToString());
return;
}
// This opcode is also sent from charmed and possessed units (players and creatures)
if (caster != GetPlayer().GetGuardianPet() && caster != GetPlayer().GetCharm())
{
Log.outError(LogFilter.Network, "WorldSession.HandlePetCastSpell: {0} isn't pet of player {1} ({2}).", petCastSpell.PetGUID.ToString(), GetPlayer().GetName(), GetPlayer().GetGUID().ToString());
return;
}
// do not cast not learned spells
if (!caster.HasSpell(spellInfo.Id) || spellInfo.IsPassive())
{
return;
}
SpellCastTargets targets = new SpellCastTargets(caster, petCastSpell.Cast);
caster.ClearUnitState(UnitState.Follow);
Spell spell = new Spell(caster, spellInfo, TriggerCastFlags.None);
spell.m_fromClient = true;
spell.m_misc.Data0 = petCastSpell.Cast.Misc[0];
spell.m_misc.Data1 = petCastSpell.Cast.Misc[1];
spell.m_targets = targets;
SpellCastResult result = spell.CheckPetCast(null);
if (result == SpellCastResult.SpellCastOk)
{
Creature creature = caster.ToCreature();
if (creature)
{
Pet pet = creature.ToPet();
if (pet)
{
// 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 (pet.GetPetType() == PetType.Summon && (RandomHelper.IRand(0, 100) < 10))
{
pet.SendPetTalk(PetTalk.SpecialSpell);
}
else
{
pet.SendPetAIReaction(petCastSpell.PetGUID);
}
}
}
SpellPrepare spellPrepare = new SpellPrepare();
spellPrepare.ClientCastID = petCastSpell.Cast.CastID;
spellPrepare.ServerCastID = spell.m_castId;
SendPacket(spellPrepare);
spell.Prepare(targets);
}
else
{
spell.SendPetCastResult(result);
if (!caster.GetSpellHistory().HasCooldown(spellInfo.Id))
{
caster.GetSpellHistory().ResetCooldown(spellInfo.Id, true);
}
spell.Finish(false);
spell.Dispose();
}
}
void HandlePetAction(PetAction packet)
{
ObjectGuid guid1 = packet.PetGUID; //pet guid
ObjectGuid guid2 = packet.TargetGUID; //tag guid
uint spellid = UnitActionBarEntry.UNIT_ACTION_BUTTON_ACTION(packet.Action);
ActiveStates flag = (ActiveStates)UnitActionBarEntry.UNIT_ACTION_BUTTON_TYPE(packet.Action); //delete = 0x07 CastSpell = C1
// used also for charmed creature
Unit pet = Global.ObjAccessor.GetUnit(GetPlayer(), guid1);
if (!pet)
{
Log.outError(LogFilter.Network, "HandlePetAction: {0} doesn't exist for {1}", guid1.ToString(), GetPlayer().GetGUID().ToString());
return;
}
if (pet != GetPlayer().GetFirstControlled())
{
Log.outError(LogFilter.Network, "HandlePetAction: {0} does not belong to {1}", guid1.ToString(), GetPlayer().GetGUID().ToString());
return;
}
if (!pet.IsAlive())
{
SpellInfo spell = (flag == ActiveStates.Enabled || flag == ActiveStates.Passive) ? Global.SpellMgr.GetSpellInfo(spellid, pet.GetMap().GetDifficultyID()) : null;
if (spell == null)
{
return;
}
if (!spell.HasAttribute(SpellAttr0.CastableWhileDead))
{
return;
}
}
// @todo allow control charmed player?
if (pet.IsTypeId(TypeId.Player) && !(flag == ActiveStates.Command && spellid == (uint)CommandStates.Attack))
{
return;
}
if (GetPlayer().m_Controlled.Count == 1)
{
HandlePetActionHelper(pet, guid1, spellid, flag, guid2, packet.ActionPosition.X, packet.ActionPosition.Y, packet.ActionPosition.Z);
}
else
{
//If a pet is dismissed, m_Controlled will change
List <Unit> controlled = new List <Unit>();
foreach (var unit in GetPlayer().m_Controlled)
{
if (unit.GetEntry() == pet.GetEntry() && unit.IsAlive())
{
controlled.Add(unit);
}
}
foreach (var unit in controlled)
{
HandlePetActionHelper(unit, guid1, spellid, flag, guid2, packet.ActionPosition.X, packet.ActionPosition.Y, packet.ActionPosition.Z);
}
}
}
void HandlePetSetAction(PetSetAction packet)
{
ObjectGuid petguid = packet.PetGUID;
Unit pet = Global.ObjAccessor.GetUnit(GetPlayer(), petguid);
if (!pet || pet != GetPlayer().GetFirstControlled())
{
Log.outError(LogFilter.Network, "HandlePetSetAction: Unknown {0} or pet owner {1}", petguid.ToString(), GetPlayer().GetGUID().ToString());
return;
}
CharmInfo charmInfo = pet.GetCharmInfo();
if (charmInfo == null)
{
Log.outError(LogFilter.Network, "WorldSession.HandlePetSetAction: {0} is considered pet-like but doesn't have a charminfo!", pet.GetGUID().ToString());
return;
}
uint position = packet.Index;
uint actionData = packet.Action;
uint spell_id = UnitActionBarEntry.UNIT_ACTION_BUTTON_ACTION(actionData);
ActiveStates act_state = (ActiveStates)UnitActionBarEntry.UNIT_ACTION_BUTTON_TYPE(actionData);
Log.outDebug(LogFilter.Network, "Player {0} has changed pet spell action. Position: {1}, Spell: {2}, State: {3}", GetPlayer().GetName(), position, spell_id, act_state);
//if it's act for spell (en/disable/cast) and there is a spell given (0 = remove spell) which pet doesn't know, don't add
if (!((act_state == ActiveStates.Enabled || act_state == ActiveStates.Disabled || act_state == ActiveStates.Passive) && spell_id != 0 && !pet.HasSpell(spell_id)))
{
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(spell_id, pet.GetMap().GetDifficultyID());
if (spellInfo != null)
{
//sign for autocast
if (act_state == ActiveStates.Enabled)
{
if (pet.GetTypeId() == TypeId.Unit && pet.IsPet())
{
((Pet)pet).ToggleAutocast(spellInfo, true);
}
else
{
foreach (var unit in GetPlayer().m_Controlled)
{
if (unit.GetEntry() == pet.GetEntry())
{
unit.GetCharmInfo().ToggleCreatureAutocast(spellInfo, true);
}
}
}
}
//sign for no/turn off autocast
else if (act_state == ActiveStates.Disabled)
{
if (pet.GetTypeId() == TypeId.Unit && pet.IsPet())
{
pet.ToPet().ToggleAutocast(spellInfo, false);
}
else
{
foreach (var unit in GetPlayer().m_Controlled)
{
if (unit.GetEntry() == pet.GetEntry())
{
unit.GetCharmInfo().ToggleCreatureAutocast(spellInfo, false);
}
}
}
}
}
charmInfo.SetActionBar((byte)position, spell_id, act_state);
}
}
void HandlePetActionHelper(Unit pet, ObjectGuid guid1, uint spellid, ActiveStates flag, ObjectGuid guid2, float x, float y, float z)
{
CharmInfo charmInfo = pet.GetCharmInfo();
if (charmInfo == null)
{
Log.outError(LogFilter.Network, "WorldSession.HandlePetAction(petGuid: {0}, tagGuid: {1}, spellId: {2}, flag: {3}): object (GUID: {4} Entry: {5} TypeId: {6}) is considered pet-like but doesn't have a charminfo!",
guid1, guid2, spellid, flag, pet.GetGUID().ToString(), pet.GetEntry(), pet.GetTypeId());
return;
}
switch (flag)
{
case ActiveStates.Command: //0x07
switch ((CommandStates)spellid)
{
case CommandStates.Stay: //flat=1792 //STAY
pet.StopMoving();
pet.GetMotionMaster().Clear(false);
pet.GetMotionMaster().MoveIdle();
charmInfo.SetCommandState(CommandStates.Stay);
charmInfo.SetIsCommandAttack(false);
charmInfo.SetIsAtStay(true);
charmInfo.SetIsCommandFollow(false);
charmInfo.SetIsFollowing(false);
charmInfo.SetIsReturning(false);
charmInfo.SaveStayPosition();
break;
case CommandStates.Follow: //spellid=1792 //FOLLOW
pet.AttackStop();
pet.InterruptNonMeleeSpells(false);
pet.ClearInPetCombat();
pet.GetMotionMaster().MoveFollow(GetPlayer(), SharedConst.PetFollowDist, pet.GetFollowAngle());
charmInfo.SetCommandState(CommandStates.Follow);
charmInfo.SetIsCommandAttack(false);
charmInfo.SetIsAtStay(false);
charmInfo.SetIsReturning(true);
charmInfo.SetIsCommandFollow(true);
charmInfo.SetIsFollowing(false);
break;
case CommandStates.Attack: //spellid=1792 //ATTACK
{
// Can't attack if owner is pacified
if (GetPlayer().HasAuraType(AuraType.ModPacify))
{
// @todo Send proper error message to client
return;
}
// only place where pet can be player
Unit TargetUnit = Global.ObjAccessor.GetUnit(GetPlayer(), guid2);
if (!TargetUnit)
{
return;
}
Unit owner = pet.GetOwner();
if (owner)
{
if (!owner.IsValidAttackTarget(TargetUnit))
{
return;
}
}
pet.ClearUnitState(UnitState.Follow);
// This is true if pet has no target or has target but targets differs.
if (pet.GetVictim() != TargetUnit || (pet.GetVictim() == TargetUnit && !pet.GetCharmInfo().IsCommandAttack()))
{
if (pet.GetVictim())
{
pet.AttackStop();
}
if (!pet.IsTypeId(TypeId.Player) && pet.ToCreature().IsAIEnabled)
{
charmInfo.SetIsCommandAttack(true);
charmInfo.SetIsAtStay(false);
charmInfo.SetIsFollowing(false);
charmInfo.SetIsCommandFollow(false);
charmInfo.SetIsReturning(false);
CreatureAI AI = pet.ToCreature().GetAI();
PetAI petAI = (PetAI)AI;
if (petAI != null)
{
petAI._AttackStart(TargetUnit); // force target switch
}
else
{
AI.AttackStart(TargetUnit);
}
//10% chance to play special pet attack talk, else growl
if (pet.IsPet() && pet.ToPet().GetPetType() == PetType.Summon && pet != TargetUnit && RandomHelper.IRand(0, 100) < 10)
{
pet.SendPetTalk(PetTalk.Attack);
}
else
{
// 90% chance for pet and 100% chance for charmed creature
pet.SendPetAIReaction(guid1);
}
}
else // charmed player
{
charmInfo.SetIsCommandAttack(true);
charmInfo.SetIsAtStay(false);
charmInfo.SetIsFollowing(false);
charmInfo.SetIsCommandFollow(false);
charmInfo.SetIsReturning(false);
pet.Attack(TargetUnit, true);
pet.SendPetAIReaction(guid1);
}
}
break;
}
case CommandStates.Abandon: // abandon (hunter pet) or dismiss (summoned pet)
if (pet.GetCharmerGUID() == GetPlayer().GetGUID())
{
GetPlayer().StopCastingCharm();
}
else if (pet.GetOwnerGUID() == GetPlayer().GetGUID())
{
Cypher.Assert(pet.IsTypeId(TypeId.Unit));
if (pet.IsPet())
{
if (pet.ToPet().GetPetType() == PetType.Hunter)
{
GetPlayer().RemovePet(pet.ToPet(), PetSaveMode.AsDeleted);
}
else
{
//dismissing a summoned pet is like killing them (this prevents returning a soulshard...)
pet.SetDeathState(DeathState.Corpse);
}
}
else if (pet.HasUnitTypeMask(UnitTypeMask.Minion))
{
((Minion)pet).UnSummon();
}
}
break;
case CommandStates.MoveTo:
pet.StopMoving();
pet.GetMotionMaster().Clear(false);
pet.GetMotionMaster().MovePoint(0, x, y, z);
charmInfo.SetCommandState(CommandStates.MoveTo);
charmInfo.SetIsCommandAttack(false);
charmInfo.SetIsAtStay(true);
charmInfo.SetIsFollowing(false);
charmInfo.SetIsReturning(false);
charmInfo.SaveStayPosition();
break;
default:
Log.outError(LogFilter.Network, "WORLD: unknown PET flag Action {0} and spellid {1}.", flag, spellid);
break;
}
break;
case ActiveStates.Reaction: // 0x6
switch ((ReactStates)spellid)
{
case ReactStates.Passive: //passive
pet.AttackStop();
pet.ClearInPetCombat();
goto case ReactStates.Defensive;
case ReactStates.Defensive: //recovery
case ReactStates.Aggressive: //activete
if (pet.IsTypeId(TypeId.Unit))
{
pet.ToCreature().SetReactState((ReactStates)spellid);
}
break;
}
break;
case ActiveStates.Disabled: // 0x81 spell (disabled), ignore
case ActiveStates.Passive: // 0x01
case ActiveStates.Enabled: // 0xC1 spell
{
Unit unit_target = null;
if (!guid2.IsEmpty())
{
unit_target = Global.ObjAccessor.GetUnit(GetPlayer(), guid2);
}
// do not cast unknown spells
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(spellid, pet.GetMap().GetDifficultyID());
if (spellInfo == null)
{
Log.outError(LogFilter.Network, "WORLD: unknown PET spell id {0}", spellid);
return;
}
foreach (SpellEffectInfo effect in spellInfo.GetEffects())
{
if (effect != null && (effect.TargetA.GetTarget() == Targets.UnitSrcAreaEnemy || effect.TargetA.GetTarget() == Targets.UnitDestAreaEnemy || effect.TargetA.GetTarget() == Targets.DestDynobjEnemy))
{
return;
}
}
// do not cast not learned spells
if (!pet.HasSpell(spellid) || spellInfo.IsPassive())
{
return;
}
// Clear the flags as if owner clicked 'attack'. AI will reset them
// after AttackStart, even if spell failed
if (pet.GetCharmInfo() != null)
{
pet.GetCharmInfo().SetIsAtStay(false);
pet.GetCharmInfo().SetIsCommandAttack(true);
pet.GetCharmInfo().SetIsReturning(false);
pet.GetCharmInfo().SetIsFollowing(false);
}
Spell spell = new Spell(pet, spellInfo, TriggerCastFlags.None);
SpellCastResult result = spell.CheckPetCast(unit_target);
//auto turn to target unless possessed
if (result == SpellCastResult.UnitNotInfront && !pet.IsPossessed() && !pet.IsVehicle())
{
Unit unit_target2 = spell.m_targets.GetUnitTarget();
if (unit_target)
{
if (!pet.IsFocusing())
{
pet.SetInFront(unit_target);
}
Player player = unit_target.ToPlayer();
if (player)
{
pet.SendUpdateToPlayer(player);
}
}
else if (unit_target2)
{
if (!pet.IsFocusing())
{
pet.SetInFront(unit_target2);
}
Player player = unit_target2.ToPlayer();
if (player)
{
pet.SendUpdateToPlayer(player);
}
}
Unit powner = pet.GetCharmerOrOwner();
if (powner)
{
Player player = powner.ToPlayer();
if (player)
{
pet.SendUpdateToPlayer(player);
}
}
result = SpellCastResult.SpellCastOk;
}
if (result == SpellCastResult.SpellCastOk)
{
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 (pet.IsPet() && (pet.ToPet().GetPetType() == PetType.Summon) && (pet != unit_target) && (RandomHelper.IRand(0, 100) < 10))
{
pet.SendPetTalk(PetTalk.SpecialSpell);
}
else
{
pet.SendPetAIReaction(guid1);
}
if (unit_target && !GetPlayer().IsFriendlyTo(unit_target) && !pet.IsPossessed() && !pet.IsVehicle())
{
// This is true if pet has no target or has target but targets differs.
if (pet.GetVictim() != unit_target)
{
pet.GetMotionMaster().Clear();
if (pet.ToCreature().IsAIEnabled)
{
CreatureAI AI = pet.ToCreature().GetAI();
PetAI petAI = (PetAI)AI;
if (petAI != null)
{
petAI._AttackStart(unit_target); // force victim switch
}
else
{
AI.AttackStart(unit_target);
}
}
}
}
spell.Prepare(spell.m_targets);
}
else
{
if (pet.IsPossessed() || pet.IsVehicle()) // @todo: confirm this check
{
Spell.SendCastResult(GetPlayer(), spellInfo, spell.m_SpellVisual, spell.m_castId, result);
}
else
{
spell.SendPetCastResult(result);
}
if (!pet.GetSpellHistory().HasCooldown(spellid))
{
pet.GetSpellHistory().ResetCooldown(spellid, true);
}
spell.Finish(false);
spell.Dispose();
// reset specific flags in case of spell fail. AI will reset other flags
if (pet.GetCharmInfo() != null)
{
pet.GetCharmInfo().SetIsCommandAttack(false);
}
}
break;
}
default:
Log.outError(LogFilter.Network, "WORLD: unknown PET flag Action {0} and spellid {1}.", flag, spellid);
break;
}
}
