SpellPackets.cpp File Reference

#include "SpellPackets.h"
#include "MovementPackets.h"

Include dependency graph for SpellPackets.cpp:

Functions
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellCastLogData const &spellCastLogData)
ByteBuffer &	operator>> (ByteBuffer &buffer, Optional< WorldPackets::Spells::TargetLocation > &location)
ByteBuffer &	operator>> (ByteBuffer &buffer, WorldPackets::Spells::SpellTargetData &targetData)
ByteBuffer &	operator>> (ByteBuffer &buffer, WorldPackets::Spells::MissileTrajectoryRequest &trajectory)
ByteBuffer &	operator>> (ByteBuffer &buffer, WorldPackets::Spells::SpellCastRequest &request)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::TargetLocation const &targetLocation)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellTargetData const &spellTargetData)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellMissStatus const &spellMissStatus)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellPowerData const &spellPowerData)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::RuneData const &runeData)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::MissileTrajectoryResult const &missileTrajectory)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellAmmo const &spellAmmo)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::CreatureImmunities const &immunities)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellHealPrediction const &spellPred)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellCastData const &spellCastData)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellModifierData const &spellModifierData)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellModifier const &spellModifier)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellCooldownStruct const &cooldown)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellHistoryEntry const &historyEntry)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellChargeEntry const &chargeEntry)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellChannelStartInterruptImmunities const &interruptImmunities)
ByteBuffer &	operator<< (ByteBuffer &data, WorldPackets::Spells::SpellTargetedHealPrediction const &targetedHealPrediction)

Function Documentation

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

{
 data << spellCastLogData.Health;
 data << spellCastLogData.AttackPower;
 data << spellCastLogData.SpellPower;
 data << int32(spellCastLogData.PowerData.size());
 for (WorldPackets::Spells::SpellLogPowerData const& powerData : spellCastLogData.PowerData)
 {
 data << powerData.PowerType;
 data << powerData.Amount;
 }
 data.WriteBit(false);
 // data << float // Unk data if bit is true
 data.FlushBits();

 return data;
}

Here is the call graph for this function:

ByteBuffer& operator<<	(	ByteBuffer &	data,
		WorldPackets::Spells::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;
}

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

{
 data.WriteBits(spellTargetData.Flags, 23);
 data.WriteBit(spellTargetData.SrcLocation.is_initialized());
 data.WriteBit(spellTargetData.DstLocation.is_initialized());
 data.WriteBit(spellTargetData.Orientation.is_initialized());
 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;

 data.WriteString(spellTargetData.Name);

 return data;
}

Here is the call graph for this function:

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

{
 data.WriteBits(spellMissStatus.Reason, 4);
 data.WriteBits(spellMissStatus.ReflectStatus, 4);
 // No need to flush bits as we written exactly 8 bits (1 byte)
 return data;
}

Here is the call graph for this function:

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

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

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

{
 data << uint8(runeData.Start);
 data << uint8(runeData.Count);

 data.WriteBits(runeData.Cooldowns.size(), 3);
 data.FlushBits();

 for (uint8 cd : runeData.Cooldowns)
 data << cd;

 return data;
}

Here is the call graph for this function:

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

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

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

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

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

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

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

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

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

{
 data << spellCastData.CasterGUID;
 data << spellCastData.CasterUnit;
 data << uint8(spellCastData.CastID);
 data << int32(spellCastData.SpellID);
 data << uint32(spellCastData.SpellXSpellVisualID);
 data << uint32(spellCastData.CastFlags);
 data << uint32(spellCastData.CastTime);
 data << uint32(spellCastData.HitTargets.size());
 data << uint32(spellCastData.MissTargets.size());
 data << uint32(spellCastData.MissStatus.size());
 data << spellCastData.Target;
 data << uint32(spellCastData.RemainingPower.size());
 data << spellCastData.MissileTrajectory;
 data << spellCastData.Ammo;
 data << uint8(spellCastData.DestLocSpellCastIndex);
 data << uint32(spellCastData.TargetPoints.size());
 data << spellCastData.Immunities;
 data << spellCastData.Predict;

 for (ObjectGuid const& target : spellCastData.HitTargets)
 data << target;

 for (ObjectGuid const& target : spellCastData.MissTargets)
 data << target;

 for (WorldPackets::Spells::SpellMissStatus const& status : spellCastData.MissStatus)
 data << status;

 for (WorldPackets::Spells::SpellPowerData const& power : spellCastData.RemainingPower)
 data << power;

 for (WorldPackets::Spells::TargetLocation const& targetLoc : spellCastData.TargetPoints)
 data << targetLoc;

 data.WriteBits(spellCastData.CastFlagsEx, 20);
 data.WriteBit(spellCastData.RemainingRunes.is_initialized());
 data.FlushBits();

 if (spellCastData.RemainingRunes)
 data << *spellCastData.RemainingRunes;

 return data;
}

Here is the call graph for this function:

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

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

 return data;
}

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

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

 return data;
}

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

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

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

{
 data << uint32(historyEntry.SpellID);
 data << uint32(historyEntry.ItemID);
 data << uint32(historyEntry.Category);
 data << int32(historyEntry.RecoveryTime);
 data << int32(historyEntry.CategoryRecoveryTime);
 data.WriteBit(historyEntry.unused622_1.is_initialized());
 data.WriteBit(historyEntry.unused622_2.is_initialized());
 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:

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

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

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

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

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

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

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

{
 location = boost::in_place();
 buffer >> location->Transport;
 buffer >> location->Location.m_positionX;
 buffer >> location->Location.m_positionY;
 buffer >> location->Location.m_positionZ;
 return buffer;
}

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

{
 buffer.ResetBitPos();

 targetData.Flags = buffer.ReadBits(23);
 bool const hasSrcLocation = buffer.ReadBit();
 bool const hasDstLocation = buffer.ReadBit();
 bool const hasOrientation = 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>();

 targetData.Name = buffer.ReadString(nameLength);

 return buffer;
}

Here is the call graph for this function:

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

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

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

{
 buffer >> request.CastID;
 buffer >> request.Misc[0];
 buffer >> request.Misc[1];
 buffer >> request.SpellID;
 buffer >> request.SpellXSpellVisualID;
 buffer >> request.Target;
 buffer >> request.MissileTrajectory;
 buffer >> request.Charmer;

 buffer.ResetBitPos();
 request.SendCastFlags = buffer.ReadBits(5);
 bool const hasMoveUpdate = buffer.ReadBit();
 request.Weight.resize(buffer.ReadBits(2));

 if (hasMoveUpdate)
 {
 MovementInfo movementInfo;
 buffer >> movementInfo;
 request.MoveUpdate = movementInfo;
 }

 for (WorldPackets::Spells::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: