MiscPackets.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * 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/>.
 */
 
#ifndef TRINITYCORE_MISC_PACKETS_H
#define TRINITYCORE_MISC_PACKETS_H
 
#include "Packet.h"
#include "Position.h"
#include "ObjectGuid.h"
#include "Optional.h"
#include "SharedDefines.h"
#include "Weather.h"
#include "WowTime.h"
#include <array>
 
enum UnitStandStateType : uint8;
enum WeatherState : uint32;
 
namespace WorldPackets
{
    namespace Misc
    {
        class BindPointUpdate final : public ServerPacket
        {
        public:
            explicit BindPointUpdate() : ServerPacket(SMSG_BIND_POINT_UPDATE, 20) { }
 
            WorldPacket const* Write() override;
 
            uint32 BindMapID = 0;
            TaggedPosition<Position::XYZ> BindPosition;
            uint32 BindAreaID = 0;
        };
 
        class PlayerBound final : public ServerPacket
        {
        public:
            explicit PlayerBound() : ServerPacket(SMSG_PLAYER_BOUND, 8 + 4) { }
            explicit PlayerBound(ObjectGuid binderId, uint32 areaId) : ServerPacket(SMSG_PLAYER_BOUND, 8 + 4), BinderID(binderId), AreaID(areaId) { }
 
            WorldPacket const* Write() override;
 
            ObjectGuid BinderID;
            uint32 AreaID = 0;
        };
 
        class BinderConfirm final : public ServerPacket
        {
        public:
            explicit BinderConfirm() : ServerPacket(SMSG_BINDER_CONFIRM, 8) { }
            explicit BinderConfirm(ObjectGuid unit) : ServerPacket(SMSG_BINDER_CONFIRM, 8), Unit(unit) { }
 
            WorldPacket const* Write() override;
 
            ObjectGuid Unit;
        };
 
        class InvalidatePlayer final : public ServerPacket
        {
        public:
            explicit InvalidatePlayer() : ServerPacket(SMSG_INVALIDATE_PLAYER, 8) { }
 
            WorldPacket const* Write() override;
 
            ObjectGuid Guid;
        };
 
        class LoginSetTimeSpeed final : public ServerPacket
        {
        public:
            explicit LoginSetTimeSpeed() : ServerPacket(SMSG_LOGIN_SET_TIME_SPEED, 12) { }
 
            WorldPacket const* Write() override;
 
            float NewSpeed = 0.0f;
            WowTime GameTime;
            int32 GameTimeHolidayOffset = 0;
        };
 
        class SetSelection final : public ClientPacket
        {
        public:
            explicit SetSelection(WorldPacket&& packet) : ClientPacket(CMSG_SET_SELECTION, std::move(packet)) { }
 
            void Read() override;
 
            ObjectGuid Selection; 
        };
 
        class TimeSyncRequest final : public ServerPacket
        {
        public:
            explicit TimeSyncRequest() : ServerPacket(SMSG_TIME_SYNC_REQ, 4) { }
 
            WorldPacket const* Write() override;
 
            uint32 SequenceIndex = 0;
        };
 
        class TimeSyncResponse final : public ClientPacket
        {
        public:
            explicit TimeSyncResponse(WorldPacket&& packet) : ClientPacket(CMSG_TIME_SYNC_RESP, std::move(packet)) { }
 
            void Read() override;
 
            TimePoint GetReceivedTime() const { return _worldPacket.GetReceivedTime(); }
 
            uint32 ClientTime = 0; // Client ticks in ms
            uint32 SequenceIndex = 0; // Same index as in request
        };
 
        class TriggerCinematic final : public ServerPacket
        {
        public:
            explicit TriggerCinematic() : ServerPacket(SMSG_TRIGGER_CINEMATIC, 4) { }
 
            WorldPacket const* Write() override;
 
            uint32 CinematicID = 0;
        };
 
        class TriggerMovie final : public ServerPacket
        {
        public:
            explicit TriggerMovie() : ServerPacket(SMSG_TRIGGER_MOVIE, 4) { }
 
            WorldPacket const* Write() override;
 
            uint32 MovieID = 0;
        };
 
        class UITimeRequest final : public ClientPacket
        {
        public:
            explicit UITimeRequest(WorldPacket&& packet) : ClientPacket(CMSG_WORLD_STATE_UI_TIMER_UPDATE, std::move(packet)) { }
 
            void Read() override { }
        };
 
        class UITime final : public ServerPacket
        {
        public:
            explicit UITime() : ServerPacket(SMSG_WORLD_STATE_UI_TIMER_UPDATE, 4) { }
 
            WorldPacket const* Write() override;
 
            uint32 Time = 0;
        };
 
        class TutorialFlags final : public ServerPacket
        {
        public:
            explicit TutorialFlags() : ServerPacket(SMSG_TUTORIAL_FLAGS, 32) { }
 
            WorldPacket const* Write() override;
 
            std::array<uint32, MAX_ACCOUNT_TUTORIAL_VALUES> TutorialData = { };
        };
 
        class TutorialSetFlag final : public ClientPacket
        {
        public:
            explicit TutorialSetFlag(WorldPacket&& packet) : ClientPacket(CMSG_TUTORIAL_FLAG, std::move(packet)) { }
 
            void Read() override;
 
            uint32 TutorialBit = 0;
        };
 
        class TutorialClear final : public ClientPacket
        {
        public:
            explicit TutorialClear(WorldPacket&& packet) : ClientPacket(CMSG_TUTORIAL_CLEAR, std::move(packet)) { }
 
            void Read() override { }
        };
 
        class TutorialReset final : public ClientPacket
        {
        public:
            explicit TutorialReset(WorldPacket&& packet) : ClientPacket(CMSG_TUTORIAL_RESET, std::move(packet)) { }
 
            void Read() override { }
        };
 
        class SetDungeonDifficulty final : public ClientPacket
        {
        public:
            explicit SetDungeonDifficulty(WorldPacket&& packet) : ClientPacket(MSG_SET_DUNGEON_DIFFICULTY, std::move(packet)) { }
 
            void Read() override;
 
            int32 DifficultyID = 0;
        };
 
        class SetRaidDifficulty final : public ClientPacket
        {
        public:
            explicit SetRaidDifficulty(WorldPacket&& packet) : ClientPacket(MSG_SET_RAID_DIFFICULTY, std::move(packet)) { }
 
            void Read() override;
 
            int32 DifficultyID = 0;
        };
 
        class DungeonDifficultySet final : public ServerPacket
        {
        public:
            explicit DungeonDifficultySet() : ServerPacket(MSG_SET_DUNGEON_DIFFICULTY, 4 + 4 + 4) { }
 
            WorldPacket const* Write() override;
 
            int32 DifficultyID = 0;
            int32 ChangeCurrentDifficulyID = 0;
            int32 ChangeGroupDifficulyID = 0;
        };
 
        class RaidDifficultySet final : public ServerPacket
        {
        public:
            explicit RaidDifficultySet() : ServerPacket(MSG_SET_RAID_DIFFICULTY, 4 + 4 + 4) { }
 
            WorldPacket const* Write() override;
 
            int32 DifficultyID = 0;
            int32 ChangeCurrentDifficulyID = 0;
            int32 ChangeGroupDifficulyID = 0;
        };
 
        class CorpseReclaimDelay final : public ServerPacket
        {
        public:
            explicit CorpseReclaimDelay() : ServerPacket(SMSG_CORPSE_RECLAIM_DELAY, 4) { }
 
            WorldPacket const* Write() override;
 
            uint32 Remaining = 0;
        };
 
        class DeathReleaseLoc final : public ServerPacket
        {
        public:
            explicit DeathReleaseLoc() : ServerPacket(SMSG_DEATH_RELEASE_LOC, 4 + (3 * 4)) { }
 
            WorldPacket const* Write() override;
 
            int32 MapID = 0;
            TaggedPosition<Position::XYZ> Loc;
        };
 
        class PreRessurect final : public ServerPacket
        {
        public:
            explicit PreRessurect() : ServerPacket(SMSG_PRE_RESURRECT, 8) { }
 
            WorldPacket const* Write() override;
 
            ObjectGuid PlayerGUID;
        };
 
        class ReclaimCorpse final : public ClientPacket
        {
        public:
            explicit ReclaimCorpse(WorldPacket&& packet) : ClientPacket(CMSG_RECLAIM_CORPSE, std::move(packet)) { }
 
            void Read() override;
 
            ObjectGuid CorpseGUID;
        };
 
        class RepopRequest final : public ClientPacket
        {
        public:
            explicit RepopRequest(WorldPacket&& packet) : ClientPacket(CMSG_REPOP_REQUEST, std::move(packet)) { }
 
            void Read() override;
 
            bool CheckInstance = false;
        };
 
        class ResurrectResponse final : public ClientPacket
        {
        public:
            explicit ResurrectResponse(WorldPacket&& packet) : ClientPacket(CMSG_RESURRECT_RESPONSE, std::move(packet)) { }
 
            void Read() override;
 
            ObjectGuid Resurrecter;
            uint8 Response = 0;
        };
 
        class TC_GAME_API Weather final : public ServerPacket
        {
        public:
            explicit Weather();
            explicit Weather(WeatherState weatherID, float intensity = 0.0f, bool abrupt = false);
 
            WorldPacket const* Write() override;
 
            bool Abrupt = false;
            float Intensity = 0.0f;
            WeatherState WeatherID = WeatherState(0);
        };
 
        class StandStateChange final : public ClientPacket
        {
        public:
            explicit StandStateChange(WorldPacket&& packet) : ClientPacket(CMSG_STANDSTATECHANGE, std::move(packet)) { }
 
            void Read() override;
 
            UnitStandStateType StandState = UnitStandStateType(0);
        };
 
        class StandStateUpdate final : public ServerPacket
        {
        public:
            explicit StandStateUpdate() : ServerPacket(SMSG_STANDSTATE_UPDATE, 1) { }
            explicit StandStateUpdate(UnitStandStateType state) : ServerPacket(SMSG_STANDSTATE_UPDATE, 1), State(state) { }
 
            WorldPacket const* Write() override;
 
            UnitStandStateType State = UnitStandStateType(0);
        };
 
        class StartMirrorTimer final : public ServerPacket
        {
        public:
            explicit StartMirrorTimer() : ServerPacket(SMSG_START_MIRROR_TIMER, 21) { }
            explicit StartMirrorTimer(uint32 timer, uint32 value, uint32 maxValue, int32 scale, bool paused, uint32 spellID) :
                ServerPacket(SMSG_START_MIRROR_TIMER, 21), Timer(timer), Value(value), MaxValue(maxValue), Scale(scale), Paused(paused), SpellID(spellID) { }
 
            WorldPacket const* Write() override;
 
            uint32 Timer = 0;
            uint32 Value = 0;
            uint32 MaxValue = 0;
            int32 Scale = 0;
            bool Paused = false;
            uint32 SpellID = 0;
        };
 
        class PauseMirrorTimer final : public ServerPacket
        {
        public:
            explicit PauseMirrorTimer() : ServerPacket(SMSG_PAUSE_MIRROR_TIMER, 5) { }
            explicit PauseMirrorTimer(uint32 timer, bool paused) : ServerPacket(SMSG_PAUSE_MIRROR_TIMER, 5), Timer(timer), Paused(paused) { }
 
            WorldPacket const* Write() override;
 
            uint32 Timer = 0;
            bool Paused = true;
        };
 
        class StopMirrorTimer final : public ServerPacket
        {
        public:
            explicit StopMirrorTimer() : ServerPacket(SMSG_STOP_MIRROR_TIMER, 4) { }
            explicit StopMirrorTimer(uint32 timer) : ServerPacket(SMSG_STOP_MIRROR_TIMER, 4), Timer(timer) { }
 
            WorldPacket const* Write() override;
 
            uint32 Timer = 0;
        };
 
        class LevelUpInfo final : public ServerPacket
        {
        public:
            explicit LevelUpInfo() : ServerPacket(SMSG_LEVELUP_INFO, 56) { }
 
            WorldPacket const* Write() override;
 
            uint32 Level = 0;
            uint32 HealthDelta = 0;
            std::array<uint32, MAX_POWERS> PowerDelta = { };
            std::array<uint32, MAX_STATS> StatDelta = { };
        };
 
        class TC_GAME_API PlayMusic final : public ServerPacket
        {
        public:
            explicit PlayMusic() : ServerPacket(SMSG_PLAY_MUSIC, 4) { }
            explicit PlayMusic(uint32 soundKitID) : ServerPacket(SMSG_PLAY_MUSIC, 4), SoundKitID(soundKitID) { }
 
            WorldPacket const* Write() override;
 
            uint32 SoundKitID = 0;
        };
 
        class RandomRollClient final : public ClientPacket
        {
        public:
            explicit RandomRollClient(WorldPacket&& packet) : ClientPacket(MSG_RANDOM_ROLL, std::move(packet)) { }
 
            void Read() override;
 
            uint32 Min = 0;
            uint32 Max = 0;
        };
 
        class RandomRoll final : public ServerPacket
        {
        public:
            explicit RandomRoll() : ServerPacket(MSG_RANDOM_ROLL, 4 + 4 + 4 + 8) { }
 
            WorldPacket const* Write() override;
 
            uint32 Min = 0;
            uint32 Max = 0;
            uint32 Result = 0;
            ObjectGuid Roller;
        };
 
        class DurabilityDamageDeath final : public ServerPacket
        {
        public:
            explicit DurabilityDamageDeath() : ServerPacket(SMSG_DURABILITY_DAMAGE_DEATH, 0) { }
 
            WorldPacket const* Write() override { return &_worldPacket; }
        };
 
        class TC_GAME_API PlayObjectSound final : public ServerPacket
        {
        public:
            explicit PlayObjectSound() : ServerPacket(SMSG_PLAY_OBJECT_SOUND, 4 + 8) { }
            explicit PlayObjectSound(ObjectGuid const& sourceObjectGUID, uint32 soundKitID)
                : ServerPacket(SMSG_PLAY_OBJECT_SOUND, 4 + 8), SourceObjectGUID(sourceObjectGUID), SoundKitID(soundKitID) { }
 
            WorldPacket const* Write() override;
 
            ObjectGuid SourceObjectGUID;
            uint32 SoundKitID = 0;
 
        };
 
        class TC_GAME_API PlaySound final : public ServerPacket
        {
        public:
            explicit PlaySound() : ServerPacket(SMSG_PLAY_SOUND, 4) { }
            explicit PlaySound(uint32 soundKitID) : ServerPacket(SMSG_PLAY_SOUND, 4), SoundKitID(soundKitID) { }
 
            WorldPacket const* Write() override;
 
            uint32 SoundKitID = 0;
        };
 
        class CompleteCinematic final : public ClientPacket
        {
        public:
            explicit CompleteCinematic(WorldPacket&& packet) : ClientPacket(CMSG_COMPLETE_CINEMATIC, std::move(packet)) { }
 
            void Read() override { }
        };
 
        class NextCinematicCamera final : public ClientPacket
        {
        public:
            explicit NextCinematicCamera(WorldPacket&& packet) : ClientPacket(CMSG_NEXT_CINEMATIC_CAMERA, std::move(packet)) { }
 
            void Read() override { }
        };
 
        class CompleteMovie final : public ClientPacket
        {
        public:
            explicit CompleteMovie(WorldPacket&& packet) : ClientPacket(CMSG_COMPLETE_MOVIE, std::move(packet)) { }
 
            void Read() override { }
        };
 
        class OpeningCinematic final : public ClientPacket
        {
        public:
            explicit OpeningCinematic(WorldPacket&& packet) : ClientPacket(CMSG_OPENING_CINEMATIC, std::move(packet)) { }
 
            void Read() override { }
        };
 
        class TogglePvP final : public ClientPacket
        {
        public:
            explicit TogglePvP(WorldPacket&& packet) : ClientPacket(CMSG_TOGGLE_PVP, std::move(packet)) { }
 
            void Read() override;
 
            bool HasPvPStatus() const { return GetSize() == 1; }
 
            Optional<bool> Enable;
        };
 
        class CrossedInebriationThreshold final : public ServerPacket
        {
        public:
            explicit CrossedInebriationThreshold() : ServerPacket(SMSG_CROSSED_INEBRIATION_THRESHOLD, 8 + 4 + 4) { }
 
            WorldPacket const* Write() override;
 
            ObjectGuid Guid;
            uint32 Threshold = 0;
            uint32 ItemID = 0;
        };
 
        class OverrideLight final : public ServerPacket
        {
        public:
            explicit OverrideLight() : ServerPacket(SMSG_OVERRIDE_LIGHT, 4 + 4 + 4) { }
 
            WorldPacket const* Write() override;
 
            int32 AreaLightID = 0;
            int32 TransitionMilliseconds = 0;
            int32 OverrideLightID = 0;
        };
 
        class WorldTeleport final : public ClientPacket
        {
        public:
            explicit WorldTeleport(WorldPacket&& packet) : ClientPacket(CMSG_WORLD_TELEPORT, std::move(packet)) { }
 
            void Read() override;
 
            uint32 Time = 0;
            uint32 MapID = 0;
            TaggedPosition<Position::XYZ> Pos;
            float Facing = 0.0f;
        };
    }
}
 
#endif // TRINITYCORE_MISC_PACKETS_H