Add equip ability functions

Fix EquipAbility SQL query

FFXIVClassic Common Class Lib/SubPacket.cs

@@ -72,9 +72,9 @@ namespace FFXIVClassic.Common
             offset += header.subpacketSize;
         }
 
-        public SubPacket(ushort opcode, uint sourceId, uint targetId, byte[] data) : this(true, opcode, sourceId, targetId, data) { }
+        public SubPacket(ushort opcode, uint sourceId, byte[] data) : this(true, opcode, sourceId, data) { }
 
-        public SubPacket(bool isGameMessage, ushort opcode, uint sourceId, uint targetId, byte[] data)
+        public SubPacket(bool isGameMessage, ushort opcode, uint sourceId, byte[] data)
         {
             header = new SubPacketHeader();
 
@@ -89,7 +89,7 @@ namespace FFXIVClassic.Common
             }
 
             header.sourceId = sourceId;
-            header.targetId = targetId;
+            header.targetId = 0;
 
             if (isGameMessage)
                 header.type = 0x03;
@@ -117,6 +117,11 @@ namespace FFXIVClassic.Common
             data = original.data;
         }
 
+        public void SetTargetId(uint target)
+        {
+            this.header.targetId = target;
+        }
+
         public byte[] GetHeaderBytes()
         {
             var size = Marshal.SizeOf(header);

FFXIVClassic Common Class Lib/Vector3.cs

@@ -70,5 +70,41 @@ namespace FFXIVClassic.Common
         {
             return (lhs.X * rhs.X) + (lhs.Y * rhs.Y) + (lhs.Z * rhs.Z);
         }
+
+        public static float GetAngle(Vector3 lhs, Vector3 rhs)
+        {
+            var angle = (float)Math.Atan((rhs.Z - lhs.Z) / (rhs.X - lhs.X));
+            return lhs.X > rhs.X ? angle + (float)Math.PI : angle; 
+        }
+
+        public Vector3 NewHorizontalVector(float angle, float extents)
+        {
+            var newVec = new Vector3();
+            newVec.Y = this.Y;
+            newVec.X = this.X + (float)Math.Cos(angle) * extents;
+            newVec.Z = this.Z + (float)Math.Sin(angle) * extents;
+
+            return newVec;
+        }
+
+        public bool IsWithinCircle(Vector3 centre, float radius)
+        {
+            float diffX = centre.X - this.X;
+            float diffZ = centre.Z - this.Z;
+
+            float distance = (float)Math.Sqrt((diffX * diffX) + (diffZ * diffZ));
+
+            return distance < radius;
+        }
+
+        public bool IsWithinBox(Vector3 upperLeftCorner, Vector3 lowerRightCorner)
+        {
+            return upperLeftCorner.X <= this.X &&
+                upperLeftCorner.Y <= this.Y &&
+                upperLeftCorner.Z <= this.Z &&
+                lowerRightCorner.X >= this.X &&
+                lowerRightCorner.Y >= this.Y &&
+                lowerRightCorner.Z >= this.Z;
+        }
     }
 }

FFXIVClassic Lobby Server/PacketProcessor.cs

@@ -90,14 +90,15 @@ namespace FFXIVClassic_Lobby_Server
 
             if (userId == 0)
             {
-                    ErrorPacket errorPacket = new ErrorPacket(sessionPacket.sequence, 0, 0, 13001, "Your session has expired, please login again.");
-                    SubPacket subpacket = errorPacket.BuildPacket();
-                    BasePacket errorBasePacket = BasePacket.CreatePacket(subpacket, true, false);
-                    BasePacket.EncryptPacket(client.blowfish, errorBasePacket);
-                    client.QueuePacket(errorBasePacket);
+                ErrorPacket errorPacket = new ErrorPacket(sessionPacket.sequence, 0, 0, 13001, "Your session has expired, please login again.");
+                SubPacket subpacket = errorPacket.BuildPacket();
+                subpacket.SetTargetId(0xe0006868);
+                BasePacket errorBasePacket = BasePacket.CreatePacket(subpacket, true, false);
+                BasePacket.EncryptPacket(client.blowfish, errorBasePacket);
+                client.QueuePacket(errorBasePacket);
 
-                    Program.Log.Info("Invalid session, kicking...");
-                    return;
+                Program.Log.Info("Invalid session, kicking...");
+                return;
             }
 
             Program.Log.Info("USER ID: {0}", userId);

FFXIVClassic Lobby Server/packets/send/AccountListPacket.cs

@@ -61,7 +61,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                     byte[] data = memStream.GetBuffer();
                     binWriter.Dispose();
                     memStream.Dispose();
-                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                    subpacket.SetTargetId(0xe0006868);
                     subPackets.Add(subpacket);
                     accountCount = 0;
                 }
@@ -88,7 +89,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                 byte[] data = memStream.GetBuffer();
                 binWriter.Dispose();
                 memStream.Dispose();
-                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);              
+                subpacket.SetTargetId(0xe0006868);
                 subPackets.Add(subpacket);
             }
 

FFXIVClassic Lobby Server/packets/send/CharaCreatorPacket.cs

@@ -59,7 +59,7 @@ namespace FFXIVClassic_Lobby_Server.packets
             binWriter.Dispose();
             memStream.Dispose();
 
-            return new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+            return new SubPacket(OPCODE, 0xe0006868, data);
         }
     }
 }

FFXIVClassic Lobby Server/packets/send/CharacterListPacket.cs

@@ -87,7 +87,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                     byte[] data = memStream.GetBuffer();
                     binWriter.Dispose();
                     memStream.Dispose();
-                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                    subpacket.SetTargetId(0xe0006868);
                     subPackets.Add(subpacket);
                     characterCount = 0;
                 }                
@@ -133,7 +134,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                     byte[] data = memStream.GetBuffer();
                     binWriter.Dispose();
                     memStream.Dispose();
-                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                    subpacket.SetTargetId(0xe0006868);
                     subPackets.Add(subpacket);
                     characterCount = 0;
                 }
@@ -145,7 +147,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                 byte[] data = memStream.GetBuffer();
                 binWriter.Dispose();
                 memStream.Dispose();
-                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                subpacket.SetTargetId(0xe0006868);
                 subPackets.Add(subpacket);
             }
 

FFXIVClassic Lobby Server/packets/send/ErrorPacket.cs

@@ -38,7 +38,8 @@ namespace FFXIVClassic_Lobby_Server.packets
             byte[] data = memStream.GetBuffer();
             binWriter.Dispose();
             memStream.Dispose();
-            SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+            SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+            subpacket.SetTargetId(0xe0006868);
             return subpacket;
         }
     }

FFXIVClassic Lobby Server/packets/send/ImportListPacket.cs

@@ -64,7 +64,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                     byte[] data = memStream.GetBuffer();
                     binWriter.Dispose();
                     memStream.Dispose();
-                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                    subpacket.SetTargetId(0xe0006868);
                     subPackets.Add(subpacket);
                     namesCount = 0;
                 }
@@ -91,7 +92,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                 byte[] data = memStream.GetBuffer();
                 binWriter.Dispose();
                 memStream.Dispose();
-                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                subpacket.SetTargetId(0xe0006868);
                 subPackets.Add(subpacket);
             }
 

FFXIVClassic Lobby Server/packets/send/RetainerListPacket.cs

@@ -65,7 +65,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                     byte[] data = memStream.GetBuffer();
                     binWriter.Dispose();
                     memStream.Dispose();
-                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                    subpacket.SetTargetId(0xe0006868);
                     subPackets.Add(subpacket);
                     retainerCount = 0;
                 }
@@ -92,7 +93,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                 byte[] data = memStream.GetBuffer();
                 binWriter.Dispose();
                 memStream.Dispose();
-                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                subpacket.SetTargetId(0xe0006868);
                 subPackets.Add(subpacket);
             }
 

FFXIVClassic Lobby Server/packets/send/SelectCharacterConfirmPacket.cs

@@ -49,7 +49,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                 data = memStream.GetBuffer();
             }
             
-            SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+            SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+            subpacket.SetTargetId(0xe0006868);
             subPackets.Add(subpacket);
             
             return subPackets;

FFXIVClassic Lobby Server/packets/send/WorldListPacket.cs

@@ -63,7 +63,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                     byte[] data = memStream.GetBuffer();
                     binWriter.Dispose();
                     memStream.Dispose();
-                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                    SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                    subpacket.SetTargetId(0xe0006868);
                     subPackets.Add(subpacket);
                     serverCount = 0;
                 }
@@ -90,7 +91,8 @@ namespace FFXIVClassic_Lobby_Server.packets
                 byte[] data = memStream.GetBuffer();
                 binWriter.Dispose();
                 memStream.Dispose();
-                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, 0xe0006868, data);
+                SubPacket subpacket = new SubPacket(OPCODE, 0xe0006868, data);
+                subpacket.SetTargetId(0xe0006868);
                 subPackets.Add(subpacket);
             }
 

FFXIVClassic Map Server/CommandProcessor.cs

@@ -14,7 +14,7 @@ namespace FFXIVClassic_Map_Server
 {
     class CommandProcessor
     {
-        private static Dictionary<uint, Item> gamedataItems = Server.GetGamedataItems();
+        private static Dictionary<uint, ItemData> gamedataItems = Server.GetGamedataItems();
 
         const UInt32 ITEM_GIL = 1000001;
       
@@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server
         private void SendMessage(Session session, String message)
         {
             if (session != null)
-                session.GetActor().QueuePacket(SendMessagePacket.BuildPacket(session.id, session.id, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", message));
+                session.GetActor().QueuePacket(SendMessagePacket.BuildPacket(session.id, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", message));
         }
 
         internal bool DoCommand(string input, Session session)

FFXIVClassic Map Server/Database.cs

@@ -70,11 +70,11 @@ namespace FFXIVClassic_Map_Server
             }
         }
 
-        public static Dictionary<uint, Item> GetItemGamedata()
+        public static Dictionary<uint, ItemData> GetItemGamedata()
         {
             using (var conn = new MySqlConnection(String.Format("Server={0}; Port={1}; Database={2}; UID={3}; Password={4}", ConfigConstants.DATABASE_HOST, ConfigConstants.DATABASE_PORT, ConfigConstants.DATABASE_NAME, ConfigConstants.DATABASE_USERNAME, ConfigConstants.DATABASE_PASSWORD)))
             {
-                Dictionary<uint, Item> gamedataItems = new Dictionary<uint, Item>();
+                Dictionary<uint, ItemData> gamedataItems = new Dictionary<uint, ItemData>();
           
                 try
                 {
@@ -98,16 +98,16 @@ namespace FFXIVClassic_Map_Server
                         while (reader.Read())
                         {
                             uint id = reader.GetUInt32("catalogID");
-                            Item item = null;
+                            ItemData item = null;
 
-                            if (Item.IsWeapon(id))
+                            if (ItemData.IsWeapon(id))
                                 item = new WeaponItem(reader);
-                            else if (Item.IsArmor(id))
+                            else if (ItemData.IsArmor(id))
                                 item = new ArmorItem(reader);
-                            else if (Item.IsAccessory(id))
+                            else if (ItemData.IsAccessory(id))
                                 item = new AccessoryItem(reader);
                             else
-                                item = new Item(reader);
+                                item = new ItemData(reader);
 
                             gamedataItems.Add(item.catalogID, item);
                         }
@@ -126,6 +126,47 @@ namespace FFXIVClassic_Map_Server
             }
         }
 
+        public static Dictionary<uint, GuildleveData> GetGuildleveGamedata()
+        {
+            using (var conn = new MySqlConnection(String.Format("Server={0}; Port={1}; Database={2}; UID={3}; Password={4}", ConfigConstants.DATABASE_HOST, ConfigConstants.DATABASE_PORT, ConfigConstants.DATABASE_NAME, ConfigConstants.DATABASE_USERNAME, ConfigConstants.DATABASE_PASSWORD)))
+            {
+                Dictionary<uint, GuildleveData> gamedataGuildleves = new Dictionary<uint, GuildleveData>();
+
+                try
+                {
+                    conn.Open();
+
+                    string query = @"
+                                SELECT
+                                *                                
+                                FROM gamedata_guildleves
+                                ";
+
+                    MySqlCommand cmd = new MySqlCommand(query, conn);
+
+                    using (MySqlDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            uint id = reader.GetUInt32("id");
+                            GuildleveData guildleve = new GuildleveData(reader);
+                            gamedataGuildleves.Add(guildleve.id, guildleve);
+                        }
+                    }
+                }
+                catch (MySqlException e)
+                {
+                    Program.Log.Error(e.ToString());
+                }
+                finally
+                {
+                    conn.Dispose();
+                }
+
+                return gamedataGuildleves;
+            }
+        }
+
         public static void SavePlayerAppearance(Player player)
         {
             string query;
@@ -391,6 +432,42 @@ namespace FFXIVClassic_Map_Server
             }
         }
 
+        public static void MarkGuildleve(Player player, uint glId, bool isAbandoned, bool isCompleted)
+        {
+            string query;
+            MySqlCommand cmd;
+
+            using (MySqlConnection conn = new MySqlConnection(String.Format("Server={0}; Port={1}; Database={2}; UID={3}; Password={4}", ConfigConstants.DATABASE_HOST, ConfigConstants.DATABASE_PORT, ConfigConstants.DATABASE_NAME, ConfigConstants.DATABASE_USERNAME, ConfigConstants.DATABASE_PASSWORD)))
+            {
+                try
+                {
+                    conn.Open();
+
+                    query = @"
+                    UPDATE characters_quest_guildleve_regional
+                    SET abandoned = @abandoned, completed = @completed
+                    WHERE characterId = @charaId and guildleveId = @guildleveId
+                    ";
+
+                    cmd = new MySqlCommand(query, conn);
+                    cmd.Parameters.AddWithValue("@charaId", player.actorId);
+                    cmd.Parameters.AddWithValue("@guildleveId", glId);
+                    cmd.Parameters.AddWithValue("@abandoned", isAbandoned);
+                    cmd.Parameters.AddWithValue("@completed", isCompleted);
+
+                    cmd.ExecuteNonQuery();
+                }
+                catch (MySqlException e)
+                {
+                    Program.Log.Error(e.ToString());
+                }
+                finally
+                {
+                    conn.Dispose();
+                }
+            }
+        }
+
         public static void SaveGuildleve(Player player, uint glId, int slot)
         {
             string query;
@@ -871,27 +948,9 @@ namespace FFXIVClassic_Map_Server
                                 player.timers[i] = reader.GetUInt32(i);
                         }
                     }
-                   
-                    //Load Hotbar
-                    query = @"
-                        SELECT 
-                        hotbarSlot,
-                        commandId,
-                        recastTime                
-                        FROM characters_hotbar WHERE characterId = @charId AND classId = @classId";
 
-                    cmd = new MySqlCommand(query, conn);
-                    cmd.Parameters.AddWithValue("@charId", player.actorId);
-                    cmd.Parameters.AddWithValue("@classId", player.charaWork.parameterSave.state_mainSkill[0]);
-                    using (MySqlDataReader reader = cmd.ExecuteReader())
-                    {                        
-                        while (reader.Read())
-                        {
-                            int index = reader.GetUInt16(0);
-                            player.charaWork.command[index+32] = reader.GetUInt32(1);
-                            player.charaWork.parameterSave.commandSlot_recastTime[index] = reader.GetUInt32(2);
-                        }
-                    }
+                    //Load Hotbar
+                    LoadHotbar(player);
 
                     //Load Scenario Quests
                     query = @"
@@ -1130,6 +1189,143 @@ namespace FFXIVClassic_Map_Server
             }
 
         }
+        public static void EquipAbility(Player player, ushort hotbarSlot, uint commandId, uint recastTime)
+        {
+            //2700083201 is where abilities start. 2700083200 is for unequipping abilities. Trying to put this in the hotbar will crash the game, need to put 0 instead
+            if (commandId > 2700083200)
+            {
+                using (MySqlConnection conn = new MySqlConnection(
+                    String.Format("Server={0}; Port={1}; Database={2}; UID={3}; Password={4}",
+                    ConfigConstants.DATABASE_HOST,
+                    ConfigConstants.DATABASE_PORT,
+                    ConfigConstants.DATABASE_NAME,
+                    ConfigConstants.DATABASE_USERNAME,
+                    ConfigConstants.DATABASE_PASSWORD)))
+                {
+                    try
+                    {
+                        conn.Open();
+                        MySqlCommand cmd;
+                        string query = @"
+                                    INSERT INTO characters_hotbar                                    
+                                    (characterId, classId, hotbarSlot, commandId, recastTime)
+                                    VALUES
+                                    (@charId, @classId, @hotbarSlot, @commandId, @recastTime)
+                                    ON DUPLICATE KEY UPDATE commandId=@commandId, recastTime=@recastTime;
+                        ";
+
+                        cmd = new MySqlCommand(query, conn);
+                        cmd.Parameters.AddWithValue("@charId", player.actorId);
+                        cmd.Parameters.AddWithValue("@classId", player.charaWork.parameterSave.state_mainSkill[0]);
+                        cmd.Parameters.AddWithValue("@commandId", commandId);
+                        cmd.Parameters.AddWithValue("@hotbarSlot", hotbarSlot);
+                        cmd.Parameters.AddWithValue("@recastTime", recastTime);
+                        cmd.ExecuteNonQuery();
+                    }
+                    catch (MySqlException e)
+                    {
+                        Program.Log.Error(e.ToString());
+                    }
+                    finally
+                    {
+                        conn.Dispose();
+                    }
+                }
+            }
+        }
+
+        //Unequipping is done by sending an equip packet with 2700083200 as the ability and the hotbar slot of the action being unequipped
+        public static void UnequipAbility(Player player, ushort hotbarSlot)
+        {
+            using (MySqlConnection conn = new MySqlConnection(
+                    String.Format("Server={0}; Port={1}; Database={2}; UID={3}; Password={4}",
+                    ConfigConstants.DATABASE_HOST,
+                    ConfigConstants.DATABASE_PORT,
+                    ConfigConstants.DATABASE_NAME,
+                    ConfigConstants.DATABASE_USERNAME,
+                    ConfigConstants.DATABASE_PASSWORD)))
+            {
+                try
+                {
+                    conn.Open();
+                    MySqlCommand cmd;
+                    string query = "";
+
+                    //Drop
+                    List<Tuple<ushort, uint>> hotbarList = new List<Tuple<ushort, uint>>();
+                    query = @"
+                                DELETE FROM characters_hotbar
+                                WHERE characterId = @charId AND classId = @classId AND hotbarSlot = @hotbarSlot
+                        ";
+                    cmd = new MySqlCommand(query, conn);
+                    cmd.Parameters.AddWithValue("@charId", player.actorId);
+                    cmd.Parameters.AddWithValue("@classId", player.charaWork.parameterSave.state_mainSkill[0]);
+                    cmd.Parameters.AddWithValue("@hotbarSlot", hotbarSlot - 1);
+                    cmd.ExecuteNonQuery();
+                }
+                catch (MySqlException e)
+                {
+                    Program.Log.Error(e.ToString());
+                }
+                finally
+                {
+                    conn.Dispose();
+                }
+            }
+
+        }
+
+        public static void LoadHotbar(Player player)
+        {
+            string query;
+            MySqlCommand cmd;
+
+            using (MySqlConnection conn = new MySqlConnection(String.Format("Server={0}; Port={1}; Database={2}; UID={3}; Password={4}", ConfigConstants.DATABASE_HOST, ConfigConstants.DATABASE_PORT, ConfigConstants.DATABASE_NAME, ConfigConstants.DATABASE_USERNAME, ConfigConstants.DATABASE_PASSWORD)))
+            {
+                try
+                {
+                    conn.Open();
+                    //Load Hotbar
+                    query = @"
+                        SELECT 
+                        hotbarSlot,
+                        commandId,
+                        recastTime                
+                        FROM characters_hotbar WHERE characterId = @charId AND classId = @classId
+                        ORDER BY hotbarSlot";
+
+                    cmd = new MySqlCommand(query, conn);
+                    cmd.Parameters.AddWithValue("@charId", player.actorId);
+                    cmd.Parameters.AddWithValue("@classId", player.charaWork.parameterSave.state_mainSkill[0]);
+                    player.charaWork.commandBorder = 32;
+                    for (int i = player.charaWork.commandBorder; i < player.charaWork.commandCategory.Length; i++)
+                    {
+                        player.charaWork.command[i] = 0;
+                        player.charaWork.commandCategory[i] = 0;
+                        player.charaWork.parameterSave.commandSlot_recastTime[i - player.charaWork.commandBorder] = 0;
+                    }
+
+                    using (MySqlDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            int index = reader.GetUInt16(0);
+                            player.charaWork.command[index] = reader.GetUInt32(1);
+                            player.charaWork.commandCategory[index] = 1;
+                            player.charaWork.parameterSave.commandSlot_recastTime[index - player.charaWork.commandBorder] = reader.GetUInt32(2);
+                        }
+                    }
+                }
+                catch (MySqlException e)
+                {
+                    Program.Log.Error(e.ToString());
+                }
+                finally
+                {
+                    conn.Dispose();
+                }
+            }
+        }
 
         public static List<InventoryItem> GetInventory(Player player, uint slotOffset, uint type)
         {

FFXIVClassic Map Server/FFXIVClassic Map Server.csproj

@@ -108,7 +108,10 @@
     <Compile Include="actors\chara\Work.cs" />
     <Compile Include="actors\debug\Debug.cs" />
     <Compile Include="actors\director\Director.cs" />
+    <Compile Include="actors\director\GuildleveDirector.cs" />
+    <Compile Include="actors\director\Work\GuildleveWork.cs" />
     <Compile Include="actors\EventList.cs" />
+    <Compile Include="actors\group\GLContentGroup.cs" />
     <Compile Include="actors\group\ContentGroup.cs" />
     <Compile Include="actors\group\Work\ContentGroupWork.cs" />
     <Compile Include="actors\group\Work\GlobalTemp.cs" />
@@ -125,6 +128,7 @@
     <Compile Include="actors\quest\Quest.cs" />
     <Compile Include="actors\StaticActors.cs" />
     <Compile Include="actors\world\WorldMaster.cs" />
+    <Compile Include="dataobjects\GuildleveData.cs" />
     <Compile Include="dataobjects\ZoneConnection.cs" />
     <Compile Include="CommandProcessor.cs" />
     <Compile Include="ConfigConstants.cs" />
@@ -144,7 +148,7 @@
     <Compile Include="actors\chara\player\PlayerWork.cs" />
     <Compile Include="dataobjects\InventoryItem.cs" />
     <Compile Include="dataobjects\Session.cs" />
-    <Compile Include="dataobjects\Item.cs" />
+    <Compile Include="dataobjects\ItemData.cs" />
     <Compile Include="dataobjects\RecruitmentDetails.cs" />
     <Compile Include="dataobjects\SeamlessBoundry.cs" />
     <Compile Include="dataobjects\SearchEntry.cs" />
@@ -176,7 +180,6 @@
     <Compile Include="packets\send\actor\ActorDoEmotePacket.cs" />
     <Compile Include="packets\send\actor\ActorInstantiatePacket.cs" />
     <Compile Include="packets\send\actor\ActorSpecialGraphicPacket.cs" />
-    <Compile Include="packets\send\actor\BattleAction1Packet.cs" />
     <Compile Include="packets\send\actor\battle\BattleAction.cs" />
     <Compile Include="packets\send\actor\battle\BattleActionX00Packet.cs" />
     <Compile Include="packets\send\actor\battle\BattleActionX18Packet.cs" />
@@ -219,8 +222,7 @@
     <Compile Include="packets\send\actor\SetActorIconPacket.cs" />
     <Compile Include="packets\send\actor\SetActorSubStatPacket.cs" />
     <Compile Include="packets\send\actor\SetActorStatusPacket.cs" />
-    <Compile Include="packets\send\actor\_0xD9Packet.cs" />
-    <Compile Include="packets\send\actor\_0xD8Packet.cs" />
+    <Compile Include="packets\send\actor\SetActorBGPropertiesPacket.cs" />
     <Compile Include="packets\send\actor\_0xFPacket.cs" />
     <Compile Include="packets\send\groups\CreateNamedGroup.cs" />
     <Compile Include="packets\send\groups\CreateNamedGroupMultiple.cs" />
@@ -260,7 +262,6 @@
     <Compile Include="packets\send\actor\MoveActorToPositionPacket.cs" />
     <Compile Include="packets\send\actor\SetActorAppearancePacket.cs" />
     <Compile Include="packets\send\actor\SetActorPositionPacket.cs" />
-    <Compile Include="packets\send\login\0x7ResponsePacket.cs" />
     <Compile Include="packets\send\LogoutPacket.cs" />
     <Compile Include="packets\send\player\SetCompletedAchievementsPacket.cs" />
     <Compile Include="packets\send\player\AchievementEarnedPacket.cs" />
@@ -359,8 +360,8 @@
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
-    <PostBuildEvent>xcopy "$(SolutionDir)data\map_config.ini" "$(SolutionDir)$(ProjectName)\$(OutDir)" /d
-xcopy "$(SolutionDir)data\scripts" "$(SolutionDir)$(ProjectName)\$(OutDir)scripts\" /e /d /y /s</PostBuildEvent>
+    <PostBuildEvent>
+    </PostBuildEvent>
   </PropertyGroup>
   <PropertyGroup>
     <PreBuildEvent>

FFXIVClassic Map Server/PacketProcessor.cs

@@ -35,7 +35,7 @@ namespace FFXIVClassic_Map_Server
 
         public void ProcessPacket(ZoneConnection client, SubPacket subpacket)
         {                          
-                Session session = mServer.GetSession(subpacket.header.targetId);
+                Session session = mServer.GetSession(subpacket.header.sourceId);
 
                 if (session == null && subpacket.gameMessage.opcode != 0x1000)
                     return;
@@ -59,7 +59,7 @@ namespace FFXIVClassic_Map_Server
 
                         SessionBeginPacket beginSessionPacket = new SessionBeginPacket(subpacket.data);
 
-                        session = mServer.AddSession(subpacket.header.targetId);
+                        session = mServer.AddSession(subpacket.header.sourceId);
 
                         if (!beginSessionPacket.isLogin)
                             Server.GetWorldManager().DoZoneIn(session.GetActor(), false, session.GetActor().destinationSpawnType);
@@ -80,7 +80,7 @@ namespace FFXIVClassic_Map_Server
                         Server.GetServer().RemoveSession(session.id);
                         Program.Log.Info("{0} has been removed from the session list.", session.GetActor().customDisplayName);
 
-                        client.QueuePacket(SessionEndConfirmPacket.BuildPacket(session, endSessionPacket.destinationZoneId), true, false);
+                        session.QueuePacket(SessionEndConfirmPacket.BuildPacket(session, endSessionPacket.destinationZoneId));
                         client.FlushQueuedSendPackets();
                         break;
                     //World Server - Party Synch
@@ -92,14 +92,14 @@ namespace FFXIVClassic_Map_Server
                     case 0x0001:
                         //subpacket.DebugPrintSubPacket();
                         PingPacket pingPacket = new PingPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(PongPacket.BuildPacket(session.id, pingPacket.time), true, false));
+                        session.QueuePacket(PongPacket.BuildPacket(session.id, pingPacket.time));
                         session.Ping();
                         break;
                     //Unknown
                     case 0x0002:
 
                         subpacket.DebugPrintSubPacket();
-                        client.QueuePacket(_0x2Packet.BuildPacket(session.id), true, false);
+                        session.QueuePacket(_0x2Packet.BuildPacket(session.id));
                         client.FlushQueuedSendPackets();
 
                         break;
@@ -115,14 +115,12 @@ namespace FFXIVClassic_Map_Server
                         }
 
                         if (chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SAY || chatMessage.logType == SendMessagePacket.MESSAGE_TYPE_SHOUT)
-                            session.GetActor().BroadcastPacket(SendMessagePacket.BuildPacket(session.id, session.id, chatMessage.logType, session.GetActor().customDisplayName, chatMessage.message), false);
+                            session.GetActor().BroadcastPacket(SendMessagePacket.BuildPacket(session.id, chatMessage.logType, session.GetActor().customDisplayName, chatMessage.message), false);
 
                         break;
                     //Langauge Code (Client safe to send packets to now)
                     case 0x0006:
                         LangaugeCodePacket langCode = new LangaugeCodePacket(subpacket.data);
-                        session = mServer.GetSession(subpacket.header.targetId);
-
                         LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onBeginLogin", true);                    
                         Server.GetWorldManager().DoZoneIn(session.GetActor(), true, 0x1);
                         LuaEngine.GetInstance().CallLuaFunction(session.GetActor(), session.GetActor(), "onLogin", true);
@@ -150,7 +148,7 @@ namespace FFXIVClassic_Map_Server
 
                         SetTargetPacket setTarget = new SetTargetPacket(subpacket.data);
                         session.GetActor().currentTarget = setTarget.actorID;
-                        session.GetActor().BroadcastPacket(SetActorTargetAnimatedPacket.BuildPacket(session.id, session.id, setTarget.actorID), true);
+                        session.GetActor().BroadcastPacket(SetActorTargetAnimatedPacket.BuildPacket(session.id, setTarget.actorID), true);
                         break;
                     //Lock Target
                     case 0x00CC:
@@ -247,15 +245,15 @@ namespace FFXIVClassic_Map_Server
                     //Start Recruiting
                     case 0x01C3:
                         StartRecruitingRequestPacket recruitRequestPacket = new StartRecruitingRequestPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(StartRecruitingResponse.BuildPacket(session.id, true), true, false));
+                        session.QueuePacket(StartRecruitingResponse.BuildPacket(session.id, true));
                         break;
                     //End Recruiting
                     case 0x01C4:
-                        client.QueuePacket(BasePacket.CreatePacket(EndRecruitmentPacket.BuildPacket(session.id), true, false));
+                        session.QueuePacket(EndRecruitmentPacket.BuildPacket(session.id));
                         break;
                     //Party Window Opened, Request State
                     case 0x01C5:
-                        client.QueuePacket(BasePacket.CreatePacket(RecruiterStatePacket.BuildPacket(session.id, false, false, 0), true, false));
+                        session.QueuePacket(RecruiterStatePacket.BuildPacket(session.id, false, false, 0));
                         break;
                     //Search Recruiting
                     case 0x01C7:
@@ -271,7 +269,7 @@ namespace FFXIVClassic_Map_Server
                         details.subTaskId = 1;
                         details.comment = "This is a test details packet sent by the server. No implementation has been Created yet...";
                         details.num[0] = 1;
-                        client.QueuePacket(BasePacket.CreatePacket(CurrentRecruitmentDetailsPacket.BuildPacket(session.id, details), true, false));
+                        session.QueuePacket(CurrentRecruitmentDetailsPacket.BuildPacket(session.id, details));
                         break;
                     //Accepted Recruiting
                     case 0x01C6:
@@ -280,64 +278,64 @@ namespace FFXIVClassic_Map_Server
                     /* SOCIAL STUFF */
                     case 0x01C9:
                         AddRemoveSocialPacket addBlackList = new AddRemoveSocialPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(BlacklistAddedPacket.BuildPacket(session.id, true, addBlackList.name), true, false));
+                        session.QueuePacket(BlacklistAddedPacket.BuildPacket(session.id, true, addBlackList.name));
                         break;
                     case 0x01CA:
                         AddRemoveSocialPacket RemoveBlackList = new AddRemoveSocialPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(BlacklistRemovedPacket.BuildPacket(session.id, true, RemoveBlackList.name), true, false));
+                        session.QueuePacket(BlacklistRemovedPacket.BuildPacket(session.id, true, RemoveBlackList.name));
                         break;
                     case 0x01CB:
                         int offset1 = 0;
-                        client.QueuePacket(BasePacket.CreatePacket(SendBlacklistPacket.BuildPacket(session.id, new String[] { "Test" }, ref offset1), true, false));
+                        session.QueuePacket(SendBlacklistPacket.BuildPacket(session.id, new String[] { "Test" }, ref offset1));
                         break;
                     case 0x01CC:
                         AddRemoveSocialPacket addFriendList = new AddRemoveSocialPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(FriendlistAddedPacket.BuildPacket(session.id, true, (uint)addFriendList.name.GetHashCode(), true, addFriendList.name), true, false));
+                        session.QueuePacket(FriendlistAddedPacket.BuildPacket(session.id, true, (uint)addFriendList.name.GetHashCode(), true, addFriendList.name));
                         break;
                     case 0x01CD:
                         AddRemoveSocialPacket RemoveFriendList = new AddRemoveSocialPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(FriendlistRemovedPacket.BuildPacket(session.id, true, RemoveFriendList.name), true, false));
+                        session.QueuePacket(FriendlistRemovedPacket.BuildPacket(session.id, true, RemoveFriendList.name));
                         break;
                     case 0x01CE:
                         int offset2 = 0;
-                        client.QueuePacket(BasePacket.CreatePacket(SendFriendlistPacket.BuildPacket(session.id, new Tuple<long, string>[] { new Tuple<long, string>(01, "Test2") }, ref offset2), true, false));
+                        session.QueuePacket(SendFriendlistPacket.BuildPacket(session.id, new Tuple<long, string>[] { new Tuple<long, string>(01, "Test2") }, ref offset2));
                         break;
                     case 0x01CF:
-                        client.QueuePacket(BasePacket.CreatePacket(FriendStatusPacket.BuildPacket(session.id, null), true, false));
+                        session.QueuePacket(FriendStatusPacket.BuildPacket(session.id, null));
                         break;
                     /* SUPPORT DESK STUFF */
                     //Request for FAQ/Info List
                     case 0x01D0:
                         FaqListRequestPacket faqRequest = new FaqListRequestPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(FaqListResponsePacket.BuildPacket(session.id, new string[] { "Testing FAQ1", "Coded style!" }), true, false));
+                        session.QueuePacket(FaqListResponsePacket.BuildPacket(session.id, new string[] { "Testing FAQ1", "Coded style!" }));
                         break;
                     //Request for body of a faq/info selection
                     case 0x01D1:
                         FaqBodyRequestPacket faqBodyRequest = new FaqBodyRequestPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(FaqBodyResponsePacket.BuildPacket(session.id, "HERE IS A GIANT BODY. Nothing else to say!"), true, false));
+                        session.QueuePacket(FaqBodyResponsePacket.BuildPacket(session.id, "HERE IS A GIANT BODY. Nothing else to say!"));
                         break;
                     //Request issue list
                     case 0x01D2:
                         GMTicketIssuesRequestPacket issuesRequest = new GMTicketIssuesRequestPacket(subpacket.data);
-                        client.QueuePacket(BasePacket.CreatePacket(IssueListResponsePacket.BuildPacket(session.id, new string[] { "Test1", "Test2", "Test3", "Test4", "Test5" }), true, false));
+                        session.QueuePacket(IssueListResponsePacket.BuildPacket(session.id, new string[] { "Test1", "Test2", "Test3", "Test4", "Test5" }));
                         break;
                     //Request if GM ticket exists
                     case 0x01D3:
-                        client.QueuePacket(BasePacket.CreatePacket(StartGMTicketPacket.BuildPacket(session.id, false), true, false));
+                        session.QueuePacket(StartGMTicketPacket.BuildPacket(session.id, false));
                         break;
                     //Request for GM response message
                     case 0x01D4:
-                        client.QueuePacket(BasePacket.CreatePacket(GMTicketPacket.BuildPacket(session.id, "This is a GM Ticket Title", "This is a GM Ticket Body."), true, false));
+                        session.QueuePacket(GMTicketPacket.BuildPacket(session.id, "This is a GM Ticket Title", "This is a GM Ticket Body."));
                         break;
                     //GM Ticket Sent
                     case 0x01D5:
                         GMSupportTicketPacket gmTicket = new GMSupportTicketPacket(subpacket.data);
                         Program.Log.Info("Got GM Ticket: \n" + gmTicket.ticketTitle + "\n" + gmTicket.ticketBody);
-                        client.QueuePacket(BasePacket.CreatePacket(GMTicketSentResponsePacket.BuildPacket(session.id, true), true, false));
+                        session.QueuePacket(GMTicketSentResponsePacket.BuildPacket(session.id, true));
                         break;
                     //Request to end ticket
                     case 0x01D6:
-                        client.QueuePacket(BasePacket.CreatePacket(EndGMTicketPacket.BuildPacket(session.id), true, false));
+                        session.QueuePacket(EndGMTicketPacket.BuildPacket(session.id));
                         break;
                     default:
                         Program.Log.Debug("Unknown command 0x{0:X} received.", subpacket.gameMessage.opcode);

FFXIVClassic Map Server/Program.cs

@@ -22,7 +22,6 @@ namespace FFXIVClassic_Map_Server
 
         static void Main(string[] args)
         {
-
             // set up logging
             Log = LogManager.GetCurrentClassLogger();
 #if DEBUG

FFXIVClassic Map Server/Server.cs

@@ -27,7 +27,8 @@ namespace FFXIVClassic_Map_Server
         private static CommandProcessor mCommandProcessor = new CommandProcessor();
         private static ZoneConnection mWorldConnection = new ZoneConnection();
         private static WorldManager mWorldManager;
-        private static Dictionary<uint, Item> mGamedataItems;
+        private static Dictionary<uint, ItemData> mGamedataItems;
+        private static Dictionary<uint, GuildleveData> mGamedataGuildleves;
         private static StaticActors mStaticActors;
 
         private PacketProcessor mProcessor;        
@@ -43,6 +44,8 @@ namespace FFXIVClassic_Map_Server
 
             mGamedataItems = Database.GetItemGamedata();
             Program.Log.Info("Loaded {0} items.", mGamedataItems.Count);
+            mGamedataGuildleves = Database.GetGuildleveGamedata();
+            Program.Log.Info("Loaded {0} guildleves.", mGamedataGuildleves.Count);
 
             mWorldManager = new WorldManager(this);
             mWorldManager.LoadZoneList();
@@ -267,7 +270,7 @@ namespace FFXIVClassic_Map_Server
             return mWorldManager;
         }
         
-        public static Dictionary<uint, Item> GetGamedataItems()
+        public static Dictionary<uint, ItemData> GetGamedataItems()
         {
             return mGamedataItems;
         }
@@ -282,7 +285,7 @@ namespace FFXIVClassic_Map_Server
             return mStaticActors.FindStaticActor(name);
         }
 
-        public static Item GetItemGamedata(uint id)
+        public static ItemData GetItemGamedata(uint id)
         {
             if (mGamedataItems.ContainsKey(id))
                 return mGamedataItems[id];
@@ -290,5 +293,13 @@ namespace FFXIVClassic_Map_Server
                 return null;
         }
 
+        public static GuildleveData GetGuildleveGamedata(uint id)
+        {
+            if (mGamedataGuildleves.ContainsKey(id))
+                return mGamedataGuildleves[id];
+            else
+                return null;
+        }
+
     }
 }

FFXIVClassic Map Server/WorldManager.cs

@@ -600,19 +600,24 @@ namespace FFXIVClassic_Map_Server
             player.positionZ = spawnZ;
             player.rotation = spawnRotation;
 
+            //Delete any GL directors
+            GuildleveDirector glDirector = player.GetGuildleveDirector();
+            if (glDirector != null)
+                player.RemoveDirector(glDirector);
+
             //Delete content if have
             if (player.currentContentGroup != null)
             {
                 player.currentContentGroup.RemoveMember(player.actorId);
-                player.SetCurrentContentGroup(null, player);
+                player.SetCurrentContentGroup(null);
 
                 if (oldZone is PrivateAreaContent)
                     ((PrivateAreaContent)oldZone).CheckDestroy();
             }                 
 
             //Send packets
-            player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId), true, false);
-            player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10), true, false);
+            player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId));
+            player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x2));
             player.SendZoneInPackets(this, spawnType);
             player.playerSession.ClearInstance();
             player.SendInstanceUpdate();
@@ -660,8 +665,8 @@ namespace FFXIVClassic_Map_Server
                 player.rotation = spawnRotation;
 
                 //Send packets
-                player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10), true, false);
-                player.playerSession.QueuePacket(player.CreateSpawnTeleportPacket(player.actorId, spawnType), true, false);
+                player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10));
+                player.playerSession.QueuePacket(player.CreateSpawnTeleportPacket(spawnType));
 
                 player.playerSession.LockUpdates(false);
                 player.SendInstanceUpdate();
@@ -704,8 +709,8 @@ namespace FFXIVClassic_Map_Server
             player.SendGameMessage(GetActor(), 34108, 0x20);
 
             //Send packets
-            player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId), true, false);
-            player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10), true, false);
+            player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId));
+            player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x10));
             player.SendZoneInPackets(this, spawnType);
             player.playerSession.ClearInstance();
             player.SendInstanceUpdate();
@@ -739,8 +744,8 @@ namespace FFXIVClassic_Map_Server
             //Send packets            
             if (!isLogin)
             {
-                player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId), true, false);
-                player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x2), true, false);
+                player.playerSession.QueuePacket(DeleteAllActorsPacket.BuildPacket(player.actorId));
+                player.playerSession.QueuePacket(_0xE2Packet.BuildPacket(player.actorId, 0x2));
                 //player.SendZoneInPackets(this, spawnType);
             }
 
@@ -766,11 +771,6 @@ namespace FFXIVClassic_Map_Server
 
         }
 
-        public ContentGroup CreateContentGroup(Director director)
-        {
-            return CreateContentGroup(director, null);
-        }
-
         public ContentGroup CreateContentGroup(Director director, params Actor[] actors)
         {
             if (director == null)
@@ -799,6 +799,62 @@ namespace FFXIVClassic_Map_Server
             }
         }
 
+        public ContentGroup CreateContentGroup(Director director, List<Actor> actors)
+        {
+            if (director == null)
+                return null;
+
+            lock (groupLock)
+            {
+                uint[] initialMembers = null;
+
+                if (actors != null)
+                {
+                    initialMembers = new uint[actors.Count];
+                    for (int i = 0; i < actors.Count; i++)
+                        initialMembers[i] = actors[i].actorId;
+                }
+
+                groupIndexId = groupIndexId | 0x3000000000000000;
+
+                ContentGroup contentGroup = new ContentGroup(groupIndexId, director, initialMembers);
+                mContentGroups.Add(groupIndexId, contentGroup);
+                groupIndexId++;
+                if (initialMembers != null && initialMembers.Length != 0)
+                    contentGroup.SendAll();
+
+                return contentGroup;
+            }
+        }
+
+        public ContentGroup CreateGLContentGroup(Director director, List<Actor> actors)
+        {
+            if (director == null)
+                return null;
+
+            lock (groupLock)
+            {
+                uint[] initialMembers = null;
+
+                if (actors != null)
+                {
+                    initialMembers = new uint[actors.Count];
+                    for (int i = 0; i < actors.Count; i++)
+                        initialMembers[i] = actors[i].actorId;
+                }
+
+                groupIndexId = groupIndexId | 0x2000000000000000;
+
+                GLContentGroup contentGroup = new GLContentGroup(groupIndexId, director, initialMembers);
+                mContentGroups.Add(groupIndexId, contentGroup);
+                groupIndexId++;
+                if (initialMembers != null && initialMembers.Length != 0)
+                    contentGroup.SendAll();
+
+                return contentGroup;
+            }
+        }
+
         public void DeleteContentGroup(ulong groupId)
         {
             lock (groupLock)
@@ -806,7 +862,6 @@ namespace FFXIVClassic_Map_Server
                 if (mContentGroups.ContainsKey(groupId) && mContentGroups[groupId] is ContentGroup)
                 {
                     ContentGroup group = (ContentGroup)mContentGroups[groupId];
-                    group.SendDeletePackets();
                     mContentGroups.Remove(groupId);
                 }
             }
@@ -825,55 +880,55 @@ namespace FFXIVClassic_Map_Server
         public void RequestWorldLinkshellCreate(Player player, string name, ushort crest)
         {
             SubPacket packet = CreateLinkshellPacket.BuildPacket(player.playerSession, name, crest, player.actorId);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellCrestModify(Player player, string name, ushort crest)
         {
             SubPacket packet = ModifyLinkshellPacket.BuildPacket(player.playerSession, 1, name, null, crest, 0);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellDelete(Player player, string name)
         {
             SubPacket packet = DeleteLinkshellPacket.BuildPacket(player.playerSession, name);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellRankChange(Player player, string lsname, string memberName, byte newRank)
         {
             SubPacket packet = LinkshellRankChangePacket.BuildPacket(player.playerSession, memberName, lsname, newRank);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellInviteMember(Player player, string lsname, uint invitedActorId)
         {
             SubPacket packet = LinkshellInvitePacket.BuildPacket(player.playerSession, invitedActorId, lsname);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellCancelInvite(Player player)
         {
             SubPacket packet = LinkshellInviteCancelPacket.BuildPacket(player.playerSession);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellLeave(Player player, string lsname)
         {
             SubPacket packet = LinkshellLeavePacket.BuildPacket(player.playerSession, lsname, null, false);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellKick(Player player, string lsname, string kickedName)
         {
             SubPacket packet = LinkshellLeavePacket.BuildPacket(player.playerSession, lsname, kickedName, true);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         public void RequestWorldLinkshellChangeActive(Player player, string lsname)
         {
             SubPacket packet = LinkshellChangePacket.BuildPacket(player.playerSession, lsname);
-            Server.GetWorldConnection().QueuePacket(packet, true, false);
+            player.QueuePacket(packet);
         }
 
         private void RequestWorldServerZoneChange(Player player, uint destinationZoneId, byte spawnType, float spawnX, float spawnY, float spawnZ, float spawnRotation)

FFXIVClassic Map Server/actors/Actor.cs

@@ -9,6 +9,7 @@ using System.Collections.Generic;
 using FFXIVClassic_Map_Server.actors.area;
 using System.Reflection;
 using System.ComponentModel;
+using FFXIVClassic_Map_Server.packets.send.actor.battle;
 
 namespace FFXIVClassic_Map_Server.Actors
 {
@@ -81,7 +82,7 @@ namespace FFXIVClassic_Map_Server.Actors
                 }
             }
         }
-
+
         public void ResetMoveSpeedsToDefault()
         {
             this.moveSpeeds[0] = SetActorSpeedPacket.DEFAULT_STOP;
@@ -93,58 +94,65 @@ namespace FFXIVClassic_Map_Server.Actors
             this.moveState = this.oldMoveState;
             hasMoved = true;
         }
-
-        public SubPacket CreateAddActorPacket(uint playerActorId, byte val)
+
+        public SubPacket CreateAddActorPacket(byte val)
         {
-            return AddActorPacket.BuildPacket(actorId, playerActorId, val);
+            return AddActorPacket.BuildPacket(actorId, val);
         }
 
-        public SubPacket CreateNamePacket(uint playerActorId)
+        public SubPacket CreateNamePacket()
         {
-            return SetActorNamePacket.BuildPacket(actorId, playerActorId, displayNameId, displayNameId == 0xFFFFFFFF | displayNameId == 0x0 ? customDisplayName : "");
+            return SetActorNamePacket.BuildPacket(actorId, displayNameId, displayNameId == 0xFFFFFFFF | displayNameId == 0x0 ? customDisplayName : "");
         }
 
-        public SubPacket CreateSpeedPacket(uint playerActorId)
+        public SubPacket CreateSpeedPacket()
         {
-            return SetActorSpeedPacket.BuildPacket(actorId, playerActorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
+            return SetActorSpeedPacket.BuildPacket(actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
         }
 
-        public SubPacket CreateSpawnPositonPacket(uint playerActorId, ushort spawnType)
+        public SubPacket CreateSpawnPositonPacket(ushort spawnType)
         {
+            return CreateSpawnPositonPacket(null, spawnType);
+        }
+
+        public SubPacket CreateSpawnPositonPacket(Player player, ushort spawnType)
+        {
+            //TODO: FIX THIS IF
+            uint playerActorId = player == null ? 0 : player.actorId; //Get Rid
             SubPacket spawnPacket;
             if (!spawnedFirstTime && playerActorId == actorId)
-                spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0, positionX, positionY, positionZ, rotation, 0x1, false);
+                spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0, positionX, positionY, positionZ, rotation, 0x1, false);
             else if (playerActorId == actorId)
-                spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, true);
+                spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, true);
             else
             {
                 if (this is Player)
-                    spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0, positionX, positionY, positionZ, rotation, spawnType, false);
+                    spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0, positionX, positionY, positionZ, rotation, spawnType, false);
                 else
-                    spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, actorId, positionX, positionY, positionZ, rotation, spawnType, false);
+                    spawnPacket = SetActorPositionPacket.BuildPacket(actorId, actorId, positionX, positionY, positionZ, rotation, spawnType, false);
             }
 
-            //return SetActorPositionPacket.BuildPacket(actorId, playerActorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE);
+            //return SetActorPositionPacket.BuildPacket(actorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE);
             spawnedFirstTime = true;
 
             return spawnPacket;
         }
 
-        public SubPacket CreateSpawnTeleportPacket(uint playerActorId, ushort spawnType)
+        public SubPacket CreateSpawnTeleportPacket(ushort spawnType)
         {
             SubPacket spawnPacket;
 
-            spawnPacket = SetActorPositionPacket.BuildPacket(actorId, playerActorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, false);
+            spawnPacket = SetActorPositionPacket.BuildPacket(actorId, 0xFFFFFFFF, positionX, positionY, positionZ, rotation, spawnType, false);
 
-            //return SetActorPositionPacket.BuildPacket(actorId, playerActorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE);
+            //return SetActorPositionPacket.BuildPacket(actorId, -211.895477f, 190.000000f, 29.651011f, 2.674819f, SetActorPositionPacket.SPAWNTYPE_PLAYERWAKE);
 
             //spawnPacket.DebugPrintSubPacket();
 
             return spawnPacket;
         }
-
-        public SubPacket CreatePositionUpdatePacket(uint playerActorId)
-        {
+
+        public SubPacket CreatePositionUpdatePacket(bool forceUpdate = false)
+        {
             int updateMs = 300;
             var diffTime = (DateTime.Now - lastMoveUpdate);
 
@@ -153,7 +161,7 @@ namespace FFXIVClassic_Map_Server.Actors
                 updateMs = 150;
             }
 
-            if (hasMoved && ((this is Player ) || diffTime.Milliseconds >= updateMs))
+            if (forceUpdate || (hasMoved && ((this is Player ) || diffTime.Milliseconds >= updateMs)))
             {
                 hasMoved = (this.positionUpdates != null && this.positionUpdates.Count > 0);
                 if (hasMoved)
@@ -172,16 +180,16 @@ namespace FFXIVClassic_Map_Server.Actors
                 }
                 lastMoveUpdate = DateTime.Now;
                 return MoveActorToPositionPacket.BuildPacket(actorId, playerActorId, positionX, positionY, positionZ, rotation, moveState);
-            }
-            return null;
+            }
+            return null;
         }
 
-        public SubPacket CreateStatePacket(uint playerActorID)
+        public SubPacket CreateStatePacket()
         {
-            return SetActorStatePacket.BuildPacket(actorId, playerActorID, currentMainState, currentSubState);
+            return SetActorStatePacket.BuildPacket(actorId, currentMainState, currentSubState);
         }
 
-        public List<SubPacket> GetEventConditionPackets(uint playerActorId)
+        public List<SubPacket> GetEventConditionPackets()
         {
             List<SubPacket> subpackets = new List<SubPacket>();
 
@@ -192,126 +200,147 @@ namespace FFXIVClassic_Map_Server.Actors
             if (eventConditions.talkEventConditions != null)
             {
                 foreach (EventList.TalkEventCondition condition in eventConditions.talkEventConditions)
-                    subpackets.Add(SetTalkEventCondition.BuildPacket(playerActorId, actorId, condition));
+                    subpackets.Add(SetTalkEventCondition.BuildPacket(actorId, condition));
             }
 
             if (eventConditions.noticeEventConditions != null)
             {
                 foreach (EventList.NoticeEventCondition condition in eventConditions.noticeEventConditions)
-                    subpackets.Add(SetNoticeEventCondition.BuildPacket(playerActorId, actorId, condition));
+                    subpackets.Add(SetNoticeEventCondition.BuildPacket(actorId, condition));
             }
 
             if (eventConditions.emoteEventConditions != null)
             {
                 foreach (EventList.EmoteEventCondition condition in eventConditions.emoteEventConditions)
-                    subpackets.Add(SetEmoteEventCondition.BuildPacket(playerActorId, actorId, condition));
+                    subpackets.Add(SetEmoteEventCondition.BuildPacket(actorId, condition));
             }
 
             if (eventConditions.pushWithCircleEventConditions != null)
             {
                 foreach (EventList.PushCircleEventCondition condition in eventConditions.pushWithCircleEventConditions)
-                    subpackets.Add(SetPushEventConditionWithCircle.BuildPacket(playerActorId, actorId, condition));
+                    subpackets.Add(SetPushEventConditionWithCircle.BuildPacket(actorId, condition));
             }
 
             if (eventConditions.pushWithFanEventConditions != null)
             {
                 foreach (EventList.PushFanEventCondition condition in eventConditions.pushWithFanEventConditions)
-                    subpackets.Add(SetPushEventConditionWithFan.BuildPacket(playerActorId, actorId, condition));
+                    subpackets.Add(SetPushEventConditionWithFan.BuildPacket(actorId, condition));
             }
 
             if (eventConditions.pushWithBoxEventConditions != null)
             {
                 foreach (EventList.PushBoxEventCondition condition in eventConditions.pushWithBoxEventConditions)
-                    subpackets.Add(SetPushEventConditionWithTriggerBox.BuildPacket(playerActorId, actorId, condition));
+                    subpackets.Add(SetPushEventConditionWithTriggerBox.BuildPacket(actorId, condition));
             }
 
             return subpackets;
         }
 
-        public BasePacket GetSetEventStatusPackets(uint playerActorId)
+        public List<SubPacket> GetSetEventStatusPackets()
         {
             List<SubPacket> subpackets = new List<SubPacket>();
 
             //Return empty list
             if (eventConditions == null)
-                return BasePacket.CreatePacket(subpackets, true, false);
+                return subpackets;
 
             if (eventConditions.talkEventConditions != null)
             {
                 foreach (EventList.TalkEventCondition condition in eventConditions.talkEventConditions)
-                    subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 1, condition.conditionName));
+                    subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 1, condition.conditionName));
             }
 
             if (eventConditions.noticeEventConditions != null)
             {
                 foreach (EventList.NoticeEventCondition condition in eventConditions.noticeEventConditions)
-                    subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 1, condition.conditionName));
+                    subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 1, condition.conditionName));
             }
 
             if (eventConditions.emoteEventConditions != null)
             {
                 foreach (EventList.EmoteEventCondition condition in eventConditions.emoteEventConditions)
-                    subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 3, condition.conditionName));
+                    subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 3, condition.conditionName));
             }
 
             if (eventConditions.pushWithCircleEventConditions != null)
             {
                 foreach (EventList.PushCircleEventCondition condition in eventConditions.pushWithCircleEventConditions)
-                    subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 2, condition.conditionName));
+                    subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 2, condition.conditionName));
             }
 
             if (eventConditions.pushWithFanEventConditions != null)
             {
                 foreach (EventList.PushFanEventCondition condition in eventConditions.pushWithFanEventConditions)
-                    subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 2, condition.conditionName));
+                    subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 2, condition.conditionName));
             }
 
             if (eventConditions.pushWithBoxEventConditions != null)
             {
                 foreach (EventList.PushBoxEventCondition condition in eventConditions.pushWithBoxEventConditions)
-                    subpackets.Add(SetEventStatus.BuildPacket(playerActorId, actorId, true, 2, condition.conditionName));
+                    subpackets.Add(SetEventStatus.BuildPacket(actorId, true, 2, condition.conditionName));
             }
 
-            return BasePacket.CreatePacket(subpackets, true, false);
+            return subpackets;
         }
 
-        public SubPacket CreateIsZoneingPacket(uint playerActorId)
+        public SubPacket CreateIsZoneingPacket()
         {
-            return SetActorIsZoningPacket.BuildPacket(actorId, playerActorId, false);
+            return SetActorIsZoningPacket.BuildPacket(actorId, false);
         }
 
-        public virtual SubPacket CreateScriptBindPacket(uint playerActorId)
+        public virtual SubPacket CreateScriptBindPacket(Player player)
         {
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, classParams);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, classParams);
         }
 
-        public virtual BasePacket GetSpawnPackets(uint playerActorId)
+        public virtual SubPacket CreateScriptBindPacket()
         {
-            return GetSpawnPackets(playerActorId, 0x1);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, classParams);
         }
 
-        public virtual BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType)
+        public virtual List<SubPacket> GetSpawnPackets(Player player, ushort spawnType)
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId, 8));
-            subpackets.AddRange(GetEventConditionPackets(playerActorId));
-            subpackets.Add(CreateSpeedPacket(playerActorId));
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, spawnType));
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));
-            subpackets.Add(CreateScriptBindPacket(playerActorId));
-            return BasePacket.CreatePacket(subpackets, true, false);
+            subpackets.Add(CreateAddActorPacket(8));
+            subpackets.AddRange(GetEventConditionPackets());
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(player, spawnType));
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.Add(CreateScriptBindPacket(player));
+            return subpackets;
         }
 
-        public virtual BasePacket GetInitPackets(uint playerActorId)
+        public virtual List<SubPacket> GetSpawnPackets()
         {
+            return GetSpawnPackets(0x1);
+        }
+
+        public virtual List<SubPacket> GetSpawnPackets(ushort spawnType)
+        {
+            List<SubPacket> subpackets = new List<SubPacket>();
+            subpackets.Add(CreateAddActorPacket(8));
+            subpackets.AddRange(GetEventConditionPackets());
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(null, spawnType));
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.Add(CreateScriptBindPacket());
+            return subpackets;
+        }
+
+        public virtual List<SubPacket> GetInitPackets()
+        {
+            List<SubPacket> packets = new List<SubPacket>();
             SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init");
             initProperties.AddByte(0xE14B0CA8, 1);
             initProperties.AddByte(0x2138FD71, 1);
             initProperties.AddByte(0xFBFBCFB1, 1);
             initProperties.AddTarget();
-            return BasePacket.CreatePacket(initProperties.BuildPacket(playerActorId, actorId), true, false);
+            packets.Add(initProperties.BuildPacket(actorId));
+            return packets;
         }
 
         public override bool Equals(Object obj)
@@ -346,8 +375,8 @@ namespace FFXIVClassic_Map_Server.Actors
         public void ChangeState(ushort newState)
         {
             currentMainState = newState;
-            SubPacket ChangeStatePacket = SetActorStatePacket.BuildPacket(actorId, actorId, newState, currentSubState);
-            SubPacket battleActionPacket = BattleAction1Packet.BuildPacket(actorId, actorId);
+            SubPacket ChangeStatePacket = SetActorStatePacket.BuildPacket(actorId, newState, currentSubState);       
+            SubPacket battleActionPacket = BattleActionX01Packet.BuildPacket(actorId, actorId, actorId, 0x72000062, 1, 0, 0x05209, 0, 0);
             zone.BroadcastPacketAroundActor(this, ChangeStatePacket);
             zone.BroadcastPacketAroundActor(this, battleActionPacket);
         }
@@ -355,7 +384,7 @@ namespace FFXIVClassic_Map_Server.Actors
         public void ChangeSpeed(int type, float value)
         {
             moveSpeeds[type] = value;
-            SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
+            SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
             zone.BroadcastPacketAroundActor(this, ChangeSpeedPacket);
         }
 
@@ -365,7 +394,7 @@ namespace FFXIVClassic_Map_Server.Actors
             moveSpeeds[1] = speedWalk;
             moveSpeeds[2] = speedRun;
             moveSpeeds[3] = speedActive;
-            SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
+            SubPacket ChangeSpeedPacket = SetActorSpeedPacket.BuildPacket(actorId, moveSpeeds[0], moveSpeeds[1], moveSpeeds[2], moveSpeeds[3]);
             zone.BroadcastPacketAroundActor(this, ChangeSpeedPacket);
         }
 
@@ -475,8 +504,8 @@ namespace FFXIVClassic_Map_Server.Actors
                         SetActorPropetyPacket changeProperty = new SetActorPropetyPacket(uiFunc);
                         changeProperty.AddProperty(this, name);
                         changeProperty.AddTarget();
-                        SubPacket subpacket = changeProperty.BuildPacket(player.actorId, player.actorId);
-                        player.playerSession.QueuePacket(subpacket, true, false);
+                        SubPacket subpacket = changeProperty.BuildPacket(player.actorId);
+                        player.playerSession.QueuePacket(subpacket);
                         subpacket.DebugPrintSubPacket();
                         return true;
                     }
@@ -493,8 +522,8 @@ namespace FFXIVClassic_Map_Server.Actors
                         SetActorPropetyPacket changeProperty = new SetActorPropetyPacket(uiFunc);
                         changeProperty.AddProperty(this, name);
                         changeProperty.AddTarget();
-                        SubPacket subpacket = changeProperty.BuildPacket(player.actorId, player.actorId);
-                        player.playerSession.QueuePacket(subpacket, true, false);
+                        SubPacket subpacket = changeProperty.BuildPacket(player.actorId);
+                        player.playerSession.QueuePacket(subpacket);
                         subpacket.DebugPrintSubPacket();
                         return true;
                     }
@@ -516,6 +545,11 @@ namespace FFXIVClassic_Map_Server.Actors
             return pos;
         }
 
+        public Vector3 GetPosAsVector3()
+        {
+            return new Vector3(positionX, positionY, positionZ);
+        }
+
         public void SetPos(float x, float y, float z, float rot = 0, uint zoneId = 0)
         {
             oldPositionX = positionX;
@@ -529,7 +563,7 @@ namespace FFXIVClassic_Map_Server.Actors
             rotation = rot;
 
             // todo: handle zone?
-            zone.BroadcastPacketAroundActor(this, MoveActorToPositionPacket.BuildPacket(this.actorId, this.actorId, x, y, z, rot, moveState));
+            zone.BroadcastPacketAroundActor(this, MoveActorToPositionPacket.BuildPacket(actorId, x, y, z, rot, moveState));
         }
 
         public Area GetZone()

FFXIVClassic Map Server/actors/area/Area.cs

@@ -84,24 +84,24 @@ namespace FFXIVClassic_Map_Server.Actors
             }
         }
 
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket()
         {
             List<LuaParam> lParams;
             lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, "/Area/Zone/ZoneDefault", -1, (byte)1, true, false, false, false, false, false, false, false);
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, "ZoneDefault", lParams);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, "ZoneDefault", lParams);
         }
 
-        public override BasePacket GetSpawnPackets(uint playerActorId)
+        public override List<SubPacket> GetSpawnPackets()
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId, 0));            
-            subpackets.Add(CreateSpeedPacket(playerActorId));
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x1));
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));
-            subpackets.Add(CreateScriptBindPacket(playerActorId));
-            return BasePacket.CreatePacket(subpackets, true, false);
+            subpackets.Add(CreateAddActorPacket(0));            
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(0x1));
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.Add(CreateScriptBindPacket());
+            return subpackets;
         }
 
         #region Actor Management
@@ -368,6 +368,26 @@ namespace FFXIVClassic_Map_Server.Actors
             }
         }
 
+        // todo: for zones override this to seach contentareas (assuming flag is passed)
+        public virtual List<Actor> GetAllActors()
+        {
+            lock (mActorList)
+            {
+                List<Actor> actorList = new List<Actor>(mActorList.Count);
+                foreach (var actor in mActorList.Values)
+                {
+                    actorList.Add(actor);
+                }
+                return actorList;
+            }
+        }
+
+        public void BroadcastPacketsAroundActor(Actor actor, List<SubPacket> packets)
+        {
+            foreach (SubPacket packet in packets)
+                BroadcastPacketAroundActor(actor, packet);
+        }
+
         public void BroadcastPacketAroundActor(Actor actor, SubPacket packet)
         {
             if (isIsolated)
@@ -466,6 +486,11 @@ namespace FFXIVClassic_Map_Server.Actors
             RemoveActorFromZone(FindActorInZoneByUniqueID(uniqueId));
         }
 
+        public void DespawnActor(Actor actor)
+        {
+            RemoveActorFromZone(actor);
+        }
+
         public Director GetWeatherDirector()
         {
             return mWeatherDirector;
@@ -477,7 +502,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
             if (player != null && !zoneWide)
             {
-                player.QueuePacket(BasePacket.CreatePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime), true, false));
+                player.QueuePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime));
             }
             if (zoneWide)
             {
@@ -488,23 +513,67 @@ namespace FFXIVClassic_Map_Server.Actors
                         if (actor.Value is Player)
                         {
                             player = ((Player)actor.Value);
-                            player.QueuePacket(BasePacket.CreatePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime), true, false));
+                            player.QueuePacket(SetWeatherPacket.BuildPacket(player.actorId, weather, transitionTime));
                         }
                     }
                 }
             }
         }                
 
-        public Director CreateDirector(string path)
+        public Director CreateDirector(string path, params object[] args)
         {
             lock (directorLock)
             {
-                Director director = new Director(directorIdCount, this, path);
+                Director director = new Director(directorIdCount, this, path, args);
+                currentDirectors.Add(director.actorId, director);
+                directorIdCount++;
+                return director;
+            }
+        }
 
-                if (!director.IsCreated())
-                    return null;
+        public Director CreateGuildleveDirector(uint glid, byte difficulty, Player owner, params object[] args)
+        {
+            String directorScriptPath = "";
 
-                currentDirectors.Add(directorIdCount, director);
+            uint type = Server.GetGuildleveGamedata(glid).plateId;
+
+            if (glid == 10801 || glid == 12401 || glid == 11601)
+                directorScriptPath = "Guildleve/PrivateGLBattleTutorial";
+            else
+            {
+                switch (type)
+                {
+                    case 20021:
+                        directorScriptPath = "Guildleve/PrivateGLBattleSweepNormal";
+                        break;
+                    case 20022:
+                        directorScriptPath = "Guildleve/PrivateGLBattleChaseNormal";
+                        break;
+                    case 20023:
+                        directorScriptPath = "Guildleve/PrivateGLBattleOrbNormal";
+                        break;
+                    case 20024:
+                        directorScriptPath = "Guildleve/PrivateGLBattleHuntNormal";
+                        break;
+                    case 20025:
+                        directorScriptPath = "Guildleve/PrivateGLBattleGatherNormal";
+                        break;
+                    case 20026:
+                        directorScriptPath = "Guildleve/PrivateGLBattleRoundNormal";
+                        break;
+                    case 20027:
+                        directorScriptPath = "Guildleve/PrivateGLBattleSurviveNormal";
+                        break;
+                    case 20028:
+                        directorScriptPath = "Guildleve/PrivateGLBattleDetectNormal";
+                        break;                   
+                }
+            }
+
+            lock (directorLock)
+            {
+                GuildleveDirector director = new GuildleveDirector(directorIdCount, this, directorScriptPath, glid, difficulty, owner, args);
+                currentDirectors.Add(director.actorId, director);
                 directorIdCount++;
                 return director;
             }
@@ -516,7 +585,8 @@ namespace FFXIVClassic_Map_Server.Actors
             {
                 if (currentDirectors.ContainsKey(id))
                 {
-                    currentDirectors[id].RemoveChildren();
+                    if (!currentDirectors[id].IsDeleted())
+                        currentDirectors[id].EndDirector();
                     currentDirectors.Remove(id);
                 }
             }

FFXIVClassic Map Server/actors/area/PrivateArea.cs

@@ -41,7 +41,7 @@ namespace FFXIVClassic_Map_Server.actors.area
             return parentZone;
         }
 
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket()
         {
             List<LuaParam> lParams;
 
@@ -50,8 +50,8 @@ namespace FFXIVClassic_Map_Server.actors.area
             string realClassName = className.Substring(className.LastIndexOf("/") + 1);
 
             lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, privateAreaName, privateAreaType, canRideChocobo ? (byte)1 : (byte)0, canStealth, isInn, false, false, false, false, false, false);
-            ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, realClassName, lParams).DebugPrintSubPacket();
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, realClassName, lParams);
+            ActorInstantiatePacket.BuildPacket(actorId, actorName, realClassName, lParams).DebugPrintSubPacket();
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, realClassName, lParams);
         }
 
 

FFXIVClassic Map Server/actors/area/Zone.cs

@@ -75,13 +75,13 @@ namespace FFXIVClassic_Map_Server.actors.area
                 return null;
         }
 
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket()
         {
             bool isEntranceDesion = false;
 
             List<LuaParam> lParams;
             lParams = LuaUtils.CreateLuaParamList(classPath, false, true, zoneName, "", -1, canRideChocobo ? (byte)1 : (byte)0, canStealth, isInn, false, false, false, true, isInstanceRaid, isEntranceDesion);
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams);        
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);        
         }
 
         public void AddSpawnLocation(SpawnLocation spawn)

FFXIVClassic Map Server/actors/chara/Character.cs

@@ -75,33 +75,33 @@ namespace FFXIVClassic_Map_Server.Actors
             this.statusEffects = new StatusEffects(this);
         }
 
-        public SubPacket CreateAppearancePacket(uint playerActorId)
+        public SubPacket CreateAppearancePacket()
         {
             SetActorAppearancePacket setappearance = new SetActorAppearancePacket(modelId, appearanceIds);
-            return setappearance.BuildPacket(actorId, playerActorId);
+            return setappearance.BuildPacket(actorId);
         }
 
-        public SubPacket CreateInitStatusPacket(uint playerActorId)
+        public SubPacket CreateInitStatusPacket()
         {
-            return (SetActorStatusAllPacket.BuildPacket(actorId, playerActorId, charaWork.status));                      
+            return (SetActorStatusAllPacket.BuildPacket(actorId, charaWork.status));                      
         }
 
-        public SubPacket CreateSetActorIconPacket(uint playerActorId)
+        public SubPacket CreateSetActorIconPacket()
         {
-            return SetActorIconPacket.BuildPacket(actorId, playerActorId, currentActorIcon);
+            return SetActorIconPacket.BuildPacket(actorId, currentActorIcon);
         }
 
-        public SubPacket CreateIdleAnimationPacket(uint playerActorId)
+        public SubPacket CreateIdleAnimationPacket()
         {
-            return SetActorSubStatPacket.BuildPacket(actorId, playerActorId, 0, 0, 0, 0, 0, 0, animationId);
+            return SetActorSubStatPacket.BuildPacket(actorId, 0, 0, 0, 0, 0, 0, animationId);
         }
 
         public void SetQuestGraphic(Player player, int graphicNum)
         {
-            player.QueuePacket(SetActorQuestGraphicPacket.BuildPacket(player.actorId, actorId, graphicNum));
+            player.QueuePacket(SetActorQuestGraphicPacket.BuildPacket(actorId, graphicNum));
         }
 
-        public void SetCurrentContentGroup(ContentGroup group, Player player = null)
+        public void SetCurrentContentGroup(ContentGroup group)
         {
             if (group != null)
                 charaWork.currentContentGroup = group.GetTypeId();
@@ -110,17 +110,21 @@ namespace FFXIVClassic_Map_Server.Actors
 
             currentContentGroup = group;
 
-            if (player != null)
-            {
-                ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("charaWork/currentContentGroup", this, actorId);
-                propPacketUtil.AddProperty("charaWork.currentContentGroup");
-                player.QueuePackets(propPacketUtil.Done());
-            }
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("charaWork/currentContentGroup", this);
+            propPacketUtil.AddProperty("charaWork.currentContentGroup");            
+            zone.BroadcastPacketsAroundActor(this, propPacketUtil.Done());
+
         }     
    
-        public void PlayAnimation(uint animId)
+        public void PlayAnimation(uint animId, bool onlySelf = false)
         {            
-            zone.BroadcastPacketAroundActor(this, PlayAnimationOnActorPacket.BuildPacket(actorId, actorId, animId));
+            if (onlySelf)
+            {
+                if (this is Player)
+                    ((Player)this).QueuePacket(PlayAnimationOnActorPacket.BuildPacket(actorId, animId));
+            }
+            else
+                zone.BroadcastPacketAroundActor(this, PlayAnimationOnActorPacket.BuildPacket(actorId, animId));
         }
 
         public void PathTo(float x, float y, float z, float stepSize = 0.70f, int maxPath = 40, float polyRadius = 0.0f)
@@ -381,6 +385,15 @@ namespace FFXIVClassic_Map_Server.Actors
 
         }
 
+        public bool IsDead()
+        {
+            return currentMainState == SetActorStatePacket.MAIN_STATE_DEAD || currentMainState == SetActorStatePacket.MAIN_STATE_DEAD2;
+        }
+
+        public bool IsAlive()
+        {
+            return !IsDead();
+        }
     }
 
 }

FFXIVClassic Map Server/actors/chara/ai/TargetFind.cs

@@ -4,16 +4,245 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using FFXIVClassic_Map_Server.Actors;
+using FFXIVClassic.Common;
+
+// port of dsp's ai code https://github.com/DarkstarProject/darkstar/blob/master/src/map/ai/
 
 namespace FFXIVClassic_Map_Server.actors.chara.ai
 {
+    /// <summary> todo: what even do i summarise this as? </summary>
+    [Flags]
+    enum TargetFindFlags
+    {
+        None,
+        /// <summary> Able to target <see cref="Player"/>s even if not in target's party </summary>
+        All,
+        /// <summary> Able to target all <see cref="Player"/>s in target's party/alliance </summary>
+        Alliance,
+        /// <summary> Able to target any <see cref="Pet"/> in target's party/alliance </summary>
+        Pets,
+        /// <summary> Target all in zone, regardless of distance </summary>
+        ZoneWide,
+        /// <summary> Able to target dead <see cref="Player"/>s </summary>
+        Dead,
+    }
+
+    /// <summary> Targeting from/to different entity types </summary>
+    enum TargetFindCharacterType
+    {
+        None,
+        /// <summary> Player can target all <see cref="Player">s in party </summary>
+        PlayerToPlayer,
+        /// <summary> Player can target all <see cref="BattleNpc"/>s (excluding player owned <see cref="Pet"/>s) </summary>
+        PlayerToBattleNpc,
+        /// <summary> BattleNpc can target other <see cref="BattleNpc"/>s </summary>
+        BattleNpcToBattleNpc,
+        /// <summary> BattleNpc can target <see cref="Player"/>s and their <see cref="Pet"/>s </summary>
+        BattleNpcToPlayer,
+    }
+
+    /// <summary> Type of AOE region to create </summary>
+    enum TargetFindAOEType
+    {
+        None,
+        /// <summary> Really a cylinder, uses extents parameter in SetAOEType </summary>
+        Circle,
+        /// <summary> Create a cone with angle in radians </summary>
+        Cone,
+        /// <summary> Box using self/target coords and </summary>
+        Box
+    }
+
+    /// <summary> Set AOE around self or target </summary>
+    enum TargetFindAOERadiusType
+    {
+        /// <summary> Set AOE's origin at target's position </summary>
+        Target,
+        /// <summary> Set AOE's origin to own position. </summary>
+        Self
+    }
+
+    /// <summary> Target finding helper class </summary>
     class TargetFind
     {
         private Character owner;
+        private Character target;
+        private TargetFindCharacterType findType;
+        private TargetFindFlags findFlags;
+        private TargetFindAOEType aoeType;
+        private TargetFindAOERadiusType radiusType;
+        private Vector3 targetPosition;
+        private float extents;
+        private float angle;
+        private List<Character> targets;
 
         public TargetFind(Character owner)
         {
             this.owner = owner;
+            Reset();
         }
+
+        public void Reset()
+        {
+            this.target = null;
+            this.findType = TargetFindCharacterType.None;
+            this.findFlags = TargetFindFlags.None;
+            this.aoeType = TargetFindAOEType.None;
+            this.radiusType = TargetFindAOERadiusType.Self;
+            this.targetPosition = null;
+            this.extents = 0.0f;
+            this.angle = 0.0f;
+            this.targets = new List<Character>();
+        }
+
+        /// <summary>
+        /// Call this before <see cref="FindWithinArea"/> <para/>
+        /// </summary>
+        /// <param name="extents">
+        /// <see cref="TargetFindAOEType.Circle"/> - radius of circle <para/>
+        /// <see cref="TargetFindAOEType.Cone"/> - height of cone <para/>
+        /// <see cref="TargetFindAOEType.Box"/> - width of box / 2
+        /// </param>
+        /// <param name="angle"> Angle in radians of cone </param>
+        public void SetAOEType(TargetFindAOERadiusType radiusType, TargetFindAOEType aoeType, float extents = -1.0f, float angle = -1.0f)
+        {
+            this.radiusType = TargetFindAOERadiusType.Target;
+            this.aoeType = aoeType;
+            this.extents = extents != -1.0f ? extents : 0.0f;
+            this.angle = angle != -1.0f ? angle : 0.0f;
+        }
+
+        /// <summary>
+        /// Find and try to add a single target to target list
+        /// </summary>
+        public void FindTarget(Character target, TargetFindFlags flags)
+        {
+            findFlags = flags;
+            this.target = null;
+            // todo: maybe this should only be set if successfully added?
+            this.targetPosition = target.GetPosAsVector3();
+            AddTarget(target, false);
+        }
+
+        /// <summary>
+        /// <para> Call SetAOEType before calling this </para>
+        /// Find targets within area set by <see cref="SetAOEType"/>
+        /// </summary>
+        /// <param name="withPet">Include pets?</param>
+
+        public void FindWithinArea(Character target, TargetFindFlags flags, bool withPet)
+        {
+            // todo: maybe we should keep a snapshot which is only updated on each tick for consistency
+
+            // are we creating aoe circles around target or self
+            if ((aoeType & TargetFindAOEType.Circle) != 0 && radiusType != TargetFindAOERadiusType.Self)
+                this.targetPosition = owner.GetPosAsVector3();
+            else
+                this.targetPosition = new Vector3(target.positionX, target.positionY, target.positionZ);
+
+            this.findFlags = flags;
+            if (aoeType == TargetFindAOEType.Box)
+            {
+                FindWithinBox(withPet);
+            }
+            else if (aoeType == TargetFindAOEType.Circle)
+            {
+                FindWithinCircle(withPet);
+            }
+        }
+
+        /// <summary>
+        /// Find targets within a box using owner's coordinates and target's coordinates as length
+        /// with corners being `extents` yalms to either side of self and target
+        /// </summary>
+        private void FindWithinBox(bool withPet)
+        {
+            // todo: loop over party members
+            if ((findFlags & TargetFindFlags.All) != 0)
+            {
+                // if we have flag set to hit all characters in zone, do it
+
+                // todo: make the distance check modifiable
+                var actors = (findFlags & TargetFindFlags.ZoneWide) != 0 ? owner.zone.GetAllActors() : owner.zone.GetActorsAroundActor(owner, 30);
+                var myPos = owner.GetPosAsVector3();
+                var angle = Vector3.GetAngle(myPos, targetPosition);
+
+                // todo: actually check this works..
+                var myCorner = myPos.NewHorizontalVector(angle, extents);
+                var myCorner2 = myPos.NewHorizontalVector(angle, -extents);
+
+                var targetCorner = targetPosition.NewHorizontalVector(angle, extents);
+                var targetCorner2 = targetPosition.NewHorizontalVector(angle, -extents);
+
+                foreach (Character actor in actors)
+                {
+                    // dont wanna add static actors
+                    if (actor is Player || actor is BattleNpc)
+                    {
+                        if (actor.GetPosAsVector3().IsWithinBox(myCorner2, targetCorner))
+                        {
+                            if (CanTarget(actor))
+                                AddTarget(actor, withPet);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Find targets within circle area. <para/>
+        /// As the name implies, it only checks horizontal coords, not vertical - 
+        /// effectively creating cylinder with infinite height
+        /// </summary>
+        private void FindWithinCircle(bool withPet)
+        {
+            var actors = (findFlags & TargetFindFlags.ZoneWide) != 0 ? owner.zone.GetAllActors() : owner.zone.GetActorsAroundActor(owner, 30);
+
+            foreach (Character target in actors)
+            {
+                if (target is Player || target is BattleNpc)
+                {
+                    if (target.GetPosAsVector3().IsWithinCircle(targetPosition, extents))
+                        AddTarget(target, withPet);
+                }
+            }
+        }
+
+        private void AddTarget(Character target, bool withPet)
+        {
+            if (CanTarget(target))
+            {
+                // todo: add pets too
+                targets.Add(target);
+            }
+        }
+
+        private void AddAllInParty(Character target, bool withPet)
+        {
+            // todo:
+        }
+
+        private void AddAllInAlliance(Character target, bool withPet)
+        {
+            // todo:
+        }
+
+        public bool CanTarget(Character target)
+        {
+            // already targeted, dont target again
+            if (targets.Contains(target))
+                return false;
+
+            // cant target dead
+            if ((findFlags & TargetFindFlags.Dead) == 0 && target.IsDead())
+                return false;
+
+            // cant target if player is zoning
+            if (target is Player && ((Player)target).playerSession.isUpdatesLocked)
+                return false;
+
+            return true;
+        }
+
     }
 }

FFXIVClassic Map Server/actors/chara/npc/Npc.cs

@@ -127,27 +127,18 @@ namespace FFXIVClassic_Map_Server.Actors
             GenerateActorName((int)actorNumber);
         }
 
-        public SubPacket CreateAddActorPacket(uint playerActorId)
+        public SubPacket CreateAddActorPacket()
         {
-            return AddActorPacket.BuildPacket(actorId, playerActorId, 8);
+            return AddActorPacket.BuildPacket(actorId, 8);
         }
 
-        int val = 0x0b00;
         // actorClassId, [], [], numBattleCommon, [battleCommon], numEventCommon, [eventCommon], args for either initForBattle/initForEvent
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket(Player player)
         {
             List<LuaParam> lParams;
-
-            Player player = Server.GetWorldManager().GetPCInWorld(playerActorId);
+            
             lParams = LuaEngine.GetInstance().CallLuaFunctionForReturn(player, this, "init", false);
 
-            if (uniqueIdentifier.Equals("1"))
-            {
-                lParams[5].value = val;
-                val++;
-                player.SendMessage(0x20, "", String.Format("ID is now: 0x{0:X}", val));                
-            }
-
             if (lParams != null && lParams.Count >= 3 && lParams[2].typeID == 0 && (int)lParams[2].value == 0)
                 isStatic = true;
             else
@@ -162,8 +153,8 @@ namespace FFXIVClassic_Map_Server.Actors
                 string classNameFake = "PopulaceStandard";
                 lParams = LuaUtils.CreateLuaParamList(classPathFake, false, false, false, false, false, 0xF47F6, false, false, 0, 0);
                 isStatic = true;
-                //ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, classNameFake, lParams).DebugPrintSubPacket();
-                return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, classNameFake, lParams);
+                //ActorInstantiatePacket.BuildPacket(actorId, actorName, classNameFake, lParams).DebugPrintSubPacket();
+                return ActorInstantiatePacket.BuildPacket(actorId, actorName, classNameFake, lParams);
             }
             else
             {
@@ -176,37 +167,37 @@ namespace FFXIVClassic_Map_Server.Actors
                 lParams.Insert(6, new LuaParam(0, (int)actorClassId));
             }
 
-            //ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams).DebugPrintSubPacket();
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams);
+            //ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams).DebugPrintSubPacket();
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
         }
-        
-        public override BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType)
+
+        public override List<SubPacket> GetSpawnPackets(Player player, ushort spawnType)
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId));
-            subpackets.AddRange(GetEventConditionPackets(playerActorId));
-            subpackets.Add(CreateSpeedPacket(playerActorId));            
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x0));
+            subpackets.Add(CreateAddActorPacket());
+            subpackets.AddRange(GetEventConditionPackets());
+            subpackets.Add(CreateSpeedPacket());            
+            subpackets.Add(CreateSpawnPositonPacket(0x0));
 
             if (isMapObj)            
-                subpackets.Add(_0xD8Packet.BuildPacket(actorId, playerActorId, instance, layout));                        
+                subpackets.Add(SetActorBGPropertiesPacket.BuildPacket(actorId, instance, layout));                        
             else
-                subpackets.Add(CreateAppearancePacket(playerActorId));
+                subpackets.Add(CreateAppearancePacket());
 
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIdleAnimationPacket(playerActorId));
-            subpackets.Add(CreateInitStatusPacket(playerActorId));
-            subpackets.Add(CreateSetActorIconPacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));           
-            subpackets.Add(CreateScriptBindPacket(playerActorId));            
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIdleAnimationPacket());
+            subpackets.Add(CreateInitStatusPacket());
+            subpackets.Add(CreateSetActorIconPacket());
+            subpackets.Add(CreateIsZoneingPacket());           
+            subpackets.Add(CreateScriptBindPacket(player));            
 
-            return BasePacket.CreatePacket(subpackets, true, false);
+            return subpackets;
         }
 
-        public override BasePacket GetInitPackets(uint playerActorId)
+        public override List<SubPacket> GetInitPackets()
         {
-            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this, playerActorId);
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this);
 
             //Potential
             propPacketUtil.AddProperty("charaWork.battleSave.potencial");
@@ -260,7 +251,7 @@ namespace FFXIVClassic_Map_Server.Actors
                 propPacketUtil.AddProperty("npcWork.pushCommandPriority");
             }
 
-            return BasePacket.CreatePacket(propPacketUtil.Done(), true, false);
+            return propPacketUtil.Done();
         }
 
         public string GetUniqueId()
@@ -276,7 +267,7 @@ namespace FFXIVClassic_Map_Server.Actors
         public void ChangeNpcAppearance(uint id)
         {
             LoadNpcAppearance(id);
-            zone.BroadcastPacketAroundActor(this, CreateAppearancePacket(actorId));
+            zone.BroadcastPacketAroundActor(this, CreateAppearancePacket());
         }
 
         public void LoadNpcAppearance(uint id)
@@ -394,10 +385,16 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public void PlayMapObjAnimation(Player player, string animationName)
         {
-            player.QueuePacket(PlayBGAnimation.BuildPacket(actorId, player.actorId, animationName));
+            player.QueuePacket(PlayBGAnimation.BuildPacket(actorId, animationName));
         }
 
-        public void Update(DateTime tick)
+
+        public void Despawn()
+        {
+            zone.DespawnActor(this);
+        }
+
+        public void Update(double deltaTime)
         {
             var deltaTime = (tick - aiContainer.GetLatestUpdate()).Milliseconds;
             LuaEngine.GetInstance().CallLuaFunction(null, this, "onUpdate", true, deltaTime);         

FFXIVClassic Map Server/actors/chara/player/Equipment.cs

@@ -63,24 +63,24 @@ namespace FFXIVClassic_Map_Server.actors.chara.player
                 }
             }
 
-            toPlayer.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, toPlayer.actorId, 0x23, Inventory.EQUIPMENT_OTHERPLAYER));
+            toPlayer.QueuePacket(InventorySetBeginPacket.BuildPacket(owner.actorId, 0x23, Inventory.EQUIPMENT_OTHERPLAYER));
             int currentIndex = 0;
 
             while (true)
             {
                 if (items.Count - currentIndex >= 16)
-                    toPlayer.QueuePacket(InventoryListX16Packet.BuildPacket(owner.actorId, toPlayer.actorId, items, ref currentIndex));
+                    toPlayer.QueuePacket(InventoryListX16Packet.BuildPacket(owner.actorId, items, ref currentIndex));
                 else if (items.Count - currentIndex > 1)
-                    toPlayer.QueuePacket(InventoryListX08Packet.BuildPacket(owner.actorId, toPlayer.actorId, items, ref currentIndex));
+                    toPlayer.QueuePacket(InventoryListX08Packet.BuildPacket(owner.actorId, items, ref currentIndex));
                 else if (items.Count - currentIndex == 1)
                 {
-                    toPlayer.QueuePacket(InventoryListX01Packet.BuildPacket(owner.actorId, toPlayer.actorId, items[currentIndex]));
+                    toPlayer.QueuePacket(InventoryListX01Packet.BuildPacket(owner.actorId, items[currentIndex]));
                     currentIndex++;
                 }
                 else
                     break;
             }
-            toPlayer.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId, toPlayer.actorId));
+            toPlayer.QueuePacket(InventorySetEndPacket.BuildPacket(owner.actorId));
         }
 
         public void SendFullEquipment(bool DoClear)

FFXIVClassic Map Server/actors/chara/player/Inventory.cs

@@ -1,5 +1,5 @@
-
-using FFXIVClassic.Common;
+
+using FFXIVClassic.Common;
 using FFXIVClassic_Map_Server.Actors;
 using FFXIVClassic_Map_Server.dataobjects;
 using FFXIVClassic_Map_Server.packets.send.actor.inventory;
@@ -92,14 +92,14 @@ namespace FFXIVClassic_Map_Server.actors.chara.player
             if (!IsSpaceForAdd(itemId, quantity))
                 return false;
 
-            Item gItem = Server.GetItemGamedata(itemId);
+            ItemData gItem = Server.GetItemGamedata(itemId);
             List<ushort> slotsToUpdate = new List<ushort>();
             List<SubPacket> addItemPackets = new List<SubPacket>();
-
+            
             if (gItem == null)
             {
                 Program.Log.Error("Inventory.AddItem: unable to find item %u", itemId);
-                return false;
+                return false;
             }
 
             //Check if item id exists 
@@ -175,7 +175,7 @@ namespace FFXIVClassic_Map_Server.actors.chara.player
             //New item that spilled over
             for (int i = 0; i < itemId.Length; i++)
             {
-                Item gItem = Server.GetItemGamedata(itemId[i]);
+                ItemData gItem = Server.GetItemGamedata(itemId[i]);
                 InventoryItem addedItem = Database.AddItem(owner, itemId[i], 1, (byte)1, gItem.isExclusive ? (byte)0x3 : (byte)0x0, gItem.durability, inventoryCode);
                 list.Add(addedItem);
             }
@@ -457,7 +457,7 @@ namespace FFXIVClassic_Map_Server.actors.chara.player
             for (int i = 0; i < list.Count; i++)
             {
                 InventoryItem item = list[i];
-                Item gItem = Server.GetItemGamedata(item.itemId);
+                ItemData gItem = Server.GetItemGamedata(item.itemId);
                 if (item.itemId == itemId && item.quantity < gItem.maxStack)
                 {
                     quantityCount -= (gItem.maxStack - item.quantity);

FFXIVClassic Map Server/actors/chara/player/Player.cs

@@ -211,11 +211,7 @@ namespace FFXIVClassic_Map_Server.Actors
             charaWork.command[12] = 0xA0F00000 | 22012;
             charaWork.command[13] = 0xA0F00000 | 22013;
             charaWork.command[14] = 0xA0F00000 | 29497;
-            charaWork.command[15] = 0xA0F00000 | 22015;
-
-            charaWork.command[32] = 0xA0F00000 | 27191;
-            charaWork.command[33] = 0xA0F00000 | 22302;
-            charaWork.command[34] = 0xA0F00000 | 28466;
+            charaWork.command[15] = 0xA0F00000 | 22015;            
 
             charaWork.commandAcquired[27150 - 26000] = true;
 
@@ -235,13 +231,9 @@ namespace FFXIVClassic_Map_Server.Actors
 
             charaWork.commandCategory[0] = 1;
             charaWork.commandCategory[1] = 1;
-            charaWork.commandCategory[32] = 1;
-            charaWork.commandCategory[33] = 1;
-            charaWork.commandCategory[34] = 1;
 
             charaWork.parameterSave.commandSlot_compatibility[0] = true;
             charaWork.parameterSave.commandSlot_compatibility[1] = true;
-            charaWork.parameterSave.commandSlot_compatibility[32] = true;
 
             charaWork.commandBorder = 0x20;
 
@@ -253,17 +245,17 @@ namespace FFXIVClassic_Map_Server.Actors
             this.aiContainer = new AIContainer(this, new PlayerController(this), null, new TargetFind(this));
         }
         
-        public List<SubPacket> Create0x132Packets(uint playerActorId)
+        public List<SubPacket> Create0x132Packets()
         {
             List<SubPacket> packets = new List<SubPacket>();
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0xB, "commandForced"));
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0xA, "commandDefault"));
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x6, "commandWeak"));
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x4, "commandContent"));
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x6, "commandJudgeMode"));
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x100, "commandRequest"));
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x100, "widgetCreate"));
-            packets.Add(_0x132Packet.BuildPacket(playerActorId, 0x100, "macroRequest"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0xB, "commandForced"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0xA, "commandDefault"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0x6, "commandWeak"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0x4, "commandContent"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0x6, "commandJudgeMode"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0x100, "commandRequest"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0x100, "widgetCreate"));
+            packets.Add(_0x132Packet.BuildPacket(actorId, 0x100, "macroRequest"));
             return packets;
         }
 
@@ -276,12 +268,12 @@ namespace FFXIVClassic_Map_Server.Actors
          * Unknown - Number
          * Unknown - Bool
          * Timer Array - 20 Number
-        */
-
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        */
+
+        public override SubPacket CreateScriptBindPacket(Player requestPlayer)
         {
             List<LuaParam> lParams;
-            if (IsMyPlayer(playerActorId))
+            if (IsMyPlayer(requestPlayer.actorId))
             {
                 if (loginInitDirector != null)
                     lParams = LuaUtils.CreateLuaParamList("/Chara/Player/Player_work", false, false, true, loginInitDirector, true, 0, false, timers, true);
@@ -291,69 +283,74 @@ namespace FFXIVClassic_Map_Server.Actors
             else
                 lParams = LuaUtils.CreateLuaParamList("/Chara/Player/Player_work", false, false, false, false, false, true);
 
-            ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams).DebugPrintSubPacket();
+            ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams).DebugPrintSubPacket();
 
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
         }
 
-        public override BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType)
+        public override List<SubPacket> GetSpawnPackets(Player requestPlayer, ushort spawnType)
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId, 8));
-            if (IsMyPlayer(playerActorId))
-                subpackets.AddRange(Create0x132Packets(playerActorId));
-            subpackets.Add(CreateSpeedPacket(playerActorId));
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, spawnType));
-            subpackets.Add(CreateAppearancePacket(playerActorId));
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(_0xFPacket.BuildPacket(playerActorId, playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIdleAnimationPacket(playerActorId));
-            subpackets.Add(CreateInitStatusPacket(playerActorId));
-            subpackets.Add(CreateSetActorIconPacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));
-            subpackets.AddRange(CreatePlayerRelatedPackets(playerActorId));
-            subpackets.Add(CreateScriptBindPacket(playerActorId));            
-            return BasePacket.CreatePacket(subpackets, true, false);
+            subpackets.Add(CreateAddActorPacket(8));
+            if (IsMyPlayer(requestPlayer.actorId))
+                subpackets.AddRange(Create0x132Packets());
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(this, spawnType));
+            subpackets.Add(CreateAppearancePacket());
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(_0xFPacket.BuildPacket(actorId));
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIdleAnimationPacket());
+            subpackets.Add(CreateInitStatusPacket());
+            subpackets.Add(CreateSetActorIconPacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.AddRange(CreatePlayerRelatedPackets(requestPlayer.actorId));
+            subpackets.Add(CreateScriptBindPacket(requestPlayer));            
+            return subpackets;
         }
 
-        public List<SubPacket> CreatePlayerRelatedPackets(uint playerActorId)
+        public List<SubPacket> CreatePlayerRelatedPackets(uint requestingPlayerActorId)
         {
             List<SubPacket> subpackets = new List<SubPacket>();
 
             if (gcCurrent != 0)
-                subpackets.Add(SetGrandCompanyPacket.BuildPacket(actorId, playerActorId, gcCurrent, gcRankLimsa, gcRankGridania, gcRankUldah));
+                subpackets.Add(SetGrandCompanyPacket.BuildPacket(actorId, gcCurrent, gcRankLimsa, gcRankGridania, gcRankUldah));
 
             if (currentTitle != 0)
-                subpackets.Add(SetPlayerTitlePacket.BuildPacket(actorId, playerActorId, currentTitle));
+                subpackets.Add(SetPlayerTitlePacket.BuildPacket(actorId, currentTitle));
 
             if (currentJob != 0)
-                subpackets.Add(SetCurrentJobPacket.BuildPacket(actorId, playerActorId, currentJob));
-
-            if (IsMyPlayer(playerActorId))
+                subpackets.Add(SetCurrentJobPacket.BuildPacket(actorId, currentJob));
+
+            if (IsMyPlayer(requestingPlayerActorId))
             {
-                subpackets.Add(SetSpecialEventWorkPacket.BuildPacket(playerActorId, playerActorId));
+                subpackets.Add(SetSpecialEventWorkPacket.BuildPacket(actorId));
 
                 if (hasChocobo && chocoboName != null && !chocoboName.Equals(""))
                 {
-                    subpackets.Add(SetChocoboNamePacket.BuildPacket(actorId, playerActorId, chocoboName));
-                    subpackets.Add(SetHasChocoboPacket.BuildPacket(playerActorId, hasChocobo));
+                    subpackets.Add(SetChocoboNamePacket.BuildPacket(actorId, chocoboName));
+                    subpackets.Add(SetHasChocoboPacket.BuildPacket(actorId, hasChocobo));
                 }
 
                 if (hasGoobbue)
-                    subpackets.Add(SetHasGoobbuePacket.BuildPacket(playerActorId, hasGoobbue));
+                    subpackets.Add(SetHasGoobbuePacket.BuildPacket(actorId, hasGoobbue));
 
-                subpackets.Add(SetAchievementPointsPacket.BuildPacket(playerActorId, achievementPoints));
+                subpackets.Add(SetAchievementPointsPacket.BuildPacket(actorId, achievementPoints));
                 subpackets.Add(Database.GetLatestAchievements(this));
                 subpackets.Add(Database.GetAchievementsPacket(this));                
             }
 
+            if (mountState == 1)
+                subpackets.Add(SetCurrentMountChocoboPacket.BuildPacket(actorId, chocoboAppearance));
+            else if (mountState == 2)
+                subpackets.Add(SetCurrentMountGoobbuePacket.BuildPacket(actorId, 1));
+          
             return subpackets;
-        }
+        }
 
-        public override BasePacket GetInitPackets(uint playerActorId)
+        public override List<SubPacket> GetInitPackets()
         {
-            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this, playerActorId);
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("/_init", this);
                         
             propPacketUtil.AddProperty("charaWork.eventSave.bazaarTax");
             propPacketUtil.AddProperty("charaWork.battleSave.potencial");
@@ -498,7 +495,7 @@ namespace FFXIVClassic_Map_Server.Actors
             propPacketUtil.AddProperty("playerWork.birthdayDay");
             propPacketUtil.AddProperty("playerWork.initialTown");
             
-            return BasePacket.CreatePacket(propPacketUtil.Done(), true, false);
+            return propPacketUtil.Done();
         }
 
         public void SendSeamlessZoneInPackets()
@@ -509,14 +506,14 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public void SendZoneInPackets(WorldManager world, ushort spawnType)
         {
-            QueuePacket(SetActorIsZoningPacket.BuildPacket(actorId, actorId, false));
+            QueuePacket(SetActorIsZoningPacket.BuildPacket(actorId, false));
             QueuePacket(_0x10Packet.BuildPacket(actorId, 0xFF));
             QueuePacket(SetMusicPacket.BuildPacket(actorId, zone.bgmDay, 0x01));
             QueuePacket(SetWeatherPacket.BuildPacket(actorId, SetWeatherPacket.WEATHER_CLEAR, 1));
-            
+
             QueuePacket(SetMapPacket.BuildPacket(actorId, zone.regionId, zone.actorId));
 
-            QueuePacket(GetSpawnPackets(actorId, spawnType));            
+            QueuePackets(GetSpawnPackets(this, spawnType));
             //GetSpawnPackets(actorId, spawnType).DebugPrintPacket();
 
             #region Inventory & Equipment
@@ -527,18 +524,18 @@ namespace FFXIVClassic_Map_Server.Actors
             inventories[Inventory.BAZAAR].SendFullInventory();
             inventories[Inventory.MELDREQUEST].SendFullInventory();
             inventories[Inventory.LOOT].SendFullInventory();
-            equipment.SendFullEquipment(false);   
-            playerSession.QueuePacket(InventoryEndChangePacket.BuildPacket(actorId), true, false);
+            equipment.SendFullEquipment(false);
+            playerSession.QueuePacket(InventoryEndChangePacket.BuildPacket(actorId));
             #endregion
 
-            playerSession.QueuePacket(GetInitPackets(actorId));
+            playerSession.QueuePacket(GetInitPackets());
+
+            List<SubPacket> areaMasterSpawn = zone.GetSpawnPackets();
+            List<SubPacket> debugSpawn = world.GetDebugActor().GetSpawnPackets();
+            List<SubPacket> worldMasterSpawn = world.GetActor().GetSpawnPackets();
 
-            BasePacket areaMasterSpawn = zone.GetSpawnPackets(actorId);
-            BasePacket debugSpawn = world.GetDebugActor().GetSpawnPackets(actorId);
-            BasePacket worldMasterSpawn = world.GetActor().GetSpawnPackets(actorId);
-            
             playerSession.QueuePacket(areaMasterSpawn);
-            playerSession.QueuePacket(debugSpawn);            
+            playerSession.QueuePacket(debugSpawn);
             playerSession.QueuePacket(worldMasterSpawn);
 
             //Inn Packets (Dream, Cutscenes, Armoire)
@@ -555,17 +552,15 @@ namespace FFXIVClassic_Map_Server.Actors
             }
 
             if (zone.GetWeatherDirector() != null)
-            {
-                BasePacket weatherDirectorSpawn = zone.GetWeatherDirector().GetSpawnPackets(actorId);
-                playerSession.QueuePacket(weatherDirectorSpawn);
+            { 
+                playerSession.QueuePacket(zone.GetWeatherDirector().GetSpawnPackets());
             }
 
-            
+            
             foreach (Director director in ownedDirectors)
             {
-                director.GetSpawnPackets(actorId).DebugPrintPacket();
-                QueuePacket(director.GetSpawnPackets(actorId));
-                QueuePacket(director.GetInitPackets(actorId));
+                QueuePackets(director.GetSpawnPackets());
+                QueuePackets(director.GetInitPackets());
             }
 
             if (currentContentGroup != null)
@@ -598,32 +593,26 @@ namespace FFXIVClassic_Map_Server.Actors
         public bool IsMyPlayer(uint otherActorId)
         {
             return actorId == otherActorId;
-        }        
-
-        public void QueuePacket(BasePacket packet)
+        }        
+
+        public void QueuePacket(SubPacket packet)
         {
             playerSession.QueuePacket(packet);
         }
 
-        public void QueuePacket(SubPacket packet)
+        public void QueuePackets(List<SubPacket> packets)
         {
-            playerSession.QueuePacket(packet, true, false);
-        }
-
-        public void QueuePackets(List<SubPacket> packets)
-        {
-            foreach (SubPacket subpacket in packets)
-                playerSession.QueuePacket(subpacket, true, false);
+            playerSession.QueuePacket(packets);
         }
 
         public void SendPacket(string path)
         {
             try
             {
-                BasePacket packet = new BasePacket(path);
+               // BasePacket packet = new BasePacket(path);
 
-                packet.ReplaceActorID(actorId);
-                QueuePacket(packet);
+                //packet.ReplaceActorID(actorId);
+                //QueuePacket(packet);
             }
             catch (Exception e)
             {
@@ -633,13 +622,19 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public void BroadcastPacket(SubPacket packet, bool sendToSelf)
         {
+            if (sendToSelf)
+            {
+                SubPacket clonedPacket = new SubPacket(packet, actorId);
+                QueuePacket(clonedPacket);
+            }
+
             foreach (Actor a in playerSession.actorInstanceList)
             {
                 if (a is Player)
                 {
                     Player p = (Player)a;
 
-                    if (p.Equals(this) && !sendToSelf)
+                    if (p.Equals(this))
                         continue;
 
                     SubPacket clonedPacket = new SubPacket(packet, a.actorId);
@@ -659,14 +654,14 @@ namespace FFXIVClassic_Map_Server.Actors
         {
             if (flag)
             {
-                BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, actorId, SetActorIconPacket.DISCONNECTING), true);
+                BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, SetActorIconPacket.DISCONNECTING), true);
             }
             else
             {
                 if (isGM)
-                    BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, actorId, SetActorIconPacket.ISGM), true);
+                    BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, SetActorIconPacket.ISGM), true);
                 else
-                    BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, actorId, 0), true);
+                    BroadcastPacket(SetActorIconPacket.BuildPacket(actorId, 0), true);
             }
         }
 
@@ -719,7 +714,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public void SendMessage(uint logType, string sender, string message)
         {
-            QueuePacket(SendMessagePacket.BuildPacket(actorId, actorId, logType, sender, message));
+            QueuePacket(SendMessagePacket.BuildPacket(actorId, logType, sender, message));
         }
 
         public void Logout()
@@ -756,19 +751,18 @@ namespace FFXIVClassic_Map_Server.Actors
             QueuePacket(SetMusicPacket.BuildPacket(actorId, musicId, 1));
         }
 
-        public void SendChocoboAppearance()
+        public void SendMountAppearance()
         {
-            BroadcastPacket(SetCurrentMountChocoboPacket.BuildPacket(actorId, chocoboAppearance), true);
-        }
-
-        public void SendGoobbueAppearance()
-        {
-            BroadcastPacket(SetCurrentMountGoobbuePacket.BuildPacket(actorId, 1), true);
+            if (mountState == 1)
+                BroadcastPacket(SetCurrentMountChocoboPacket.BuildPacket(actorId, chocoboAppearance), true);
+            else if (mountState == 2)
+                BroadcastPacket(SetCurrentMountGoobbuePacket.BuildPacket(actorId, 1), true);
         }
 
         public void SetMountState(byte mountState)
         {
             this.mountState = mountState;
+            SendMountAppearance();
         }
 
         public byte GetMountState()
@@ -778,41 +772,41 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public void DoEmote(uint targettedActor, uint animId, uint descId)
         {
-            BroadcastPacket(ActorDoEmotePacket.BuildPacket(actorId, actorId, targettedActor, animId, descId), true);
+            BroadcastPacket(ActorDoEmotePacket.BuildPacket(actorId, targettedActor, animId, descId), true);
         }
 
         public void SendGameMessage(Actor sourceActor, Actor textIdOwner, ushort textId, byte log, params object[] msgParams)
         {
             if (msgParams == null || msgParams.Length == 0)
             {
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, sourceActor.actorId, textIdOwner.actorId, textId, log));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, sourceActor.actorId, textIdOwner.actorId, textId, log));
             }
             else
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, sourceActor.actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams)));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, sourceActor.actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams)));
         }
 
         public void SendGameMessage(Actor textIdOwner, ushort textId, byte log, params object[] msgParams)
         {
             if (msgParams == null || msgParams.Length == 0)
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, log));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, log));
             else
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams)));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, log, LuaUtils.CreateLuaParamList(msgParams)));
         }
 
-        public void SendGameMessage(Actor textIdOwner, ushort textId, byte log, string customSender, params object[] msgParams)
+        public void SendGameMessageCustomSender(Actor textIdOwner, ushort textId, byte log, string customSender, params object[] msgParams)
         {
             if (msgParams == null || msgParams.Length == 0)
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, customSender, log));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, customSender, log));
             else
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, customSender, log, LuaUtils.CreateLuaParamList(msgParams)));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, customSender, log, LuaUtils.CreateLuaParamList(msgParams)));
         }
 
-        public void SendGameMessage(Actor textIdOwner, ushort textId, byte log, uint displayId, params object[] msgParams)
+        public void SendGameMessageDisplayIDSender(Actor textIdOwner, ushort textId, byte log, uint displayId, params object[] msgParams)
         {
             if (msgParams == null || msgParams.Length == 0)
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, displayId, log));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, displayId, log));
             else
-                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, actorId, textIdOwner.actorId, textId, displayId, log, LuaUtils.CreateLuaParamList(msgParams)));
+                QueuePacket(GameMessagePacket.BuildPacket(Server.GetWorldManager().GetActor().actorId, textIdOwner.actorId, textId, displayId, log, LuaUtils.CreateLuaParamList(msgParams)));
         }
 
         public void BroadcastWorldMessage(ushort worldMasterId, params object[] msgParams)
@@ -847,7 +841,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public void SendAppearance()
         {
-            BroadcastPacket(CreateAppearancePacket(actorId), true);
+            BroadcastPacket(CreateAppearancePacket(), true);
         }
 
         public void SendCharaExpInfo()
@@ -879,7 +873,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
                 charaInfo1.AddTarget();
 
-                QueuePacket(charaInfo1.BuildPacket(actorId, actorId));
+                QueuePacket(charaInfo1.BuildPacket(actorId));
             }
             else if (lastStep == 1)
             {
@@ -910,7 +904,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
                 charaInfo1.AddTarget();
 
-                QueuePacket(charaInfo1.BuildPacket(actorId, actorId));
+                QueuePacket(charaInfo1.BuildPacket(actorId));
             }
            
         }
@@ -964,16 +958,18 @@ namespace FFXIVClassic_Map_Server.Actors
 
             charaWork.parameterSave.state_mainSkill[0] = classId;
             charaWork.parameterSave.state_mainSkillLevel = charaWork.battleSave.skillLevel[classId-1];
-
+            Database.LoadHotbar(this);
             playerWork.restBonusExpRate = 0.0f;
 
-            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("charaWork/stateForAll", this, actorId);
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("charaWork/stateForAll", this);
 
             propertyBuilder.AddProperty("charaWork.parameterSave.state_mainSkill[0]");
             propertyBuilder.AddProperty("charaWork.parameterSave.state_mainSkillLevel");
             propertyBuilder.NewTarget("playerWork/expBonus");
             propertyBuilder.AddProperty("playerWork.restBonusExpRate");
 
+            QueuePackets(GetUpdateHotbarPacket(actorId).Done());
+
             List<SubPacket> packets = propertyBuilder.Done();
 
             foreach (SubPacket packet in packets)
@@ -988,7 +984,7 @@ namespace FFXIVClassic_Map_Server.Actors
                 appearanceIds[slot] = 0;            
             else
             {
-                Item item = Server.GetItemGamedata(invItem.itemId);
+                ItemData item = Server.GetItemGamedata(invItem.itemId);
                 if (item is EquipmentItem)
                 {
                     EquipmentItem eqItem = (EquipmentItem)item;
@@ -1011,7 +1007,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
             Database.SavePlayerAppearance(this);
 
-            BroadcastPacket(CreateAppearancePacket(actorId), true);
+            BroadcastPacket(CreateAppearancePacket(), true);
         }
 
         public Inventory GetInventory(ushort type)
@@ -1096,9 +1092,9 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public int GetFreeGuildleveSlot()
         {
-            for (int i = 0; i < questGuildleve.Length; i++)
+            for (int i = 0; i < work.guildleveId.Length; i++)
             {
-                if (questGuildleve[i] == 0)
+                if (work.guildleveId[i] == 0)
                     return i;
             }
 
@@ -1139,23 +1135,38 @@ namespace FFXIVClassic_Map_Server.Actors
             if (freeSlot == -1)
                 return;
 
-            playerWork.questScenario[freeSlot] = id;
-            questGuildleve[freeSlot] = id;
+            work.guildleveId[freeSlot] = (ushort)id;
             Database.SaveGuildleve(this, id, freeSlot);
             SendGuildleveClientUpdate(freeSlot);
         }
 
+        public void MarkGuildleve(uint id, bool abandoned, bool completed)
+        {
+            if (HasGuildleve(id))
+            {
+                for (int i = 0; i < work.guildleveId.Length; i++)
+                {
+                    if (work.guildleveId[i] == id)
+                    {
+                        work.guildleveChecked[i] = completed;
+                        work.guildleveDone[i] = abandoned;
+                        Database.MarkGuildleve(this, id, abandoned, completed);
+                        SendGuildleveMarkClientUpdate(i);
+                    }
+                }
+            }
+        }
+
         public void RemoveGuildleve(uint id)
         {
             if (HasGuildleve(id))
             {
-                for (int i = 0; i < questGuildleve.Length; i++)
+                for (int i = 0; i < work.guildleveId.Length; i++)
                 {
-                    if (questGuildleve[i] != null && questGuildleve[i] == id)
+                    if (work.guildleveId[i] == id)
                     {
                         Database.RemoveGuildleve(this, id);
-                        questGuildleve[i] = 0;
-                        playerWork.questGuildleve[i] = 0;
+                        work.guildleveId[i] = 0;
                         SendGuildleveClientUpdate(i);
                         break;
                     }
@@ -1338,9 +1349,9 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public bool HasGuildleve(uint id)
         {
-            for (int i = 0; i < questGuildleve.Length; i++)
+            for (int i = 0; i < work.guildleveId.Length; i++)
             {
-                if (questGuildleve[i] != null && questGuildleve[i] == id)
+                if (work.guildleveId[i] == id)
                     return true;
             }
 
@@ -1393,7 +1404,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
             Database.SaveNpcLS(this, npcLSId, isCalling, isExtra);
 
-            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/npcLinkshellChat", this, actorId);
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/npcLinkshellChat", this);
             propPacketUtil.AddProperty(String.Format("playerWork.npcLinkshellChatExtra[{0}]", npcLSId));
             propPacketUtil.AddProperty(String.Format("playerWork.npcLinkshellChatCalling[{0}]", npcLSId));
             QueuePackets(propPacketUtil.Done());
@@ -1401,15 +1412,23 @@ namespace FFXIVClassic_Map_Server.Actors
 
         private void SendQuestClientUpdate(int slot)
         {
-            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/journal", this, actorId);
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/journal", this);
             propPacketUtil.AddProperty(String.Format("playerWork.questScenario[{0}]", slot));
             QueuePackets(propPacketUtil.Done());
         }
 
-        private void SendGuildleveClientUpdate(int slot)
+        private void SendGuildleveClientUpdate(int slot)
+        {
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("work/guildleve", this);
+            propPacketUtil.AddProperty(String.Format("work.guildleveId[{0}]", slot));
+            QueuePackets(propPacketUtil.Done());
+        }
+
+        private void SendGuildleveMarkClientUpdate(int slot)
         {
-            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("playerWork/journal", this, actorId);
-            propPacketUtil.AddProperty(String.Format("playerWork.questGuildleve[{0}]", slot));
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("work/guildleve", this);
+            propPacketUtil.AddProperty(String.Format("work.guildleveDone[{0}]", slot));
+            propPacketUtil.AddProperty(String.Format("work.guildleveChecked[{0}]", slot));
             QueuePackets(propPacketUtil.Done());
         }
 
@@ -1424,32 +1443,36 @@ namespace FFXIVClassic_Map_Server.Actors
             if (!ownedDirectors.Contains(director))
             {
                 ownedDirectors.Add(director);
-                director.AddChild(this);
-                
-                if (spawnImmediatly)
-                {
-                    director.GetSpawnPackets(actorId).DebugPrintPacket();
-                    QueuePacket(director.GetSpawnPackets(actorId));
-                    QueuePacket(director.GetInitPackets(actorId));
-                }
+                director.AddMember(this);                
             }
         }
-
+
         public void SendDirectorPackets(Director director)
-        {
-            director.GetSpawnPackets(actorId).DebugPrintPacket();
-            QueuePacket(director.GetSpawnPackets(actorId));
-            QueuePacket(director.GetInitPackets(actorId));        
+        {
+            QueuePackets(director.GetSpawnPackets());
+            QueuePackets(director.GetInitPackets());        
         }
 
         public void RemoveDirector(Director director)
         {
-            if (!ownedDirectors.Contains(director))
-            {
+            if (ownedDirectors.Contains(director))
+            {
+                QueuePacket(RemoveActorPacket.BuildPacket(director.actorId));
                 ownedDirectors.Remove(director);
-                director.RemoveChild(this);
+                director.RemoveMember(this);
             }
         }
+        
+        public GuildleveDirector GetGuildleveDirector()
+        {
+            foreach (Director d in ownedDirectors)
+            {
+                if (d is GuildleveDirector)
+                    return (GuildleveDirector)d;
+            }
+
+            return null;
+        }
 
         public Director GetDirector(string directorName)
         {
@@ -1481,15 +1504,15 @@ namespace FFXIVClassic_Map_Server.Actors
             else
                 return;
 
-            QueuePacket(InventoryBeginChangePacket.BuildPacket(toBeExamined.actorId, actorId));
+            QueuePacket(InventoryBeginChangePacket.BuildPacket(toBeExamined.actorId));
             toBeExamined.GetEquipment().SendCheckEquipmentToPlayer(this);
-            QueuePacket(InventoryEndChangePacket.BuildPacket(toBeExamined.actorId, actorId));
+            QueuePacket(InventoryEndChangePacket.BuildPacket(toBeExamined.actorId));
         }
 
         public void SendDataPacket(params object[] parameters)
         {
             List<LuaParam> lParams = LuaUtils.CreateLuaParamList(parameters);
-            SubPacket spacket = InfoRequestResponsePacket.BuildPacket(actorId, actorId, lParams);
+            SubPacket spacket = InfoRequestResponsePacket.BuildPacket(actorId, lParams);
             spacket.DebugPrintSubPacket();
             QueuePacket(spacket);
         }
@@ -1517,7 +1540,7 @@ namespace FFXIVClassic_Map_Server.Actors
 
         public void SetEventStatus(Actor actor, string conditionName, bool enabled, byte unknown)
         {
-            QueuePacket(packets.send.actor.events.SetEventStatus.BuildPacket(actorId, actor.actorId, enabled, unknown, conditionName));
+            QueuePacket(packets.send.actor.events.SetEventStatus.BuildPacket(actor.actorId, enabled, unknown, conditionName));
         }
 
         public void RunEventFunction(string functionName, params object[] parameters)
@@ -1531,7 +1554,7 @@ namespace FFXIVClassic_Map_Server.Actors
         public void EndEvent()
         {
             SubPacket p = EndEventPacket.BuildPacket(actorId, currentEventOwner, currentEventName);
-            p.DebugPrintSubPacket();
+            //p.DebugPrintSubPacket();
             QueuePacket(p);
 
             currentEventOwner = 0;
@@ -1638,12 +1661,161 @@ namespace FFXIVClassic_Map_Server.Actors
             currentParty = null;
         }
 
-        
-
         public void Update(double delta)
         {
             LuaEngine.GetInstance().CallLuaFunction(this, this, "OnUpdate", true, delta);
         }
 
+        //Update all the hotbar slots past the commandborder. Commands before the commandborder only need to be sent on init since they never change
+        public ActorPropertyPacketUtil GetUpdateHotbarPacket(uint playerActorId)
+        {
+            List<ushort> slotsToUpdate = new List<ushort>();
+            for (ushort i = charaWork.commandBorder; i < charaWork.commandBorder + 30; i++)
+            {
+                slotsToUpdate.Add(i);
+            }
+
+            return GetUpdateHotbarPacket(playerActorId, slotsToUpdate);
+        }
+
+        //Update select hotbar slots.
+        public ActorPropertyPacketUtil GetUpdateHotbarPacket(uint playerActorId, List<ushort> slotsToUpdate)
+        {
+            ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("charawork/command", this);
+
+            propPacketUtil.AddProperty("charaWork.commandBorder");
+
+            foreach (ushort slot in slotsToUpdate)
+            {
+                propPacketUtil.AddProperty(String.Format("charaWork.command[{0}]", slot));
+                propPacketUtil.AddProperty(String.Format("charaWork.commandCategory[{0}]", slot));
+            }
+
+            for (int i = 0; i < charaWork.parameterSave.commandSlot_compatibility.Length; i++)
+            {
+                //charaWork.parameterSave.commandSlot_compatibility[i] = true;
+                // propPacketUtil.AddProperty(String.Format("charaWork.parameterSave.commandSlot_compatibility[{0}]", i));
+            }
+
+            charaWork.parameterTemp.otherClassAbilityCount[0] = 3;
+            charaWork.parameterTemp.otherClassAbilityCount[1] = 5;
+            // charaWork.parameterTemp.giftCount[1] = 5;
+            propPacketUtil.AddProperty("charaWork.parameterTemp.otherClassAbilityCount[0]");
+            propPacketUtil.AddProperty("charaWork.parameterTemp.otherClassAbilityCount[1]");
+            propPacketUtil.AddProperty("charaWork.parameterTemp.giftCount[1]");
+
+            ActorPropertyPacketUtil recastPacketUtil = new ActorPropertyPacketUtil("charaWork/commandDetailForSelf", this);
+            for(int i = 0; i < charaWork.parameterSave.commandSlot_recastTime.Length; i++)
+            {
+                propPacketUtil.AddProperty(String.Format("charawork.parameterSave.commandSlot_recastTime[{0}]", i));
+                propPacketUtil.AddProperty(String.Format("charawork.parameterTemp.maxCommandRecastTime[{0}]", i));
+            }
+
+            QueuePackets(recastPacketUtil.Done());
+
+            return propPacketUtil;
+        }
+
+
+        public void EquipAbility(ushort hotbarSlot, uint commandId, uint recastTime)
+        {
+            //if (charaWork.commandAcquired[commandId])
+            {
+                uint trueCommandId = 0xA0F00000 | commandId;
+                ushort trueHotbarSlot = (ushort)(hotbarSlot + charaWork.commandBorder - 1);
+                ushort endOfHotbar = (ushort)(charaWork.commandBorder + 30);
+                List<ushort> slotsToUpdate = new List<ushort>();
+                if (trueCommandId != 2700083200)
+                {
+                    bool canEquip = true;
+                    bool isAlreadyEquipped = false;
+
+                    //If hotbar slot is 0, look for the first open slot
+                    if (hotbarSlot == 0)
+                    {
+                        trueHotbarSlot = findFirstCommandSlotById(0);
+                        int equippedSlot = findFirstCommandSlotById(trueCommandId);
+                        //We can only equip a command if there is an open hotbar slot and if the command was not found in the hotbar.
+                        canEquip = trueHotbarSlot < endOfHotbar && equippedSlot >= endOfHotbar;
+                        //If the command was found in the hotbar, mark it as already equipped
+                        isAlreadyEquipped = equippedSlot < endOfHotbar;
+                    }
+                    //If the slot the command is being moved to is occupied, move that command to the slot currently occupied by the command being placed.
+                    else if (charaWork.command[trueHotbarSlot] != trueCommandId)
+                    {
+                        ushort oldSlot = findFirstCommandSlotById(trueCommandId);
+                        //If the command was found, update the old slot, otherwise it will just be overwritten
+                        if (oldSlot < endOfHotbar)
+                        {
+                            Database.EquipAbility(this, oldSlot, charaWork.command[trueHotbarSlot], recastTime);
+                            charaWork.command[oldSlot] = charaWork.command[trueHotbarSlot];
+                            slotsToUpdate.Add(oldSlot);
+                        }
+                    }
+                    
+                    if (canEquip)
+                    {
+                        Actor a = Server.GetStaticActors(trueCommandId);
+                        Database.EquipAbility(this, trueHotbarSlot, trueCommandId, recastTime);
+                        charaWork.command[trueHotbarSlot] = trueCommandId;
+                        charaWork.commandCategory[trueHotbarSlot] = 1;
+                        slotsToUpdate.Add(trueHotbarSlot);
+
+                        //"[Command] set."
+                        SendGameMessage(Server.GetWorldManager().GetActor(), 30603, 0x20, 0, commandId);
+                    }
+                    else if (isAlreadyEquipped)
+                    {
+                        //"That action is already set to an action slot."
+                        SendGameMessage(Server.GetWorldManager().GetActor(), 30719, 0x20, 0);
+                    }
+                    else
+                    {
+                        //"You cannot set any more actions."
+                        SendGameMessage(Server.GetWorldManager().GetActor(), 30720, 0x20, 0);
+                    }
+                }
+                //Unequip command
+                else if (trueCommandId == 2700083200)
+                {
+                    //Need to get the commandId this way because when unequipping an ability the commandId is 0.
+                    commandId = charaWork.command[trueHotbarSlot] ^ 2700083200;                    
+                    SendGameMessage(Server.GetWorldManager().GetActor(), 30604, 0x20, 0, charaWork.command[trueHotbarSlot] ^ 2700083200);
+                    Database.UnequipAbility(this, trueHotbarSlot);
+                    charaWork.command[trueHotbarSlot] = 0;
+                    slotsToUpdate.Add(trueHotbarSlot);                   
+                    //"[Command] removed."
+                    SendGameMessage(Server.GetWorldManager().GetActor(), 30747, 0x20, 0);
+                    
+                }
+                ActorPropertyPacketUtil packet = GetUpdateHotbarPacket(actorId, slotsToUpdate);
+                QueuePackets(packet.Done());
+            }
+            //action not acquired
+            // else
+            {
+                //"You have not yet acquired that action."
+                //SendGameMessage(Server.GetWorldManager().GetActor(), 30742, 0x20, 0, 0);
+            }
+        }
+
+        //Finds the first hotbar slot with a given commandId.
+        //If the returned value is outside the hotbar, it indicates it wasn't found.
+        private ushort findFirstCommandSlotById(uint commandId)
+        {
+            ushort firstSlot = (ushort)(charaWork.commandBorder + 30);
+
+            for (ushort i = charaWork.commandBorder; i < charaWork.commandBorder + 30; i++)
+            {
+                if (charaWork.command[i] == commandId)
+                {
+                    firstSlot = i;
+                    break;
+                }
+            }
+
+            return firstSlot;
+        }
+
     }
 }

FFXIVClassic Map Server/actors/debug/Debug.cs

@@ -18,24 +18,24 @@ namespace FFXIVClassic_Map_Server.Actors
             this.className = "Debug";
         }
 
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket()
         {
             List<LuaParam> lParams;
             lParams = LuaUtils.CreateLuaParamList("/System/Debug.prog", false, false, false, false, true, 0xC51F, true, true);
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
         }
 
-        public override BasePacket GetSpawnPackets(uint playerActorId)
+        public override List<SubPacket> GetSpawnPackets()
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId, 0));            
-            subpackets.Add(CreateSpeedPacket(playerActorId));
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x1));
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));
-            subpackets.Add(CreateScriptBindPacket(playerActorId));
-            return BasePacket.CreatePacket(subpackets, true, false);
+            subpackets.Add(CreateAddActorPacket(0));            
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(0x1));
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.Add(CreateScriptBindPacket());
+            return subpackets;
         }
 
     }

FFXIVClassic Map Server/actors/director/Director.cs

@@ -15,26 +15,32 @@ namespace FFXIVClassic_Map_Server.actors.director
     {
         private uint directorId;
         private string directorScriptPath;
-        private List<Actor> childrenOwners = new List<Actor>();
+        private List<Actor> members = new List<Actor>();
         private bool isCreated = false;
+        private bool isDeleted = false;
+        private bool isDeleting = false;
 
-        public Director(uint id, Area zone, string directorPath)
+        private Script directorScript;
+        private Coroutine currentCoroutine;
+
+        public Director(uint id, Area zone, string directorPath, params object[] args)
             : base((6 << 28 | zone.actorId << 19 | (uint)id))
         {
             directorId = id;
             this.zone = zone;
-            directorScriptPath = directorPath;            
-            DoActorInit(directorScriptPath);
-            GenerateActorName((int)id);
+            this.zoneId = zone.actorId;
+            directorScriptPath = directorPath;
+
+            LoadLuaScript();
 
             eventConditions = new EventList();
             eventConditions.noticeEventConditions = new List<EventList.NoticeEventCondition>();
             eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("noticeEvent",  0xE,0x0));
             eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("noticeRequest", 0x0, 0x1));
-            eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("reqForChild", 0x0, 0x1));
+            eventConditions.noticeEventConditions.Add(new EventList.NoticeEventCondition("reqForChild", 0x0, 0x1));            
         }       
 
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket()
         {
             List<LuaParam> actualLParams = new List<LuaParam>();
             actualLParams.Insert(0, new LuaParam(2, classPath));
@@ -48,28 +54,30 @@ namespace FFXIVClassic_Map_Server.actors.director
             for (int i = 1; i < lparams.Count; i++)
                 actualLParams.Add(lparams[i]);
 
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, actualLParams);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, actualLParams);
         }
 
-        public override BasePacket GetSpawnPackets(uint playerActorId, ushort spawnType)
+        public override List<SubPacket> GetSpawnPackets(ushort spawnType = 1)
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId, 0));
-            subpackets.AddRange(GetEventConditionPackets(playerActorId));
-            subpackets.Add(CreateSpeedPacket(playerActorId));
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0));
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));
-            subpackets.Add(CreateScriptBindPacket(playerActorId));
-            return BasePacket.CreatePacket(subpackets, true, false);
-        }        
+            subpackets.Add(CreateAddActorPacket(0));
+            subpackets.AddRange(GetEventConditionPackets());
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(0));
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.Add(CreateScriptBindPacket());
+            return subpackets;
+        }
 
-        public override BasePacket GetInitPackets(uint playerActorId)
+        public override List<SubPacket> GetInitPackets()
         {
+            List<SubPacket> subpackets = new List<SubPacket>();
             SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init");
             initProperties.AddTarget();
-            return BasePacket.CreatePacket(initProperties.BuildPacket(playerActorId, actorId), true, false);
+            subpackets.Add(initProperties.BuildPacket(actorId));
+            return subpackets;
         }
 
         public void OnTalkEvent(Player player, Npc npc)
@@ -80,45 +88,93 @@ namespace FFXIVClassic_Map_Server.actors.director
         public void OnCommandEvent(Player player, Command command)
         {
             LuaEngine.GetInstance().CallLuaFunction(player, this, "onCommandEvent", false, command);
-        }        
+        }   
 
-        public void DoActorInit(string directorPath)
+        public void StartDirector(bool spawnImmediate, params object[] args)
         {
-            List<LuaParam> lparams = LuaEngine.GetInstance().CallLuaFunctionForReturn(null, this, "init", false);            
+            object[] args2 = new object[args.Length + 1];
+            args2[0] = this;
+            Array.Copy(args, 0, args2, 1, args.Length);
+
+            List<LuaParam> lparams = CallLuaScript("init", args2);
             
             if (lparams.Count >= 1 && lparams[0].value is string)
             {
                 classPath = (string)lparams[0].value;
                 className = classPath.Substring(classPath.LastIndexOf("/") + 1);
+                GenerateActorName((int)directorId);
                 isCreated = true;
             }
+
+            if (isCreated && spawnImmediate)
+            {
+                foreach (Player p in GetPlayerMembers())
+                {
+                    p.QueuePackets(GetSpawnPackets());
+                    p.QueuePackets(GetInitPackets());
+                }
+            }
+
+            if (this is GuildleveDirector)
+                ((GuildleveDirector)this).LoadGuildleve();
+
+            StartCoroutine("main", this);
         }
 
-        public void AddChild(Actor actor)
+        public void EndDirector()
         {
-            if (!childrenOwners.Contains(actor))
-                childrenOwners.Add(actor);
-        }
+            isDeleting = true;
 
-        public void RemoveChild(Actor actor)
-        {
-            if (childrenOwners.Contains(actor))
-                childrenOwners.Remove(actor);
-            if (childrenOwners.Count == 0)
-                Server.GetWorldManager().GetZone(zoneId).DeleteDirector(actorId);
-        }
+            if (this is GuildleveDirector)
+                ((GuildleveDirector)this).EndGuildleveDirector();
 
-        public void RemoveChildren()
-        {
-            childrenOwners.Clear();
+            List<Actor> players = GetPlayerMembers();
+            foreach (Actor player in players)
+                ((Player)player).RemoveDirector(this);
+            members.Clear();
+            isDeleted = true;
             Server.GetWorldManager().GetZone(zoneId).DeleteDirector(actorId);
         }
+        
+        public void AddMember(Actor actor)
+        {
+            if (!members.Contains(actor))
+                members.Add(actor);
+        }
+
+        public void RemoveMember(Actor actor)
+        {
+            if (members.Contains(actor))
+                members.Remove(actor);
+            if (GetPlayerMembers().Count == 0 && !isDeleting)
+                EndDirector();
+        }
+
+        public List<Actor> GetMembers()
+        {
+            return members;
+        }
+
+        public List<Actor> GetPlayerMembers()
+        {
+            return members.FindAll(s => s is Player);
+        }
+
+        public List<Actor> GetNpcMembers()
+        {
+            return members.FindAll(s => s is Npc);
+        }
 
         public bool IsCreated()
         {
             return isCreated;
         }
 
+        public bool IsDeleted()
+        {
+            return isDeleted;
+        }
+
         public void GenerateActorName(int actorNumber)
         {            
             //Format Class Name
@@ -166,5 +222,45 @@ namespace FFXIVClassic_Map_Server.actors.director
             return directorScriptPath;
         }
 
+        private void LoadLuaScript()
+        {
+            string luaPath = String.Format(LuaEngine.FILEPATH_DIRECTORS, GetScriptPath());
+            directorScript = LuaEngine.LoadScript(luaPath);
+            if (directorScript == null)
+                Program.Log.Error("Could not find script for director {0}.", GetName());
+        }
+
+        private List<LuaParam> CallLuaScript(string funcName, params object[] args)
+        {
+            if (directorScript != null)
+            {
+                if (!directorScript.Globals.Get(funcName).IsNil())
+                {
+                    DynValue result = directorScript.Call(directorScript.Globals[funcName], args);
+                    List<LuaParam> lparams = LuaUtils.CreateLuaParamList(result);
+                    return lparams;
+                }
+                else
+                    Program.Log.Error("Could not find script for director {0}.", GetName());
+            }
+            return null;
+        }
+
+        private List<LuaParam> StartCoroutine(string funcName, params object[] args)
+        {
+            if (directorScript != null)
+            {
+                if (!directorScript.Globals.Get(funcName).IsNil())
+                {
+                    currentCoroutine = directorScript.CreateCoroutine(directorScript.Globals[funcName]).Coroutine;
+                    DynValue value = currentCoroutine.Resume(args);
+                    LuaEngine.GetInstance().ResolveResume(null, currentCoroutine, value);
+                }
+                else
+                    Program.Log.Error("Could not find script for director {0}.", GetName());
+            }
+            return null;
+        }
+
     }    
-}
+}

FFXIVClassic Map Server/actors/director/GuildleveDirector.cs

@@ -0,0 +1,258 @@
+using FFXIVClassic.Common;
+using FFXIVClassic_Map_Server.actors.area;
+using FFXIVClassic_Map_Server.actors.director.Work;
+using FFXIVClassic_Map_Server.actors.group;
+using FFXIVClassic_Map_Server.Actors;
+using FFXIVClassic_Map_Server.dataobjects;
+using FFXIVClassic_Map_Server.utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Map_Server.actors.director
+{
+    class GuildleveDirector : Director
+    {
+        public uint guildleveId;
+        public Player guildleveOwner;        
+        public byte selectedDifficulty;
+        public ContentGroup contentGroup;
+
+        public GuildleveData guildleveData;
+        public GuildleveWork guildleveWork = new GuildleveWork();
+
+        public bool isEnded = false;
+        public uint completionTime = 0;
+
+        public GuildleveDirector(uint id, Area zone, string directorPath, uint guildleveId, byte selectedDifficulty, Player guildleveOwner, params object[] args)
+            : base(id, zone, directorPath, args)
+        {
+            this.guildleveId = guildleveId;
+            this.selectedDifficulty = selectedDifficulty;
+            this.guildleveData = Server.GetGuildleveGamedata(guildleveId);
+            this.guildleveOwner = guildleveOwner;
+
+            guildleveWork.aimNum[0] = guildleveData.aimNum[0];
+            guildleveWork.aimNum[1] = guildleveData.aimNum[1];
+            guildleveWork.aimNum[2] = guildleveData.aimNum[2];
+            guildleveWork.aimNum[3] = guildleveData.aimNum[3];
+
+            if (guildleveWork.aimNum[0] != 0)
+                guildleveWork.uiState[0] = 1;
+            if (guildleveWork.aimNum[1] != 0)
+                guildleveWork.uiState[1] = 1;
+            if (guildleveWork.aimNum[2] != 0)
+                guildleveWork.uiState[2] = 1;
+            if (guildleveWork.aimNum[3] != 0)
+                guildleveWork.uiState[3] = 1;
+
+            guildleveWork.aimNumNow[0] = guildleveWork.aimNumNow[1] = guildleveWork.aimNumNow[2] = guildleveWork.aimNumNow[3] = 0;
+        }
+
+        public void LoadGuildleve()
+        {
+            contentGroup = Server.GetWorldManager().CreateGLContentGroup(this, GetMembers());
+        }
+
+        public void StartGuildleve()
+        {
+            foreach (Actor p in GetPlayerMembers())
+            {
+                Player player = (Player) p;
+
+                //Set music
+                if (guildleveData.location == 1)
+                    player.ChangeMusic(22);
+                else if (guildleveData.location == 2)
+                    player.ChangeMusic(14);
+                else if (guildleveData.location == 3)
+                    player.ChangeMusic(26);
+                else if (guildleveData.location == 4)
+                    player.ChangeMusic(16);
+
+                //Show Start Messages
+                player.SendGameMessage(Server.GetWorldManager().GetActor(), 50022, 0x20, guildleveId, selectedDifficulty);
+                player.SendDataPacket("attention", Server.GetWorldManager().GetActor(), "", 50022, guildleveId, selectedDifficulty);
+                player.SendGameMessage(Server.GetWorldManager().GetActor(), 50026, 0x20, (object)(int)guildleveData.timeLimit);
+            }
+
+            guildleveWork.startTime = Utils.UnixTimeStampUTC();
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/start", this);
+            propertyBuilder.AddProperty("guildleveWork.startTime");
+            SendPacketsToPlayers(propertyBuilder.Done());            
+        }
+
+        public void EndGuildleve(bool wasCompleted)
+        {
+            if (isEnded)
+                return;
+            isEnded = true;
+
+            completionTime = Utils.UnixTimeStampUTC() - guildleveWork.startTime;
+
+            if (wasCompleted)
+            {
+                foreach (Actor a in GetPlayerMembers())
+                {
+                    Player player = (Player)a;
+                    player.MarkGuildleve(guildleveId, true, true);
+                    player.PlayAnimation(0x02000002, true);
+                    player.ChangeMusic(81);
+                    player.SendGameMessage(Server.GetWorldManager().GetActor(), 50023, 0x20, (object)(int)guildleveId);
+                    player.SendDataPacket("attention", Server.GetWorldManager().GetActor(), "", 50023, (object)(int)guildleveId);
+                }
+            }
+
+            foreach (Actor a in GetNpcMembers())
+            {
+                Npc npc = (Npc)a;
+                npc.Despawn();
+                RemoveMember(a);
+            }
+
+            guildleveWork.startTime = 0;
+            guildleveWork.signal = -1;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/signal", this);
+            propertyBuilder.AddProperty("guildleveWork.signal");
+            propertyBuilder.NewTarget("guildleveWork/start");
+            propertyBuilder.AddProperty("guildleveWork.startTime");
+            SendPacketsToPlayers(propertyBuilder.Done());
+            
+            if (wasCompleted)
+            {
+                Npc aetheryteNode = zone.SpawnActor(1200040, String.Format("{0}:warpExit", guildleveOwner.actorName), guildleveOwner.positionX, guildleveOwner.positionY, guildleveOwner.positionZ);
+                contentGroup.AddMember(aetheryteNode);
+
+                foreach (Actor a in GetPlayerMembers())
+                {
+                    Player player = (Player)a;
+                    player.SendGameMessage(Server.GetWorldManager().GetActor(), 50029, 0x20);
+                    player.SendGameMessage(Server.GetWorldManager().GetActor(), 50032, 0x20);
+                }
+            }
+        }   
+        
+        public void AbandonGuildleve()
+        {
+            foreach (Actor p in GetPlayerMembers())
+            {
+                Player player = (Player)p;                
+                player.SendGameMessage(Server.GetWorldManager().GetActor(), 50147, 0x20, (object)guildleveId);
+                player.MarkGuildleve(guildleveId, true, false);
+            }
+
+            EndGuildleve(false);
+            EndDirector();
+        }
+
+        //Delete ContentGroup, change music back
+        public void EndGuildleveDirector()
+        {
+            contentGroup.DeleteGroup();
+            foreach (Actor p in GetPlayerMembers())
+            {
+                Player player = (Player)p;
+                player.ChangeMusic(player.GetZone().bgmDay);
+            }
+        }
+
+        public void SyncAllInfo()
+        {
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
+
+            if (guildleveWork.aimNum[0] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[0]");
+            if (guildleveWork.aimNum[1] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[1]");
+            if (guildleveWork.aimNum[2] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[2]");
+            if (guildleveWork.aimNum[3] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNum[3]");
+
+            if (guildleveWork.aimNumNow[0] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[0]");
+            if (guildleveWork.aimNumNow[1] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[1]");
+            if (guildleveWork.aimNumNow[2] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[2]");
+            if (guildleveWork.aimNumNow[3] != 0)
+                propertyBuilder.AddProperty("guildleveWork.aimNumNow[3]");
+
+            if (guildleveWork.uiState[0] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[0]");
+            if (guildleveWork.uiState[1] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[1]");
+            if (guildleveWork.uiState[2] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[2]");
+            if (guildleveWork.uiState[3] != 0)
+                propertyBuilder.AddProperty("guildleveWork.uiState[3]");
+
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void UpdateAimNumNow(int index, sbyte value)
+        {
+            guildleveWork.aimNumNow[index] = value;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
+            propertyBuilder.AddProperty(String.Format("guildleveWork.aimNumNow[{0}]", index));
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void UpdateUiState(int index, sbyte value)
+        {
+            guildleveWork.uiState[index] = value;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/infoVariable", this);
+            propertyBuilder.AddProperty(String.Format("guildleveWork.uiState[{0}]", index));
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void UpdateMarkers(int markerIndex, float x, float y, float z)
+        {
+            guildleveWork.markerX[markerIndex] = x;
+            guildleveWork.markerY[markerIndex] = y;
+            guildleveWork.markerZ[markerIndex] = z;
+            ActorPropertyPacketUtil propertyBuilder = new ActorPropertyPacketUtil("guildleveWork/marker", this);
+            propertyBuilder.AddProperty(String.Format("guildleveWork.markerX[{0}]", markerIndex));
+            propertyBuilder.AddProperty(String.Format("guildleveWork.markerY[{0}]", markerIndex));
+            propertyBuilder.AddProperty(String.Format("guildleveWork.markerZ[{0}]", markerIndex));
+            SendPacketsToPlayers(propertyBuilder.Done());
+        }
+
+        public void SendPacketsToPlayers(List<SubPacket> packets)
+        {
+            List<Actor> players = GetPlayerMembers();
+            foreach (Actor p in players)
+            {
+                ((Player)p).QueuePackets(packets);
+            }
+        }
+
+        public static uint GlBorderIconIDToAnimID(uint iconId)
+        {
+	        return iconId - 20000;
+        }
+
+        public static uint GlPlateIconIDToAnimID(uint iconId)
+        {
+	        return iconId - 20020;
+        }
+
+        public static uint GetGLStartAnimationFromSheet(uint border, uint plate, bool isBoost)
+        {
+	        return GetGLStartAnimation(GlBorderIconIDToAnimID(border), GlPlateIconIDToAnimID(plate), isBoost);
+        }
+
+        public static uint GetGLStartAnimation(uint border, uint plate, bool isBoost)
+        {
+            uint borderBits = border;
+	        uint plateBits = plate << 7;
+
+            uint boostBits = isBoost ? (uint)0x8000 : (uint) 0;
+	        
+	        return 0x0B000000 | boostBits | plateBits | borderBits;
+        }
+	
+    }
+}

FFXIVClassic Map Server/actors/director/Work/GuildleveWork.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Map_Server.actors.director.Work
+{
+
+    class GuildleveWork
+    {
+        public uint startTime = 0;
+        public sbyte[] aimNum = new sbyte[4];
+        public sbyte[] aimNumNow = new sbyte[4];
+        public sbyte[] uiState = new sbyte[4];
+        public float[] markerX = new float[3];
+        public float[] markerY = new float[3];
+        public float[] markerZ = new float[3];
+        public sbyte signal;
+    }
+
+}

FFXIVClassic Map Server/actors/group/ContentGroup.cs

@@ -25,7 +25,13 @@ namespace FFXIVClassic_Map_Server.actors.group
             if (initialMembers != null)
             {
                 for (int i = 0; i < initialMembers.Length; i++)
+                {
+                    Session s = Server.GetServer().GetSession(initialMembers[i]);
+                    if (s != null)
+                        s.GetActor().SetCurrentContentGroup(this);
+
                     members.Add(initialMembers[i]);
+                }
             }
 
             this.director = director;
@@ -38,11 +44,10 @@ namespace FFXIVClassic_Map_Server.actors.group
                 return;
 
             members.Add(actor.actorId);
-            if (actor is Character)
-            {
-                ((Character)actor).SetCurrentContentGroup(this);
-                SendCurrentContentSync(actor);
-            }
+
+            if (actor is Character)            
+                ((Character)actor).SetCurrentContentGroup(this);          
+  
             SendGroupPacketsAll(members);
         }
         
@@ -79,7 +84,7 @@ namespace FFXIVClassic_Map_Server.actors.group
 
             SubPacket test = groupWork.buildPacket(session.id, session.id);
             test.DebugPrintSubPacket();
-            session.QueuePacket(test, true, false);
+            session.QueuePacket(test);
         }
 
         public override void SendGroupPackets(Session session)
@@ -87,43 +92,29 @@ namespace FFXIVClassic_Map_Server.actors.group
             ulong time = Utils.MilisUnixTimeStampUTC();
             List<GroupMember> members = BuildMemberList(session.id);
 
-            session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false);
-            session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false);
+            session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
+            session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
 
             int currentIndex = 0;
 
             while (true)
             {
                 if (GetMemberCount() - currentIndex >= 64)
-                    session.QueuePacket(ContentMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(ContentMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else if (GetMemberCount() - currentIndex >= 32)
-                    session.QueuePacket(ContentMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(ContentMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else if (GetMemberCount() - currentIndex >= 16)
-                    session.QueuePacket(ContentMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(ContentMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else if (GetMemberCount() - currentIndex > 0)
-                    session.QueuePacket(ContentMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(ContentMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else
                     break;
             }
 
-            session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false);
+            session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
 
         }
 
-        public void SendCurrentContentSync(Actor currentContentChanged)
-        {
-            foreach (uint memberId in members)
-            {
-                Session session = Server.GetServer().GetSession(memberId);
-                if (session != null)
-                {
-                    ActorPropertyPacketUtil propPacketUtil = new ActorPropertyPacketUtil("charaWork/currentContentGroup", currentContentChanged, session.id);
-                    propPacketUtil.AddProperty("charaWork.currentContentGroup");
-                    session.GetActor().QueuePackets(propPacketUtil.Done());
-                }
-            }            
-        }
-
         public override uint GetTypeId()
         {
             return Group.ContentGroup_SimpleContentGroup24B;
@@ -135,12 +126,23 @@ namespace FFXIVClassic_Map_Server.actors.group
             SendGroupPacketsAll(members);            
         }
 
-        public void DeleteAll()
+        public void DeleteGroup()
         {
             SendDeletePackets(members);
+            for (int i = 0; i < members.Count; i++)
+            {
+                Session s = Server.GetServer().GetSession(members[i]);
+                if (s != null)
+                    s.GetActor().SetCurrentContentGroup(null);
+                Actor a = director.GetZone().FindActorInArea(members[i]);
+                if (a is Npc)
+                    ((Npc)a).Despawn();
+                members.Remove(members[i]);
+                i--;
+            }
+            Server.GetWorldManager().DeleteContentGroup(groupIndex);
         }
 
-
         public void CheckDestroy()
         {
             bool foundSession = false;
@@ -155,7 +157,7 @@ namespace FFXIVClassic_Map_Server.actors.group
             }
 
             if (!foundSession)
-                Server.GetWorldManager().DeleteContentGroup(groupIndex);
+                DeleteGroup();
         }
 
     }

FFXIVClassic Map Server/actors/group/GLContentGroup.cs

@@ -0,0 +1,29 @@
+using FFXIVClassic.Common;
+using FFXIVClassic_Map_Server.actors.director;
+using FFXIVClassic_Map_Server.actors.group.Work;
+using FFXIVClassic_Map_Server.Actors;
+using FFXIVClassic_Map_Server.dataobjects;
+using FFXIVClassic_Map_Server.packets.send.group;
+using FFXIVClassic_Map_Server.packets.send.groups;
+using FFXIVClassic_Map_Server.utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Map_Server.actors.group
+{
+    class GLContentGroup : ContentGroup
+    {
+        public GLContentGroup(ulong groupIndex, Director director, uint[] initialMembers)
+            : base(groupIndex, director, initialMembers)
+        {
+        }
+
+        public override uint GetTypeId()
+        {
+            return Group.ContentGroup_GuildleveGroup;
+        }
+    }
+}

FFXIVClassic Map Server/actors/group/Group.cs

@@ -120,33 +120,33 @@ namespace FFXIVClassic_Map_Server.actors.group
             ulong time = Utils.MilisUnixTimeStampUTC();
             List<GroupMember> members = BuildMemberList(session.id);
 
-            session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false);
-            session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false);
+            session.QueuePacket(GroupHeaderPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
+            session.QueuePacket(GroupMembersBeginPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
 
             int currentIndex = 0;
 
             while (true)
             {
                 if (GetMemberCount() - currentIndex >= 64)
-                    session.QueuePacket(GroupMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(GroupMembersX64Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else if (GetMemberCount() - currentIndex >= 32)
-                    session.QueuePacket(GroupMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(GroupMembersX32Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else if (GetMemberCount() - currentIndex >= 16)
-                    session.QueuePacket(GroupMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(GroupMembersX16Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else if (GetMemberCount() - currentIndex > 0)
-                    session.QueuePacket(GroupMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex), true, false);
+                    session.QueuePacket(GroupMembersX08Packet.buildPacket(session.id, session.GetActor().zoneId, time, members, ref currentIndex));
                 else
                     break;
             }
             
-            session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this), true, false);
+            session.QueuePacket(GroupMembersEndPacket.buildPacket(session.id, session.GetActor().zoneId, time, this));
 
         }
 
         public void SendDeletePacket(Session session)
         {            
             if (session != null)
-                session.QueuePacket(DeleteGroupPacket.buildPacket(session.id, this), true, false);
+                session.QueuePacket(DeleteGroupPacket.buildPacket(session.id, this));
         }
 
         public virtual void SendInitWorkValues(Session session)

FFXIVClassic Map Server/actors/group/MonsterParty.cs

@@ -51,7 +51,7 @@ namespace FFXIVClassic_Map_Server.actors.group
             groupWork.setTarget("/_init");
 
             SubPacket test = groupWork.buildPacket(session.id, session.id);
-            session.QueuePacket(test, true, false);
+            session.QueuePacket(test);
         }
 
         public override uint GetTypeId()

FFXIVClassic Map Server/actors/group/Relation.cs

@@ -70,7 +70,7 @@ namespace FFXIVClassic_Map_Server.actors.group
 
             SubPacket test = groupWork.buildPacket(session.id, session.id);
             test.DebugPrintSubPacket();
-            session.QueuePacket(test, true, false);
+            session.QueuePacket(test);
         }
 
     }

FFXIVClassic Map Server/actors/world/WorldMaster.cs

@@ -17,24 +17,24 @@ namespace FFXIVClassic_Map_Server.Actors
             this.className = "WorldMaster";
         }
 
-        public override SubPacket CreateScriptBindPacket(uint playerActorId)
+        public override SubPacket CreateScriptBindPacket()
         {
             List<LuaParam> lParams;
             lParams = LuaUtils.CreateLuaParamList("/World/WorldMaster_event", false, false, false, false, false, null);
-            return ActorInstantiatePacket.BuildPacket(actorId, playerActorId, actorName, className, lParams);
+            return ActorInstantiatePacket.BuildPacket(actorId, actorName, className, lParams);
         }
 
-        public override BasePacket GetSpawnPackets(uint playerActorId)
+        public override List<SubPacket> GetSpawnPackets()
         {
             List<SubPacket> subpackets = new List<SubPacket>();
-            subpackets.Add(CreateAddActorPacket(playerActorId, 0));
-            subpackets.Add(CreateSpeedPacket(playerActorId));
-            subpackets.Add(CreateSpawnPositonPacket(playerActorId, 0x1));
-            subpackets.Add(CreateNamePacket(playerActorId));
-            subpackets.Add(CreateStatePacket(playerActorId));
-            subpackets.Add(CreateIsZoneingPacket(playerActorId));
-            subpackets.Add(CreateScriptBindPacket(playerActorId));
-            return BasePacket.CreatePacket(subpackets, true, false);
+            subpackets.Add(CreateAddActorPacket(0));
+            subpackets.Add(CreateSpeedPacket());
+            subpackets.Add(CreateSpawnPositonPacket(0x1));
+            subpackets.Add(CreateNamePacket());
+            subpackets.Add(CreateStatePacket());
+            subpackets.Add(CreateIsZoneingPacket());
+            subpackets.Add(CreateScriptBindPacket());
+            return subpackets;
         }
     }
 }

FFXIVClassic Map Server/dataobjects/GuildleveData.cs

@@ -0,0 +1,61 @@
+using MySql.Data.MySqlClient;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FFXIVClassic_Map_Server.dataobjects
+{
+    class GuildleveData
+    {
+        public readonly uint id;
+        public readonly uint classType;
+        public readonly uint location;
+        public readonly ushort factionCreditRequired;
+        public readonly ushort level;
+        public readonly uint aetheryte;
+        public readonly uint plateId;
+        public readonly uint borderId;
+        public readonly uint objective;
+        public readonly byte timeLimit;
+        public readonly uint skill;
+        public readonly byte favorCount;
+
+        public readonly sbyte[] aimNum = new sbyte[4];
+        public readonly uint[] itemTarget = new uint[4];
+        public readonly uint[] mobTarget = new uint[4];
+
+        public GuildleveData(MySqlDataReader reader)
+        {
+            id = reader.GetUInt32("id");
+            classType = reader.GetUInt32("classType");
+            location = reader.GetUInt32("location");
+            factionCreditRequired = reader.GetUInt16("factionCreditRequired");
+            level = reader.GetUInt16("level");
+            aetheryte = reader.GetUInt32("aetheryte");
+            plateId = reader.GetUInt32("plateId");
+            borderId = reader.GetUInt32("borderId");
+            objective = reader.GetUInt32("objective");
+            timeLimit = reader.GetByte("timeLimit");
+            skill = reader.GetUInt32("skill");
+            favorCount = reader.GetByte("favorCount");
+
+            aimNum[0] = reader.GetSByte("aimNum1");
+            aimNum[1] = reader.GetSByte("aimNum2");
+            aimNum[2] = reader.GetSByte("aimNum3");
+            aimNum[3] = reader.GetSByte("aimNum4");
+
+            itemTarget[0] = reader.GetUInt32("item1");
+            itemTarget[1] = reader.GetUInt32("item2");
+            itemTarget[2] = reader.GetUInt32("item3");
+            itemTarget[3] = reader.GetUInt32("item4");
+
+            mobTarget[0] = reader.GetUInt32("mob1");
+            mobTarget[1] = reader.GetUInt32("mob2");
+            mobTarget[2] = reader.GetUInt32("mob3");
+            mobTarget[3] = reader.GetUInt32("mob4");
+        }
+
+    }
+}

FFXIVClassic Map Server/dataobjects/InventoryItem.cs

@@ -30,7 +30,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
             this.quantity = 1;
             this.slot = slot;
 
-            Item gItem = Server.GetItemGamedata(itemId);
+            ItemData gItem = Server.GetItemGamedata(itemId);
             itemType = gItem.isExclusive ? (byte)0x3 : (byte)0x0;
         }
 

FFXIVClassic Map Server/dataobjects/ItemData.cs

@@ -3,7 +3,7 @@ using System;
 
 namespace FFXIVClassic_Map_Server.dataobjects
 {
-    class Item
+    class ItemData
     {
         //Basic
         public readonly uint catalogID;
@@ -39,7 +39,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
         public readonly int repairLevel;
         public readonly int repairLicense;
 
-        public Item(MySqlDataReader reader)
+        public ItemData(MySqlDataReader reader)
         {
             catalogID = reader.GetUInt32("catalogID");
             name = reader.GetString("name");
@@ -387,7 +387,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
 
     }
 
-    class EquipmentItem : Item
+    class EquipmentItem : ItemData
     {
         //graphics
         public readonly uint graphicsWeaponId;

FFXIVClassic Map Server/dataobjects/Session.cs

@@ -28,17 +28,18 @@ namespace FFXIVClassic_Map_Server.dataobjects
         {
             this.id = sessionId;
             playerActor = new Player(this, sessionId);
-            actorInstanceList.Add(playerActor);
         }
 
-        public void QueuePacket(BasePacket basePacket)
+        public void QueuePacket(List<SubPacket> packets)
         {
-            Server.GetWorldConnection().QueuePacket(basePacket);
+            foreach (SubPacket s in packets)
+                QueuePacket(s);
         }
 
-        public void QueuePacket(SubPacket subPacket, bool isAuthed, bool isEncrypted)
+        public void QueuePacket(SubPacket subPacket)
         {
-            Server.GetWorldConnection().QueuePacket(subPacket, isAuthed, isEncrypted);
+            subPacket.SetTargetId(id);
+            Server.GetWorldConnection().QueuePacket(subPacket);
         }
 
         public Player GetActor()
@@ -99,29 +100,11 @@ namespace FFXIVClassic_Map_Server.dataobjects
             //Remove missing actors
             for (int i = 0; i < actorInstanceList.Count; i++)
             {
-                if (list.Contains(actorInstanceList[i]) && actorInstanceList[i] is Npc)
-                {
-                    Npc npc = (Npc)actorInstanceList[i];
-                    
-
-                       long milliseconds = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
-
-
-                    if (npc.GetUniqueId().Equals("1") && milliseconds - lastMilis > 1000)
-                    {
-                        lastMilis = milliseconds;
-                        GetActor().QueuePacket(RemoveActorPacket.BuildPacket(playerActor.actorId, actorInstanceList[i].actorId));
-                        actorInstanceList.RemoveAt(i);
-                        continue;
-                    }
-                }
-
                 if (!list.Contains(actorInstanceList[i]))
                 {
-                    GetActor().QueuePacket(RemoveActorPacket.BuildPacket(playerActor.actorId, actorInstanceList[i].actorId));
+                    QueuePacket(RemoveActorPacket.BuildPacket(actorInstanceList[i].actorId));
                     actorInstanceList.RemoveAt(i);
-                }
-                
+                }                
             }
 
             //Add new actors or move
@@ -139,16 +122,16 @@ namespace FFXIVClassic_Map_Server.dataobjects
                     if (actor is Character && ((Character)actor).isStatic)
                         continue;
 
-                    var packet = actor.CreatePositionUpdatePacket(playerActor.actorId);
-
+                    var packet = actor.CreatePositionUpdatePacket();
                     if (packet != null)
-                        GetActor().QueuePacket(packet);
+                        QueuePacket(packet);
                 }
                 else
-                {
-                    GetActor().QueuePacket(actor.GetSpawnPackets(playerActor.actorId, 1));
-                    GetActor().QueuePacket(actor.GetInitPackets(playerActor.actorId));
-                    GetActor().QueuePacket(actor.GetSetEventStatusPackets(playerActor.actorId));
+                {   
+                    QueuePacket(actor.GetSpawnPackets(playerActor, 1));   
+
+                    QueuePacket(actor.GetInitPackets());
+                    QueuePacket(actor.GetSetEventStatusPackets());
                     actorInstanceList.Add(actor);
 
                     if (actor is Npc)

FFXIVClassic Map Server/dataobjects/ZoneConnection.cs

@@ -17,14 +17,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
         private BlockingCollection<SubPacket> SendPacketQueue = new BlockingCollection<SubPacket>(1000);
         public int lastPartialSize = 0;
 
-        public void QueuePacket(BasePacket packet)
-        {
-            List<SubPacket> subPackets = packet.GetSubpackets();
-            foreach (SubPacket s in subPackets)
-                SendPacketQueue.Add(s);
-        }
-
-        public void QueuePacket(SubPacket subpacket, bool isAuthed, bool isEncrypted)
+        public void QueuePacket(SubPacket subpacket)
         {
             SendPacketQueue.Add(subpacket);
         }
@@ -68,7 +61,7 @@ namespace FFXIVClassic_Map_Server.dataobjects
         public void RequestZoneChange(uint sessionId, uint destinationZoneId, byte spawnType, float spawnX, float spawnY, float spawnZ, float spawnRotation)
         {
             WorldRequestZoneChangePacket.BuildPacket(sessionId, destinationZoneId, spawnType, spawnX, spawnY, spawnZ, spawnRotation).DebugPrintSubPacket();
-            QueuePacket(WorldRequestZoneChangePacket.BuildPacket(sessionId, destinationZoneId, spawnType, spawnX, spawnY, spawnZ, spawnRotation), true, false);
+            QueuePacket(WorldRequestZoneChangePacket.BuildPacket(sessionId, destinationZoneId, spawnType, spawnX, spawnY, spawnZ, spawnRotation));
         }
     }
 }

FFXIVClassic Map Server/lua/LuaEngine.cs

@@ -21,13 +21,13 @@ namespace FFXIVClassic_Map_Server.lua
 {
     class LuaEngine
     {
-        const string FILEPATH_PLAYER = "./scripts/player.lua";
-        const string FILEPATH_ZONE = "./scripts/unique/{0}/zone.lua";
-        const string FILEPATH_CONTENT = "./scripts/content/{0}.lua";
-        const string FILEPATH_COMMANDS = "./scripts/commands/{0}.lua";
-        const string FILEPATH_DIRECTORS = "./scripts/directors/{0}.lua";
-        const string FILEPATH_NPCS = "./scripts/unique/{0}/{1}/{2}.lua";
-        const string FILEPATH_QUEST = "./scripts/quests/{0}/{1}.lua";
+        public const string FILEPATH_PLAYER = "./scripts/player.lua";
+        public const string FILEPATH_ZONE = "./scripts/unique/{0}/zone.lua";
+        public const string FILEPATH_CONTENT = "./scripts/content/{0}.lua";
+        public const string FILEPATH_COMMANDS = "./scripts/commands/{0}.lua";
+        public const string FILEPATH_DIRECTORS = "./scripts/directors/{0}.lua";
+        public const string FILEPATH_NPCS = "./scripts/unique/{0}/{1}/{2}.lua";
+        public const string FILEPATH_QUEST = "./scripts/quests/{0}/{1}.lua";
 
         private static LuaEngine mThisEngine;
         private Dictionary<Coroutine, ulong> mSleepingOnTime = new Dictionary<Coroutine, ulong>();
@@ -112,10 +112,18 @@ namespace FFXIVClassic_Map_Server.lua
         {
             if (mSleepingOnPlayerEvent.ContainsKey(player.actorId))
             {
-                Coroutine coroutine = mSleepingOnPlayerEvent[player.actorId];                
-                mSleepingOnPlayerEvent.Remove(player.actorId);               
-                DynValue value = coroutine.Resume(LuaUtils.CreateLuaParamObjectList(args));
-                ResolveResume(null, coroutine, value);
+                try
+                {
+                    Coroutine coroutine = mSleepingOnPlayerEvent[player.actorId];
+                    mSleepingOnPlayerEvent.Remove(player.actorId);
+                    DynValue value = coroutine.Resume(LuaUtils.CreateLuaParamObjectList(args));
+                    ResolveResume(null, coroutine, value);
+                }
+                catch (ScriptRuntimeException e)
+                {
+                    LuaEngine.SendError(player, String.Format("OnEventUpdated: {0}", e.DecoratedMessage));
+                    player.EndEvent();
+                }
             }
             else
                 player.EndEvent();
@@ -365,22 +373,30 @@ namespace FFXIVClassic_Map_Server.lua
             if (mSleepingOnPlayerEvent.ContainsKey(player.actorId))
             {
                 Coroutine coroutine = mSleepingOnPlayerEvent[player.actorId];                
-                mSleepingOnPlayerEvent.Remove(player.actorId);                
-                DynValue value = coroutine.Resume();
-                ResolveResume(null, coroutine, value);
+                mSleepingOnPlayerEvent.Remove(player.actorId);
+
+                try{
+                    DynValue value = coroutine.Resume();
+                    ResolveResume(null, coroutine, value);                  
+                }
+                catch (ScriptRuntimeException e)
+                {
+                    LuaEngine.SendError(player, String.Format("OnEventStarted: {0}", e.DecoratedMessage));
+                    player.EndEvent();
+                }                
             }
             else                
                 CallLuaFunction(player, target, "onEventStarted", false, LuaUtils.CreateLuaParamObjectList(lparams));
         }
-
-        private DynValue ResolveResume(Actor actor, Coroutine coroutine, DynValue value)
+
+        public DynValue ResolveResume(Actor actor, Coroutine coroutine, DynValue value)
         {
             var isPlayer = actor is Player;
 
             if (value == null || value.IsVoid())
                 return value;
-
-            if (isPlayer && value.String != null && value.String.Equals("_WAIT_EVENT"))
+
+            if (isPlayer && value.String != null && value.String.Equals("_WAIT_EVENT"))
             {                
                 GetInstance().AddWaitEventCoroutine((Player)actor, coroutine);      
             }
@@ -579,22 +595,22 @@ namespace FFXIVClassic_Map_Server.lua
             script.Globals["GetStaticActor"] = (Func<string, Actor>)Server.GetStaticActors;
             script.Globals["GetStaticActorById"] = (Func<uint, Actor>)Server.GetStaticActors;
             script.Globals["GetWorldMaster"] = (Func<Actor>)Server.GetWorldManager().GetActor;
-            script.Globals["GetItemGamedata"] = (Func<uint, Item>)Server.GetItemGamedata;
+            script.Globals["GetItemGamedata"] = (Func<uint, ItemData>)Server.GetItemGamedata;
+            script.Globals["GetGuildleveGamedata"] = (Func<uint, GuildleveData>)Server.GetGuildleveGamedata;
             script.Globals["GetLuaInstance"] = (Func<LuaEngine>)LuaEngine.GetInstance;
 
             script.Options.DebugPrint = s => { Program.Log.Debug(s); };
             return script;
         }
 
-        private static void SendError(Player player, string message)
+        public static void SendError(Player player, string message)
         {
             message = "[LuaError] " + message;
             if (player == null)
                 return;
             List<SubPacket> SendError = new List<SubPacket>();
-            SendError.Add(EndEventPacket.BuildPacket(player.actorId, player.currentEventOwner, player.currentEventName));
             player.SendMessage(SendMessagePacket.MESSAGE_TYPE_SYSTEM_ERROR, "", message);
-            player.playerSession.QueuePacket(BasePacket.CreatePacket(SendError, true, false));
+            player.QueuePacket(EndEventPacket.BuildPacket(player.actorId, player.currentEventOwner, player.currentEventName));
         }
         
     }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/CreateLinkshellPacket.cs

@@ -24,7 +24,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write((UInt32)master);
                 }
             }
-            return new SubPacket(true, OPCODE, 0, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }      
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/DeleteLinkshellPacket.cs

@@ -21,7 +21,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name));                    
                 }
             }
-            return new SubPacket(true, OPCODE, 0, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }      
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/GroupInviteResultPacket.cs

@@ -25,7 +25,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write((UInt32)result);
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
 
     }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellChangePacket.cs

@@ -23,7 +23,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write(Encoding.ASCII.GetBytes(lsName), 0, Encoding.ASCII.GetByteCount(lsName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(lsName));
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
 
     }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellInviteCancelPacket.cs

@@ -17,7 +17,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
         public static SubPacket BuildPacket(Session session)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];            
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }      
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellInvitePacket.cs

@@ -25,7 +25,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write(Encoding.ASCII.GetBytes(linkshellName), 0, Encoding.ASCII.GetByteCount(linkshellName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(linkshellName));
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }      
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellLeavePacket.cs

@@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write(Encoding.ASCII.GetBytes(lsName), 0, Encoding.ASCII.GetByteCount(lsName) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(lsName));
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
 
     }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/LinkshellRankChangePacket.cs

@@ -27,7 +27,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write((Byte)rank);
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
 
     }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/ModifyLinkshellPacket.cs

@@ -35,7 +35,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     
                 }
             }
-            return new SubPacket(true, OPCODE, 0, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }      
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/PartyInvitePacket.cs

@@ -25,7 +25,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name));
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
 
         public static SubPacket BuildPacket(Session session, uint actorId)
@@ -39,7 +39,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write((UInt32)actorId);
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }      
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/PartyLeavePacket.cs

@@ -23,7 +23,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write((UInt16)(isDisband ? 1 : 0));
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
 
     }

FFXIVClassic Map Server/packets/WorldPackets/Send/Group/PartyModifyPacket.cs

@@ -24,7 +24,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write(Encoding.ASCII.GetBytes(name), 0, Encoding.ASCII.GetByteCount(name) >= 0x20 ? 0x20 : Encoding.ASCII.GetByteCount(name));
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
 
         public static SubPacket BuildPacket(Session session, ushort command, uint actorId)
@@ -38,7 +38,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send.Group
                     binWriter.Write((UInt32)actorId);
                 }
             }
-            return new SubPacket(true, OPCODE, session.id, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }      
 
     }

FFXIVClassic Map Server/packets/WorldPackets/Send/SessionBeginConfirmPacket.cs

@@ -21,7 +21,7 @@ namespace  FFXIVClassic_Map_Server.packets.WorldPackets.Send
                     binWriter.Write((UInt16)errorCode);
                 }
             }
-            return new SubPacket(true, OPCODE, 0, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/SessionEndConfirmPacket.cs

@@ -22,7 +22,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send
                     binWriter.Write((UInt32)destinationZone);
                 }
             }
-            return new SubPacket(true, OPCODE, 0, session.id, data);
+            return new SubPacket(true, OPCODE, session.id, data);
         }
     }
 }

FFXIVClassic Map Server/packets/WorldPackets/Send/WorldRequestZoneChangePacket.cs

@@ -31,7 +31,7 @@ namespace FFXIVClassic_Map_Server.packets.WorldPackets.Send
                 }
             }
 
-            return new SubPacket(OPCODE, sessionId, sessionId, data);
+            return new SubPacket(OPCODE, sessionId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/ActorDoEmotePacket.cs

@@ -10,7 +10,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00E1;
         public const uint PACKET_SIZE = 0x30;
 
-        public static SubPacket BuildPacket(uint sourceActorId, uint targetActorId, uint targettedActorId, uint animationId, uint descriptionId)
+        public static SubPacket BuildPacket(uint sourceActorId, uint targettedActorId, uint animationId, uint descriptionId)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -32,7 +32,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            SubPacket packet = new SubPacket(OPCODE, sourceActorId, targetActorId, data);
+            SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
             packet.DebugPrintSubPacket();
             return packet;
         }

FFXIVClassic Map Server/packets/send/Actor/ActorInstantiatePacket.cs

@@ -13,7 +13,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00CC;
         public const uint PACKET_SIZE = 0x128;
 
-        public static SubPacket BuildPacket(uint sourceActorID, uint targetActorID, string objectName, string className, List<LuaParam> initParams)
+        public static SubPacket BuildPacket(uint sourceActorId, string objectName, string className, List<LuaParam> initParams)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -33,7 +33,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/ActorSpecialGraphicPacket.cs

@@ -15,7 +15,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00E3;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, int iconCode)
+        public static SubPacket BuildPacket(uint sourceActorId, int iconCode)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -27,7 +27,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, targetActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/AddActorPacket.cs

@@ -9,12 +9,12 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00CA;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint actorID, byte val)
+        public static SubPacket BuildPacket(uint sourceActorId, byte val)
         {
             byte[] data = new byte[PACKET_SIZE-0x20];
             data[0] = val; //Why?
 
-            return new SubPacket(OPCODE, playerActorID, actorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/BattleAction1Packet.cs

@@ -1,27 +0,0 @@
-using FFXIVClassic.Common;
-using System.IO;
-
-using FFXIVClassic.Common;
-
-namespace  FFXIVClassic_Map_Server.packets.send.actor
-{
-    class BattleAction1Packet
-    {
-        public const ushort OPCODE = 0x0139;
-        public const uint PACKET_SIZE = 0x58;
-
-        public static SubPacket BuildPacket(uint sourceId, uint targetId)
-        {
-            byte[] data = new byte[PACKET_SIZE - 0x20];
-
-            using (MemoryStream mem = new MemoryStream(data))
-            {
-                using (BinaryWriter binWriter = new BinaryWriter(mem))
-                {                    
-                }
-            }
-
-            return new SubPacket(OPCODE, sourceId, targetId, data);
-        }
-    }
-}

FFXIVClassic Map Server/packets/send/Actor/DeleteAllActorsPacket.cs

@@ -9,9 +9,9 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x0007;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID)
+        public static SubPacket BuildPacket(uint sourceActorId)
         {
-            return new SubPacket(OPCODE, playerActorID, playerActorID, new byte[8]);
+            return new SubPacket(OPCODE, sourceActorId, new byte[8]);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/MoveActorToPositionPacket.cs

@@ -10,7 +10,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00CF;
         public const uint PACKET_SIZE = 0x50;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, float x, float y, float z, float rot, ushort moveState)
+        public static SubPacket BuildPacket(uint sourceActorId, float x, float y, float z, float rot, ushort moveState)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -27,7 +27,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            SubPacket packet = new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
             return packet;
         }
 

FFXIVClassic Map Server/packets/send/Actor/PlayAnimationOnActorPacket.cs

@@ -12,9 +12,9 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00DA;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint animationID)
+        public static SubPacket BuildPacket(uint sourceActorId, uint animationID)
         {
-            return new SubPacket(OPCODE, playerActorID, targetActorID, BitConverter.GetBytes((ulong)animationID));
+            return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes((ulong)animationID));
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/PlayBGAnimation.cs

@@ -12,7 +12,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00D9;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, string animName)
+        public static SubPacket BuildPacket(uint sourceActorId, string animName)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
           
@@ -24,7 +24,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);            
+            return new SubPacket(OPCODE, sourceActorId, data);            
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/RemoveActorPacket.cs

@@ -10,7 +10,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00CB;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint actorId)
+        public static SubPacket BuildPacket(uint sourceActorId)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -18,11 +18,11 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
             {
                 using (BinaryWriter binWriter = new BinaryWriter(mem))
                 {
-                    binWriter.Write((UInt32)actorId);                 
+                    binWriter.Write((UInt32)sourceActorId);                 
                 }
             }
 
-            return new SubPacket(OPCODE, actorId, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/SetActorAppearancePacket.cs

@@ -53,7 +53,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
             appearanceIDs = appearanceTable;
         }
 
-        public SubPacket BuildPacket(uint playerActorID, uint actorID)
+        public SubPacket BuildPacket(uint sourceActorId)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -74,7 +74,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
 
             }
 
-            SubPacket packet = new SubPacket(OPCODE, playerActorID, actorID, data);
+            SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
             return packet;
         }       
 

FFXIVClassic Map Server/packets/send/Actor/SetActorBGPropertiesPacket.cs

@@ -5,12 +5,12 @@ using System;
 
 namespace  FFXIVClassic_Map_Server.packets.send.actor
 {
-    class _0xD8Packet
+    class SetActorBGPropertiesPacket
     {
         public const ushort OPCODE = 0x00D8;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint val1, uint val2)
+        public static SubPacket BuildPacket(uint sourceActorId, uint val1, uint val2)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -23,7 +23,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorIconPacket.cs

@@ -14,7 +14,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x0145;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint iconCode)
+        public static SubPacket BuildPacket(uint sourceActorId, uint iconCode)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -26,7 +26,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorIsZoningPacket.cs

@@ -7,11 +7,11 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x017B;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, bool isDimmed)
+        public static SubPacket BuildPacket(uint sourceActorId, bool isDimmed)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
             data[0] = (byte)(isDimmed ? 1 : 0);
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorNamePacket.cs

@@ -11,7 +11,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x013D;
         public const uint PACKET_SIZE = 0x48;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint displayNameID, string customName)
+        public static SubPacket BuildPacket(uint sourceActorId, uint displayNameID, string customName)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -29,7 +29,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            SubPacket packet = new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
             return packet;
         }
 

FFXIVClassic Map Server/packets/send/Actor/SetActorPositionPacket.cs

@@ -19,7 +19,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort SPAWNTYPE_WARP_DUTY2 = 6;
         public const ushort SPAWNTYPE_WARP_LIGHT = 7;
         
-        public static SubPacket BuildPacket(uint sourceActorID, uint targetActorID, uint actorId, float x, float y, float z, float rotation, ushort spawnType, bool isZoningPlayer)
+        public static SubPacket BuildPacket(uint sourceActorId, uint actorId, float x, float y, float z, float rotation, ushort spawnType, bool isZoningPlayer)
         {
             byte[] data = new byte[PACKET_SIZE-0x20];
 
@@ -41,7 +41,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/SetActorPropetyPacket.cs

@@ -113,7 +113,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
             string[] split = name.Split('.');
             int arrayIndex = 0;
 
-            if (!(split[0].Equals("work") || split[0].Equals("charaWork") || split[0].Equals("playerWork") || split[0].Equals("npcWork")))
+            if (!(split[0].Equals("work") || split[0].Equals("charaWork") || split[0].Equals("playerWork") || split[0].Equals("npcWork") || split[0].Equals("guildleveWork")))
                 return false;
 
             Object curObj = actor;
@@ -159,6 +159,8 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                     return AddByte(id, (byte)(((bool)curObj) ? 1 : 0));
                 else if (curObj is byte)
                     return AddByte(id, (byte)curObj);
+                else if (curObj is sbyte)
+                    return AddByte(id, (byte)(sbyte)curObj);
                 else if (curObj is ushort)
                     return AddShort(id, (ushort)curObj);
                 else if (curObj is short)
@@ -207,14 +209,14 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
             currentTarget = newTarget;
         }
 
-        public SubPacket BuildPacket(uint playerActorID, uint actorID)
+        public SubPacket BuildPacket(uint sourceActorId)
         {
             binWriter.Seek(0, SeekOrigin.Begin);
             binWriter.Write((byte)runningByteTotal);
             
             CloseStreams();
 
-            SubPacket packet = new SubPacket(OPCODE, actorID, playerActorID, data);
+            SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
             return packet;
         }       
     

FFXIVClassic Map Server/packets/send/Actor/SetActorSpeedPacket.cs

@@ -14,7 +14,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const float DEFAULT_RUN = 5.0f;
         public const float DEFAULT_ACTIVE = 5.0f;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID)
+        public static SubPacket BuildPacket(uint sourceActorId)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -40,10 +40,10 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, float stopSpeed, float walkSpeed, float runSpeed, float activeSpeed)
+        public static SubPacket BuildPacket(uint sourceActorId, float stopSpeed, float walkSpeed, float runSpeed, float activeSpeed)
         {               
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -69,7 +69,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorStatePacket.cs

@@ -30,10 +30,10 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x134;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetID, uint mainState, uint subState)
+        public static SubPacket BuildPacket(uint sourceActorId, uint mainState, uint subState)
         {            
             ulong combined = (mainState & 0xFF) | ((subState & 0xFF) << 8);
-            return new SubPacket(OPCODE, playerActorID, targetID, BitConverter.GetBytes(combined));
+            return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes(combined));
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorStatusAllPacket.cs

@@ -11,7 +11,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x0179;
         public const uint PACKET_SIZE = 0x48;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, ushort[] statusIds)
+        public static SubPacket BuildPacket(uint sourceActorId, ushort[] statusIds)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
           
@@ -28,7 +28,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            SubPacket packet = new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            SubPacket packet = new SubPacket(OPCODE, sourceActorId, data);
             return packet;
         }
     }

FFXIVClassic Map Server/packets/send/Actor/SetActorStatusPacket.cs

@@ -11,7 +11,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x0177;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, ushort index, ushort statusCode)
+        public static SubPacket BuildPacket(uint sourceActorId, ushort index, ushort statusCode)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
           
@@ -24,7 +24,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);            
+            return new SubPacket(OPCODE, sourceActorId, data);            
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorSubStatPacket.cs

@@ -10,7 +10,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x144;
         public const uint PACKET_SIZE = 0x28;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetID, byte breakage, int leftChant, int rightChant, int guard, int wasteStat, int statMode, uint idleAnimationId)
+        public static SubPacket BuildPacket(uint sourceActorId, byte breakage, int leftChant, int rightChant, int guard, int wasteStat, int statMode, uint idleAnimationId)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -28,7 +28,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorTargetAnimatedPacket.cs

@@ -9,9 +9,9 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00D3;
         public const uint PACKET_SIZE = 0x28;
         
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint targetID)
+        public static SubPacket BuildPacket(uint sourceActorId, uint targetID)
         {            
-            return new SubPacket(OPCODE, playerActorID, targetID, BitConverter.GetBytes((ulong)targetID));
+            return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes((ulong)targetID));
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/SetActorTargetPacket.cs

@@ -8,9 +8,9 @@ namespace FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x00DB;
         public const uint PACKET_SIZE = 0x28;
         
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, uint targetID)
+        public static SubPacket BuildPacket(uint sourceActorId, uint targetID)
         {            
-            return new SubPacket(OPCODE, playerActorID, targetID, BitConverter.GetBytes((ulong)targetID));
+            return new SubPacket(OPCODE, sourceActorId, BitConverter.GetBytes((ulong)targetID));
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/_0x132Packet.cs

@@ -11,7 +11,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x132;
         public const uint PACKET_SIZE = 0x48;
 
-        public static SubPacket BuildPacket(uint playerActorID, ushort number, string function)
+        public static SubPacket BuildPacket(uint sourceActorId, ushort number, string function)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -24,7 +24,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/_0xD9Packet.cs

@@ -1,29 +0,0 @@
-using System.IO;
-
-using FFXIVClassic.Common;
-using System;
-using System.Text;
-
-namespace  FFXIVClassic_Map_Server.packets.send.actor
-{
-    class _0xD9Packet
-    {
-        public const ushort OPCODE = 0x00D9;
-        public const uint PACKET_SIZE = 0x28;
-
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID, string anim)
-        {
-            byte[] data = new byte[PACKET_SIZE - 0x20];
-
-            using (MemoryStream mem = new MemoryStream(data))
-            {
-                using (BinaryWriter binWriter = new BinaryWriter(mem))
-                {
-                    binWriter.Write(Encoding.ASCII.GetBytes(anim), 0, Encoding.ASCII.GetByteCount(anim) >= 4 ? 4 : Encoding.ASCII.GetByteCount(anim));
-                }
-            }
-
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);
-        }
-    }
-}

FFXIVClassic Map Server/packets/send/Actor/_0xFPacket.cs

@@ -9,7 +9,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
         public const ushort OPCODE = 0x000F;
         public const uint PACKET_SIZE = 0x38;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint targetActorID)
+        public static SubPacket BuildPacket(uint sourceActor)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -21,7 +21,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, targetActorID, data);
+            return new SubPacket(OPCODE, sourceActor, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX00Packet.cs

@@ -32,7 +32,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.battle
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorId, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX01Packet.cs

@@ -2,8 +2,6 @@
 using System;
 using System.IO;
 
-using FFXIVClassic.Common;
-
 namespace  FFXIVClassic_Map_Server.packets.send.actor.battle
 {
     // see xtx_command
@@ -47,7 +45,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.battle
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorId, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX10Packet.cs

@@ -55,7 +55,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.battle
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorId, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/battle/BattleActionX18Packet.cs

@@ -55,7 +55,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.battle
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorId, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/events/SetEmoteEventCondition.cs

@@ -13,7 +13,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
         public const ushort OPCODE = 0x016C;
         public const uint PACKET_SIZE = 0x48;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.EmoteEventCondition condition)
+        public static SubPacket BuildPacket(uint sourceActorId, EventList.EmoteEventCondition condition)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -27,7 +27,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/events/SetEventStatus.cs

@@ -11,7 +11,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
         public const ushort OPCODE = 0x0136;
         public const uint PACKET_SIZE = 0x48;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, bool enabled, byte unknown2, string conditionName)
+        public static SubPacket BuildPacket(uint sourceActorId, bool enabled, byte unknown2, string conditionName)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -25,7 +25,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/events/SetNoticeEventCondition.cs

@@ -12,7 +12,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
         public const ushort OPCODE = 0x016B;
         public const uint PACKET_SIZE = 0x48;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.NoticeEventCondition condition)
+        public static SubPacket BuildPacket(uint sourceActorId, EventList.NoticeEventCondition condition)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -26,7 +26,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/events/SetPushEventConditionWithCircle.cs

@@ -12,7 +12,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
         public const ushort OPCODE = 0x016F;
         public const uint PACKET_SIZE = 0x58;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.PushCircleEventCondition condition)
+        public static SubPacket BuildPacket(uint sourceActorId, EventList.PushCircleEventCondition condition)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -31,7 +31,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/events/SetPushEventConditionWithFan.cs

@@ -12,7 +12,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
         public const ushort OPCODE = 0x0170;
         public const uint PACKET_SIZE = 0x60;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.PushFanEventCondition condition)
+        public static SubPacket BuildPacket(uint sourceActorId, EventList.PushFanEventCondition condition)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -23,7 +23,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                     binWriter.Write((Single)condition.radius);
                     binWriter.Write((UInt32)0xbfc90fdb);
                     binWriter.Write((UInt32)0x3f860a92);
-                    binWriter.Write((UInt32)sourceActorID); //Actor Id
+                    binWriter.Write((UInt32)sourceActorId); //Actor Id
                     binWriter.Write((Single)10.0f);
                     binWriter.Seek(4, SeekOrigin.Current);
                     binWriter.Write((Byte)(condition.outwards ? 0x11 : 0x1)); //If == 0x10, Inverted Bounding Box
@@ -32,8 +32,8 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                     binWriter.Write(Encoding.ASCII.GetBytes(condition.conditionName), 0, Encoding.ASCII.GetByteCount(condition.conditionName) >= 0x24 ? 0x24 : Encoding.ASCII.GetByteCount(condition.conditionName));
                 }
             }
-            new SubPacket(OPCODE, sourceActorID, playerActorID, data).DebugPrintSubPacket();
-            return new SubPacket(OPCODE, sourceActorID, playerActorID, data);
+            new SubPacket(OPCODE, sourceActorId, data).DebugPrintSubPacket();
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/events/SetPushEventConditionWithTriggerBox.cs

@@ -12,7 +12,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
         public const ushort OPCODE = 0x0175;
         public const uint PACKET_SIZE = 0x60;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.PushBoxEventCondition condition)
+        public static SubPacket BuildPacket(uint sourceActorId, EventList.PushBoxEventCondition condition)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -31,7 +31,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/events/SetTalkEventCondition.cs

@@ -12,7 +12,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
         public const ushort OPCODE = 0x012E;
         public const uint PACKET_SIZE = 0x48;
 
-        public static SubPacket BuildPacket(uint playerActorID, uint sourceActorID, EventList.TalkEventCondition condition)
+        public static SubPacket BuildPacket(uint sourceActorId, EventList.TalkEventCondition condition)
         {
             byte[] data = new byte[PACKET_SIZE - 0x20];
 
@@ -27,7 +27,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.events
                 }
             }
 
-            return new SubPacket(OPCODE, sourceActorID, playerActorID, data);
+            return new SubPacket(OPCODE, sourceActorId, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX01Packet.cs

@@ -23,7 +23,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.inventory
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorID, playerActorID, data);
+            return new SubPacket(OPCODE, playerActorID, data);
         }
     }
 }

FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX08Packet.cs

@@ -38,7 +38,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.inventory
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorId, playerActorId, data);
+            return new SubPacket(OPCODE, playerActorId, data);
         }
 
     }

FFXIVClassic Map Server/packets/send/Actor/inventory/EquipmentListX16Packet.cs

@@ -36,7 +36,7 @@ namespace  FFXIVClassic_Map_Server.packets.send.actor.inventory
                 }
             }
 
-            return new SubPacket(OPCODE, playerActorId, playerActorId, data);
+            return new SubPacket(OPCODE, playerActorId, data);
         }
 
     }