public static void Handle(Entities.GameClient client, DataPacket packet) { using (var arenaplayers = new ArenaPlayersPacket(Data.ArenaQualifier.GetTop10())) { client.Send(arenaplayers); } }
public static void Handle(Entities.GameClient client, DataPacket packet) { /*using (var watch = new ArenaWatchPacket(packet)) { Entities.GameClient Fighter; if (Core.Kernel.Clients.TrySelect(watch.EntityUID, out Fighter)) { if (Fighter.Battle == null) return; if (!(Fighter.Battle is Data.ArenaMatch)) return; Data.ArenaMatch Match = Fighter.Battle as Data.ArenaMatch; switch (watch.Type) { case 0: { Match.JoinAsWatcher(client); //client.Send(packet); break; } case 1: { Match.LeaveWatcher(client); break; } } } }*/ }
public static void Handle(Entities.GameClient client, DataPacket inPacket) { if (client.Trade.Trading) return; if (!client.Alive) return; using (var npcrequest = new NPCRequestPacket(inPacket)) { try { if (npcrequest.Option == 255) { client.CurrentNPC = null; return; } if (Core.Kernel.Shops.ContainsKey(npcrequest.NPCID)) { if (!Core.Kernel.Shops[npcrequest.NPCID].AssociatedNPC.IsInMap(client)) { return; } Packets.GeneralDataPacket pack = new Packets.GeneralDataPacket(); pack.Action = Enums.DataAction.OpenUpgrade; pack.Id = client.EntityUID; pack.Data1 = 32; pack.Data3Low = client.X; pack.Data3High = client.Y; pack.Timestamp = npcrequest.NPCID; client.Send(pack); } else { Entities.NPC npc = Core.Kernel.NPCs[npcrequest.NPCID]; if (!npc.IsInMap(client)) { return; } if (Core.Screen.GetDistance(client.X, client.Y, npc.X, npc.Y) >= Core.NumericConst.MaxNPCDistance && npc.NPCType != Enums.NPCType.Distance) { using (var fmsg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.TOO_FAR_NPC)) client.Send(fmsg); return; } client.CurrentNPC = npc; client.CurrentNPC.CallDialog(client, npcrequest.Option); } } catch { using (var fmsg = Packets.Message.MessageCore.CreateSystem(client.Name, string.Format("NPCID: {0}", npcrequest.NPCID))) client.Send(fmsg); } } }
public NPCResponsePacket(DataPacket inPacket) : base(inPacket) { string[] stringdata = StringPacker.Analyze(this, 12); if (stringdata.Length > 0) InputData = stringdata[0]; else InputData = string.Empty; }
public MessagePacket(DataPacket inPacket) : base(inPacket) { string[] strings = StringPacker.Analyze(inPacket, 24); From = strings[0]; To = strings[1]; Unknown = strings[2]; Message = strings[3]; }
/// <summary> /// Creates a new instance of StringPacker. /// </summary> /// <param name="strings">The strings to add.</param> public StringPacker(params string[] strings) { int totallength = strings.Length + 1; foreach (string str in strings) totallength += str.Length; stringPacket = new DataPacket(new byte[totallength]); stringPacket.WriteByte((byte)strings.Length, 0); int nextoffset = 1; foreach (string str in strings) { stringPacket.WriteStringWithLength(str, nextoffset, out nextoffset); } }
public static void Handle(Entities.GameClient client, DataPacket packet) { if (client.Guild == null) return; using (var donation = new GuildDonationPacket()) { donation.DonationFlag = Enums.GuildDonationFlags.AllDonations; donation.Money = client.GuildMemberInfo.MoneyDonation; donation.CPs = client.GuildMemberInfo.CPDonation; client.Send(donation); } }
/// <summary> /// Analyzes a stringpacker within a packet. /// </summary> /// <param name="Packet">The packet.</param> /// <param name="offset">The offset.</param> /// <returns>Returns the strings.</returns> public static string[] Analyze(DataPacket Packet, int offset) { int count = Packet.ReadByte(offset); offset++; string[] strings = new string[count]; for (int i = 0; i < count; i++) { strings[i] = Packet.ReadStringFromLength(offset, out offset); } return strings; }
public static void Handle(Entities.GameClient client, DataPacket packet) { using (var warehouse = new WarehousePacket(packet)) { Data.Warehouse wh; if (client.Warehouses.TryGetValue((ushort)warehouse.WarehouseID, out wh)) { switch (warehouse.Action) { case Enums.WarehouseAction.Display: { wh.SendAll(); break; } case Enums.WarehouseAction.Add: { if (wh.FreeSpaces == 20) return; if (client.Inventory.ContainsByUID(warehouse.Identifier)) { Data.ItemInfo item = client.Inventory.RemoveItemByUID(warehouse.Identifier); if (item != null) { wh.AddItem(item); } } break; } case Enums.WarehouseAction.Remove: { if (client.Inventory.FreeSpaces == 40) return; if (wh.ContainsByUID(warehouse.Identifier)) { Data.ItemInfo item = wh.RemoveItemByUID(warehouse.Identifier); if (item != null) { client.Inventory.AddItem(item); //warehouse.WhType = 10; client.Send(warehouse); } } break; } } } } }
public static void Handle(Entities.GameClient client, DataPacket packet) { using (var subclass = new SubClassPacket(packet)) { switch (subclass.Action) { case Enums.SubClassActions.Info: { //client.SendSubClasses2(); break; } } } }
public static void Handle(Entities.GameClient client, DataPacket packet) { using (var strings = new StringPacket(packet)) { switch (strings.Action) { case Enums.StringAction.WhisperWindowInfo: Packets.Strings.WhisperWindowInfo.Handle(client, strings); break; case Enums.StringAction.QueryMate: Packets.Strings.QueryMate.Handle(client, strings); break; default: Console.WriteLine("Unknown StringPacket {0} from {1}", strings.Action, client.Name); break; } } }
public static void Handle(Entities.GameClient client, DataPacket packet) { Console.WriteLine("TYPE: {0}", packet.ReadByte(4)); if (packet.ReadByte(4) > 2) { string[] Strings = StringPacker.Analyze(packet, 12); if (Strings != null) { if (Strings.Length > 0) { if (client.CPs >= 5) { client.CPs -= 5; Threads.BroadcastThread.AddBroadcast(Packets.Message.MessageCore.CreateBroadcast(client.Name, Strings[0])); } } } } }
/// <summary> /// Handling all packets received. /// </summary> /// <param name="socketClient">The socket client.</param> /// <param name="Packet">The packet.</param> public static bool Handle_Receive(SocketClient socketClient, DataPacket Packet) { try { Client.AuthClient client = socketClient.Owner as Client.AuthClient; switch (Packet.PacketID) { case Packets.PacketType.AuthRequestPacket1: case Packets.PacketType.AuthRequestPacket2: Packets.AuthRequestPacket.Handle(client, Packet); break; } } catch (Exception e) { Console.WriteLine(e.ToString()); } return true; }
public static void Handle(Entities.GameClient client, DataPacket packet) { if (client.Guild == null) return; using (var info = new GuildMemberListPacket(packet)) { Data.GuildMember[] members = client.Guild.SelectFromIndex(info.StartIndex); using (var sinfo = new GuildMemberListPacket(members.Length)) { foreach (Data.GuildMember member in members) sinfo.AddInfo(GuildMemberInfo.Create(member)); int offset = 16; foreach (GuildMemberInfo minfo in sinfo.MemberList) { minfo.Append(sinfo, offset, out offset); } client.Send(sinfo); } } }
public StringPacket(DataPacket inPacket) : base(inPacket) { Strings = StringPacker.Analyze(inPacket, 9); }
public static void Handle(Entities.GameClient client, DataPacket packet) { using (var composition = new CompositionPacket(packet)) { if (!client.Inventory.ContainsByUID(composition.MainItem)) { using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.ITEM_NOT_FOUND)) client.Send(msg); return; } if (!client.Inventory.ContainsByUID(composition.MinorItem)) { using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.ITEM_NOT_FOUND)) client.Send(msg); return; } Data.ItemInfo MainItem = client.Inventory.GetItemByUID(composition.MainItem); if (MainItem.IsGarment() || MainItem.IsArrow() || MainItem.IsBottle() || MainItem.IsMisc() || MainItem.IsMountArmor()) { using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.ITEM_INVALID_UPGRADE)) client.Send(msg); return; } if (MainItem.CurrentDura < MainItem.MaxDura) { using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.ITEM_LOW_DURA)) client.Send(msg); return; } Data.ItemInfo MinorItem = client.Inventory.GetItemByUID(composition.MinorItem); if (MainItem.Plus >= Core.NumericConst.MaxPlus) { using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.ITEM_MAX_PLUS)) client.Send(msg); return; } if (MinorItem.Plus == 0) { using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.ITEM_NO_PLUS)) client.Send(msg); return; } if (MinorItem.Plus < MainItem.Plus) { using (var msg = Packets.Message.MessageCore.CreateSystem(client.Name, Core.MessageConst.ITEM_LOW_PLUS)) client.Send(msg); return; } //ushort[] CompositionPoints = new ushort[12] { 20, 20, 80, 240, 720, 2160, 6480, 19440, 58320, 2700, 5500, 9000 }; //ushort AddPoints = (CompositionPoints[MainItem.Plus] / 2); switch (composition.CompositionType) { case Enums.CompositionType.SteedComposition: { int color1 = (int)MainItem.SocketAndRGB; int color2 = (int)MinorItem.SocketAndRGB; int B1 = color1 & 0xFF; int B2 = color2 & 0xFF; int G1 = (color1 >> 8) & 0xFF; int G2 = (color2 >> 8) & 0xFF; int R1 = (color1 >> 16) & 0xFF; int R2 = (color2 >> 16) & 0xFF; int newB = (int)Math.Floor(0.9 * B1) + (int)Math.Floor(0.1 * B2); int newG = (int)Math.Floor(0.9 * G1) + (int)Math.Floor(0.1 * G2); int newR = (int)Math.Floor(0.9 * R1) + (int)Math.Floor(0.1 * R2); uint NewColor = (uint)(newB | (newG << 8) | (newR << 16)); if (NewColor == MainItem.SocketAndRGB) return; MainItem.SocketAndRGB = NewColor; goto case Enums.CompositionType.BonusCompositionA; } case Enums.CompositionType.BonusCompositionA: case Enums.CompositionType.BonusCompositionB: { //uint CompositionPoints = Calculations.BasicCalculations.CompositionPoints(MinorItem.Plus); client.Inventory.RemoveItemByUID(MinorItem.UID); if (MainItem.Composition > 0) { MainItem.Plus++; MainItem.Composition = 0; } else { MainItem.Composition = 1; } Database.CharacterDatabase.SaveInventory(client, MainItem, client.Inventory.GetPositionFromItemUID(MainItem.UID)); MainItem.SendPacket(client, 3); break; } } } }
public CompositionPacket(DataPacket inPacket) : base(inPacket) { }
/// <summary> /// Empty method for the buffer events. /// </summary> /// <param name="sClient">The socket client.</param> /// <param name="packet">The data packet.</param> /// <returns>Returns true always.</returns> static bool empty_buff(SocketClient sClient, DataPacket packet) { return true; }
public GuildMemberListPacket(DataPacket inPacket) : base(inPacket) { }
public ArenaActionPacket(DataPacket inPacket) : base(inPacket) { }
public void Append(DataPacket buffer, int offset, out int nextoffset) { nextoffset = offset; buffer.WriteString(Name, offset); buffer.WriteUInt32(Unknown16, offset + 16); buffer.WriteUInt32(Unknown20, offset + 20); buffer.WriteUInt32(Level, offset + 24); buffer.WriteUInt16((ushort)Rank, offset + 28); buffer.WriteUInt16(Unknown30, offset + 30); buffer.WriteUInt32(Unknown32, offset + 32); buffer.WriteInt32(Donation, offset + 36); buffer.WriteBool(IsOnline, offset + 40); buffer.WriteUInt32(Unknown44, offset + 44); nextoffset += 48; }
public ArenaWatchPacket(DataPacket inPacket) : base(inPacket) { }
public static void Handle(Entities.GameClient client, DataPacket packet) { using (var stats = new CharacterStatsPacket(packet)) { if (stats.EntityUID != client.EntityUID) { Entities.GameClient viewclient; if (Core.Kernel.Clients.TrySelect(stats.EntityUID, out viewclient)) client.Send(viewclient.CreateStatsPacket()); } else client.Send(client.CreateStatsPacket()); } }
/// <summary> /// Sends a packet to the client. /// </summary> /// <param name="Packet">The packet to send.</param> public void Send(DataPacket Packet) { if (IsAIBot) return; // TODO: rewrite the sockets to actually handle this proper ... if (Packet.ReadString(Packet.BufferLength - 8, 8) == "TQClient") // this is actually never used, not removing it though just to be sure { using (var sendPacket = new DataPacket(Packet)) { sendPacket.WriteBytes(Packet.Copy(), 0); sendPacket.WriteString("TQServer", sendPacket.BufferLength - 8); NetworkClient.Send(sendPacket); } } else { using (var sendPacket = new DataPacket(new byte[Packet.BufferLength + 8])) { sendPacket.WriteBytes(Packet.Copy(), 0); sendPacket.WriteString("TQServer", sendPacket.BufferLength - 8); NetworkClient.Send(sendPacket); } } }
public CharacterStatsPacket(DataPacket inPacket) : base(inPacket) { }
/// <summary> /// Handles the message packet. /// </summary> /// <param name="client">The client.</param> /// <param name="packet">The packet.</param> public static void Handle(Entities.GameClient client, DataPacket packet) { using (var message = new MessagePacket(packet)) { if (message.Message.StartsWith("/") && !message.Message.StartsWith("//") || message.Message.StartsWith("@") && !message.Message.StartsWith("@@")) { Packets.Message.Commands.Handle(client, message.Message, message.Message.Split(' ')); } else { if (message.ChatType != Enums.ChatType.Team && !client.Alive && message.ChatType != Enums.ChatType.Ghost) return; if (message.From != client.Name) { client.NetworkClient.Disconnect("INVALID_CHAT_NAME"); return; } switch (message.ChatType) { #region Whisper case Enums.ChatType.Whisper: { if (message.To == client.Name) return; Entities.GameClient toclient; if (Core.Kernel.Clients.TrySelect(message.To, out toclient)) { message.FromMesh = client.Mesh; message.ToMesh = toclient.Mesh; toclient.Send(message); } else { if (Database.CharacterDatabase.CharacterExists(message.To))//(System.IO.File.Exists(Database.ServerDatabase.DatabaseLocation + "\\UsedNames\\" + message.To + ".nm")) { using (var fmsg = Packets.Message.MessageCore.CreateSystem( client.Name, string.Format(Core.MessageConst.PLAYER_OFFLINE_WHISPER, message.To))) client.Send(fmsg); ProjectX_V3_Lib.IO.IniFile whisper = new ProjectX_V3_Lib.IO.IniFile( Database.ServerDatabase.DatabaseLocation + "\\MessageQuery\\" + message.To + ".ini", "Whisper"); int count = whisper.ReadInt32("Count", 0); count++; whisper.Write<int>("Count", count); whisper.SetSection(count.ToString()); whisper.WriteString("From", client.Name); whisper.WriteString("Message", message.Message); whisper.Write<uint>("Mesh", client.Mesh); } else { using (var fmsg = Packets.Message.MessageCore.CreateSystem( client.Name, string.Format(Core.MessageConst.PLAYER_OFFLINE_WHISPER2, message.To))) client.Send(fmsg); } } break; } #endregion #region Talk + Ghost case Enums.ChatType.Talk: case Enums.ChatType.Ghost: { client.SendToScreen(message, false, message.ChatType == Enums.ChatType.Ghost); break; } #endregion #region World case Enums.ChatType.World: { if (client.Level < 70) { using (var fmsg = Packets.Message.MessageCore.CreateSystem( client.Name, Core.MessageConst.WORLD_CHAT_NO_PERMISSION)) client.Send(fmsg); return; } int required = 60000; if (client.Level >= 100) required = 45000; if (client.Level >= 110) required = 30000; if (client.Level >= 120) required = 15000; if (DateTime.Now >= client.WorldChatSend.AddMilliseconds(required)) { client.WorldChatSend = DateTime.Now; foreach (Entities.GameClient sclient in Core.Kernel.Clients.selectorCollection1.Values) { if (sclient.EntityUID != client.EntityUID) sclient.Send(message); } } else { using (var fmsg = Packets.Message.MessageCore.CreateSystem( client.Name, string.Format(Core.MessageConst.WORLD_CHAT_WAIT, required))) client.Send(fmsg); } break; } #endregion #region Guild case Enums.ChatType.Guild: { if (client.Guild != null) { client.Guild.BroadcastMessage(message); } break; } #endregion #region Hawk case Enums.ChatType.HawkMessage: { if (client.Booth == null) return; client.Booth.HawkMessage = message.Message; break; } #endregion #region Team case Enums.ChatType.Team: { if (client.TournamentTeam != null) { foreach (Entities.GameClient teamMember in client.TournamentTeam.TeamMembers.ToDictionary().Values) { teamMember.Send(message); } } else if (client.Team != null) { foreach (Entities.GameClient teamMember in client.Team.Members.Values) { teamMember.Send(message); } } break; } #endregion } } } }
/// <summary> /// Handles all packets received by the game auth server. /// </summary> /// <param name="client">The socket client.</param> /// <param name="Packet">The packet.</param> /// <returns>ALWAYS returns false.</returns> private static bool HandlePacket(SocketClient client, DataPacket Packet) { if (Packet.PacketID == 9001) { if (Packet.ReadString(4, 16) == Program.Config.ReadString("ServerPassword")) { string Account = Packet.ReadString(20, 16); int DatabaseUID = Packet.ReadInt32(36); if (DatabaseUID == 0) return false; uint EntityUID = Packet.ReadUInt32(40); if (EntityUID == 0) return false; if (Core.Kernel.Clients.Contains(EntityUID)) { UIDCollection.TryRemove(EntityUID); return false; } if (UIDCollection.Contains(EntityUID)) { int secondkey; if (UIDCollection.TryGetSecondKey(EntityUID, out secondkey)) { if (DatabaseUID == secondkey) UIDCollection.TryRemove(EntityUID); } return false; } if (UIDCollection.Contains(DatabaseUID)) { uint firstkey; if (UIDCollection.TryGetFirstKey(DatabaseUID, out firstkey)) { UIDCollection.TryRemove(DatabaseUID); } } UIDCollection.TryAdd(EntityUID, DatabaseUID, DateTime.Now.AddMinutes(10)); // return false; } } return false; }
public WarehousePacket(DataPacket inPacket) : base(inPacket) { }
/// <summary> /// Sends a packet to all nearby clients. /// </summary> /// <param name="Packet">The packet to send.</param> /// <param name="sendtoself">True if send to itself.</param> public void SendToScreen(DataPacket Packet, bool sendtoself, bool deadonly = false) { if (sendtoself && !IsAIBot) Send(Packet); // send to screen Screen.UpdateScreen(Packet, deadonly); // Update will send a packet if there is any packets attached to it }
public static void Handle(Entities.GameClient client, DataPacket packet) { using (var action = new ArenaActionPacket(packet)) { switch (action.DialogID) { case 0: { Data.ArenaQualifier.JoinArena(client); client.Send(action); break; } case 1: { Data.ArenaQualifier.QuitWaitArena(client); client.Send(action); break; } case 3: { if (action.OptionID == 1) { Data.ArenaQualifier.AcceptArena(client); } else if (action.OptionID == 2) { Data.ArenaQualifier.GiveUpArena(client); } break; } case 4: { Data.ArenaQualifier.QuitArena(client); break; } case 10: case 11: { if (action.OptionID == 0) { Data.ArenaQualifier.JoinArena(client); } break; } default: Console.WriteLine("ARENA PACKET: {0} FROM {1}", action.DialogID, client.Name); break; } } }