Reorganized the packets to follow the format the map server follows.

2025-05-20 08:26:59 -04:00 · 2016-02-18 23:55:03 -05:00
parent 8c73f6e926
commit 23dcc1dafe
14 changed files with 141 additions and 103 deletions
--- a/FFXIVClassic_Lobby_Server/packets/send/AccountListPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/AccountListPacket.cs
@@ -0,0 +1,99 @@
+using FFXIVClassic_Lobby_Server.dataobjects;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class AccountListPacket
+    {
+        public const ushort OPCODE = 0x0C;
+        public const ushort MAXPERPACKET = 8;
+
+        private UInt64 sequence;
+        private List<Account> accountList;
+
+        public AccountListPacket(UInt64 sequence, List<Account> accountList)
+        {
+            this.sequence = sequence;
+            this.accountList = accountList;
+        }        
+
+        public List<SubPacket> buildPackets()
+        {
+            List<SubPacket> subPackets = new List<SubPacket>();
+
+            int accountCount = 0;
+            int totalCount = 0;
+
+            MemoryStream memStream = null;
+            BinaryWriter binWriter = null;
+
+            foreach (Account account in accountList)
+            {
+                if (totalCount == 0 || accountCount % MAXPERPACKET == 0)
+                {
+                    memStream = new MemoryStream(0x280);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(accountList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write(accountList.Count - totalCount <= MAXPERPACKET ? (UInt32)(accountList.Count - totalCount) : (UInt32)MAXPERPACKET);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                //Write Entries
+                binWriter.Write((UInt32)account.id);
+                binWriter.Write((UInt32)0);
+                binWriter.Write(Encoding.ASCII.GetBytes(account.name.PadRight(0x40, '\0')));
+
+                accountCount++;
+                totalCount++;
+
+                //Send this chunk of world list
+                if (accountCount >= MAXPERPACKET)
+                {
+                    byte[] data = memStream.GetBuffer();
+                    binWriter.Dispose();
+                    memStream.Dispose();
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    subPackets.Add(subpacket);
+                    accountCount = 0;
+                }
+
+            }
+
+            //If there is anything left that was missed or the list is empty
+            if (accountCount > 0 || accountList.Count == 0)
+            {
+                if (accountList.Count == 0)
+                {
+                    memStream = new MemoryStream(0x210);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write Empty List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(accountList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write((UInt32)0);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                byte[] data = memStream.GetBuffer();
+                binWriter.Dispose();
+                memStream.Dispose();
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                subPackets.Add(subpacket);
+            }
+
+            return subPackets;
+        }
+    }
+}
--- a/FFXIVClassic_Lobby_Server/packets/send/CharaCreatorPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/CharaCreatorPacket.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class CharaCreatorPacket
+    {
+        public const ushort OPCODE = 0x0E;
+
+        public const ushort RESERVE = 0x01;
+        public const ushort MAKE = 0x02;
+        public const ushort RENAME = 0x03;
+        public const ushort DELETE = 0x04;
+        public const ushort RENAME_RETAINER = 0x06;
+
+        private UInt64 sequence;
+
+        private ushort command;
+        private uint pid;
+        private uint cid;
+        private uint type;
+        private uint ticket;
+        private string charaName;
+        private string worldName;
+
+        public CharaCreatorPacket(UInt64 sequence, ushort command, uint pid, uint cid, uint ticket, string charaName, string worldName)
+        {
+            this.sequence = sequence;
+            this.command = command;
+            this.pid = pid;
+            this.cid = cid;
+            this.type = 0x400017;
+            this.ticket = ticket;
+            this.charaName = charaName; 
+            this.worldName = worldName;
+        }        
+
+        public SubPacket buildPacket()    
+        {
+            MemoryStream memStream = new MemoryStream(0x1F0);
+            BinaryWriter binWriter = new BinaryWriter(memStream);
+
+            binWriter.Write((UInt64)sequence);
+            binWriter.Write((byte)1);
+            binWriter.Write((byte)1);
+            binWriter.Write((UInt16)command);
+            binWriter.Write((UInt32)0);
+
+            binWriter.Write((UInt32)pid); //PID
+            binWriter.Write((UInt32)cid); //CID
+            binWriter.Write((UInt32)type); //Type?
+            binWriter.Write((UInt32)ticket); //Ticket
+            binWriter.Write(Encoding.ASCII.GetBytes(charaName.PadRight(0x20, '\0'))); //Name
+            binWriter.Write(Encoding.ASCII.GetBytes(worldName.PadRight(0x20, '\0'))); //World Name
+
+            byte[] data = memStream.GetBuffer();
+            binWriter.Dispose();
+            memStream.Dispose();
+
+            return new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+        }
+    }
+}
--- a/FFXIVClassic_Lobby_Server/packets/send/CharacterListPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/CharacterListPacket.cs
@@ -0,0 +1,157 @@
+using FFXIVClassic_Lobby_Server.dataobjects;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class CharacterListPacket
+    {
+        public const ushort OPCODE = 0x0D;
+        public const ushort MAXPERPACKET = 2;
+
+        private ulong sequence;
+        private List<Character> characterList;
+
+        public CharacterListPacket(ulong sequence, List<Character> characterList)
+        {
+            this.sequence = sequence;
+            this.characterList = characterList;
+        }        
+
+        public List<SubPacket> buildPackets()
+        {
+            List<SubPacket> subPackets = new List<SubPacket>();
+
+            int numCharacters = characterList.Count >= 8 ? 8 : characterList.Count + 1;
+
+            int characterCount = 0;
+            int totalCount = 0;
+
+            MemoryStream memStream = null;
+            BinaryWriter binWriter = null;
+
+            foreach (Character chara in characterList)
+            {
+                Appearance appearance = Database.getAppearance(chara.id);
+
+                if (totalCount == 0 || characterCount % MAXPERPACKET == 0)
+                {
+                    memStream = new MemoryStream(0x3B0);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(numCharacters - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write(numCharacters - totalCount <= MAXPERPACKET ? (UInt32)(numCharacters - totalCount) : (UInt32)MAXPERPACKET);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                binWriter.Seek(0x10 + (0x1D0 * characterCount), SeekOrigin.Begin);
+
+                //Write Entries
+                World world = Database.getServer(chara.serverId);
+                string worldname = world == null ? "Unknown" : world.name;
+
+                binWriter.Write((uint)0); //???
+                binWriter.Write((uint)chara.id); //Character Id            
+                binWriter.Write((byte)(totalCount)); //Slot
+
+                byte options = 0;
+                if (chara.state == 1)
+                    options |= 0x01;
+                if (chara.doRename)
+                    options |= 0x02;
+                if (chara.isLegacy)
+                    options |= 0x08;
+                
+                binWriter.Write((byte)options); //Options (0x01: Service Account not active, 0x72: Change Chara Name) 
+                binWriter.Write((ushort)0);  
+                binWriter.Write((uint)0xF4); //Logged out zone
+                binWriter.Write(Encoding.ASCII.GetBytes(chara.name.PadRight(0x20, '\0'))); //Name
+                binWriter.Write(Encoding.ASCII.GetBytes(worldname.PadRight(0xE, '\0'))); //World Name
+
+                binWriter.Write(CharaInfo.buildForCharaList(chara, appearance)); //Appearance Data
+                //binWriter.Write(CharaInfo.debug()); //Appearance Data
+                
+                characterCount++;
+                totalCount++;                
+
+                //Send this chunk of character list
+                if (characterCount >= MAXPERPACKET)
+                {
+                    byte[] data = memStream.GetBuffer();
+                    binWriter.Dispose();
+                    memStream.Dispose();
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    subPackets.Add(subpacket);
+                    characterCount = 0;
+                }                
+
+                //Incase DB came back with more than max
+                if (totalCount >= 8)
+                    break;
+            }
+
+            //Add a 'NEW' slot if there is space
+            if (characterList.Count < 8)
+            {
+                if (characterCount % MAXPERPACKET == 0)
+                {
+                    memStream = new MemoryStream(0x3B0);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(numCharacters - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write(numCharacters - totalCount <= MAXPERPACKET ? (UInt32)(numCharacters-totalCount) : (UInt32)MAXPERPACKET);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                binWriter.Seek(0x10 + (0x1D0 * characterCount), SeekOrigin.Begin);
+
+                //Write Entries
+                binWriter.Write((uint)0); //???
+                binWriter.Write((uint)0); //Character Id            
+                binWriter.Write((byte)(totalCount)); //Slot
+                binWriter.Write((byte)0); //Options (0x01: Service Account not active, 0x72: Change Chara Name) 
+                binWriter.Write((ushort)0);
+                binWriter.Write((uint)0); //Logged out zone
+
+                characterCount++;
+                totalCount++;
+
+                //Send this chunk of character list
+                if (characterCount >= MAXPERPACKET)
+                {
+                    byte[] data = memStream.GetBuffer();
+                    binWriter.Dispose();
+                    memStream.Dispose();
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    subPackets.Add(subpacket);
+                    characterCount = 0;
+                }
+            }
+
+            //If there is anything left that was missed or the list is empty
+            if (characterCount > 0 || numCharacters == 0)
+            {                
+                byte[] data = memStream.GetBuffer();
+                binWriter.Dispose();
+                memStream.Dispose();
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                subPackets.Add(subpacket);
+            }
+
+            return subPackets;
+        }
+    }
+}
--- a/FFXIVClassic_Lobby_Server/packets/send/ErrorPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/ErrorPacket.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class ErrorPacket
+    {
+        private const ushort OPCODE = 0x02;
+
+        private UInt64 sequence;
+        private uint errorCode;
+        private uint statusCode;
+        private uint textId;
+        private string message;
+
+        public ErrorPacket(UInt64 sequence, uint errorCode, uint statusCode, uint textId, string message)
+        {
+            this.sequence = sequence;
+            this.errorCode = errorCode;
+            this.statusCode = statusCode;
+            this.textId = textId;
+            this.message = message;
+        }
+
+        public SubPacket buildPacket()
+        {
+            MemoryStream memStream = new MemoryStream(0x210);
+            BinaryWriter binWriter = new BinaryWriter(memStream);
+
+            binWriter.Write(sequence);
+            binWriter.Write(errorCode);
+            binWriter.Write(statusCode);
+            binWriter.Write(textId);
+            binWriter.Write(Encoding.ASCII.GetBytes(message));
+
+            byte[] data = memStream.GetBuffer();
+            binWriter.Dispose();
+            memStream.Dispose();
+            SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+            return subpacket;
+        }
+    }
+}
--- a/FFXIVClassic_Lobby_Server/packets/send/ImportListPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/ImportListPacket.cs
@@ -0,0 +1,103 @@
+using FFXIVClassic_Lobby_Server.dataobjects;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class ImportListPacket
+    {
+        public const ushort OPCODE = 0x16;
+        public const ushort MAXPERPACKET = 12;
+
+        private UInt64 sequence;
+        private List<String> namesList;
+
+        public ImportListPacket(UInt64 sequence, List<String> names)
+        {
+            this.sequence = sequence;
+            this.namesList = names;
+        }        
+
+        public List<SubPacket> buildPackets()
+        {
+            List<SubPacket> subPackets = new List<SubPacket>();
+
+            int namesCount = 0;
+            int totalCount = 0;
+
+            MemoryStream memStream = null;
+            BinaryWriter binWriter = null;
+
+            foreach (String name in namesList)
+            {
+                if (totalCount == 0 || namesCount % MAXPERPACKET == 0)
+                {
+                    memStream = new MemoryStream(0x210);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(namesList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write(namesList.Count - totalCount <= MAXPERPACKET ? (UInt32)(namesList.Count - totalCount) : (UInt32)MAXPERPACKET);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                //Write Entries
+                binWriter.Write((uint)0);
+                binWriter.Write((uint)totalCount);
+
+                if (!name.Contains(" "))
+                    binWriter.Write(Encoding.ASCII.GetBytes((name+" Last").PadRight(0x20, '\0')));
+                else
+                    binWriter.Write(Encoding.ASCII.GetBytes(name.PadRight(0x20, '\0')));
+
+                namesCount++;
+                totalCount++;
+
+                //Send this chunk of world list
+                if (namesCount >= MAXPERPACKET)
+                {
+                    byte[] data = memStream.GetBuffer();
+                    binWriter.Dispose();
+                    memStream.Dispose();
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    subPackets.Add(subpacket);
+                    namesCount = 0;
+                }
+
+            }
+
+            //If there is anything left that was missed or the list is empty
+            if (namesCount > 0 || namesList.Count == 0)
+            {
+                if (namesList.Count == 0)
+                {
+                    memStream = new MemoryStream(0x210);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write Empty List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(namesList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write((UInt32)0);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                byte[] data = memStream.GetBuffer();
+                binWriter.Dispose();
+                memStream.Dispose();
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                subPackets.Add(subpacket);
+            }
+
+            return subPackets;
+        }
+    }
+}
--- a/FFXIVClassic_Lobby_Server/packets/send/RetainerListPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/RetainerListPacket.cs
@@ -0,0 +1,104 @@
+using FFXIVClassic_Lobby_Server.dataobjects;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class RetainerListPacket
+    {
+        public const ushort OPCODE = 0x17;
+        public const ushort MAXPERPACKET = 9; 
+
+        private UInt64 sequence;
+        private List<Retainer> retainerList;
+
+        public RetainerListPacket(UInt64 sequence, List<Retainer> retainerList)
+        {
+            this.sequence = sequence;
+            this.retainerList = retainerList;
+        }        
+
+        public List<SubPacket> buildPackets()
+        {
+            List<SubPacket> subPackets = new List<SubPacket>();
+
+            int retainerCount = 0;
+            int totalCount = 0;
+
+            MemoryStream memStream = null;
+            BinaryWriter binWriter = null;
+
+            foreach (Retainer retainer in retainerList)
+            {
+                if (totalCount == 0 || retainerCount % MAXPERPACKET == 0)
+                {
+                    memStream = new MemoryStream(0x210);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(retainerList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write(retainerList.Count - totalCount <= MAXPERPACKET ? (UInt32)(retainerList.Count - totalCount) : (UInt32)MAXPERPACKET);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                    binWriter.Write((UInt64)0);
+                    binWriter.Write((UInt32)0);
+                }
+
+                //Write Entries
+                binWriter.Write((uint)retainer.id);
+                binWriter.Write((uint)retainer.characterId);
+                binWriter.Write((ushort)retainer.slot);
+                binWriter.Write((ushort)(retainer.doRename ? 0x04 : 0x00));
+                binWriter.Write((uint)0);
+                binWriter.Write(Encoding.ASCII.GetBytes(retainer.name.PadRight(0x20, '\0')));
+
+                retainerCount++;
+                totalCount++;
+
+                //Send this chunk of character list
+                if (retainerCount >= MAXPERPACKET)
+                {
+                    byte[] data = memStream.GetBuffer();
+                    binWriter.Dispose();
+                    memStream.Dispose();
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    subPackets.Add(subpacket);
+                    retainerCount = 0;
+                }
+
+            }
+
+            //If there is anything left that was missed or the list is empty
+            if (retainerCount > 0 || retainerList.Count == 0)
+            {
+                if (retainerList.Count == 0)
+                {
+                    memStream = new MemoryStream(0x210);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write Empty List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(retainerList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write((UInt32)0);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                byte[] data = memStream.GetBuffer();
+                binWriter.Dispose();
+                memStream.Dispose();
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                subPackets.Add(subpacket);
+            }
+
+            return subPackets;
+        }
+    }
+}
--- a/FFXIVClassic_Lobby_Server/packets/send/SelectCharacterConfirmPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/SelectCharacterConfirmPacket.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class SelectCharacterConfirmPacket
+    {
+        public const ushort OPCODE = 0x0F;
+
+        private UInt64 sequence;
+        private UInt32 characterId;
+        private string sessionToken;
+        private string worldIp;
+        private UInt16 worldPort;
+        private UInt64 selectCharTicket;
+
+        public SelectCharacterConfirmPacket(UInt64 sequence, UInt32 characterId, string sessionToken, string worldIp, ushort worldPort, UInt64 selectCharTicket)
+        {
+            this.sequence = sequence;
+            this.characterId = characterId;
+            this.sessionToken = sessionToken;
+            this.worldIp = worldIp;
+            this.worldPort = worldPort;
+            this.selectCharTicket = selectCharTicket;            
+        }        
+
+        public List<SubPacket> buildPackets()
+        {
+            List<SubPacket> subPackets = new List<SubPacket>();
+
+            byte[] data;
+            
+            using (MemoryStream memStream = new MemoryStream(0x98))
+            {
+                using (BinaryWriter binWriter = new BinaryWriter(memStream))
+                {
+                    binWriter.Write((UInt64)sequence);
+                    binWriter.Write((UInt32)characterId); //ActorId
+                    binWriter.Write((UInt32)characterId); //CharacterId
+                    binWriter.Write((UInt32)0);
+                    binWriter.Write(Encoding.ASCII.GetBytes(sessionToken.PadRight(0x42, '\0'))); //Session Token
+                    binWriter.Write((UInt16)worldPort); //World Port
+                    binWriter.Write(Encoding.ASCII.GetBytes(worldIp.PadRight(0x38, '\0'))); //World Hostname/IP
+                    binWriter.Write((UInt64)selectCharTicket); //Ticket or Handshake of somekind
+                }
+                data = memStream.GetBuffer();
+            }
+            
+            SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+            subPackets.Add(subpacket);
+            
+            return subPackets;
+        }
+    }
+}
--- a/FFXIVClassic_Lobby_Server/packets/send/WorldListPacket.cs
+++ b/FFXIVClassic_Lobby_Server/packets/send/WorldListPacket.cs
@@ -0,0 +1,101 @@
+using FFXIVClassic_Lobby_Server.dataobjects;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Lobby_Server.packets
+{
+    class WorldListPacket
+    {
+        public const ushort OPCODE = 0x15;
+        public const ushort MAXPERPACKET = 6;
+
+        private UInt64 sequence;
+        private List<World> worldList;
+
+        public WorldListPacket(UInt64 sequence, List<World> serverList)
+        {
+            this.sequence = sequence;
+            this.worldList = serverList;
+        }        
+
+        public List<SubPacket> buildPackets()
+        {
+            List<SubPacket> subPackets = new List<SubPacket>();
+
+            int serverCount = 0;
+            int totalCount = 0;
+
+            MemoryStream memStream = null;
+            BinaryWriter binWriter = null;
+
+            foreach (World world in worldList)
+            {
+                if (totalCount == 0 || serverCount % MAXPERPACKET == 0)
+                {
+                    memStream = new MemoryStream(0x210);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(worldList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write(worldList.Count - totalCount <= MAXPERPACKET ? (UInt32)(worldList.Count - totalCount) : (UInt32)MAXPERPACKET);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                //Write Entries
+                binWriter.Write((ushort)world.id);
+                binWriter.Write((ushort)world.listPosition);
+                binWriter.Write((uint)world.population);
+                binWriter.Write((UInt64)0);
+                binWriter.Write(Encoding.ASCII.GetBytes(world.name.PadRight(64, '\0')));
+
+                serverCount++;
+                totalCount++;
+
+                //Send this chunk of world list
+                if (serverCount >= MAXPERPACKET)
+                {
+                    byte[] data = memStream.GetBuffer();
+                    binWriter.Dispose();
+                    memStream.Dispose();
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    subPackets.Add(subpacket);
+                    serverCount = 0;
+                }
+
+            }
+
+            //If there is anything left that was missed or the list is empty
+            if (serverCount > 0 || worldList.Count == 0)
+            {
+                if (worldList.Count == 0)
+                {
+                    memStream = new MemoryStream(0x210);
+                    binWriter = new BinaryWriter(memStream);
+
+                    //Write Empty List Info
+                    binWriter.Write((UInt64)sequence);
+                    byte listTracker = (byte)((MAXPERPACKET * 2) * subPackets.Count);
+                    binWriter.Write(worldList.Count - totalCount <= MAXPERPACKET ? (byte)(listTracker + 1) : (byte)(listTracker));
+                    binWriter.Write((UInt32)0);
+                    binWriter.Write((byte)0);
+                    binWriter.Write((UInt16)0);
+                }
+
+                byte[] data = memStream.GetBuffer();
+                binWriter.Dispose();
+                memStream.Dispose();
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                subPackets.Add(subpacket);
+            }
+
+            return subPackets;
+        }
+    }
+}