mirror of
https://github.com/araxiaonline/TrinityCore.git
synced 2026-06-13 11:43:18 -04:00
667 lines
16 KiB
C++
667 lines
16 KiB
C++
/*
|
|
* Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "MiscPackets.h"
|
|
#include "PacketUtilities.h"
|
|
|
|
WorldPacket const* WorldPackets::Misc::BindPointUpdate::Write()
|
|
{
|
|
_worldPacket << BindPosition;
|
|
_worldPacket << uint32(BindMapID);
|
|
_worldPacket << uint32(BindAreaID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::InvalidatePlayer::Write()
|
|
{
|
|
_worldPacket << Guid;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::LoginSetTimeSpeed::Write()
|
|
{
|
|
_worldPacket.AppendPackedTime(ServerTime);
|
|
_worldPacket.AppendPackedTime(GameTime);
|
|
_worldPacket << float(NewSpeed);
|
|
_worldPacket << uint32(ServerTimeHolidayOffset);
|
|
_worldPacket << uint32(GameTimeHolidayOffset);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::SetCurrency::Write()
|
|
{
|
|
_worldPacket << int32(Type);
|
|
_worldPacket << int32(Quantity);
|
|
_worldPacket << uint32(Flags);
|
|
_worldPacket.WriteBit(WeeklyQuantity.is_initialized());
|
|
_worldPacket.WriteBit(TrackedQuantity.is_initialized());
|
|
_worldPacket.WriteBit(MaxQuantity.is_initialized());
|
|
_worldPacket.WriteBit(SuppressChatLog);
|
|
_worldPacket.FlushBits();
|
|
|
|
if (WeeklyQuantity)
|
|
_worldPacket << int32(*WeeklyQuantity);
|
|
|
|
if (TrackedQuantity)
|
|
_worldPacket << int32(*TrackedQuantity);
|
|
|
|
if (MaxQuantity)
|
|
_worldPacket << int32(*MaxQuantity);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::SetSelection::Read()
|
|
{
|
|
_worldPacket >> Selection;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::SetupCurrency::Write()
|
|
{
|
|
_worldPacket << uint32(Data.size());
|
|
|
|
for (Record const& data : Data)
|
|
{
|
|
_worldPacket << int32(data.Type);
|
|
_worldPacket << int32(data.Quantity);
|
|
|
|
_worldPacket.WriteBit(data.WeeklyQuantity.is_initialized());
|
|
_worldPacket.WriteBit(data.MaxWeeklyQuantity.is_initialized());
|
|
_worldPacket.WriteBit(data.TrackedQuantity.is_initialized());
|
|
_worldPacket.WriteBit(data.MaxQuantity.is_initialized());
|
|
_worldPacket.WriteBits(data.Flags, 5);
|
|
_worldPacket.FlushBits();
|
|
|
|
if (data.WeeklyQuantity)
|
|
_worldPacket << uint32(*data.WeeklyQuantity);
|
|
if (data.MaxWeeklyQuantity)
|
|
_worldPacket << uint32(*data.MaxWeeklyQuantity);
|
|
if (data.TrackedQuantity)
|
|
_worldPacket << uint32(*data.TrackedQuantity);
|
|
if (data.MaxQuantity)
|
|
_worldPacket << int32(*data.MaxQuantity);
|
|
}
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::ViolenceLevel::Read()
|
|
{
|
|
_worldPacket >> ViolenceLvl;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::TimeSyncRequest::Write()
|
|
{
|
|
_worldPacket << SequenceIndex;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::TimeSyncResponse::Read()
|
|
{
|
|
_worldPacket >> SequenceIndex;
|
|
_worldPacket >> ClientTime;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::UITime::Write()
|
|
{
|
|
_worldPacket << Time;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::TriggerMovie::Write()
|
|
{
|
|
_worldPacket << uint32(MovieID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
WorldPacket const* WorldPackets::Misc::TriggerCinematic::Write()
|
|
{
|
|
_worldPacket << uint32(CinematicID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::TutorialFlags::Write()
|
|
{
|
|
_worldPacket.append(TutorialData, MAX_ACCOUNT_TUTORIAL_VALUES);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::TutorialSetFlag::Read()
|
|
{
|
|
Action = _worldPacket.ReadBits(2);
|
|
|
|
if (Action == TUTORIAL_ACTION_UPDATE)
|
|
_worldPacket >> TutorialBit;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::WorldServerInfo::Write()
|
|
{
|
|
_worldPacket << uint32(DifficultyID);
|
|
_worldPacket << uint8(IsTournamentRealm);
|
|
_worldPacket.WriteBit(XRealmPvpAlert);
|
|
_worldPacket.WriteBit(RestrictedAccountMaxLevel.is_initialized());
|
|
_worldPacket.WriteBit(RestrictedAccountMaxMoney.is_initialized());
|
|
_worldPacket.WriteBit(InstanceGroupSize.is_initialized());
|
|
|
|
if (RestrictedAccountMaxLevel)
|
|
_worldPacket << uint32(*RestrictedAccountMaxLevel);
|
|
|
|
if (RestrictedAccountMaxMoney)
|
|
_worldPacket << uint32(*RestrictedAccountMaxMoney);
|
|
|
|
if (InstanceGroupSize)
|
|
_worldPacket << uint32(*InstanceGroupSize);
|
|
|
|
_worldPacket.FlushBits();
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::AreaTrigger::Read()
|
|
{
|
|
_worldPacket >> AreaTriggerID;
|
|
Entered = _worldPacket.ReadBit();
|
|
FromClient = _worldPacket.ReadBit();
|
|
}
|
|
|
|
void WorldPackets::Misc::SetDungeonDifficulty::Read()
|
|
{
|
|
_worldPacket >> DifficultyID;
|
|
}
|
|
|
|
void WorldPackets::Misc::SetRaidDifficulty::Read()
|
|
{
|
|
_worldPacket >> DifficultyID;
|
|
_worldPacket >> Legacy;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::DungeonDifficultySet::Write()
|
|
{
|
|
_worldPacket << int32(DifficultyID);
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::RaidDifficultySet::Write()
|
|
{
|
|
_worldPacket << int32(DifficultyID);
|
|
_worldPacket << uint8(Legacy);
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::CorpseReclaimDelay::Write()
|
|
{
|
|
_worldPacket << Remaining;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::DeathReleaseLoc::Write()
|
|
{
|
|
_worldPacket << MapID;
|
|
_worldPacket << Loc;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::PreRessurect::Write()
|
|
{
|
|
_worldPacket << PlayerGUID;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::ReclaimCorpse::Read()
|
|
{
|
|
_worldPacket >> CorpseGUID;
|
|
}
|
|
|
|
void WorldPackets::Misc::RepopRequest::Read()
|
|
{
|
|
CheckInstance = _worldPacket.ReadBit();
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::RequestCemeteryListResponse::Write()
|
|
{
|
|
_worldPacket.WriteBit(IsGossipTriggered);
|
|
_worldPacket.FlushBits();
|
|
|
|
_worldPacket << uint32(CemeteryID.size());
|
|
for (uint32 cemetery : CemeteryID)
|
|
_worldPacket << cemetery;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::ResurrectResponse::Read()
|
|
{
|
|
_worldPacket >> Resurrecter;
|
|
_worldPacket >> Response;
|
|
}
|
|
|
|
WorldPackets::Misc::Weather::Weather() : ServerPacket(SMSG_WEATHER, 4 + 4 + 1) { }
|
|
|
|
WorldPackets::Misc::Weather::Weather(WeatherState weatherID, float intensity /*= 0.0f*/, bool abrupt /*= false*/)
|
|
: ServerPacket(SMSG_WEATHER, 4 + 4 + 1), Abrupt(abrupt), Intensity(intensity), WeatherID(weatherID) { }
|
|
|
|
WorldPacket const* WorldPackets::Misc::Weather::Write()
|
|
{
|
|
_worldPacket << uint32(WeatherID);
|
|
_worldPacket << float(Intensity);
|
|
_worldPacket.WriteBit(Abrupt);
|
|
|
|
_worldPacket.FlushBits();
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::StandStateChange::Read()
|
|
{
|
|
uint32 state;
|
|
_worldPacket >> state;
|
|
|
|
StandState = UnitStandStateType(state);
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::StandStateUpdate::Write()
|
|
{
|
|
_worldPacket << uint32(AnimKitID);
|
|
_worldPacket << uint8(State);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::PlayerBound::Write()
|
|
{
|
|
_worldPacket << BinderID;
|
|
_worldPacket << uint32(AreaID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::BinderConfirm::Write()
|
|
{
|
|
_worldPacket << Unit;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::StartMirrorTimer::Write()
|
|
{
|
|
_worldPacket << int32(Timer);
|
|
_worldPacket << int32(Value);
|
|
_worldPacket << int32(MaxValue);
|
|
_worldPacket << int32(Scale);
|
|
_worldPacket << int32(SpellID);
|
|
_worldPacket.WriteBit(Paused);
|
|
_worldPacket.FlushBits();
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::PauseMirrorTimer::Write()
|
|
{
|
|
_worldPacket << int32(Timer);
|
|
_worldPacket.WriteBit(Paused);
|
|
_worldPacket.FlushBits();
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::StopMirrorTimer::Write()
|
|
{
|
|
_worldPacket << int32(Timer);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::ExplorationExperience::Write()
|
|
{
|
|
_worldPacket << int32(AreaID);
|
|
_worldPacket << int32(Experience);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::LevelUpInfo::Write()
|
|
{
|
|
_worldPacket << int32(Level);
|
|
_worldPacket << int32(HealthDelta);
|
|
|
|
for (int32 power : PowerDelta)
|
|
_worldPacket << power;
|
|
|
|
for (int32 stat : StatDelta)
|
|
_worldPacket << stat;
|
|
|
|
_worldPacket << int32(Cp);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::PlayMusic::Write()
|
|
{
|
|
_worldPacket << uint32(SoundKitID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::RandomRollClient::Read()
|
|
{
|
|
_worldPacket >> Min;
|
|
_worldPacket >> Max;
|
|
_worldPacket >> PartyIndex;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::RandomRoll::Write()
|
|
{
|
|
_worldPacket << Roller;
|
|
_worldPacket << RollerWowAccount;
|
|
_worldPacket << int32(Min);
|
|
_worldPacket << int32(Max);
|
|
_worldPacket << int32(Result);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::PhaseShift::Write()
|
|
{
|
|
_worldPacket << ClientGUID; // CLientGUID
|
|
_worldPacket << uint32(PhaseShifts.size() ? 0 : 8); // PhaseShiftFlags
|
|
_worldPacket << uint32(PhaseShifts.size()); // PhaseShiftCount
|
|
_worldPacket << PersonalGUID; // PersonalGUID
|
|
for (uint32 phase : PhaseShifts)
|
|
{
|
|
_worldPacket << uint16(1); // PhaseFlags
|
|
_worldPacket << uint16(phase); // PhaseID
|
|
}
|
|
|
|
_worldPacket << uint32(VisibleMapIDs.size() * 2); // Active terrain swaps size
|
|
for (uint32 map : VisibleMapIDs)
|
|
_worldPacket << uint16(map); // Active terrain swap map id
|
|
|
|
_worldPacket << uint32(PreloadMapIDs.size() * 2); // Inactive terrain swaps size
|
|
for (uint32 map : PreloadMapIDs)
|
|
_worldPacket << uint16(map); // Inactive terrain swap map id
|
|
|
|
_worldPacket << uint32(UiWorldMapAreaIDSwaps.size() * 2); // UI map swaps size
|
|
for (uint32 map : UiWorldMapAreaIDSwaps)
|
|
_worldPacket << uint16(map); // UI map id, WorldMapArea.dbc, controls map display
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::ZoneUnderAttack::Write()
|
|
{
|
|
_worldPacket << int32(AreaID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::DurabilityDamageDeath::Write()
|
|
{
|
|
_worldPacket << int32(Percent);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::ObjectUpdateFailed::Read()
|
|
{
|
|
_worldPacket >> ObjectGUID;
|
|
}
|
|
|
|
void WorldPackets::Misc::ObjectUpdateRescued::Read()
|
|
{
|
|
_worldPacket >> ObjectGUID;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::PlaySound::Write()
|
|
{
|
|
_worldPacket << int32(SoundKitID);
|
|
_worldPacket << SourceObjectGuid;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::FarSight::Read()
|
|
{
|
|
Enable = _worldPacket.ReadBit();
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::Dismount::Write()
|
|
{
|
|
_worldPacket << Guid;
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::SaveCUFProfiles::Read()
|
|
{
|
|
uint32 count;
|
|
_worldPacket >> count;
|
|
|
|
for (uint8 i = 0; i < count && i < MAX_CUF_PROFILES; i++)
|
|
{
|
|
std::unique_ptr<CUFProfile> cufProfile = Trinity::make_unique<CUFProfile>();
|
|
|
|
uint8 strLen = _worldPacket.ReadBits(7);
|
|
|
|
// Bool Options
|
|
for (uint8 option = 0; option < CUF_BOOL_OPTIONS_COUNT; option++)
|
|
cufProfile->BoolOptions.set(option, _worldPacket.ReadBit());
|
|
|
|
// Other Options
|
|
_worldPacket >> cufProfile->FrameHeight;
|
|
_worldPacket >> cufProfile->FrameWidth;
|
|
|
|
_worldPacket >> cufProfile->SortBy;
|
|
_worldPacket >> cufProfile->HealthText;
|
|
|
|
_worldPacket >> cufProfile->TopPoint;
|
|
_worldPacket >> cufProfile->BottomPoint;
|
|
_worldPacket >> cufProfile->LeftPoint;
|
|
|
|
_worldPacket >> cufProfile->TopOffset;
|
|
_worldPacket >> cufProfile->BottomOffset;
|
|
_worldPacket >> cufProfile->LeftOffset;
|
|
|
|
cufProfile->ProfileName = _worldPacket.ReadString(strLen);
|
|
|
|
CUFProfiles.push_back(std::move(cufProfile));
|
|
}
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::LoadCUFProfiles::Write()
|
|
{
|
|
_worldPacket << uint32(CUFProfiles.size());
|
|
|
|
for (CUFProfile const* cufProfile : CUFProfiles)
|
|
{
|
|
_worldPacket.WriteBits(cufProfile->ProfileName.size(), 7);
|
|
|
|
// Bool Options
|
|
for (uint8 option = 0; option < CUF_BOOL_OPTIONS_COUNT; option++)
|
|
_worldPacket.WriteBit(cufProfile->BoolOptions[option]);
|
|
|
|
// Other Options
|
|
_worldPacket << cufProfile->FrameHeight;
|
|
_worldPacket << cufProfile->FrameWidth;
|
|
|
|
_worldPacket << cufProfile->SortBy;
|
|
_worldPacket << cufProfile->HealthText;
|
|
|
|
_worldPacket << cufProfile->TopPoint;
|
|
_worldPacket << cufProfile->BottomPoint;
|
|
_worldPacket << cufProfile->LeftPoint;
|
|
|
|
_worldPacket << cufProfile->TopOffset;
|
|
_worldPacket << cufProfile->BottomOffset;
|
|
_worldPacket << cufProfile->LeftOffset;
|
|
|
|
_worldPacket.WriteString(cufProfile->ProfileName);
|
|
}
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::PlayOneShotAnimKit::Write()
|
|
{
|
|
_worldPacket << Unit;
|
|
_worldPacket << uint16(AnimKitID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::SetAIAnimKit::Write()
|
|
{
|
|
_worldPacket << Unit;
|
|
_worldPacket << uint16(AnimKitID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::SetMovementAnimKit::Write()
|
|
{
|
|
_worldPacket << Unit;
|
|
_worldPacket << uint16(AnimKitID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::SetMeleeAnimKit::Write()
|
|
{
|
|
_worldPacket << Unit;
|
|
_worldPacket << uint16(AnimKitID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::SetPlayHoverAnim::Write()
|
|
{
|
|
_worldPacket << UnitGUID;
|
|
_worldPacket.WriteBit(PlayHoverAnim);
|
|
_worldPacket.FlushBits();
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::SetPvP::Read()
|
|
{
|
|
EnablePVP = _worldPacket.ReadBit();
|
|
}
|
|
|
|
void WorldPackets::Misc::WorldTeleport::Read()
|
|
{
|
|
_worldPacket >> MapID;
|
|
_worldPacket >> TransportGUID;
|
|
_worldPacket >> Pos;
|
|
_worldPacket >> Facing;
|
|
_worldPacket >> LfgDungeonID;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::AccountHeirloomUpdate::Write()
|
|
{
|
|
_worldPacket.WriteBit(IsFullUpdate);
|
|
_worldPacket.FlushBits();
|
|
|
|
_worldPacket << int32(Unk);
|
|
|
|
// both lists have to have the same size
|
|
_worldPacket << int32(Heirlooms->size());
|
|
_worldPacket << int32(Heirlooms->size());
|
|
|
|
for (auto const& item : *Heirlooms)
|
|
_worldPacket << uint32(item.first);
|
|
|
|
for (auto const& flags : *Heirlooms)
|
|
_worldPacket << uint32(flags.second.flags);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::SpecialMountAnim::Write()
|
|
{
|
|
_worldPacket << UnitGUID;
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::CrossedInebriationThreshold::Write()
|
|
{
|
|
_worldPacket << Guid;
|
|
_worldPacket << int32(Threshold);
|
|
_worldPacket << int32(ItemID);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::SetTaxiBenchmarkMode::Read()
|
|
{
|
|
Enable = _worldPacket.ReadBit();
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::OverrideLight::Write()
|
|
{
|
|
_worldPacket << int32(AreaLightID);
|
|
_worldPacket << int32(OverrideLightID);
|
|
_worldPacket << int32(TransitionMilliseconds);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::DisplayGameError::Write()
|
|
{
|
|
_worldPacket << uint32(Error);
|
|
_worldPacket.WriteBit(Arg.is_initialized());
|
|
_worldPacket.WriteBit(Arg2.is_initialized());
|
|
_worldPacket.FlushBits();
|
|
|
|
if (Arg)
|
|
_worldPacket << int32(*Arg);
|
|
|
|
if (Arg2)
|
|
_worldPacket << int32(*Arg2);
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
WorldPacket const* WorldPackets::Misc::AccountMountUpdate::Write()
|
|
{
|
|
_worldPacket.WriteBit(IsFullUpdate);
|
|
_worldPacket << uint32(Mounts->size());
|
|
|
|
for (auto const& spell : *Mounts)
|
|
{
|
|
_worldPacket << int32(spell.first);
|
|
_worldPacket.WriteBits(spell.second, 2);
|
|
}
|
|
|
|
_worldPacket.FlushBits();
|
|
|
|
return &_worldPacket;
|
|
}
|
|
|
|
void WorldPackets::Misc::MountSetFavorite::Read()
|
|
{
|
|
_worldPacket >> MountSpellID;
|
|
IsFavorite = _worldPacket.ReadBit();
|
|
}
|