private void OnPlayerSpeedChanged(Player player, UnitMoveType moveType, float rate)
{
if (player.BoltEntity.Controller != null)
{
PlayerSpeedRateChangedEvent speedChangeEvent = PlayerSpeedRateChangedEvent.Create(player.BoltEntity.Controller, ReliabilityModes.ReliableOrdered);
speedChangeEvent.MoveType = (int)moveType;
speedChangeEvent.SpeedRate = rate;
speedChangeEvent.Send();
}
}
public void SetSpeedRate(UnitMoveType type, float rate)
{
if (rate < 0)
{
rate = 0.0f;
}
if (speedRates[type] == rate)
{
return;
}
speedRates[type] = rate;
}
public float BaseSpeedByType(UnitMoveType moveType)
{
switch (moveType)
{
case UnitMoveType.Walk:
return(walkSpeed);
case UnitMoveType.Run:
return(runSpeed);
case UnitMoveType.RunBack:
return(runBackSpeed);
default:
throw new ArgumentOutOfRangeException(nameof(moveType), moveType, "Unknown movement type!");
}
}
public override void MovementInform(MovementGeneratorType movementType, uint pointId)
{
if (movementType == MovementGeneratorType.Waypoint && pointId == 2)
{
me.SetSheath(SheathState.Melee);
me.RemoveAllAuras();
Player owner = me.GetCharmerOrOwner().ToPlayer();
if (owner)
{
owner.RemoveAura(SpellIds.EyeFlightBoost);
for (UnitMoveType i = 0; i < UnitMoveType.Max; ++i)
{
me.SetSpeedRate(i, owner.GetSpeedRate(i));
}
Talk(TextIds.TalkControl, owner);
}
me.SetDisableGravity(false);
DoCast(me, SpellIds.EyeFlight);
}
if (movementType == MovementGeneratorType.Point && pointId == 1)
{
me.SetDisableGravity(true);
me.SetControlled(true, UnitState.Root);
_scheduler.Schedule(System.TimeSpan.FromSeconds(5), task =>
{
DoCast(me, SpellIds.EyeFlightBoost);
me.SetControlled(false, UnitState.Root);
Player owner = me.GetCharmerOrOwner().ToPlayer();
if (owner)
{
for (UnitMoveType i = 0; i < UnitMoveType.Max; ++i)
{
me.SetSpeedRate(i, owner.GetSpeedRate(i));
}
Talk(TextIds.TalkMoveStart, owner);
}
me.GetMotionMaster().MovePath(me.GetEntry() * 100, false);
});
}
}
public void SetMinion(Minion minion, bool apply)
{
Log.outDebug(LogFilter.Unit, "SetMinion {0} for {1}, apply {2}", minion.GetEntry(), GetEntry(), apply);
if (apply)
{
if (!minion.GetOwnerGUID().IsEmpty())
{
Log.outFatal(LogFilter.Unit, "SetMinion: Minion {0} is not the minion of owner {1}", minion.GetEntry(), GetEntry());
return;
}
minion.SetOwnerGUID(GetGUID());
m_Controlled.Add(minion);
if (IsTypeId(TypeId.Player))
{
minion.m_ControlledByPlayer = true;
minion.SetFlag(UnitFields.Flags, UnitFlags.PvpAttackable);
}
// Can only have one pet. If a new one is summoned, dismiss the old one.
if (minion.IsGuardianPet())
{
Guardian oldPet = GetGuardianPet();
if (oldPet)
{
if (oldPet != minion && (oldPet.IsPet() || minion.IsPet() || oldPet.GetEntry() != minion.GetEntry()))
{
// remove existing minion pet
if (oldPet.IsPet())
{
((Pet)oldPet).Remove(PetSaveMode.AsCurrent);
}
else
{
oldPet.UnSummon();
}
SetPetGUID(minion.GetGUID());
SetMinionGUID(ObjectGuid.Empty);
}
}
else
{
SetPetGUID(minion.GetGUID());
SetMinionGUID(ObjectGuid.Empty);
}
}
if (minion.HasUnitTypeMask(UnitTypeMask.Guardian))
{
AddGuidValue(UnitFields.Summon, minion.GetGUID());
}
if (minion.m_Properties != null && minion.m_Properties.Type == SummonType.Minipet)
{
SetCritterGUID(minion.GetGUID());
if (GetTypeId() == TypeId.Player)
{
minion.SetGuidValue(UnitFields.BattlePetCompanionGuid, GetGuidValue(PlayerFields.SummonedBattlePetId));
}
}
// PvP, FFAPvP
minion.SetByteValue(UnitFields.Bytes2, UnitBytes2Offsets.PvpFlag, GetByteValue(UnitFields.Bytes2, UnitBytes2Offsets.PvpFlag));
// FIXME: hack, speed must be set only at follow
if (IsTypeId(TypeId.Player) && minion.IsPet())
{
for (UnitMoveType i = 0; i < UnitMoveType.Max; ++i)
{
minion.SetSpeedRate(i, m_speed_rate[(int)i]);
}
}
// Send infinity cooldown - client does that automatically but after relog cooldown needs to be set again
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(minion.GetUInt32Value(UnitFields.CreatedBySpell));
if (spellInfo != null && spellInfo.IsCooldownStartedOnEvent())
{
GetSpellHistory().StartCooldown(spellInfo, 0, null, true);
}
}
else
{
if (minion.GetOwnerGUID() != GetGUID())
{
Log.outFatal(LogFilter.Unit, "SetMinion: Minion {0} is not the minion of owner {1}", minion.GetEntry(), GetEntry());
return;
}
m_Controlled.Remove(minion);
if (minion.m_Properties != null && minion.m_Properties.Type == SummonType.Minipet)
{
if (GetCritterGUID() == minion.GetGUID())
{
SetCritterGUID(ObjectGuid.Empty);
}
}
if (minion.IsGuardianPet())
{
if (GetPetGUID() == minion.GetGUID())
{
SetPetGUID(ObjectGuid.Empty);
}
}
else if (minion.IsTotem())
{
// All summoned by totem minions must disappear when it is removed.
SpellInfo spInfo = Global.SpellMgr.GetSpellInfo(minion.ToTotem().GetSpell());
if (spInfo != null)
{
foreach (SpellEffectInfo effect in spInfo.GetEffectsForDifficulty(Difficulty.None))
{
if (effect == null || effect.Effect != SpellEffectName.Summon)
{
continue;
}
RemoveAllMinionsByEntry((uint)effect.MiscValue);
}
}
}
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(minion.GetUInt32Value(UnitFields.CreatedBySpell));
// Remove infinity cooldown
if (spellInfo != null && spellInfo.IsCooldownStartedOnEvent())
{
GetSpellHistory().SendCooldownEvent(spellInfo);
}
if (RemoveGuidValue(UnitFields.Summon, minion.GetGUID()))
{
// Check if there is another minion
foreach (var unit in m_Controlled)
{
// do not use this check, creature do not have charm guid
if (GetGUID() == unit.GetCharmerGUID())
{
continue;
}
Contract.Assert(unit.GetOwnerGUID() == GetGUID());
if (unit.GetOwnerGUID() != GetGUID())
{
Contract.Assert(false);
}
Contract.Assert(unit.IsTypeId(TypeId.Unit));
if (!unit.HasUnitTypeMask(UnitTypeMask.Guardian))
{
continue;
}
if (AddGuidValue(UnitFields.Summon, unit.GetGUID()))
{
// show another pet bar if there is no charm bar
if (IsTypeId(TypeId.Player) && GetCharmGUID().IsEmpty())
{
if (unit.IsPet())
{
ToPlayer().PetSpellInitialize();
}
else
{
ToPlayer().CharmSpellInitialize();
}
}
}
break;
}
}
}
}
public void SetMinion(Minion minion, bool apply)
{
Log.outDebug(LogFilter.Unit, "SetMinion {0} for {1}, apply {2}", minion.GetEntry(), GetEntry(), apply);
if (apply)
{
if (!minion.GetOwnerGUID().IsEmpty())
{
Log.outFatal(LogFilter.Unit, "SetMinion: Minion {0} is not the minion of owner {1}", minion.GetEntry(), GetEntry());
return;
}
minion.SetOwnerGUID(GetGUID());
if (!m_Controlled.Contains(minion))
{
m_Controlled.Add(minion);
}
if (IsTypeId(TypeId.Player))
{
minion.m_ControlledByPlayer = true;
minion.AddUnitFlag(UnitFlags.PlayerControlled);
}
// Can only have one pet. If a new one is summoned, dismiss the old one.
if (minion.IsGuardianPet())
{
Guardian oldPet = GetGuardianPet();
if (oldPet)
{
if (oldPet != minion && (oldPet.IsPet() || minion.IsPet() || oldPet.GetEntry() != minion.GetEntry()))
{
// remove existing minion pet
if (oldPet.IsPet())
{
((Pet)oldPet).Remove(PetSaveMode.AsCurrent);
}
else
{
oldPet.UnSummon();
}
SetPetGUID(minion.GetGUID());
SetMinionGUID(ObjectGuid.Empty);
}
}
else
{
SetPetGUID(minion.GetGUID());
SetMinionGUID(ObjectGuid.Empty);
}
}
if (minion.HasUnitTypeMask(UnitTypeMask.Guardian))
{
if (GetMinionGUID().IsEmpty())
{
SetMinionGUID(minion.GetGUID());
}
}
var properties = minion.m_Properties;
if (properties != null && properties.Title == SummonTitle.Companion)
{
SetCritterGUID(minion.GetGUID());
Player thisPlayer = ToPlayer();
if (thisPlayer != null)
{
if (properties.GetFlags().HasFlag(SummonPropertiesFlags.SummonFromBattlePetJournal))
{
var pet = thisPlayer.GetSession().GetBattlePetMgr().GetPet(thisPlayer.GetSummonedBattlePetGUID());
if (pet != null)
{
minion.SetBattlePetCompanionGUID(thisPlayer.GetSummonedBattlePetGUID());
minion.SetBattlePetCompanionNameTimestamp((uint)pet.NameTimestamp);
minion.SetWildBattlePetLevel(pet.PacketInfo.Level);
uint display = pet.PacketInfo.DisplayID;
if (display != 0)
{
minion.SetDisplayId(display);
minion.SetNativeDisplayId(display);
}
}
}
}
}
// PvP, FFAPvP
minion.SetPvpFlags(GetPvpFlags());
// FIXME: hack, speed must be set only at follow
if (IsTypeId(TypeId.Player) && minion.IsPet())
{
for (UnitMoveType i = 0; i < UnitMoveType.Max; ++i)
{
minion.SetSpeedRate(i, m_speed_rate[(int)i]);
}
}
// Send infinity cooldown - client does that automatically but after relog cooldown needs to be set again
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(minion.m_unitData.CreatedBySpell, GetMap().GetDifficultyID());
if (spellInfo != null && spellInfo.IsCooldownStartedOnEvent())
{
GetSpellHistory().StartCooldown(spellInfo, 0, null, true);
}
}
else
{
if (minion.GetOwnerGUID() != GetGUID())
{
Log.outFatal(LogFilter.Unit, "SetMinion: Minion {0} is not the minion of owner {1}", minion.GetEntry(), GetEntry());
return;
}
m_Controlled.Remove(minion);
if (minion.m_Properties != null && minion.m_Properties.Title == SummonTitle.Companion)
{
if (GetCritterGUID() == minion.GetGUID())
{
SetCritterGUID(ObjectGuid.Empty);
}
}
if (minion.IsGuardianPet())
{
if (GetPetGUID() == minion.GetGUID())
{
SetPetGUID(ObjectGuid.Empty);
}
}
else if (minion.IsTotem())
{
// All summoned by totem minions must disappear when it is removed.
SpellInfo spInfo = Global.SpellMgr.GetSpellInfo(minion.ToTotem().GetSpell(), GetMap().GetDifficultyID());
if (spInfo != null)
{
foreach (var spellEffectInfo in spInfo.GetEffects())
{
if (spellEffectInfo == null || !spellEffectInfo.IsEffect(SpellEffectName.Summon))
{
continue;
}
RemoveAllMinionsByEntry((uint)spellEffectInfo.MiscValue);
}
}
}
SpellInfo spellInfo = Global.SpellMgr.GetSpellInfo(minion.m_unitData.CreatedBySpell, GetMap().GetDifficultyID());
// Remove infinity cooldown
if (spellInfo != null && spellInfo.IsCooldownStartedOnEvent())
{
GetSpellHistory().SendCooldownEvent(spellInfo);
}
if (GetMinionGUID() == minion.GetGUID())
{
SetMinionGUID(ObjectGuid.Empty);
// Check if there is another minion
foreach (var unit in m_Controlled)
{
// do not use this check, creature do not have charm guid
if (GetGUID() == unit.GetCharmerGUID())
{
continue;
}
Cypher.Assert(unit.GetOwnerGUID() == GetGUID());
if (unit.GetOwnerGUID() != GetGUID())
{
Cypher.Assert(false);
}
Cypher.Assert(unit.IsTypeId(TypeId.Unit));
if (!unit.HasUnitTypeMask(UnitTypeMask.Guardian))
{
continue;
}
SetMinionGUID(unit.GetGUID());
// show another pet bar if there is no charm bar
if (GetTypeId() == TypeId.Player && GetCharmedGUID().IsEmpty())
{
if (unit.IsPet())
{
ToPlayer().PetSpellInitialize();
}
else
{
ToPlayer().CharmSpellInitialize();
}
}
break;
}
}
}
UpdatePetCombatState();
}
public void SetSpeed(UnitMoveType speednr, float speed)
{
_speed[(byte)speednr] = speed;
}
public void SetSpeed(UnitMoveType type, float newValue)
{
SetSpeedRate(type, newValue / StatHelper.BaseMovementSpeed(type));
}
public float GetSpeedRate(UnitMoveType type)
{
return(speedRates[type]);
}
public float GetSpeed(UnitMoveType type)
{
return(speedRates[type] * StatHelper.BaseMovementSpeed(type));
}
public void UpdateSpeed(UnitMoveType type)
{
int main_speed_mod = 0;
float stack_bonus = 1.0f;
float non_stack_bonus = 1.0f;
switch (type)
{
// only apply debuffs
case UnitMoveType.RunBack:
break;
case UnitMoveType.Run:
main_speed_mod = /*GetMaxPositiveAuraModifier(SPELL_AURA_MOD_INCREASE_SPEED)*/ 0;
stack_bonus = /*GetTotalAuraMultiplier(SPELL_AURA_MOD_SPEED_ALWAYS)*/ 0;
non_stack_bonus += /*GetMaxPositiveAuraModifier(SPELL_AURA_MOD_SPEED_NOT_STACK) / 100.0f*/ 0;
break;
default:
Debug.LogErrorFormat("Character::UpdateSpeed: Unsupported move type - {0}", type);
return;
}
// now we ready for speed calculation
float speed = Mathf.Max(non_stack_bonus, stack_bonus);
if (main_speed_mod != 0)
{
speed *= main_speed_mod;
}
switch (type)
{
case UnitMoveType.Run:
// Normalize speed by 191 aura SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED if need #TODO
int normalization /* = GetMaxPositiveAuraModifier(SPELL_AURA_USE_NORMAL_MOVEMENT_SPEED)*/ = 0;
if (normalization > 0)
{
// Use speed from aura
float max_speed = normalization / StatHelper.BaseMovementSpeed(type);
if (speed > max_speed)
{
speed = max_speed;
}
}
// force minimum speed rate @ aura 437 SPELL_AURA_MOD_MINIMUM_SPEED_RATE
int minSpeedModRate = /*GetMaxPositiveAuraModifier(SPELL_AURA_MOD_MINIMUM_SPEED_RATE)*/ 0;
if (minSpeedModRate != 0)
{
float minSpeed = minSpeedModRate / StatHelper.BaseMovementSpeed(type);
if (speed < minSpeed)
{
speed = minSpeed;
}
}
break;
default:
break;
}
// Apply strongest slow aura mod to speed
int slow = /*GetMaxNegativeAuraModifier(SPELL_AURA_MOD_DECREASE_SPEED)*/ 0;
if (slow != 0)
{
speed *= slow;
}
float minSpeedMod = (float)/*GetMaxPositiveAuraModifier(SPELL_AURA_MOD_MINIMUM_SPEED)*/ 0;
if (minSpeedMod > 0)
{
float min_speed = minSpeedMod / 100.0f;
if (speed < min_speed)
{
speed = min_speed;
}
}
SetSpeedRate(type, speed);
}
public static float BaseMovementSpeed(UnitMoveType moveType)
{
return(baseMoveSpeed[moveType]);
}