public int HandlePacket(BaseClient client, PacketIn packet)
{
WorldClient cclient = (WorldClient)client;
UInt32 code = packet.GetUint32();
cclient.Send(new ANS_DISTRICT_RESERVE(code, packet.GetUint32(), cclient.Character.LFG, cclient));
return 0;
}
static public void CMSG_CONNECT(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
UInt32 sequence = packet.GetUint32();
UInt32 unk = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.SMSG_CONNECT_RESPONSE);
Out.WriteUInt32(sequence);
Out.WriteUInt16(0);
Out.WriteUInt32(unk);
cclient.SendTCPCuted(Out);
}
public static void F_DUMP_STATICS(BaseClient client, PacketIn packet)
{
GameClient cclient = (GameClient)client;
if (cclient.Plr == null || !cclient.Plr.IsInWorld())
{
return;
}
cclient.Plr.MoveBlock = false;
uint Unk1 = packet.GetUint32();
ushort Unk2 = packet.GetUint16();
ushort OffX = packet.GetUint16();
ushort Unk3 = packet.GetUint16();
ushort OffY = packet.GetUint16();
//cclient.Plr.DebugMessage("DUMP_STATICS : OFFSETS "+OffX+", "+OffY);
cclient.Plr.SetOffset(OffX, OffY);
if (!cclient.Plr.IsActive)
{
cclient.Plr.IsActive = true;
}
if (cclient.Plr.PendingDumpStatic)
{
cclient.Plr.OnClientLoaded();
}
}
static public void CMSG_AUTHENTICATE(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
UInt32 Sequence = packet.GetUint32();
string Username = packet.GetString();
string Token = packet.GetString();
AuthResult Result = Program.AcctMgr.CheckToken(Username, Token);
PacketOut Out = new PacketOut((byte)Opcodes.SMSG_AUTHENTICATE_RESPONSE);
Out.WriteUInt32(Sequence);
Out.WriteUInt16((UInt16)Result);
Out.WriteByte(0);
cclient.SendTCPCuted(Out);
if (Result != AuthResult.AUTH_SUCCESS)
{
cclient.Disconnect();
}
else
{
cclient.Username = Username;
cclient.Token = Token;
}
}
static public void CL_START(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
string Username = packet.GetString();
UInt32 Len = packet.GetUint32();
byte[] Password = packet.Read((int)Len);
bool result = Program.AcctMgr.CheckAccount(Username, Password);
Log.Debug("CL_START", "Launching of client : " + Username + " " + result);
PacketOut Out = new PacketOut((byte)Opcodes.LCR_START);
if (result == true)
{
Out.WriteByte(0);
Out.WriteString(Program.AcctMgr.GenerateToken(Username));
}
else
{
Out.WriteByte(1);
}
cclient.SendPacket(Out);
}
static public void F_ZONEJUMP(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null || !cclient.Plr.IsInWorld())
{
return;
}
//Log.Dump("Jump", packet, true);
UInt32 Id = packet.GetUint32();
Log.Info("Jump", "Jump to :" + Id);
Zone_jump Jump = WorldMgr.GetZoneJump(Id);
if (Jump != null)
{
cclient.Plr.Teleport(Jump.ZoneID, Jump.WorldX, Jump.WorldY, Jump.WorldZ, Jump.WorldO);
}
else
{
Log.Error("Jump", "Invalid Jump");
}
}
static public void F_CONNECT(Connection conn, PacketIn packet)
{
Log.Debug("F_CONNECT");
packet.Skip(8);
UInt32 Tag = packet.GetUint32();
string Token = packet.GetString(80);
packet.Skip(21);
string Username = packet.GetString(23);
Log.Debug("New Connection : " + Token + ",User="******"Emulator");
Out.WriteByte(0);
Out.WriteUInt16(0);
conn.SendTCP(Out);
}
public static void F_OBJECTIVE_UPDATE(BaseClient client, PacketIn packet)
{
GameClient cclient = (GameClient)client;
uint pQuestID = packet.GetUint32();
byte op = packet.GetUint8();
switch (op)
{
case 8: // switch opt out state
byte optOutType = packet.GetUint8();
PublicQuest pQuest = cclient.Plr.QtsInterface.PublicQuest;
if (pQuest == null || pQuest.Info.Entry != pQuestID)
{
return;
}
pQuest.ProcessOptOut(cclient.Plr, optOutType);
break;
default:
Log.Error("F_OBJECTIVE_UPDATE", $"Received unknown op {op} from client");
break;
}
}
static public void F_DO_ABILITY(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null)
{
return;
}
UInt32 Unk, Unk2, Unk3 = 0;
UInt16 AbilityID = 0;
Unk = packet.GetUint32();
Unk2 = packet.GetUint32();
Unk3 = packet.GetUint32();
AbilityID = packet.GetUint16();
cclient.Plr.AbtInterface.StartCast(AbilityID);
}
public static void F_AUCTION_POST_ITEM(BaseClient client, PacketIn packet)
{
GameClient cclient = (GameClient)client;
if (!cclient.IsPlaying() || !cclient.Plr.IsInWorld())
{
return;
}
Player plr = cclient.Plr;
if (AuctionHouse.PlayerAuctionCount(plr.CharacterId) >= AuctionHouse.MAX_AUCTIONS_PER_CHAR)
{
plr.SendMessage("You have reached the maximum of " + AuctionHouse.MAX_AUCTIONS_PER_CHAR + " auctions.", ChatLogFilters.CHATLOGFILTERS_USER_ERROR);
return;
}
ushort slot = packet.GetUint16();
packet.Skip(2);
uint price = packet.GetUint32();
if (plr.ItmInterface.GetItemInSlot(slot) == null)
{
return;
}
if (plr.ItmInterface.GetItemInSlot(slot).BoundtoPlayer || plr.ItmInterface.GetItemInSlot(slot).Info.Bind == 1)
{
plr.SendLocalizeString(plr.ItmInterface.GetItemInSlot(slot).Info.Name, ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_AUCTION_ITEM_IS_BOUND);
return;
}
Auction auction = new Auction
{
Item = plr.ItmInterface.GetItemInSlot(slot).Info,
ItemId = plr.ItmInterface.GetItemInSlot(slot).Info.Entry,
_Talismans = plr.ItmInterface.GetItemInSlot(slot).GetTalismans(),
PrimaryDye = plr.ItmInterface.GetItemInSlot(slot).GetPrimaryDye(),
SecondaryDye = plr.ItmInterface.GetItemInSlot(slot).GetSecondaryDye(),
Count = plr.ItmInterface.GetItemInSlot(slot).Count,
Seller = plr.Info,
SellerId = plr.CharacterId,
SellPrice = price,
StartTime = (uint)TCPManager.GetTimeStamp(),
Realm = plr.Info.Realm,
AuctionId = (uint)AuctionHouse.GenerateAuctionGUID()
};
AuctionHouse.AddAuction(auction);
plr.ItmInterface.DeleteItem(slot);
}
static public void F_CONNECT(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
packet.Skip(8);
UInt32 Tag = packet.GetUint32();
string Token = packet.GetString(80);
packet.Skip(21);
string Username = packet.GetString(23);
// TODO
AuthResult Result = Program.AcctMgr.CheckToken(Username, Token);
if (Result != AuthResult.AUTH_SUCCESS)
{
Log.Error("F_CONNECT", "Invalid Token =" + Username);
cclient.Disconnect();
}
else
{
cclient._Account = Program.AcctMgr.GetAccount(Username);
if (cclient._Account == null)
{
Log.Error("F_CONNECT", "Invalid Account =" + Username);
cclient.Disconnect();
}
else
{
//Log.Success("F_CONNECT", "MeId=" + cclient.Id);
GameClient Other = (cclient.Server as TCPServer).GetClientByAccount(cclient, cclient._Account.AccountId);
if (Other != null)
{
Other.Disconnect();
}
{
PacketOut Out = new PacketOut((byte)Opcodes.S_CONNECTED);
Out.WriteUInt32(0);
Out.WriteUInt32(Tag);
Out.WriteByte(Program.Rm.RealmId);
Out.WriteUInt32(0);// this was 1// setting this at 0 removes the server population box
Out.WritePascalString(Username);
Out.WritePascalString(Program.Rm.Name);
Out.WriteByte(0);
Out.WriteUInt16(0);
cclient.SendPacket(Out);
}
}
}
}
static public void F_PING(Connection conn, PacketIn packet)
{
uint Timestamp = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.S_PONG);
Out.WriteUInt32(Timestamp);
Out.WriteUInt64((UInt64)Listener.GetTimeStamp());
Out.WriteUInt32((UInt32)(conn.SequenceID + 1));
Out.WriteUInt32(0);
conn.SendTCP(Out);
Log.Trace("ping");
}
public static void F_AUCTION_BID_ITEM(BaseClient client, PacketIn packet)
{
GameClient cclient = (GameClient)client;
if (!cclient.IsPlaying() || !cclient.Plr.IsInWorld())
{
return;
}
uint price = packet.GetUint32();
packet.GetUint32(); // unk
// item id
// 10 bytes which are sent along with the item list, might be a very long number however lets take the first 8
ulong Id = packet.GetUint64();
packet.Skip(2); // last byte ranges from 01 - 03? a flag?
packet.GetUint32(); // unk
AuctionHouse.BuyOutAuction(cclient.Plr, Id, price);
}
static public void CMSG_GET_CHARACTER_SUMMARIES(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
uint sequence = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.SMSG_GET_CHARACTER_SUMMARIES_RESPONSE);
Out.WriteUInt32(sequence);
Out.WriteUInt16(0);
Out.WriteUInt16(0); // Character count
cclient.SendTCPCuted(Out);
}
static public void F_PING(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
uint Timestamp = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.S_PONG);
Out.WriteUInt32(Timestamp);
Out.WriteUInt64((UInt64)TCPManager.GetTimeStamp());
Out.WriteUInt32((UInt32)(cclient.SequenceID + 1));
Out.WriteUInt32(0);
cclient.SendPacket(Out);
}
public static void F_MAIL(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.IsPlaying() || !cclient.Plr.IsInWorld())
{
return;
}
Player Plr = cclient.Plr;
Plr.MlInterface.CheckMailExpired();
byte Type = packet.GetUint8();
switch (Type)
{
case 0: // Mailbox closed
{
if (Plr.GldInterface.IsInGuild() && Plr.GldInterface.Guild.GuildVaultUser.Contains(Plr))
{
Plr.GldInterface.Guild.GuildVaultClosed(Plr);
}
if (Plr.CurrentSiege != null && Plr.CurrentSiege.SiegeInterface.IsDeployed)
{
Plr.CurrentSiege.SiegeInterface.RemovePlayer(Plr);
}
} break;
case 1: // Mail sent
{
Plr.MlInterface.SendPacketMail(packet);
} break;
case 2: // Open mail
case 3: // Return mail
case 4: // Delete mail
case 5: // Mark as read/unread
case 7: // Take Item
case 8: // Take money
{
byte page = packet.GetUint8();
uint guid = ByteOperations.ByteSwap.Swap(packet.GetUint32());
Plr.MlInterface.MailInteract((MailInteractType)Type, guid, packet);
}
break;
}
}
static public void CMSG_GET_SERVER_LIST(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
uint sequence = packet.GetUint32();
byte[] Res = Program.AcctMgr.BuildRealms(sequence);
PacketOut Out = new PacketOut((byte)Opcodes.SMSG_GET_SERVER_LIST_RESPONSE);
Out.Write(Res, 0, Res.Length);
cclient.SendTCPCuted(Out);
}
public static void CL_CHECK(BaseClient client, PacketIn packet)
{
Client cclient = (Client)client;
uint version = packet.GetUint32();
Log.Debug("CL_CHECK", "Launcher Version : " + version);
PacketOut Out = new PacketOut((byte)Opcodes.LCR_CHECK);
if (version != Program.Version)
{
Out.WriteByte((byte)CheckResult.LAUNCHER_VERSION); // Version incorrect + message
Out.WriteString(Program.Message);
client.SendPacketNoBlock(Out);
cclient.Disconnect("Incorrect game version");
return;
}
byte options = packet.GetUint8();
ulong len = 0;
if ((options & 1) == 1)
{
Log.Debug("CHECK", "Has mythic file info");
len = packet.GetUint64();
if ((long)len != Program.Info.Length)
{
Out.WriteByte((byte)CheckResult.LAUNCHER_FILE);
Out.WriteString(Program.StrInfo);
cclient.SendPacketNoBlock(Out);
return;
}
}
if ((options & 2) == 2)
{
Dictionary <string, object> computerProfile = readProfile(ref packet);
Log.Debug("CHECK", "Has system info");
}
Out.WriteByte((byte)CheckResult.LAUNCHER_OK);
cclient.SendPacketNoBlock(Out);
}
static public void F_GROUP_COMMAND(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.IsPlaying() || !cclient.Plr.IsInWorld())
{
return;
}
Player Plr = cclient.Plr;
packet.GetUint32(); // UNK
byte State = packet.GetUint8();
switch (State)
{
case 2: // Accept invitation
if (Plr.Invitation == null)
{
return;
}
Plr.Invitation.AcceptInvitation();
break;
case 6: // Decline invitation
if (Plr.Invitation == null)
{
return;
}
Plr.Invitation.DeclineInvitation();
break;
case 3: // Leave group
if (Plr.GetGroup() == null)
{
return;
}
Plr.GetGroup().RemoveMember(Plr);
Plr.SetGroup(null);
break;
case 17: // Make main
break;
default:
Log.Error("GroupHandler", "Unsupported type: " + State);
break;
}
}
static public void F_CONNECT(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
packet.Skip(8);
UInt32 Tag = packet.GetUint32();
string Token = packet.GetString(80);
packet.Skip(21);
string Username = packet.GetString(23);
Log.Debug("Connect", "Connexion avec : " + Token + ",User="******"F_CONNECT", "MeId=" + cclient.Id);
GameClient Other = (cclient.Server as TCPServer).GetClientByAccount(cclient, cclient._Account.AccountId);
if (Other != null)
{
Other.Disconnect();
}
PacketOut Out = new PacketOut((byte)Opcodes.S_CONNECTED);
Out.WriteUInt32(0);
Out.WriteUInt32(Tag);
Out.WriteByte(Program.Rm.RealmId);
Out.WriteUInt32(0);
Out.WritePascalString(Username);
Out.WritePascalString(Program.Rm.Name);
Out.WriteByte(0);
Out.WriteUInt16(0);
cclient.SendTCP(Out);
}
}
}
static public void CMSG_LOGIN_CLEARANCE(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
UInt32 sequence = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.SMSG_LOGIN_CLEARANCE_RESPONSE);
Out.WriteUInt32(sequence);
Out.WriteUInt32(0);
Out.WriteUInt16(1);
Out.WriteUInt16(1);
Out.WriteUInt32(1);
cclient.SendTCPCuted(Out);
}
static public void F_DUMP_STATICS(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null || !cclient.Plr.IsInWorld())
return;
UInt32 Unk1 = packet.GetUint32();
UInt16 Unk2 = packet.GetUint16();
UInt16 OffX = packet.GetUint16();
UInt16 Unk3 = packet.GetUint16();
UInt16 OffY = packet.GetUint16();
Log.Success("F_DUMP_STATIC", "X=" + OffX + ",Y=" + OffY);
cclient.Plr.SetOffset(OffX, OffY);
}
protected override void OnReceive(byte[] Packet)
{
lock (this)
{
PacketIn pack = new PacketIn(Packet, 0, Packet.Length);
pack.Size = pack.GetUint32();
pack.Opcode = pack.GetUint8();
if (!Enum.IsDefined(typeof(Opcodes), (byte)pack.Opcode))
{
Log.Error("OnReceive", "Opcode invalide : " + pack.Opcode);
return;
}
Server.HandlePacket((BaseClient)this, pack);
}
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
WorldClient cclient = (WorldClient)client;
uint instanceUID = packet.GetUint32();
PacketOut Out = new PacketOut((uint)Opcodes.ANS_GROUP_LIST);
Out.WriteUInt32((uint)ResponseCodes.RC_SUCCESS);
Out.WriteUInt32(instanceUID);
Out.WriteByte(0);
Out.WriteUInt32Reverse(0); //leader's charUID
Out.WriteParsedString(""); //leader
Out.WriteByte(0); //members amount
Out.WriteByte(0); //rating
Out.WriteByte(0); //threat
cclient.Send(Out);
return(0);
}
public static void F_PING(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
uint Timestamp = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.S_PONG, 20);
Out.WriteUInt32(Timestamp);
Out.WriteUInt64((ulong)TCPManager.GetTimeStamp());
Out.WriteUInt32((uint)(cclient.SequenceID + 1));
Out.WriteUInt32(0);
cclient.SendPacket(Out);
Player plr = cclient.Plr;
if (plr != null)
{
plr.LastKeepAliveTime = TCPManager.GetTimeStampMS();
}
}
static public void F_EMOTE(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null)
{
return;
}
UInt32 emote = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.F_EMOTE);
Out.WriteUInt16(cclient.Plr.Oid);
Out.WriteUInt16((UInt16)emote);
if (cclient.Plr.CbtInterface.HasTarget())
{
Out.WriteUInt16(cclient.Plr.CbtInterface.CurrentTarget.Target.Oid);
}
cclient.Plr.DispatchPacket(Out, false);
cclient.Plr.SendPacket(Out);
}
public static void F_DO_ABILITY(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null)
{
return;
}
byte LOS = packet.GetUint8();
bool Moving = Convert.ToBoolean(packet.GetUint8());
ushort Heading = packet.GetUint16();
ushort X = packet.GetUint16();
ushort Y = packet.GetUint16();
ushort ZoneID = packet.GetUint16();
ushort Z = packet.GetUint16();
ushort AbilityID = packet.GetUint16();
// prevent ability when banner is out
if (cclient.Plr.WeaponStance == WeaponStance.Standard && !(AbilityID == 14508 || AbilityID == 14524 || AbilityID == 14527 || AbilityID == 14526))
{
return;
}
byte abGroup = packet.GetUint8();
byte unk = packet.GetUint8();
uint unk2 = packet.GetUint32();
bool enemyVisible = Convert.ToBoolean(LOS & 128);
bool friendlyVisible = Convert.ToBoolean(LOS & 8);
cclient.Plr.SetPosition(X, Y, Z, Heading, ZoneID);
cclient.Plr.AbtInterface.StartCast(cclient.Plr, AbilityID, abGroup, 0, 0, enemyVisible, friendlyVisible, Moving);
}
static public void F_DUMP_STATICS(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null || !cclient.Plr.IsInWorld())
{
return;
}
UInt32 Unk1 = packet.GetUint32();
UInt16 Unk2 = packet.GetUint16();
UInt16 OffX = packet.GetUint16();
UInt16 Unk3 = packet.GetUint16();
UInt16 OffY = packet.GetUint16();
cclient.Plr.SetOffset(OffX, OffY);
if (!cclient.Plr.IsActive)
{
cclient.Plr.IsActive = true;
}
}
static public void F_EMOTE(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (cclient.Plr == null)
{
return;
}
UInt32 emote = packet.GetUint32();
PacketOut Out = new PacketOut((byte)Opcodes.F_EMOTE);
Out.WriteUInt16(cclient.Plr.Oid);
Out.WriteUInt16((UInt16)emote);
if (cclient.Plr.CbtInterface.HasTarget(GameData.TargetTypes.TARGETTYPES_TARGET_ALLY))
{
Out.WriteUInt16(cclient.Plr.CbtInterface.Targets[(int)GameData.TargetTypes.TARGETTYPES_TARGET_ALLY]);
}
cclient.Plr.DispatchPacket(Out, false);
cclient.Plr.SendPacket(Out);
}
static public void CL_CHECK(BaseClient client, PacketIn packet)
{
Client cclient = client as Client;
uint Version = packet.GetUint32();
Log.Debug("CL_CHECK", "Launcher Version : " + Version);
PacketOut Out = new PacketOut((byte)Opcodes.LCR_CHECK);
if (Version != Program.Version)
{
Out.WriteByte((byte)CheckResult.LAUNCHER_VERSION); // Version incorrect + message
Out.WriteString(Program.Message);
client.SendPacket(Out);
cclient.Disconnect();
return;
}
byte File = packet.GetUint8();
UInt64 Len = 0;
if (File >= 1)
{
Len = packet.GetUint64();
}
if ((long)Len != Program.Info.Length)
{
Out.WriteByte((byte)CheckResult.LAUNCHER_FILE);
Out.WriteString(Program.StrInfo);
}
else
{
Out.WriteByte((byte)CheckResult.LAUNCHER_OK);
}
cclient.SendPacket(Out);
}
public static void F_GUILD_COMMAND(BaseClient client, PacketIn packet)
{
GameClient cclient = client as GameClient;
if (!cclient.IsPlaying() || !cclient.Plr.IsInWorld())
{
return;
}
Player Plr = cclient.Plr;
packet.Skip(2);
UInt16 Target = packet.GetUint16(); // ?
uint CharacterId = packet.GetUint32();
byte State = packet.GetUint8();
//Log.Info("state ",""+State);
switch (State)
{
case 1: // Accepted Invite
{
if (Plr.GldInterface.invitedTo == null)
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILD_INVITE_ERR_NOINVITE);
return;
}
Plr.GldInterface.Guild = Plr.GldInterface.invitedTo;
Plr.GldInterface.invitedTo = null;
Plr.GldInterface.Guild.JoinGuild(Plr);
} break;
case 2: // Declined Invite
{
Plr.GldInterface.invitedTo = null;
} break;
case 3: // Leave Guild
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
if (Plr.GldInterface.Guild.Info.LeaderId == Plr.CharacterId)
{
// wrong message
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_ALLIANCE_INVITE_ERROR);
return;
}
Guild_member GldMem = Plr.GldInterface.Guild.Info.Members[Plr.CharacterId];
Plr.GldInterface.Guild.LeaveGuild(GldMem, false);
} break;
case 5: // Promote
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
Plr.GldInterface.Guild.PromoteMember(Plr, CharacterId);
} break;
case 6: // Demote
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
Plr.GldInterface.Guild.DemoteMember(Plr, CharacterId);
} break;
case 7: // Assign as leader
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
Plr.GldInterface.Guild.AssignLeader(Plr, CharacterId);
} break;
case 9: // Guild NPC
{
PacketOut Out = new PacketOut((byte)Opcodes.F_INTERACT_RESPONSE, 4);
Out.WriteByte(0x0e);
Out.WriteByte(1);
Out.WriteByte(1);
Out.WriteByte(0);
Plr.SendPacket(Out);
Log.Info("GUILd", "CREATE");
} break;
case 10: // Create guild
{
packet.Skip(1);
String name = packet.GetStringToZero();
if (Plr.GldInterface.IsInGuild())
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILDNPC_INVALIDREQ_GUILDED);
}
else if (Guild.GetGuild(name) != null)
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILDNPC_BAD_NAME);
}
else if (Plr.GmLevel > 0)
{
new GuildInvitation(Plr, name);
}
else if (Plr.WorldGroup == null)
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILDNPC_INVALIDREQ_NOTGROUPED);
}
else if (Plr.WorldGroup.GetLeader() != Plr)
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILDNPC_INVALIDREQ_NOTLEADER);
}
else if (!Plr.WorldGroup.HasMaxMembers)
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILDNPC_INVALIDREQ_NUMPLAYERS);
}
else
{
foreach (Player groupMember in Plr.WorldGroup.GetPlayerList())
{
if (groupMember.GldInterface.IsInGuild())
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILDNPC_INVALIDREQ_GUILDED);
return;
}
}
new GuildInvitation(Plr, name);
}
} break;
case 16: // Accepted Alliance Invite
{
if (Plr.GldInterface.AllianceinvitedTo > 0) // alli invite
{
Plr.GldInterface.Guild.JoinAlliance(Plr.GldInterface.AllianceinvitedTo);
Plr.GldInterface.AllianceinvitedTo = 0;
}
else if (Plr.GldInterface.AllianceFormGuildId > 0) // alli form
{
Plr.GldInterface.Guild.FormAlliance(Plr.GldInterface.AllianceFormName, Plr.GldInterface.AllianceFormGuildId);
Plr.GldInterface.AllianceFormGuildId = 0;
Plr.GldInterface.AllianceFormName = "";
}
else
{
Plr.SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_USER_ERROR, GameData.Localized_text.TEXT_GUILD_INVITE_ERR_NOINVITE);
return;
}
}
break;
case 17: // Declined Alliance Invite
{
//CharMgr.GetCharacter().SendLocalizeString("", ChatLogFilters.CHATLOGFILTERS_SAY, GameData.Localized_text.TEXT_ALLIANCE_INVITE_DECLINED);
Plr.GldInterface.AllianceinvitedTo = 0;
}
break;
case 21: // buy tactic
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(1);
string spell = packet.GetStringToZero();
Plr.GldInterface.Guild.TrainGuildTactics((byte)CharacterId, ushort.Parse(spell));
} break;
case 22: // calendar create
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(156);
UInt32 begin = packet.GetUint32();
UInt32 end = packet.GetUint32();
String name = packet.GetPascalString();
String description = packet.GetPascalString();
byte alliance = packet.GetUint8();
byte locked = packet.GetUint8();
Plr.GldInterface.Guild.CreateEvent(Plr.GetPlayer().CharacterId, begin, end, name, description, alliance, locked);
} break;
case 23: // calendar save
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(151);
byte eventid = packet.GetUint8();
uint guildid = packet.GetUint32R();
UInt32 begin = packet.GetUint32();
UInt32 end = packet.GetUint32();
String name = packet.GetPascalString();
String description = packet.GetPascalString();
byte alliance = packet.GetUint8();
byte locked = packet.GetUint8();
Plr.GldInterface.Guild.EventEdit(Plr, eventid, guildid, begin, end, name, description, alliance, locked);
}
break;
case 24: // calendar delete
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(151);
byte eventid = packet.GetUint8();
uint guildid = packet.GetUint32R();
Plr.GldInterface.Guild.DeleteEvent(Plr, eventid, guildid);
}
break;
case 25: // calendar signup
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(151);
byte eventid = packet.GetUint8();
uint guildid = packet.GetUint32R();
Plr.GldInterface.Guild.EventSignup(Plr, eventid, guildid);
}
break;
case 26: // calendar signup cancel
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(151);
byte eventid = packet.GetUint8();
uint guildid = packet.GetUint32R();
Plr.GldInterface.Guild.EventSignupCancel(Plr, eventid, guildid);
}
break;
case 27: // calendar signup kick
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(151);
byte eventid = packet.GetUint8();
uint guildid = packet.GetUint32R();
uint characterid = packet.GetUint32R();
Plr.GldInterface.Guild.EventSignupKick(Plr, eventid, guildid, characterid);
}
break;
case 28: // calendar signup approved
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(151);
byte eventid = packet.GetUint8();
uint guildid = packet.GetUint32R();
uint charid = packet.GetUint32R();
Plr.GldInterface.Guild.EventSignupApproved(Plr, eventid, guildid, charid);
}
break;
case 29: // banner save
{
packet.Skip(151);
byte banner = packet.GetUint8();
byte post = packet.GetUint8();
packet.Skip(1);
ushort spell1 = packet.GetUint16R();
packet.Skip(2);
ushort spell2 = packet.GetUint16R();
packet.Skip(2);
ushort spell3 = packet.GetUint16R();
Plr.GldInterface.Guild.SaveBanner((byte)(banner - 1), post, spell1, spell2, spell3);
} break;
case 30: // reserve banner
{
packet.Skip(151);
ushort emblem = packet.GetUint16R();
ushort pattern = packet.GetUint16R();
byte color1 = packet.GetUint8();
byte color2 = packet.GetUint8();
byte shape = packet.GetUint8();
Plr.GldInterface.Guild.ReserveBanner(Plr, emblem, pattern, color1, color2, shape);
} break;
case 37: //close guild vault
{
Plr.GldInterface.Guild.GuildVaultClosed(Plr);
} break;
case 38: // Drop item to guild vault
{
packet.Skip(151);
byte sourceVault = packet.GetUint8(); // will be > 0 if item transfer from player to vault
ushort itemSlot = packet.GetUint16R();
packet.Skip(2);
byte destVault = packet.GetUint8();
ushort slot = packet.GetUint16R();
//Log.Info("slot", "" + slot + " vault " + Vault+" unk:"+Itemslot);
if (sourceVault != 0 && destVault != 0)
{
Plr.GldInterface.Guild.MoveVaultItem(Plr, sourceVault, itemSlot, destVault, slot);
}
else if (sourceVault == 0)
{
Plr.GldInterface.Guild.DepositVaultItem(Plr, destVault, slot, itemSlot);
}
else
{
Plr.GldInterface.Guild.WithdrawVaultItem(Plr, sourceVault, itemSlot, slot);
}
} break;
case 39: // Deposit money to guild vault
{
packet.Skip(151);
uint Money = packet.GetUint32R();
Plr.GldInterface.Guild.DepositMoney(Plr, Money);
} break;
case 40: // Withdraw money to guild vault
{
packet.Skip(151);
uint Money = packet.GetUint32R();
Plr.GldInterface.Guild.WithdrawMoney(Plr, Money);
} break;
case 41: // Lock item in guild vault
{
packet.Skip(151);
byte Vault = packet.GetUint8();
byte slot = packet.GetUint8();
// Log.Info("slot", "" + slot + " vault " + Vault);
Plr.GldInterface.Guild.LockVaultItem(Plr, Vault, slot, 0);
} break;
case 42: // cancel guild vault item move
{
packet.Skip(151);
byte Vault = packet.GetUint8();
byte slot = packet.GetUint8();
// Log.Info("slot", "" + slot + " vault " + Vault);
Plr.GldInterface.Guild.ReleaseVaultItemLock(Plr, Vault, slot);
} break;
case 46: // Update recruit page save
{
if (!Plr.GldInterface.IsInGuild())
{
return;
}
packet.Skip(152);
String BriefDescription = packet.GetPascalString(); //might be ushort for size
String Summary = packet.GetString(packet.GetUint16());
byte PlayStyle = packet.GetUint8();
byte Atmosphere = packet.GetUint8();
uint CareersNeeded = packet.GetUint32();
packet.Skip(3);
byte RanksNeeded = packet.GetUint8();
packet.Skip(3);
byte Interests = packet.GetUint8();
packet.Skip(3);
byte ActivelyRecruiting = packet.GetUint8();
//packet.Skip(6);
Plr.GldInterface.Guild.SetRecruitmentInfo(BriefDescription, Summary, PlayStyle, Atmosphere, CareersNeeded, RanksNeeded, Interests, ActivelyRecruiting);
} break;
case 47: // Search guilds
{
packet.Skip(151);
byte Style = packet.GetUint8();
byte Atmosphere = packet.GetUint8();
packet.Skip(7);
byte MyLevelCareer = packet.GetUint8();
packet.Skip(2);
ushort Pop = packet.GetUint16();
packet.Skip(3);
byte Online = packet.GetUint8();
packet.Skip(3);
byte Rank = packet.GetUint8();
Plr.GldInterface.SendGuilds(Guild.GetGuilds(Plr.Realm, Style, Atmosphere, MyLevelCareer, Plr.Level, Plr.Info.Career, Pop, Online, Rank));
} break;
case 52: // guild tactic respec
{
Plr.GldInterface.Guild.GuildsTacticRespec(Plr);
} break;
case 53: // Buy Guild Vault Slot
{
packet.Skip(151);
byte Vault = packet.GetUint8();
uint Money = packet.GetUint32R();
// Log.Info("", "vault " + Vault+" prize"+Money);
Plr.GldInterface.Guild.BuyVaultSlot(Plr, Vault, Money);
} break;
}
}
public int HandlePacket(BaseClient client, PacketIn packet)
{
(client as WorldClient).Send(new ANS_GROUP_LIST(packet.GetUint32()));
return 0;
}