diff options
Diffstat (limited to 'src/server/game/Server')
| -rw-r--r-- | src/server/game/Server/Packets/CalendarPackets.cpp | 461 | ||||
| -rw-r--r-- | src/server/game/Server/Packets/CalendarPackets.h | 562 | ||||
| -rw-r--r-- | src/server/game/Server/Protocol/Opcodes.cpp | 65 | ||||
| -rw-r--r-- | src/server/game/Server/WorldSession.h | 49 |
4 files changed, 1090 insertions, 47 deletions
diff --git a/src/server/game/Server/Packets/CalendarPackets.cpp b/src/server/game/Server/Packets/CalendarPackets.cpp new file mode 100644 index 00000000000..655d33da73d --- /dev/null +++ b/src/server/game/Server/Packets/CalendarPackets.cpp @@ -0,0 +1,461 @@ +/* + * Copyright (C) 2008-2015 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 "CalendarPackets.h" +#include "CalendarMgr.h" + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarEventInfo const& eventInfo) +{ + data << uint64(eventInfo.EventID); + data << uint8(eventInfo.EventType); + data.AppendPackedTime(eventInfo.Date); + data << uint32(eventInfo.Flags); + data << int32(eventInfo.TextureID); + data << eventInfo.EventGuildID; + data << eventInfo.OwnerGuid; + + data.WriteBits(eventInfo.EventName.size(), 8); + data.FlushBits(); + data.WriteString(eventInfo.EventName); + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarRaidResetInfo const& resetInfo) +{ + data << int32(resetInfo.MapID); + data << uint32(resetInfo.Duration); + data << int32(resetInfo.Offset); + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarRaidLockoutInfo const& lockoutInfo) +{ + data << uint64(lockoutInfo.InstanceID); + data << int32(lockoutInfo.MapID); + data << uint32(lockoutInfo.DifficultyID); + data << uint32(lockoutInfo.ExpireTime); + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarSendCalendarInviteInfo const& inviteInfo) +{ + data << uint64(inviteInfo.EventID); + data << uint64(inviteInfo.InviteID); + data << uint8(inviteInfo.Status); + data << uint8(inviteInfo.Moderator); + data << uint8(inviteInfo.InviteType); + data << inviteInfo.InviterGuid; + + return data; +} + +ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::Calendar::CalendarEventInviteInfo const& inviteInfo) +{ + data << inviteInfo.Guid; + data << uint64(inviteInfo.InviteID); + + data << uint8(inviteInfo.Level); + data << uint8(inviteInfo.Status); + data << uint8(inviteInfo.Moderator); + data << uint8(inviteInfo.InviteType); + + data.AppendPackedTime(inviteInfo.ResponseTime); + + data.WriteBits(inviteInfo.Notes.size(), 8); + data.FlushBits(); + data.WriteString(inviteInfo.Notes); + + return data; +} + +void WorldPackets::Calendar::CalendarGetEvent::Read() +{ + _worldPacket >> EventID; +} + +void WorldPackets::Calendar::CalendarGuildFilter::Read() +{ + _worldPacket >> MinLevel; + _worldPacket >> MaxLevel; + _worldPacket >> MaxRankOrder; +} + +void WorldPackets::Calendar::CalendarAddEvent::Read() +{ + uint8 titleLength = _worldPacket.ReadBits(8); + uint16 descriptionLength = _worldPacket.ReadBits(11); + + _worldPacket >> EventInfo.EventType; + _worldPacket >> EventInfo.TextureID; + EventInfo.Time = _worldPacket.ReadPackedTime(); + _worldPacket >> EventInfo.Flags; + uint32 count = _worldPacket.read<uint32>(); + + EventInfo.Title = _worldPacket.ReadString(titleLength); + EventInfo.Description = _worldPacket.ReadString(descriptionLength); + + for (uint32 i = 0; i < count && i < CALENDAR_MAX_INVITES; i++) + { + WorldPackets::Calendar::CalendarAddEventInviteInfo invite; + _worldPacket >> invite.Guid; + _worldPacket >> invite.Status; + _worldPacket >> invite.Moderator; + + EventInfo.Invites.push_back(invite); + } + + _worldPacket >> MaxSize; +} + +void WorldPackets::Calendar::CalendarUpdateEvent::Read() +{ + _worldPacket >> EventInfo.EventID; + _worldPacket >> EventInfo.ModeratorID; + _worldPacket >> EventInfo.EventType; + _worldPacket >> EventInfo.TextureID; + EventInfo.Time = _worldPacket.ReadPackedTime(); + _worldPacket >> EventInfo.Flags; + + uint8 titleLen = _worldPacket.ReadBits(8); + uint16 descLen = _worldPacket.ReadBits(11); + + EventInfo.Title = _worldPacket.ReadString(titleLen); + EventInfo.Description = _worldPacket.ReadString(descLen); + _worldPacket >> MaxSize; +} + +void WorldPackets::Calendar::CalendarRemoveEvent::Read() +{ + _worldPacket >> EventID; + _worldPacket >> ModeratorID; + _worldPacket >> Flags; +} + +void WorldPackets::Calendar::CalendarCopyEvent::Read() +{ + _worldPacket >> EventID; + _worldPacket >> ModeratorID; + Date = _worldPacket.ReadPackedTime(); +} + +void WorldPackets::Calendar::CalendarEventRSVP::Read() +{ + _worldPacket >> EventID; + _worldPacket >> InviteID; + _worldPacket >> Status; +} + +void WorldPackets::Calendar::CalendarEventInvite::Read() +{ + _worldPacket >> EventID; + _worldPacket >> ModeratorID; + + uint16 nameLen = _worldPacket.ReadBits(9); + Creating = _worldPacket.ReadBit(); + IsSignUp = _worldPacket.ReadBit(); + + Name = _worldPacket.ReadString(nameLen); +} + +void WorldPackets::Calendar::CalendarEventSignUp::Read() +{ + _worldPacket >> EventID; + Tentative = _worldPacket.ReadBit(); +} + +void WorldPackets::Calendar::CalendarRemoveInvite::Read() +{ + _worldPacket >> Guid; + _worldPacket >> InviteID; + _worldPacket >> ModeratorID; + _worldPacket >> EventID; +} + +void WorldPackets::Calendar::CalendarEventStatus::Read() +{ + _worldPacket >> Guid; + _worldPacket >> EventID; + _worldPacket >> InviteID; + _worldPacket >> ModeratorID; + _worldPacket >> Status; +} + +void WorldPackets::Calendar::SetSavedInstanceExtend::Read() +{ + _worldPacket >> MapID; + _worldPacket >> DifficultyID; + Extend = _worldPacket.ReadBit(); +} + +void WorldPackets::Calendar::CalendarEventModeratorStatus::Read() +{ + _worldPacket >> Guid; + _worldPacket >> EventID; + _worldPacket >> InviteID; + _worldPacket >> ModeratorID; + _worldPacket >> Status; +} + +WorldPacket const* WorldPackets::Calendar::SCalendarEventInvite::Write() +{ + _worldPacket << InviteGuid; + _worldPacket << uint64(EventID); + _worldPacket << uint64(InviteID); + _worldPacket << uint8(Level); + _worldPacket << uint8(Status); + _worldPacket << uint8(Type); + _worldPacket.AppendPackedTime(ResponseTime); + + _worldPacket.WriteBit(ClearPending); + _worldPacket.FlushBits(); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarSendCalendar::Write() +{ + _worldPacket << uint32(ServerNow); + _worldPacket.AppendPackedTime(ServerTime); + _worldPacket << uint32(RaidOrigin); + _worldPacket << uint32(Invites.size()); + _worldPacket << uint32(Events.size()); + _worldPacket << uint32(RaidLockouts.size()); + _worldPacket << uint32(RaidResets.size()); + + for (auto const& invite : Invites) + _worldPacket << invite; + + for (auto const& event : Events) + _worldPacket << event; + + for (auto const& lockout : RaidLockouts) + _worldPacket << lockout; + + for (auto const& reset : RaidResets) + _worldPacket << reset; + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarSendEvent::Write() +{ + _worldPacket << uint8(EventType); + _worldPacket << OwnerGuid; + _worldPacket << uint64(EventID); + _worldPacket << uint8(GetEventType); + _worldPacket << int32(TextureID); + _worldPacket << uint32(Flags); + _worldPacket.AppendPackedTime(Date); + _worldPacket << uint32(LockDate); + _worldPacket << EventGuildID; + + _worldPacket << uint32(Invites.size()); + for (auto const& invite : Invites) + _worldPacket << invite; + + _worldPacket.WriteBits(EventName.size(), 8); + _worldPacket.WriteBits(Description.size(), 11); + _worldPacket.FlushBits(); + + _worldPacket.WriteString(EventName); + _worldPacket.WriteString(Description); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteAlert::Write() +{ + _worldPacket << uint64(EventID); + _worldPacket.AppendPackedTime(Date); + _worldPacket << uint32(Flags); + _worldPacket << uint8(EventType); + _worldPacket << int32(TextureID); + _worldPacket << EventGuildID; + _worldPacket << uint64(InviteID); + _worldPacket << uint8(Status); + _worldPacket << uint8(ModeratorStatus); + + // Todo: check order + _worldPacket << InvitedByGuid; + _worldPacket << OwnerGuid; + + _worldPacket.WriteBits(EventName.size(), 8); + _worldPacket.FlushBits(); + _worldPacket.WriteString(EventName); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteStatus::Write() +{ + _worldPacket << InviteGuid; + _worldPacket << uint64(EventID); + _worldPacket.AppendPackedTime(Date); + _worldPacket << uint32(Flags); + _worldPacket << uint8(Status); + _worldPacket.AppendPackedTime(ResponseTime); + + _worldPacket.WriteBit(ClearPending); + _worldPacket.FlushBits(); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteRemoved::Write() +{ + _worldPacket << InviteGuid; + _worldPacket << uint64(EventID); + _worldPacket << uint32(Flags); + + _worldPacket.WriteBit(ClearPending); + _worldPacket.FlushBits(); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteModeratorStatus::Write() +{ + _worldPacket << InviteGuid; + _worldPacket << uint64(EventID); + _worldPacket << uint8(Status); + + _worldPacket.WriteBit(ClearPending); + _worldPacket.FlushBits(); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteRemovedAlert::Write() +{ + _worldPacket << uint64(EventID); + _worldPacket.AppendPackedTime(Date); + _worldPacket << uint32(Flags); + _worldPacket << uint8(Status); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventUpdatedAlert::Write() +{ + _worldPacket << uint64(EventID); + + _worldPacket.AppendPackedTime(OriginalDate); + _worldPacket.AppendPackedTime(Date); + _worldPacket << uint32(LockDate); + _worldPacket << uint32(Flags); + _worldPacket << uint32(TextureID); + _worldPacket << uint8(EventType); + + _worldPacket.WriteBits(EventName.size(), 8); + _worldPacket.WriteBits(Description.size(), 11); + _worldPacket.WriteBit(ClearPending); + _worldPacket.FlushBits(); + + _worldPacket.WriteString(EventName); + _worldPacket.WriteString(Description); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventRemovedAlert::Write() +{ + _worldPacket << uint64(EventID); + _worldPacket.AppendPackedTime(Date); + + _worldPacket.WriteBit(ClearPending); + _worldPacket.FlushBits(); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarSendNumPending::Write() +{ + _worldPacket << uint32(NumPending); + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarCommandResult::Write() +{ + _worldPacket << uint8(Command); + _worldPacket << uint8(Result); + + _worldPacket.WriteBits(Name.size(), 9); + _worldPacket.FlushBits(); + _worldPacket.WriteString(Name); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarRaidLockoutUpdated::Write() +{ + _worldPacket << uint32(ServerTime); + _worldPacket << int32(MapID); + _worldPacket << uint32(DifficultyID); + _worldPacket << int32(NewTimeRemaining); + _worldPacket << int32(OldTimeRemaining); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInitialInvites::Write() +{ + _worldPacket << uint32(Invites.size()); + for (auto const& invite : Invites) + { + _worldPacket << invite.InviteGuid; + _worldPacket << uint8(invite.Level); + } + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteStatusAlert::Write() +{ + _worldPacket << uint64(EventID); + _worldPacket.AppendPackedTime(Date); + _worldPacket << uint32(Flags); + _worldPacket << uint8(Status); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteNotesAlert::Write() +{ + _worldPacket << uint64(EventID); + + _worldPacket.WriteBits(Notes.size(), 8); + _worldPacket.FlushBits(); + _worldPacket.WriteString(Notes); + + return &_worldPacket; +} + +WorldPacket const* WorldPackets::Calendar::CalendarEventInviteNotes::Write() +{ + _worldPacket << InviteGuid; + _worldPacket << uint64(EventID); + + _worldPacket.WriteBits(Notes.size(), 8); + _worldPacket.WriteBit(ClearPending); + _worldPacket.FlushBits(); + _worldPacket.WriteString(Notes); + + return &_worldPacket; +} diff --git a/src/server/game/Server/Packets/CalendarPackets.h b/src/server/game/Server/Packets/CalendarPackets.h new file mode 100644 index 00000000000..023041d427f --- /dev/null +++ b/src/server/game/Server/Packets/CalendarPackets.h @@ -0,0 +1,562 @@ +/* + * Copyright (C) 2008-2015 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/>. + */ +/* + * Copyright (C) 2008-2015 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/>. + */ + +#ifndef CalendarPackets_h__ +#define CalendarPackets_h__ + +#include "ObjectGuid.h" +#include "Packet.h" + +namespace WorldPackets +{ + namespace Calendar + { + class CalendarGetCalendar final : public ClientPacket + { + public: + CalendarGetCalendar(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GET, std::move(packet)) { } + + void Read() override { } + }; + + class CalendarGetEvent final : public ClientPacket + { + public: + CalendarGetEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GET_EVENT, std::move(packet)) { } + + void Read() override; + + uint64 EventID = 0; + }; + + class CalendarGuildFilter final : public ClientPacket + { + public: + CalendarGuildFilter(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GUILD_FILTER, std::move(packet)) { } + + void Read() override; + + uint8 MinLevel = 1; + uint8 MaxLevel = 100; + uint8 MaxRankOrder = 0; + }; + + struct CalendarAddEventInviteInfo + { + ObjectGuid Guid; + uint8 Status = 0; + uint8 Moderator = 0; + }; + + struct CalendarAddEventInfo + { + std::string Title; + std::string Description; + uint8 EventType = 0; + int32 TextureID = 0; + time_t Time = time_t(0); + uint32 Flags = 0; + std::vector<CalendarAddEventInviteInfo> Invites; + }; + + class CalendarAddEvent final : public ClientPacket + { + public: + CalendarAddEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_ADD_EVENT, std::move(packet)) { } + + void Read() override; + + uint32 MaxSize = 100; + CalendarAddEventInfo EventInfo; + }; + + struct CalendarUpdateEventInfo + { + uint64 EventID = 0; + uint64 ModeratorID = 0; + std::string Title; + std::string Description; + uint8 EventType = 0; + uint32 TextureID = 0; + time_t Time = time_t(0); + uint32 Flags = 0; + }; + + class CalendarUpdateEvent final : public ClientPacket + { + public: + CalendarUpdateEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_UPDATE_EVENT, std::move(packet)) { } + + void Read() override; + + uint32 MaxSize = 0; + CalendarUpdateEventInfo EventInfo; + }; + + class CalendarRemoveEvent final : public ClientPacket + { + public: + CalendarRemoveEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_REMOVE_EVENT, std::move(packet)) { } + + void Read() override; + + uint64 ModeratorID = 0; + uint64 EventID = 0; + uint32 Flags = 0; + }; + + class CalendarCopyEvent final : public ClientPacket + { + public: + CalendarCopyEvent(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_COPY_EVENT, std::move(packet)) { } + + void Read() override; + + uint64 ModeratorID = 0; + uint64 EventID = 0; + time_t Date = time_t(0); + }; + + class SCalendarEventInvite final : public ServerPacket + { + public: + SCalendarEventInvite() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE, 43) { } + + WorldPacket const* Write() override; + + uint64 InviteID = 0; + time_t ResponseTime = time_t(0); + uint8 Level = 100; + ObjectGuid InviteGuid; + uint64 EventID = 0; + uint8 Type = 0; + bool ClearPending = false; + uint8 Status = 0; + }; + + struct CalendarSendCalendarInviteInfo + { + uint64 EventID = 0; + uint64 InviteID = 0; + ObjectGuid InviterGuid; + uint8 Status = 0; + uint8 Moderator = 0; + uint8 InviteType = 0; + }; + + struct CalendarSendCalendarRaidLockoutInfo + { + uint64 InstanceID = 0; + int32 MapID = 0; + uint32 DifficultyID = 0; + time_t ExpireTime = time_t(0); + }; + + struct CalendarSendCalendarRaidResetInfo + { + int32 MapID = 0; + uint32 Duration = 0; + int32 Offset = 0; + }; + + struct CalendarSendCalendarEventInfo + { + uint64 EventID = 0; + std::string EventName; + uint8 EventType = 0; + time_t Date = time_t(0); + uint32 Flags = 0; + int32 TextureID = 0; + ObjectGuid EventGuildID; + ObjectGuid OwnerGuid; + }; + + class CalendarSendCalendar final : public ServerPacket + { + public: + CalendarSendCalendar() : ServerPacket(SMSG_CALENDAR_SEND_CALENDAR, 338) { } + + WorldPacket const* Write() override; + + time_t RaidOrigin = time_t(0); + time_t ServerTime = time_t(0); + time_t ServerNow = time_t(0); + std::vector<CalendarSendCalendarInviteInfo> Invites; + std::vector<CalendarSendCalendarRaidLockoutInfo> RaidLockouts; + std::vector<CalendarSendCalendarRaidResetInfo> RaidResets; + std::vector<CalendarSendCalendarEventInfo> Events; + }; + + struct CalendarEventInviteInfo + { + ObjectGuid Guid; + uint64 InviteID = 0; + time_t ResponseTime = time_t(0); + uint8 Level = 1; + uint8 Status = 0; + uint8 Moderator = 0; + uint8 InviteType = 0; + std::string Notes; + }; + + class CalendarSendEvent final : public ServerPacket + { + public: + CalendarSendEvent() : ServerPacket(SMSG_CALENDAR_SEND_EVENT, 93) { } + + WorldPacket const* Write() override; + + ObjectGuid OwnerGuid; + ObjectGuid EventGuildID; + uint64 EventID = 0; + time_t Date = time_t(0); + time_t LockDate = time_t(0); + uint32 Flags = 0; + int32 TextureID = 0; + uint8 GetEventType = 0; + uint8 EventType = 0; + std::string Description; + std::string EventName; + std::vector<CalendarEventInviteInfo> Invites; + }; + + class CalendarEventInviteAlert final : public ServerPacket + { + public: + CalendarEventInviteAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_ALERT, 80) { } + + WorldPacket const* Write() override; + + ObjectGuid OwnerGuid; + ObjectGuid EventGuildID; + ObjectGuid InvitedByGuid; + uint64 InviteID = 0; + uint64 EventID = 0; + uint32 Flags = 0; + time_t Date = time_t(0); + int32 TextureID = 0; + uint8 Status = 0; + uint8 EventType = 0; + uint8 ModeratorStatus = 0; + std::string EventName; + }; + + class CalendarEventInvite final : public ClientPacket + { + public: + CalendarEventInvite(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_INVITE, std::move(packet)) { } + + void Read() override; + + uint64 ModeratorID = 0; + bool IsSignUp = false; + bool Creating = true; + uint64 EventID = 0; + std::string Name; + }; + + class CalendarEventRSVP final : public ClientPacket + { + public: + CalendarEventRSVP(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_RSVP, std::move(packet)) { } + + void Read() override; + + uint64 InviteID = 0; + uint64 EventID = 0; + uint8 Status = 0; + }; + + class CalendarEventInviteStatus final : public ServerPacket + { + public: + CalendarEventInviteStatus() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_STATUS, 41) { } + + WorldPacket const* Write() override; + + uint32 Flags = 0; + uint64 EventID = 0; + uint8 Status = 0; + bool ClearPending = false; + time_t ResponseTime = time_t(0); + time_t Date = time_t(0); + ObjectGuid InviteGuid; + }; + + class CalendarEventInviteRemoved final : public ServerPacket + { + public: + CalendarEventInviteRemoved() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_REMOVED, 29) { } + + WorldPacket const* Write() override; + + ObjectGuid InviteGuid; + uint64 EventID = 0; + uint32 Flags = 0; + bool ClearPending = false; + }; + + class CalendarEventInviteModeratorStatus final : public ServerPacket + { + public: + CalendarEventInviteModeratorStatus() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS, 26) { } + + WorldPacket const* Write() override; + + ObjectGuid InviteGuid; + uint64 EventID = 0; + uint8 Status = 0; + bool ClearPending = false; + }; + + class CalendarEventInviteRemovedAlert final : public ServerPacket + { + public: + CalendarEventInviteRemovedAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, 17) { } + + WorldPacket const* Write() override; + + uint64 EventID = 0; + time_t Date = time_t(0); + uint32 Flags = 0; + uint8 Status = 0; + }; + + class CalendarClearPendingAction final : public ServerPacket + { + public: + CalendarClearPendingAction() : ServerPacket(SMSG_CALENDAR_CLEAR_PENDING_ACTION, 0) { } + + WorldPacket const* Write() override { return &_worldPacket; } + }; + + class CalendarEventUpdatedAlert final : public ServerPacket + { + public: + CalendarEventUpdatedAlert() : ServerPacket(SMSG_CALENDAR_EVENT_UPDATED_ALERT, 32) { } + + WorldPacket const* Write() override; + + uint64 EventID = 0; + time_t Date = time_t(0); + uint32 Flags = 0; + time_t LockDate = time_t(0); + time_t OriginalDate = time_t(0); + int32 TextureID = 0; + uint8 EventType = 0; + bool ClearPending = false; + std::string Description; + std::string EventName; + }; + + class CalendarEventRemovedAlert final : public ServerPacket + { + public: + CalendarEventRemovedAlert() : ServerPacket(SMSG_CALENDAR_EVENT_REMOVED_ALERT, 13) { } + + WorldPacket const* Write() override; + + uint64 EventID = 0; + time_t Date = time_t(0); + bool ClearPending = false; + }; + + class CalendarSendNumPending final : public ServerPacket + { + public: + CalendarSendNumPending() : ServerPacket(SMSG_CALENDAR_SEND_NUM_PENDING, 4) { } + CalendarSendNumPending(uint32 numPending) : ServerPacket(SMSG_CALENDAR_SEND_NUM_PENDING, 4), NumPending(numPending) { } + + WorldPacket const* Write() override; + + uint32 NumPending = 0; + }; + + class CalendarGetNumPending final : public ClientPacket + { + public: + CalendarGetNumPending(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_GET_NUM_PENDING, std::move(packet)) { } + + void Read() override { } + }; + + class CalendarEventSignUp final : public ClientPacket + { + public: + CalendarEventSignUp(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_SIGN_UP, std::move(packet)) { } + + void Read() override; + + bool Tentative = false; + uint64 EventID = 0; + }; + + class CalendarRemoveInvite final : public ClientPacket + { + public: + CalendarRemoveInvite(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_REMOVE_INVITE, std::move(packet)) { } + + void Read() override; + + ObjectGuid Guid; + uint64 EventID = 0; + uint64 ModeratorID = 0; + uint64 InviteID = 0; + }; + + class CalendarEventStatus final : public ClientPacket + { + public: + CalendarEventStatus(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_STATUS, std::move(packet)) { } + + void Read() override; + + ObjectGuid Guid; + uint64 EventID = 0; + uint64 ModeratorID = 0; + uint64 InviteID = 0; + uint8 Status = 0; + }; + + class SetSavedInstanceExtend final : public ClientPacket + { + public: + SetSavedInstanceExtend(WorldPacket&& packet) : ClientPacket(CMSG_SET_SAVED_INSTANCE_EXTEND, std::move(packet)) { } + + void Read() override; + + int32 MapID = 0; + bool Extend = false; + uint32 DifficultyID = 0; + }; + + class CalendarEventModeratorStatus final : public ClientPacket + { + public: + CalendarEventModeratorStatus(WorldPacket&& packet) : ClientPacket(CMSG_CALENDAR_EVENT_MODERATOR_STATUS, std::move(packet)) { } + + void Read() override; + + ObjectGuid Guid; + uint64 EventID = 0; + uint64 InviteID = 0; + uint64 ModeratorID = 0; + uint8 Status = 0; + }; + + class CalendarCommandResult final : public ServerPacket + { + public: + CalendarCommandResult() : ServerPacket(SMSG_CALENDAR_COMMAND_RESULT, 3) { } + CalendarCommandResult(uint8 command, uint8 result, std::string const& name) : ServerPacket(SMSG_CALENDAR_COMMAND_RESULT, 3), Command(command), Result(result), Name(name) { } + + WorldPacket const* Write() override; + + uint8 Command = 0; + uint8 Result = 0; + std::string Name; + }; + + class CalendarRaidLockoutUpdated final : public ServerPacket + { + public: + CalendarRaidLockoutUpdated() : ServerPacket(SMSG_CALENDAR_RAID_LOCKOUT_UPDATED, 20) { } + + WorldPacket const* Write() override; + + int32 MapID = 0; + int32 OldTimeRemaining = 0; + time_t ServerTime = 0; + uint32 DifficultyID = 0; + int32 NewTimeRemaining = 0; + }; + + struct CalendarEventInitialInviteInfo + { + CalendarEventInitialInviteInfo(ObjectGuid inviteGuid, uint8 level) : InviteGuid(inviteGuid), Level(level) { } + + ObjectGuid InviteGuid; + uint8 Level = 100; + }; + + class CalendarEventInitialInvites final : public ServerPacket + { + public: + CalendarEventInitialInvites() : ServerPacket(SMSG_CALENDAR_EVENT_INITIAL_INVITES, 17) { } + + WorldPacket const* Write() override; + + std::vector<CalendarEventInitialInviteInfo> Invites; + }; + + class CalendarEventInviteStatusAlert final : public ServerPacket + { + public: + CalendarEventInviteStatusAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT, 5) { } + + WorldPacket const* Write() override; + + uint64 EventID = 0; + uint32 Flags = 0; + time_t Date = time_t(0); + uint8 Status = 0; + }; + + class CalendarEventInviteNotesAlert final : public ServerPacket + { + public: + CalendarEventInviteNotesAlert() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT, 9) { } + CalendarEventInviteNotesAlert(uint64 eventID, std::string const& notes) : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT, 8 + notes.size()), EventID(eventID), Notes(notes) { } + + WorldPacket const* Write() override; + + uint64 EventID = 0; + std::string Notes; + }; + + class CalendarEventInviteNotes final : public ServerPacket + { + public: + CalendarEventInviteNotes() : ServerPacket(SMSG_CALENDAR_EVENT_INVITE_NOTES, 26) { } + + WorldPacket const* Write() override; + + ObjectGuid InviteGuid; + uint64 EventID = 0; + std::string Notes; + bool ClearPending = false; + }; + } +} + +#endif // CalendarPackets_h__ diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp index fd7b00301b2..814a40a037d 100644 --- a/src/server/game/Server/Protocol/Opcodes.cpp +++ b/src/server/game/Server/Protocol/Opcodes.cpp @@ -23,6 +23,7 @@ #include "Packets/BankPackets.h" #include "Packets/BattlegroundPackets.h" #include "Packets/BlackMarketPackets.h" +#include "Packets/CalendarPackets.h" #include "Packets/ChannelPackets.h" #include "Packets/CharacterPackets.h" #include "Packets/ChatPackets.h" @@ -230,21 +231,21 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_BUY_WOW_TOKEN_CONFIRM, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_BUY_WOW_TOKEN_START, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_CAGE_BATTLE_PET, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_ADD_EVENT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarAddEvent ); + DEFINE_HANDLER(CMSG_CALENDAR_ADD_EVENT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarAddEvent, &WorldSession::HandleCalendarAddEvent); DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_COMPLAIN, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarComplain ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_COPY_EVENT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarCopyEvent ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_INVITE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventInvite ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_MODERATOR_STATUS, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventModeratorStatus); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_RSVP, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventRsvp ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_SIGN_UP, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventSignup ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_EVENT_STATUS, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventStatus ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GET, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetCalendar ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GET_EVENT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetEvent ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GET_NUM_PENDING, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGetNumPending ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_GUILD_FILTER, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarGuildFilter ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_REMOVE_EVENT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarRemoveEvent ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_REMOVE_INVITE, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarEventRemoveInvite ); - DEFINE_OPCODE_HANDLER_OLD(CMSG_CALENDAR_UPDATE_EVENT, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCalendarUpdateEvent ); + DEFINE_HANDLER(CMSG_CALENDAR_COPY_EVENT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarCopyEvent, &WorldSession::HandleCalendarCopyEvent); + DEFINE_HANDLER(CMSG_CALENDAR_EVENT_INVITE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventInvite, &WorldSession::HandleCalendarEventInvite); + DEFINE_HANDLER(CMSG_CALENDAR_EVENT_MODERATOR_STATUS, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventModeratorStatus, &WorldSession::HandleCalendarEventModeratorStatus); + DEFINE_HANDLER(CMSG_CALENDAR_EVENT_RSVP, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventRSVP, &WorldSession::HandleCalendarEventRsvp); + DEFINE_HANDLER(CMSG_CALENDAR_EVENT_SIGN_UP, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventSignUp, &WorldSession::HandleCalendarEventSignup); + DEFINE_HANDLER(CMSG_CALENDAR_EVENT_STATUS, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarEventStatus, &WorldSession::HandleCalendarEventStatus); + DEFINE_HANDLER(CMSG_CALENDAR_GET, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGetCalendar, &WorldSession::HandleCalendarGetCalendar); + DEFINE_HANDLER(CMSG_CALENDAR_GET_EVENT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGetEvent, &WorldSession::HandleCalendarGetEvent); + DEFINE_HANDLER(CMSG_CALENDAR_GET_NUM_PENDING, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGetNumPending, &WorldSession::HandleCalendarGetNumPending); + DEFINE_HANDLER(CMSG_CALENDAR_GUILD_FILTER, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarGuildFilter, &WorldSession::HandleCalendarGuildFilter); + DEFINE_HANDLER(CMSG_CALENDAR_REMOVE_EVENT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarRemoveEvent, &WorldSession::HandleCalendarRemoveEvent); + DEFINE_HANDLER(CMSG_CALENDAR_REMOVE_INVITE, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarRemoveInvite, &WorldSession::HandleCalendarEventRemoveInvite); + DEFINE_HANDLER(CMSG_CALENDAR_UPDATE_EVENT, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::CalendarUpdateEvent, &WorldSession::HandleCalendarUpdateEvent); DEFINE_HANDLER(CMSG_CANCEL_AURA, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Spells::CancelAura, &WorldSession::HandleCancelAuraOpcode); DEFINE_OPCODE_HANDLER_OLD(CMSG_CANCEL_AUTO_REPEAT_SPELL, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleCancelAutoRepeatSpellOpcode); DEFINE_HANDLER(CMSG_CANCEL_CAST, STATUS_LOGGEDIN, PROCESS_THREADSAFE, WorldPackets::Spells::CancelCast, &WorldSession::HandleCancelCastOpcode); @@ -735,7 +736,7 @@ void OpcodeTable::Initialize() DEFINE_HANDLER(CMSG_SET_PVP, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); DEFINE_HANDLER(CMSG_SET_RAID_DIFFICULTY, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::SetRaidDifficulty, &WorldSession::HandleSetRaidDifficultyOpcode); DEFINE_HANDLER(CMSG_SET_ROLE, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Party::SetRole, &WorldSession::HandleSetRoleOpcode); - DEFINE_OPCODE_HANDLER_OLD(CMSG_SET_SAVED_INSTANCE_EXTEND, STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::HandleSetSavedInstanceExtend ); + DEFINE_HANDLER(CMSG_SET_SAVED_INSTANCE_EXTEND, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Calendar::SetSavedInstanceExtend, &WorldSession::HandleSetSavedInstanceExtend); DEFINE_HANDLER(CMSG_SET_SELECTION, STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, WorldPackets::Misc::SetSelection, &WorldSession::HandleSetSelectionOpcode); DEFINE_HANDLER(CMSG_SET_SHEATHED, STATUS_LOGGEDIN, PROCESS_INPLACE, WorldPackets::Combat::SetSheathed, &WorldSession::HandleSetSheathedOpcode); DEFINE_HANDLER(CMSG_SET_SORT_BAGS_RIGHT_TO_LEFT, STATUS_UNHANDLED, PROCESS_INPLACE, WorldPackets::Null, &WorldSession::Handle_NULL); @@ -947,26 +948,26 @@ void OpcodeTable::Initialize() DEFINE_SERVER_OPCODE_HANDLER(SMSG_BUY_FAILED, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_BUY_SUCCEEDED, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_CACHE_VERSION, STATUS_NEVER, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_CLEAR_PENDING_ACTION, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_COMMAND_RESULT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INITIAL_INVITES, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_ALERT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_REMOVED_ALERT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_UPDATED_ALERT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_CLEAR_PENDING_ACTION, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_COMMAND_RESULT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INITIAL_INVITES, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_ALERT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_MODERATOR_STATUS, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_NOTES_ALERT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_REMOVED_ALERT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_INVITE_STATUS_ALERT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_REMOVED_ALERT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_EVENT_UPDATED_ALERT, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_RAID_LOCKOUT_ADDED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_RAID_LOCKOUT_REMOVED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_RAID_LOCKOUT_UPDATED, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_CALENDAR, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_EVENT, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); - DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_NUM_PENDING, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_CALENDAR, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_EVENT, STATUS_NEVER, CONNECTION_TYPE_REALM); + DEFINE_SERVER_OPCODE_HANDLER(SMSG_CALENDAR_SEND_NUM_PENDING, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_CAMERA_SHAKE, STATUS_UNHANDLED, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_AUTO_REPEAT, STATUS_NEVER, CONNECTION_TYPE_REALM); DEFINE_SERVER_OPCODE_HANDLER(SMSG_CANCEL_COMBAT, STATUS_NEVER, CONNECTION_TYPE_REALM); diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h index 9c092ec98a1..9b9e8f93f55 100644 --- a/src/server/game/Server/WorldSession.h +++ b/src/server/game/Server/WorldSession.h @@ -122,6 +122,25 @@ namespace WorldPackets class BlackMarketOpen; } + namespace Calendar + { + class CalendarAddEvent; + class CalendarCopyEvent; + class CalendarEventInvite; + class CalendarEventModeratorStatus; + class CalendarEventRSVP; + class CalendarEventSignUp; + class CalendarEventStatus; + class CalendarGetCalendar; + class CalendarGetEvent; + class CalendarGetNumPending; + class CalendarGuildFilter; + class CalendarRemoveEvent; + class CalendarRemoveInvite; + class CalendarUpdateEvent; + class SetSavedInstanceExtend; + } + namespace Character { struct CharacterCreateInfo; @@ -1460,25 +1479,25 @@ class WorldSession void HandleAcceptGrantLevel(WorldPackets::RaF::AcceptLevelGrant& acceptLevelGrant); // Calendar - void HandleCalendarGetCalendar(WorldPacket& recvData); - void HandleCalendarGetEvent(WorldPacket& recvData); - void HandleCalendarGuildFilter(WorldPacket& recvData); - void HandleCalendarAddEvent(WorldPacket& recvData); - void HandleCalendarUpdateEvent(WorldPacket& recvData); - void HandleCalendarRemoveEvent(WorldPacket& recvData); - void HandleCalendarCopyEvent(WorldPacket& recvData); - void HandleCalendarEventInvite(WorldPacket& recvData); - void HandleCalendarEventRsvp(WorldPacket& recvData); - void HandleCalendarEventRemoveInvite(WorldPacket& recvData); - void HandleCalendarEventStatus(WorldPacket& recvData); - void HandleCalendarEventModeratorStatus(WorldPacket& recvData); + void HandleCalendarGetCalendar(WorldPackets::Calendar::CalendarGetCalendar& calendarGetCalendar); + void HandleCalendarGetEvent(WorldPackets::Calendar::CalendarGetEvent& calendarGetEvent); + void HandleCalendarGuildFilter(WorldPackets::Calendar::CalendarGuildFilter& calendarGuildFilter); + void HandleCalendarAddEvent(WorldPackets::Calendar::CalendarAddEvent& calendarAddEvent); + void HandleCalendarUpdateEvent(WorldPackets::Calendar::CalendarUpdateEvent& calendarUpdateEvent); + void HandleCalendarRemoveEvent(WorldPackets::Calendar::CalendarRemoveEvent& calendarRemoveEvent); + void HandleCalendarCopyEvent(WorldPackets::Calendar::CalendarCopyEvent& calendarCopyEvent); + void HandleCalendarEventInvite(WorldPackets::Calendar::CalendarEventInvite& calendarEventInvite); + void HandleCalendarEventRsvp(WorldPackets::Calendar::CalendarEventRSVP& calendarEventRSVP); + void HandleCalendarEventRemoveInvite(WorldPackets::Calendar::CalendarRemoveInvite& calendarRemoveInvite); + void HandleCalendarEventStatus(WorldPackets::Calendar::CalendarEventStatus& calendarEventStatus); + void HandleCalendarEventModeratorStatus(WorldPackets::Calendar::CalendarEventModeratorStatus& calendarEventModeratorStatus); void HandleCalendarComplain(WorldPacket& recvData); - void HandleCalendarGetNumPending(WorldPacket& recvData); - void HandleCalendarEventSignup(WorldPacket& recvData); + void HandleCalendarGetNumPending(WorldPackets::Calendar::CalendarGetNumPending& calendarGetNumPending); + void HandleCalendarEventSignup(WorldPackets::Calendar::CalendarEventSignUp& calendarEventSignUp); void SendCalendarRaidLockout(InstanceSave const* save, bool add); void SendCalendarRaidLockoutUpdated(InstanceSave const* save); - void HandleSetSavedInstanceExtend(WorldPacket& recvData); + void HandleSetSavedInstanceExtend(WorldPackets::Calendar::SetSavedInstanceExtend& setSavedInstanceExtend); // Void Storage void HandleVoidStorageUnlock(WorldPackets::VoidStorage::UnlockVoidStorage& unlockVoidStorage); |