hondacrx
2f68906ed6
Port From (https://github.com/TrinityCore/TrinityCore/commit/792721ad6450065ec81da6472c1e2a143ad57341)
594 lines
18 KiB
C#
594 lines
18 KiB
C#
/*
|
|
* Copyright (C) 2012-2020 CypherCore <http://github.com/CypherCore>
|
|
*
|
|
* 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 3 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/>.
|
|
*/
|
|
|
|
using Framework.Constants;
|
|
using Framework.Dynamic;
|
|
using Framework.GameMath;
|
|
using Game.Entities;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Game.Networking.Packets
|
|
{
|
|
public class GMTicketGetSystemStatus : ClientPacket
|
|
{
|
|
public GMTicketGetSystemStatus(WorldPacket packet) : base(packet) { }
|
|
|
|
public override void Read() { }
|
|
}
|
|
|
|
public class GMTicketSystemStatusPkt : ServerPacket
|
|
{
|
|
public GMTicketSystemStatusPkt() : base(ServerOpcodes.GmTicketSystemStatus) { }
|
|
|
|
public override void Write()
|
|
{
|
|
_worldPacket.WriteInt32(Status);
|
|
}
|
|
|
|
public int Status;
|
|
}
|
|
|
|
public class GMTicketGetCaseStatus : ClientPacket
|
|
{
|
|
public GMTicketGetCaseStatus(WorldPacket packet) : base(packet) { }
|
|
|
|
public override void Read() { }
|
|
}
|
|
|
|
public class GMTicketCaseStatus : ServerPacket
|
|
{
|
|
public GMTicketCaseStatus() : base(ServerOpcodes.GmTicketCaseStatus) { }
|
|
|
|
public override void Write()
|
|
{
|
|
_worldPacket.WriteInt32(Cases.Count);
|
|
|
|
foreach (var c in Cases)
|
|
{
|
|
_worldPacket.WriteInt32(c.CaseID);
|
|
_worldPacket.WriteInt64(c.CaseOpened);
|
|
_worldPacket.WriteInt32(c.CaseStatus);
|
|
_worldPacket.WriteUInt16(c.CfgRealmID);
|
|
_worldPacket.WriteUInt64(c.CharacterID);
|
|
_worldPacket.WriteInt32(c.WaitTimeOverrideMinutes);
|
|
|
|
_worldPacket.WriteBits(c.Url.GetByteCount(), 11);
|
|
_worldPacket.WriteBits(c.WaitTimeOverrideMessage.GetByteCount(), 10);
|
|
|
|
_worldPacket.WriteString(c.Url);
|
|
_worldPacket.WriteString(c.WaitTimeOverrideMessage);
|
|
}
|
|
}
|
|
|
|
public List<GMTicketCase> Cases = new();
|
|
|
|
public struct GMTicketCase
|
|
{
|
|
public int CaseID;
|
|
public long CaseOpened;
|
|
public int CaseStatus;
|
|
public ushort CfgRealmID;
|
|
public ulong CharacterID;
|
|
public int WaitTimeOverrideMinutes;
|
|
public string Url;
|
|
public string WaitTimeOverrideMessage;
|
|
}
|
|
}
|
|
|
|
public class GMTicketAcknowledgeSurvey : ClientPacket
|
|
{
|
|
public GMTicketAcknowledgeSurvey(WorldPacket packet) : base(packet) { }
|
|
|
|
public override void Read()
|
|
{
|
|
CaseID = _worldPacket.ReadInt32();
|
|
}
|
|
|
|
int CaseID;
|
|
}
|
|
|
|
public class SubmitUserFeedback : ClientPacket
|
|
{
|
|
public SupportTicketHeader Header;
|
|
public string Note;
|
|
public bool IsSuggestion;
|
|
|
|
public SubmitUserFeedback(WorldPacket packet) : base(packet) { }
|
|
|
|
public override void Read()
|
|
{
|
|
Header.Read(_worldPacket);
|
|
uint noteLength = _worldPacket.ReadBits<uint>(24);
|
|
IsSuggestion = _worldPacket.HasBit();
|
|
|
|
if (noteLength != 0)
|
|
Note = _worldPacket.ReadString(noteLength - 1);
|
|
}
|
|
}
|
|
|
|
public class SupportTicketSubmitComplaint : ClientPacket
|
|
{
|
|
public SupportTicketSubmitComplaint(WorldPacket packet) : base(packet) { }
|
|
|
|
public override void Read()
|
|
{
|
|
Header.Read(_worldPacket);
|
|
TargetCharacterGUID = _worldPacket.ReadPackedGuid();
|
|
ChatLog.Read(_worldPacket);
|
|
ComplaintType = _worldPacket.ReadBits<byte>(5);
|
|
|
|
uint noteLength = _worldPacket.ReadBits<uint>(10);
|
|
bool hasMailInfo = _worldPacket.HasBit();
|
|
bool hasCalendarInfo = _worldPacket.HasBit();
|
|
bool hasPetInfo = _worldPacket.HasBit();
|
|
bool hasGuildInfo = _worldPacket.HasBit();
|
|
bool hasLFGListSearchResult = _worldPacket.HasBit();
|
|
bool hasLFGListApplicant = _worldPacket.HasBit();
|
|
bool hasClubMessage = _worldPacket.HasBit();
|
|
bool hasClubFinderResult = _worldPacket.HasBit();
|
|
bool hasUnk910 = _worldPacket.HasBit();
|
|
|
|
_worldPacket.ResetBitPos();
|
|
|
|
if (hasClubMessage)
|
|
{
|
|
CommunityMessage.HasValue = true;
|
|
CommunityMessage.Value.IsPlayerUsingVoice = _worldPacket.HasBit();
|
|
_worldPacket.ResetBitPos();
|
|
}
|
|
|
|
HorusChatLog.Read(_worldPacket);
|
|
|
|
Note = _worldPacket.ReadString(noteLength);
|
|
|
|
if (hasMailInfo)
|
|
{
|
|
MailInfo.HasValue = true;
|
|
MailInfo.Value.Read(_worldPacket);
|
|
}
|
|
|
|
if (hasCalendarInfo)
|
|
{
|
|
CalenderInfo.HasValue = true;
|
|
CalenderInfo.Value.Read(_worldPacket);
|
|
}
|
|
|
|
if (hasPetInfo)
|
|
{
|
|
PetInfo.HasValue = true;
|
|
PetInfo.Value.Read(_worldPacket);
|
|
}
|
|
|
|
if (hasGuildInfo)
|
|
{
|
|
GuildInfo.HasValue = true;
|
|
GuildInfo.Value.Read(_worldPacket);
|
|
}
|
|
|
|
if (hasLFGListSearchResult)
|
|
{
|
|
LFGListSearchResult.HasValue = true;
|
|
LFGListSearchResult.Value.Read(_worldPacket);
|
|
}
|
|
|
|
if (hasLFGListApplicant)
|
|
{
|
|
LFGListApplicant.HasValue = true;
|
|
LFGListApplicant.Value.Read(_worldPacket);
|
|
}
|
|
|
|
if (hasClubFinderResult)
|
|
{
|
|
ClubFinderResult.HasValue = true;
|
|
ClubFinderResult.Value.Read(_worldPacket);
|
|
}
|
|
|
|
if (hasUnk910)
|
|
{
|
|
Unused910.HasValue = true;
|
|
Unused910.Value.Read(_worldPacket);
|
|
}
|
|
}
|
|
|
|
public SupportTicketHeader Header;
|
|
public SupportTicketChatLog ChatLog;
|
|
public ObjectGuid TargetCharacterGUID;
|
|
public byte ComplaintType;
|
|
public string Note;
|
|
public SupportTicketHorusChatLog HorusChatLog;
|
|
public Optional<SupportTicketMailInfo> MailInfo;
|
|
public Optional<SupportTicketCalendarEventInfo> CalenderInfo;
|
|
public Optional<SupportTicketPetInfo> PetInfo;
|
|
public Optional<SupportTicketGuildInfo> GuildInfo;
|
|
public Optional<SupportTicketLFGListSearchResult> LFGListSearchResult;
|
|
public Optional<SupportTicketLFGListApplicant> LFGListApplicant;
|
|
public Optional<SupportTicketCommunityMessage> CommunityMessage;
|
|
public Optional<SupportTicketClubFinderResult> ClubFinderResult;
|
|
public Optional<SupportTicketUnused910> Unused910;
|
|
|
|
public struct SupportTicketChatLine
|
|
{
|
|
public long Timestamp;
|
|
public string Text;
|
|
|
|
public SupportTicketChatLine(WorldPacket data)
|
|
{
|
|
Timestamp = data.ReadInt64();
|
|
Text = data.ReadString(data.ReadBits<uint>(12));
|
|
}
|
|
|
|
public SupportTicketChatLine(long timestamp, string text)
|
|
{
|
|
Timestamp = timestamp;
|
|
Text = text;
|
|
}
|
|
|
|
public void Read(WorldPacket data)
|
|
{
|
|
Timestamp = data.ReadUInt32();
|
|
Text = data.ReadString(data.ReadBits<uint>(12));
|
|
}
|
|
}
|
|
|
|
public class SupportTicketChatLog
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
uint linesCount = data.ReadUInt32();
|
|
ReportLineIndex.HasValue = data.HasBit();
|
|
data.ResetBitPos();
|
|
|
|
for (uint i = 0; i < linesCount; i++)
|
|
Lines.Add(new SupportTicketChatLine(data));
|
|
|
|
if (ReportLineIndex.HasValue)
|
|
ReportLineIndex.Value = data.ReadUInt32();
|
|
}
|
|
|
|
public List<SupportTicketChatLine> Lines = new();
|
|
public Optional<uint> ReportLineIndex;
|
|
}
|
|
|
|
public struct SupportTicketHorusChatLine
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
Timestamp = data.ReadInt64();
|
|
AuthorGUID = data.ReadPackedGuid();
|
|
|
|
bool hasClubID = data.HasBit();
|
|
bool hasChannelGUID = data.HasBit();
|
|
bool hasRealmAddress = data.HasBit();
|
|
bool hasSlashCmd = data.HasBit();
|
|
uint textLength = data.ReadBits<uint>(12);
|
|
|
|
if (hasClubID)
|
|
{
|
|
ClubID.HasValue = true;
|
|
ClubID.Value = data.ReadUInt64();
|
|
}
|
|
|
|
if (hasChannelGUID)
|
|
{
|
|
ChannelGUID.HasValue = true;
|
|
ChannelGUID.Value = data.ReadPackedGuid();
|
|
}
|
|
|
|
if (hasRealmAddress)
|
|
{
|
|
RealmAddress.HasValue = true;
|
|
RealmAddress.Value.VirtualRealmAddress = data.ReadUInt32();
|
|
RealmAddress.Value.field_4 = data.ReadUInt16();
|
|
RealmAddress.Value.field_6 = data.ReadUInt8();
|
|
}
|
|
|
|
if (hasSlashCmd)
|
|
{
|
|
SlashCmd.HasValue = true;
|
|
SlashCmd.Value = data.ReadInt32();
|
|
}
|
|
|
|
Text = data.ReadString(textLength);
|
|
}
|
|
|
|
public struct SenderRealm
|
|
{
|
|
public uint VirtualRealmAddress;
|
|
public ushort field_4;
|
|
public byte field_6;
|
|
}
|
|
|
|
public long Timestamp;
|
|
public ObjectGuid AuthorGUID;
|
|
public Optional<ulong> ClubID;
|
|
public Optional<ObjectGuid> ChannelGUID;
|
|
public Optional<SenderRealm> RealmAddress;
|
|
public Optional<int> SlashCmd;
|
|
public string Text;
|
|
}
|
|
|
|
public class SupportTicketHorusChatLog
|
|
{
|
|
public List<SupportTicketHorusChatLine> Lines = new();
|
|
|
|
public void Read(WorldPacket data)
|
|
{
|
|
uint linesCount = data.ReadUInt32();
|
|
data.ResetBitPos();
|
|
|
|
for (uint i = 0; i < linesCount; i++)
|
|
{
|
|
var chatLine = new SupportTicketHorusChatLine();
|
|
chatLine.Read(data);
|
|
Lines.Add(chatLine);
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct SupportTicketMailInfo
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
MailID = data.ReadInt32();
|
|
uint bodyLength = data.ReadBits<uint>(13);
|
|
uint subjectLength = data.ReadBits<uint>(9);
|
|
|
|
MailBody = data.ReadString(bodyLength);
|
|
MailSubject = data.ReadString(subjectLength);
|
|
}
|
|
|
|
public int MailID;
|
|
public string MailSubject;
|
|
public string MailBody;
|
|
}
|
|
|
|
public struct SupportTicketCalendarEventInfo
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
EventID = data.ReadUInt64();
|
|
InviteID = data.ReadUInt64();
|
|
|
|
EventTitle = data.ReadString(data.ReadBits<byte>(8));
|
|
}
|
|
|
|
public ulong EventID;
|
|
public ulong InviteID;
|
|
public string EventTitle;
|
|
}
|
|
|
|
public struct SupportTicketPetInfo
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
PetID = data.ReadPackedGuid();
|
|
|
|
PetName = data.ReadString(data.ReadBits<byte>(8));
|
|
}
|
|
|
|
public ObjectGuid PetID;
|
|
public string PetName;
|
|
}
|
|
|
|
public struct SupportTicketGuildInfo
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
byte nameLength = data.ReadBits<byte>(8);
|
|
GuildID = data.ReadPackedGuid();
|
|
|
|
GuildName = data.ReadString(nameLength);
|
|
}
|
|
|
|
public ObjectGuid GuildID;
|
|
public string GuildName;
|
|
}
|
|
|
|
public struct SupportTicketLFGListSearchResult
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
RideTicket = new RideTicket();
|
|
RideTicket.Read(data);
|
|
|
|
GroupFinderActivityID = data.ReadUInt32();
|
|
LastTitleAuthorGuid = data.ReadPackedGuid();
|
|
LastDescriptionAuthorGuid = data.ReadPackedGuid();
|
|
LastVoiceChatAuthorGuid = data.ReadPackedGuid();
|
|
ListingCreatorGuid = data.ReadPackedGuid();
|
|
Unknown735 = data.ReadPackedGuid();
|
|
|
|
byte titleLength = data.ReadBits<byte>(10);
|
|
byte descriptionLength = data.ReadBits<byte>(11);
|
|
byte voiceChatLength = data.ReadBits<byte>(8);
|
|
|
|
Title = data.ReadString(titleLength);
|
|
Description = data.ReadString(descriptionLength);
|
|
VoiceChat = data.ReadString(voiceChatLength);
|
|
}
|
|
|
|
public RideTicket RideTicket;
|
|
public uint GroupFinderActivityID;
|
|
public ObjectGuid LastTitleAuthorGuid;
|
|
public ObjectGuid LastDescriptionAuthorGuid;
|
|
public ObjectGuid LastVoiceChatAuthorGuid;
|
|
public ObjectGuid ListingCreatorGuid;
|
|
public ObjectGuid Unknown735;
|
|
public string Title;
|
|
public string Description;
|
|
public string VoiceChat;
|
|
}
|
|
|
|
public struct SupportTicketLFGListApplicant
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
RideTicket = new RideTicket();
|
|
RideTicket.Read(data);
|
|
|
|
Comment = data.ReadString(data.ReadBits<uint>(9));
|
|
}
|
|
|
|
public RideTicket RideTicket;
|
|
public string Comment;
|
|
}
|
|
|
|
public struct SupportTicketCommunityMessage
|
|
{
|
|
public bool IsPlayerUsingVoice;
|
|
}
|
|
|
|
public struct SupportTicketClubFinderResult
|
|
{
|
|
public ulong ClubFinderPostingID;
|
|
public ulong ClubID;
|
|
public ObjectGuid ClubFinderGUID;
|
|
public string ClubName;
|
|
|
|
public void Read(WorldPacket data)
|
|
{
|
|
ClubFinderPostingID = data.ReadUInt64();
|
|
ClubID = data.ReadUInt64();
|
|
ClubFinderGUID = data.ReadPackedGuid();
|
|
ClubName = data.ReadString(data.ReadBits<uint>(12));
|
|
}
|
|
}
|
|
|
|
public struct SupportTicketUnused910
|
|
{
|
|
public string field_0;
|
|
public ObjectGuid field_104;
|
|
|
|
public void Read(WorldPacket data)
|
|
{
|
|
uint field_0Length = data.ReadBits<uint>(7);
|
|
field_104 = data.ReadPackedGuid();
|
|
field_0 = data.ReadString(field_0Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
class Complaint : ClientPacket
|
|
{
|
|
public Complaint(WorldPacket packet) : base(packet) { }
|
|
|
|
public override void Read()
|
|
{
|
|
ComplaintType = (SupportSpamType)_worldPacket.ReadUInt8();
|
|
Offender.Read(_worldPacket);
|
|
|
|
switch (ComplaintType)
|
|
{
|
|
case SupportSpamType.Mail:
|
|
MailID = _worldPacket.ReadUInt32();
|
|
break;
|
|
case SupportSpamType.Chat:
|
|
Chat.Read(_worldPacket);
|
|
break;
|
|
case SupportSpamType.Calendar:
|
|
EventGuid = _worldPacket.ReadUInt64();
|
|
InviteGuid = _worldPacket.ReadUInt64();
|
|
break;
|
|
}
|
|
}
|
|
|
|
public SupportSpamType ComplaintType;
|
|
ComplaintOffender Offender;
|
|
uint MailID;
|
|
ComplaintChat Chat;
|
|
|
|
ulong EventGuid;
|
|
ulong InviteGuid;
|
|
|
|
struct ComplaintOffender
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
PlayerGuid = data.ReadPackedGuid();
|
|
RealmAddress = data.ReadUInt32();
|
|
TimeSinceOffence = data.ReadUInt32();
|
|
}
|
|
|
|
public ObjectGuid PlayerGuid;
|
|
public uint RealmAddress;
|
|
public uint TimeSinceOffence;
|
|
}
|
|
|
|
struct ComplaintChat
|
|
{
|
|
public void Read(WorldPacket data)
|
|
{
|
|
Command = data.ReadUInt32();
|
|
ChannelID = data.ReadUInt32();
|
|
MessageLog = data.ReadString(data.ReadBits<uint>(12));
|
|
}
|
|
|
|
public uint Command;
|
|
public uint ChannelID;
|
|
public string MessageLog;
|
|
}
|
|
}
|
|
|
|
public class ComplaintResult : ServerPacket
|
|
{
|
|
public ComplaintResult() : base(ServerOpcodes.ComplaintResult) { }
|
|
|
|
public override void Write()
|
|
{
|
|
_worldPacket.WriteUInt32((uint)ComplaintType);
|
|
_worldPacket.WriteUInt8(Result);
|
|
}
|
|
|
|
public SupportSpamType ComplaintType;
|
|
public byte Result;
|
|
}
|
|
|
|
class BugReport : ClientPacket
|
|
{
|
|
public BugReport(WorldPacket packet) : base(packet) { }
|
|
|
|
public override void Read()
|
|
{
|
|
Type = _worldPacket.ReadBit();
|
|
uint diagLen = _worldPacket.ReadBits<uint>(12);
|
|
uint textLen = _worldPacket.ReadBits<uint>(10);
|
|
DiagInfo = _worldPacket.ReadString(diagLen);
|
|
Text = _worldPacket.ReadString(textLen);
|
|
}
|
|
|
|
public uint Type;
|
|
public string Text;
|
|
public string DiagInfo;
|
|
}
|
|
|
|
//Structs
|
|
public struct SupportTicketHeader
|
|
{
|
|
public void Read(WorldPacket packet)
|
|
{
|
|
MapID = packet.ReadUInt32();
|
|
Position = packet.ReadVector3();
|
|
Facing = packet.ReadFloat();
|
|
}
|
|
|
|
public uint MapID;
|
|
public Vector3 Position;
|
|
public float Facing;
|
|
}
|
|
}
|