WorldPackets::Spells Namespace Reference

Classes
class	AddRunePower
struct	AuraDataInfo
struct	AuraInfo
class	AuraUpdate
class	CancelAura
class	CancelAutoRepeatSpell
class	CancelCast
class	CancelChannelling
class	CancelGrowthAura
class	CancelModSpeedNoControlAuras
class	CancelMountAura
class	CancelOrphanSpellVisual
class	CancelSpellVisual
class	CancelSpellVisualKit
class	CastFailed
class	CastSpell
class	CategoryCooldown
class	ClearAllSpellCharges
class	ClearCooldown
class	ClearCooldowns
class	ClearSpellCharges
class	ClearTarget
struct	ContentTuningParams
class	CooldownEvent
struct	CreatureImmunities
class	CustomLoadScreen
class	DispelFailed
class	GetMirrorImageData
class	KeyboundOverride
struct	LearnedSpellInfo
class	LearnedSpells
class	MirrorImageComponentedData
class	MirrorImageCreatureData
class	MissileCancel
class	MissileTrajectoryCollision
struct	MissileTrajectoryRequest
struct	MissileTrajectoryResult
class	ModifyCooldown
class	MountResult
class	NotifyMissileTrajectoryCollision
class	OpenItem
class	PetCancelAura
class	PetCastFailed
class	PetCastSpell
class	PlayOrphanSpellVisual
class	PlaySpellVisual
class	PlaySpellVisualKit
class	RequestCategoryCooldowns
class	ResurrectRequest
class	ResyncRunes
struct	RuneData
class	SelfRes
class	SendKnownSpells
class	SendSpellCharges
class	SendSpellHistory
class	SendUnlearnSpells
class	SetActionButton
class	SetSpellCharges
class	SetSpellModifier
struct	SpellAmmo
struct	SpellCastData
struct	SpellCastLogData
struct	SpellCastRequest
struct	SpellCastVisual
class	SpellChannelStart
struct	SpellChannelStartInterruptImmunities
class	SpellChannelUpdate
struct	SpellChargeEntry
class	SpellClick
class	SpellCooldown
struct	SpellCooldownStruct
struct	SpellCraftingReagent
class	SpellDelayed
struct	SpellExtraCurrencyCost
class	SpellFailedOther
class	SpellFailure
class	SpellGo
struct	SpellHealPrediction
struct	SpellHistoryEntry
struct	SpellHitStatus
struct	SpellLogPowerData
struct	SpellMissStatus
struct	SpellModifier
struct	SpellModifierData
struct	SpellPowerData
class	SpellPrepare
class	SpellStart
struct	SpellTargetData
struct	SpellTargetedHealPrediction
class	SpellVisualLoadScreen
struct	SpellWeight
class	SupercededSpells
struct	TargetLocation
class	TradeSkillSetFavorite
class	UnlearnedSpells
class	UnlearnSkill
class	UpdateActionButtons
class	UpdateMissileTrajectory
class	UseItem

Functions
ByteBuffer &	operator<< (ByteBuffer &data, SpellCastLogData const &spellCastLogData)
ByteBuffer &	operator<< (ByteBuffer &data, ContentTuningParams const &contentTuningParams)
ByteBuffer &	operator>> (ByteBuffer &data, SpellCastVisual &visual)
ByteBuffer &	operator<< (ByteBuffer &data, SpellCastVisual const &visual)
ByteBuffer &	operator<< (ByteBuffer &data, AuraDataInfo const &auraData)
ByteBuffer &	operator<< (ByteBuffer &data, AuraInfo const &aura)
ByteBuffer &	operator>> (ByteBuffer &buffer, Optional< TargetLocation > &location)
ByteBuffer &	operator>> (ByteBuffer &buffer, SpellTargetData &targetData)
ByteBuffer &	operator>> (ByteBuffer &buffer, MissileTrajectoryRequest &trajectory)
ByteBuffer &	operator>> (ByteBuffer &data, SpellCraftingReagent &optionalReagent)
ByteBuffer &	operator>> (ByteBuffer &data, SpellExtraCurrencyCost &extraCurrencyCost)
ByteBuffer &	operator>> (ByteBuffer &buffer, SpellCastRequest &request)
ByteBuffer &	operator<< (ByteBuffer &data, TargetLocation const &targetLocation)
ByteBuffer &	operator<< (ByteBuffer &data, SpellTargetData const &spellTargetData)
ByteBuffer &	operator<< (ByteBuffer &data, SpellMissStatus const &spellMissStatus)
ByteBuffer &	operator<< (ByteBuffer &data, SpellHitStatus const &spellHitStatus)
ByteBuffer &	operator<< (ByteBuffer &data, SpellPowerData const &spellPowerData)
ByteBuffer &	operator<< (ByteBuffer &data, RuneData const &runeData)
ByteBuffer &	operator<< (ByteBuffer &data, MissileTrajectoryResult const &missileTrajectory)
ByteBuffer &	operator<< (ByteBuffer &data, SpellAmmo const &spellAmmo)
ByteBuffer &	operator<< (ByteBuffer &data, CreatureImmunities const &immunities)
ByteBuffer &	operator<< (ByteBuffer &data, SpellHealPrediction const &spellPred)
ByteBuffer &	operator<< (ByteBuffer &data, SpellCastData const &spellCastData)
ByteBuffer &	operator<< (ByteBuffer &data, LearnedSpellInfo const &learnedSpellInfo)
ByteBuffer &	operator<< (ByteBuffer &data, SpellModifierData const &spellModifierData)
ByteBuffer &	operator<< (ByteBuffer &data, SpellModifier const &spellModifier)
ByteBuffer &	operator<< (ByteBuffer &data, SpellCooldownStruct const &cooldown)
ByteBuffer &	operator<< (ByteBuffer &data, SpellHistoryEntry const &historyEntry)
ByteBuffer &	operator<< (ByteBuffer &data, SpellChargeEntry const &chargeEntry)
ByteBuffer &	operator<< (ByteBuffer &data, SpellChannelStartInterruptImmunities const &interruptImmunities)
ByteBuffer &	operator<< (ByteBuffer &data, SpellTargetedHealPrediction const &targetedHealPrediction)

Function Documentation

operator<<() [1/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		AuraDataInfo const &	auraData
	)

{
 data << auraData.CastID;
 data << int32(auraData.SpellID);
 data << auraData.Visual;
 data << uint16(auraData.Flags);
 data << uint32(auraData.ActiveFlags);
 data << uint16(auraData.CastLevel);
 data << uint8(auraData.Applications);
 data << int32(auraData.ContentTuningID);
 data.WriteBit(auraData.CastUnit.has_value());
 data.WriteBit(auraData.Duration.has_value());
 data.WriteBit(auraData.Remaining.has_value());
 data.WriteBit(auraData.TimeMod.has_value());
 data.WriteBits(auraData.Points.size(), 6);
 data.WriteBits(auraData.EstimatedPoints.size(), 6);
 data.WriteBit(auraData.ContentTuning.has_value());
 
 if (auraData.ContentTuning)
 data << *auraData.ContentTuning;
 
 if (auraData.CastUnit)
 data << *auraData.CastUnit;
 
 if (auraData.Duration)
 data << uint32(*auraData.Duration);
 
 if (auraData.Remaining)
 data << uint32(*auraData.Remaining);
 
 if (auraData.TimeMod)
 data << float(*auraData.TimeMod);
 
 if (!auraData.Points.empty())
 data.append(auraData.Points.data(), auraData.Points.size());
 
 if (!auraData.EstimatedPoints.empty())
 data.append(auraData.EstimatedPoints.data(), auraData.EstimatedPoints.size());
 
 return data;
}

Here is the call graph for this function:

operator<<() [2/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		AuraInfo const &	aura
	)

{
 data << aura.Slot;
 data.WriteBit(aura.AuraData.has_value());
 data.FlushBits();
 
 if (aura.AuraData)
 data << *aura.AuraData;
 
 return data;
}

Here is the call graph for this function:

operator<<() [3/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		ContentTuningParams const &	contentTuningParams
	)

{
 data << float(contentTuningParams.PlayerItemLevel);
 data << float(contentTuningParams.TargetItemLevel);
 data << int16(contentTuningParams.PlayerLevelDelta);
 data << uint16(contentTuningParams.ScalingHealthItemLevelCurveID);
 data << uint8(contentTuningParams.TargetLevel);
 data << uint8(contentTuningParams.Expansion);
 data << int8(contentTuningParams.TargetScalingLevelDelta);
 data << uint32(contentTuningParams.Flags);
 data << int32(contentTuningParams.PlayerContentTuningID);
 data << int32(contentTuningParams.TargetContentTuningID);
 data << int32(contentTuningParams.Unused927);
 data.WriteBits(contentTuningParams.Type, 4);
 data.FlushBits();
 return data;
}

Here is the call graph for this function:

operator<<() [4/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		CreatureImmunities const &	immunities
	)

{
 data << int32(immunities.School);
 data << int32(immunities.Value);
 return data;
}

operator<<() [5/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		LearnedSpellInfo const &	learnedSpellInfo
	)

{
 data << int32(learnedSpellInfo.SpellID);
 data.WriteBit(learnedSpellInfo.IsFavorite);
 data.WriteBit(learnedSpellInfo.field_8.has_value());
 data.WriteBit(learnedSpellInfo.Superceded.has_value());
 data.WriteBit(learnedSpellInfo.TraitDefinitionID.has_value());
 data.FlushBits();
 
 if (learnedSpellInfo.field_8)
 data << int32(*learnedSpellInfo.field_8);
 
 if (learnedSpellInfo.Superceded)
 data << int32(*learnedSpellInfo.Superceded);
 
 if (learnedSpellInfo.TraitDefinitionID)
 data << int32(*learnedSpellInfo.TraitDefinitionID);
 
 return data;
}

Here is the call graph for this function:

operator<<() [6/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		MissileTrajectoryResult const &	missileTrajectory
	)

{
 data << uint32(missileTrajectory.TravelTime);
 data << float(missileTrajectory.Pitch);
 return data;
}

operator<<() [7/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		RuneData const &	runeData
	)

{
 data << uint8(runeData.Start);
 data << uint8(runeData.Count);
 data << uint32(runeData.Cooldowns.size());
 if (!runeData.Cooldowns.empty())
 data.append(runeData.Cooldowns.data(), runeData.Cooldowns.size());
 
 return data;
}

Here is the call graph for this function:

operator<<() [8/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellAmmo const &	spellAmmo
	)

{
 data << int32(spellAmmo.DisplayID);
 data << int8(spellAmmo.InventoryType);
 return data;
}

operator<<() [9/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellCastData const &	spellCastData
	)

{
 data << spellCastData.CasterGUID;
 data << spellCastData.CasterUnit;
 data << spellCastData.CastID;
 data << spellCastData.OriginalCastID;
 data << int32(spellCastData.SpellID);
 data << spellCastData.Visual;
 data << uint32(spellCastData.CastFlags);
 data << uint32(spellCastData.CastFlagsEx);
 data << uint32(spellCastData.CastTime);
 data << spellCastData.MissileTrajectory;
 data << int32(spellCastData.Ammo.DisplayID);
 data << uint8(spellCastData.DestLocSpellCastIndex);
 data << spellCastData.Immunities;
 data << spellCastData.Predict;
 data.WriteBits(spellCastData.HitTargets.size(), 16);
 data.WriteBits(spellCastData.MissTargets.size(), 16);
  data.WriteBits(spellCastData.HitStatus.size(), 16);
 data.WriteBits(spellCastData.MissStatus.size(), 16);
 data.WriteBits(spellCastData.RemainingPower.size(), 9);
 data.WriteBit(spellCastData.RemainingRunes.has_value());
 data.WriteBits(spellCastData.TargetPoints.size(), 16);
 data.FlushBits();
 
 for (SpellMissStatus const& missStatus : spellCastData.MissStatus)
 data << missStatus;
 
 data << spellCastData.Target;
 
 for (ObjectGuid const& hitTarget : spellCastData.HitTargets)
 data << hitTarget;
 
 for (ObjectGuid const& missTarget : spellCastData.MissTargets)
 data << missTarget;
 
 for (SpellHitStatus const& hitStatus : spellCastData.HitStatus)
 data << hitStatus;
 
 for (SpellPowerData const& power : spellCastData.RemainingPower)
 data << power;
 
 if (spellCastData.RemainingRunes)
 data << *spellCastData.RemainingRunes;
 
 for (TargetLocation const& targetLoc : spellCastData.TargetPoints)
 data << targetLoc;
 
 return data;
}

Here is the call graph for this function:

operator<<() [10/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellCastLogData const &	spellCastLogData
	)

{
 data << int64(spellCastLogData.Health);
 data << int32(spellCastLogData.AttackPower);
 data << int32(spellCastLogData.SpellPower);
 data << int32(spellCastLogData.Armor);
 data.WriteBits(spellCastLogData.PowerData.size(), 9);
 data.FlushBits();
 
 for (WorldPackets::Spells::SpellLogPowerData const& powerData : spellCastLogData.PowerData)
 {
 data << int32(powerData.PowerType);
 data << int32(powerData.Amount);
 data << int32(powerData.Cost);
 }
 
 return data;
}

Here is the call graph for this function:

operator<<() [11/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellCastVisual const &	visual
	)

{
 data << int32(visual.SpellXSpellVisualID);
 data << int32(visual.ScriptVisualID);
 
 return data;
}

operator<<() [12/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellChannelStartInterruptImmunities const &	interruptImmunities
	)

{
 data << int32(interruptImmunities.SchoolImmunities);
 data << int32(interruptImmunities.Immunities);
 return data;
}

operator<<() [13/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellChargeEntry const &	chargeEntry
	)

{
 data << uint32(chargeEntry.Category);
 data << uint32(chargeEntry.NextRecoveryTime);
 data << float(chargeEntry.ChargeModRate);
 data << uint8(chargeEntry.ConsumedCharges);
 return data;
}

operator<<() [14/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellCooldownStruct const &	cooldown
	)

{
 data << uint32(cooldown.SrecID);
 data << uint32(cooldown.ForcedCooldown);
 data << float(cooldown.ModRate);
 return data;
}

operator<<() [15/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellHealPrediction const &	spellPred
	)

{
 data << int32(spellPred.Points);
 data << uint8(spellPred.Type);
 data << spellPred.BeaconGUID;
 return data;
}

operator<<() [16/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellHistoryEntry const &	historyEntry
	)

{
 data << uint32(historyEntry.SpellID);
 data << uint32(historyEntry.ItemID);
 data << uint32(historyEntry.Category);
 data << int32(historyEntry.RecoveryTime);
 data << int32(historyEntry.CategoryRecoveryTime);
 data << float(historyEntry.ModRate);
 data.WriteBit(historyEntry.unused622_1.has_value());
 data.WriteBit(historyEntry.unused622_2.has_value());
 data.WriteBit(historyEntry.OnHold);
 if (historyEntry.unused622_1)
 data << uint32(*historyEntry.unused622_1);
 if (historyEntry.unused622_2)
 data << uint32(*historyEntry.unused622_2);
 data.FlushBits();
 
 return data;
}

Here is the call graph for this function:

operator<<() [17/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellHitStatus const &	spellHitStatus
	)

{
 data << uint8(spellHitStatus.Reason);
 return data;
}

operator<<() [18/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellMissStatus const &	spellMissStatus
	)

{
 data.WriteBits(spellMissStatus.Reason, 4);
 if (spellMissStatus.Reason == SPELL_MISS_REFLECT)
 data.WriteBits(spellMissStatus.ReflectStatus, 4);
 
 data.FlushBits();
 return data;
}

Here is the call graph for this function:

operator<<() [19/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellModifier const &	spellModifier
	)

{
 data << uint8(spellModifier.ModIndex);
 data << uint32(spellModifier.ModifierData.size());
 for (SpellModifierData const& modData : spellModifier.ModifierData)
 data << modData;
 
 return data;
}

operator<<() [20/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellModifierData const &	spellModifierData
	)

{
 data << float(spellModifierData.ModifierValue);
 data << uint8(spellModifierData.ClassIndex);
 
 return data;
}

operator<<() [21/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellPowerData const &	spellPowerData
	)

{
 data << int32(spellPowerData.Cost);
 data << int8(spellPowerData.Type);
 return data;
}

operator<<() [22/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellTargetData const &	spellTargetData
	)

{
 data.WriteBits(spellTargetData.Flags, 28);
 data.WriteBit(spellTargetData.SrcLocation.has_value());
 data.WriteBit(spellTargetData.DstLocation.has_value());
 data.WriteBit(spellTargetData.Orientation.has_value());
 data.WriteBit(spellTargetData.MapID.has_value());
 data.WriteBits(spellTargetData.Name.size(), 7);
 data.FlushBits();
 
 data << spellTargetData.Unit;
 data << spellTargetData.Item;
 
 if (spellTargetData.SrcLocation)
 data << *spellTargetData.SrcLocation;
 
 if (spellTargetData.DstLocation)
 data << *spellTargetData.DstLocation;
 
 if (spellTargetData.Orientation)
 data << *spellTargetData.Orientation;
 
 if (spellTargetData.MapID)
 data << *spellTargetData.MapID;
 
 data.WriteString(spellTargetData.Name);
 
 return data;
}

Here is the call graph for this function:

operator<<() [23/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		SpellTargetedHealPrediction const &	targetedHealPrediction
	)

{
 data << targetedHealPrediction.TargetGUID;
 data << targetedHealPrediction.Predict;
 return data;
}

operator<<() [24/24]

ByteBuffer & WorldPackets::Spells::operator<<	(	ByteBuffer &	data,
		TargetLocation const &	targetLocation
	)

{
 data << targetLocation.Transport;
 data << float(targetLocation.Location.m_positionX);
 data << float(targetLocation.Location.m_positionY);
 data << float(targetLocation.Location.m_positionZ);
 return data;
}

operator>>() [1/7]

ByteBuffer & WorldPackets::Spells::operator>>	(	ByteBuffer &	buffer,
		MissileTrajectoryRequest &	trajectory
	)

{
 buffer >> trajectory.Pitch;
 buffer >> trajectory.Speed;
 return buffer;
}

operator>>() [2/7]

ByteBuffer & WorldPackets::Spells::operator>>	(	ByteBuffer &	buffer,
		Optional< TargetLocation > &	location
	)

{
 location.emplace();
 buffer >> location->Transport;
 buffer >> location->Location.m_positionX;
 buffer >> location->Location.m_positionY;
 buffer >> location->Location.m_positionZ;
 return buffer;
}

operator>>() [3/7]

ByteBuffer & WorldPackets::Spells::operator>>	(	ByteBuffer &	buffer,
		SpellCastRequest &	request
	)

{
 buffer >> request.CastID;
 buffer >> request.Misc[0];
 buffer >> request.Misc[1];
 buffer >> request.SpellID;
 buffer >> request.Visual;
 buffer >> request.MissileTrajectory;
 buffer >> request.CraftingNPC;
 request.OptionalCurrencies.resize(buffer.read<uint32>());
 request.OptionalReagents.resize(buffer.read<uint32>());
 
 for (SpellExtraCurrencyCost& optionalCurrency : request.OptionalCurrencies)
 buffer >> optionalCurrency;
 
 request.SendCastFlags = buffer.ReadBits(5);
 bool hasMoveUpdate = buffer.ReadBit();
 request.Weight.resize(buffer.ReadBits(2));
 bool hasCraftingOrderID = buffer.ReadBit();
 buffer >> request.Target;
 
 if (hasCraftingOrderID)
 request.CraftingOrderID = buffer.read<uint64>();
 
 for (SpellCraftingReagent& optionalReagent : request.OptionalReagents)
 buffer >> optionalReagent;
 
 if (hasMoveUpdate)
 {
 request.MoveUpdate.emplace();
 buffer >> *request.MoveUpdate;
 }
 
 for (SpellWeight& weight : request.Weight)
 {
 buffer.ResetBitPos();
 weight.Type = buffer.ReadBits(2);
 buffer >> weight.ID;
 buffer >> weight.Quantity;
 }
 
 return buffer;
}

Here is the call graph for this function:

operator>>() [4/7]

ByteBuffer & WorldPackets::Spells::operator>>	(	ByteBuffer &	buffer,
		SpellTargetData &	targetData
	)

{
 buffer.ResetBitPos();
 
 targetData.Flags = buffer.ReadBits(28);
 bool hasSrcLocation = buffer.ReadBit();
 bool hasDstLocation = buffer.ReadBit();
 bool hasOrientation = buffer.ReadBit();
 bool hasMapID = buffer.ReadBit();
 uint32 nameLength = buffer.ReadBits(7);
 
 buffer >> targetData.Unit;
 buffer >> targetData.Item;
 
 if (hasSrcLocation)
 buffer >> targetData.SrcLocation;
 
 if (hasDstLocation)
 buffer >> targetData.DstLocation;
 
 if (hasOrientation)
 targetData.Orientation = buffer.read<float>();
 
 if (hasMapID)
 targetData.MapID = buffer.read<int32>();
 
 targetData.Name = buffer.ReadString(nameLength);
 
 return buffer;
}

Here is the call graph for this function:

operator>>() [5/7]

ByteBuffer & WorldPackets::Spells::operator>>	(	ByteBuffer &	data,
		SpellCastVisual &	visual
	)

{
 data >> visual.SpellXSpellVisualID;
 data >> visual.ScriptVisualID;
 
 return data;
}

operator>>() [6/7]

ByteBuffer & WorldPackets::Spells::operator>>	(	ByteBuffer &	data,
		SpellCraftingReagent &	optionalReagent
	)

{
 data >> optionalReagent.ItemID;
 data >> optionalReagent.DataSlotIndex;
 data >> optionalReagent.Quantity;
 if (data.ReadBit())
 optionalReagent.Unknown_1000 = data.read<uint8>();
 
 return data;
}

Here is the call graph for this function:

operator>>() [7/7]

ByteBuffer & WorldPackets::Spells::operator>>	(	ByteBuffer &	data,
		SpellExtraCurrencyCost &	extraCurrencyCost
	)

{
 data >> extraCurrencyCost.CurrencyID;
 data >> extraCurrencyCost.Count;
 return data;
}