/// <summary>
 /// We only use the default options for SendMessagePacket.
 /// May as well make it less unwieldly to view
 /// </summary>
 /// <param name="client"></param>
 /// <param name="message"></param>
 private void sendMessage(ConnectedPlayer client, String message)
 {
     if (client != null)
     {
         client.getActor().queuePacket(SendMessagePacket.buildPacket(client.actorID, client.actorID, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", message));
     }
 }
        public void doWarp(ConnectedPlayer client, uint zoneId, string privateArea, byte spawnType, float x, float y, float z, float r)
        {
            WorldManager worldManager = Server.GetWorldManager();

            if (worldManager.GetZone(zoneId) == null)
            {
                if (client != null)
                {
                    client.queuePacket(BasePacket.createPacket(SendMessagePacket.buildPacket(client.actorID, client.actorID, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", "Zone does not exist or setting isn't valid."), true, false));
                }
                Log.error("Zone does not exist or setting isn't valid.");
            }

            if (client != null)
            {
                worldManager.DoZoneChange(client.getActor(), zoneId, privateArea, spawnType, x, y, z, r);
            }
            else
            {
                foreach (KeyValuePair <uint, ConnectedPlayer> entry in mConnectedPlayerList)
                {
                    worldManager.DoZoneChange(entry.Value.getActor(), zoneId, privateArea, spawnType, x, y, z, r);
                }
            }
        }
 public void printPos(ConnectedPlayer client)
 {
     if (client != null)
     {
         Player p = client.getActor();
         client.queuePacket(BasePacket.createPacket(SendMessagePacket.buildPacket(client.actorID, client.actorID, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", String.Format("{0}\'s position: ZoneID: {1}, X: {2}, Y: {3}, Z: {4}, Rotation: {5}", p.customDisplayName, p.zoneId, p.positionX, p.positionY, p.positionZ, p.rotation)), true, false));
     }
     else
     {
         foreach (KeyValuePair <uint, ConnectedPlayer> entry in mConnectedPlayerList)
         {
             Player p = entry.Value.getActor();
             Log.info(String.Format("{0}\'s position: ZoneID: {1}, X: {2}, Y: {3}, Z: {4}, Rotation: {5}", p.customDisplayName, p.zoneId, p.positionX, p.positionY, p.positionZ, p.rotation));
         }
     }
 }
 public void sendMessage(uint logType, string sender, string message)
 {
     queuePacket(SendMessagePacket.buildPacket(actorId, actorId, logType, sender, message));
 }
        internal bool doCommand(string input, ConnectedPlayer client)
        {
            input.Trim();
            if (input.StartsWith("!"))
            {
                input = input.Substring(1);
            }

            String[] split = input.Split(' ');
            split = split.Select(temp => temp.ToLower()).ToArray(); // Ignore case on commands
            split = split.Where(temp => temp != "").ToArray();      // strips extra whitespace from commands

            // Debug
            //sendMessage(client, string.Join(",", split));

            if (split.Length >= 1)
            {
                #region !help
                if (split[0].Equals("help"))
                {
                    if (split.Length == 1)
                    {
                        sendMessage(client, Resources.CPhelp);
                    }
                    if (split.Length == 2)
                    {
                        if (split[1].Equals("mypos"))
                        {
                            sendMessage(client, Resources.CPmypos);
                        }
                        else if (split[1].Equals("music"))
                        {
                            sendMessage(client, Resources.CPmusic);
                        }
                        else if (split[1].Equals("warp"))
                        {
                            sendMessage(client, Resources.CPwarp);
                        }
                        else if (split[1].Equals("givecurrency"))
                        {
                            sendMessage(client, Resources.CPgivecurrency);
                        }
                        else if (split[1].Equals("giveitem"))
                        {
                            sendMessage(client, Resources.CPgiveitem);
                        }
                        else if (split[1].Equals("givekeyitem"))
                        {
                            sendMessage(client, Resources.CPgivekeyitem);
                        }
                        else if (split[1].Equals("removecurrency"))
                        {
                            sendMessage(client, Resources.CPremovecurrency);
                        }
                        else if (split[1].Equals("removeitem"))
                        {
                            sendMessage(client, Resources.CPremoveitem);
                        }
                        else if (split[1].Equals("removekeyitem"))
                        {
                            sendMessage(client, Resources.CPremovekeyitem);
                        }
                        else if (split[1].Equals("reloaditems"))
                        {
                            sendMessage(client, Resources.CPreloaditems);
                        }
                        else if (split[1].Equals("reloadzones"))
                        {
                            sendMessage(client, Resources.CPreloadzones);
                        }

                        /*
                         * else if (split[1].Equals("property"))
                         *  sendMessage(client, Resources.CPproperty);
                         * else if (split[1].Equals("property2"))
                         *  sendMessage(client, Resources.CPproperty2);
                         * else if (split[1].Equals("sendpacket"))
                         *   sendMessage(client, Resources.CPsendpacket);
                         * else if (split[1].Equals("setgraphic"))
                         *     sendMessage(client, Resources.CPsetgraphic);
                         */
                    }
                    if (split.Length == 3)
                    {
                        if (split[1].Equals("test"))
                        {
                            if (split[2].Equals("weather"))
                            {
                                sendMessage(client, Resources.CPtestweather);
                            }
                        }
                    }

                    return(true);
                }
                #endregion

                #region !test
                else if (split[0].Equals("test"))
                {
                    if (split.Length == 1)
                    {
                        // catch invalid commands
                        sendMessage(client, Resources.CPhelp);
                    }
                    else if (split.Length >= 2)
                    {
                        #region !test weather
                        if (split[1].Equals("weather"))
                        {
                            try
                            {
                                doWeather(client, split[2], split[3]);
                                return(true);
                            }
                            catch (Exception e)
                            {
                                Log.error("Could not change weather: " + e);
                            }
                        }
                        #endregion
                    }
                }
                #endregion

                #region !mypos
                else if (split[0].Equals("mypos"))
                {
                    try
                    {
                        printPos(client);
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not load packet: " + e);
                    }
                }
                #endregion

                #region !reloadzones
                else if (split[0].Equals("reloadzones"))
                {
                    if (client != null)
                    {
                        Log.info(String.Format("Got request to reset zone: {0}", client.getActor().zoneId));
                        client.getActor().zone.clear();
                        client.getActor().zone.addActorToZone(client.getActor());
                        client.getActor().sendInstanceUpdate();
                        client.queuePacket(BasePacket.createPacket(SendMessagePacket.buildPacket(client.actorID, client.actorID, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", String.Format("Reseting zone {0}...", client.getActor().zoneId)), true, false));
                    }
                    Server.GetWorldManager().reloadZone(client.getActor().zoneId);
                    return(true);
                }
                #endregion

                #region !reloaditems
                else if (split[0].Equals("reloaditems"))
                {
                    Log.info(String.Format("Got request to reload item gamedata"));
                    sendMessage(client, "Reloading Item Gamedata...");
                    gamedataItems.Clear();
                    gamedataItems = Database.getItemGamedata();
                    Log.info(String.Format("Loaded {0} items.", gamedataItems.Count));
                    sendMessage(client, String.Format("Loaded {0} items.", gamedataItems.Count));
                    return(true);
                }
                #endregion

                #region !sendpacket
                else if (split[0].Equals("sendpacket"))
                {
                    if (split.Length < 2)
                    {
                        return(false);
                    }

                    try
                    {
                        sendPacket(client, "./packets/" + split[1]);
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not load packet: " + e);
                    }
                }
                #endregion

                #region !graphic
                else if (split[0].Equals("graphic"))
                {
                    try
                    {
                        if (split.Length == 6)
                        {
                            setGraphic(client, UInt32.Parse(split[1]), UInt32.Parse(split[2]), UInt32.Parse(split[3]), UInt32.Parse(split[4]), UInt32.Parse(split[5]));
                        }
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not give item.");
                    }
                }
                #endregion

                #region !giveitem
                else if (split[0].Equals("giveitem"))
                {
                    try
                    {
                        if (split.Length == 2)
                        {
                            giveItem(client, UInt32.Parse(split[1]), 1);
                        }
                        else if (split.Length == 3)
                        {
                            giveItem(client, UInt32.Parse(split[1]), Int32.Parse(split[2]));
                        }
                        else if (split.Length == 4)
                        {
                            giveItem(client, UInt32.Parse(split[1]), Int32.Parse(split[2]), UInt16.Parse(split[3]));
                        }
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not give item.");
                    }
                }
                #endregion

                #region !removeitem
                else if (split[0].Equals("removeitem"))
                {
                    if (split.Length < 2)
                    {
                        return(false);
                    }

                    try
                    {
                        if (split.Length == 2)
                        {
                            removeItem(client, UInt32.Parse(split[1]), 1);
                        }
                        else if (split.Length == 3)
                        {
                            removeItem(client, UInt32.Parse(split[1]), Int32.Parse(split[2]));
                        }
                        else if (split.Length == 4)
                        {
                            removeItem(client, UInt32.Parse(split[1]), Int32.Parse(split[2]), UInt16.Parse(split[3]));
                        }
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not remove item.");
                    }
                }
                #endregion

                #region !givekeyitem
                else if (split[0].Equals("givekeyitem"))
                {
                    try
                    {
                        if (split.Length == 2)
                        {
                            giveKeyItem(client, UInt32.Parse(split[1]));
                        }
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not give keyitem.");
                    }
                }
                #endregion

                #region !removekeyitem
                else if (split[0].Equals("removekeyitem"))
                {
                    if (split.Length < 2)
                    {
                        return(false);
                    }

                    try
                    {
                        if (split.Length == 2)
                        {
                            removeKeyItem(client, UInt32.Parse(split[1]));
                        }
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not remove keyitem.");
                    }
                }
                #endregion

                #region !givecurrency
                else if (split[0].Equals("givecurrency"))
                {
                    try
                    {
                        if (split.Length == 2)
                        {
                            giveCurrency(client, ITEM_GIL, Int32.Parse(split[1]));
                        }
                        else if (split.Length == 3)
                        {
                            giveCurrency(client, UInt32.Parse(split[1]), Int32.Parse(split[2]));
                        }
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not give currency.");
                    }
                }
                #endregion

                #region !removecurrency
                else if (split[0].Equals("removecurrency"))
                {
                    if (split.Length < 2)
                    {
                        return(false);
                    }

                    try
                    {
                        if (split.Length == 2)
                        {
                            removeCurrency(client, ITEM_GIL, Int32.Parse(split[1]));
                        }
                        else if (split.Length == 3)
                        {
                            removeCurrency(client, UInt32.Parse(split[1]), Int32.Parse(split[2]));
                        }
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not remove currency.");
                    }
                }
                #endregion

                #region !music
                else if (split[0].Equals("music"))
                {
                    if (split.Length < 2)
                    {
                        return(false);
                    }

                    try
                    {
                        doMusic(client, split[1]);
                        return(true);
                    }
                    catch (Exception e)
                    {
                        Log.error("Could not change music: " + e);
                    }
                }
                #endregion

                #region !warp
                else if (split[0].Equals("warp"))
                {
                    parseWarp(client, split);
                    return(true);
                }
                #endregion

                #region !property
                else if (split[0].Equals("property"))
                {
                    if (split.Length == 4)
                    {
                        changeProperty(Utils.MurmurHash2(split[1], 0), Convert.ToUInt32(split[2], 16), split[3]);
                    }
                    return(true);
                }
                #endregion

                #region !property2
                else if (split[0].Equals("property2"))
                {
                    if (split.Length == 4)
                    {
                        changeProperty(Convert.ToUInt32(split[1], 16), Convert.ToUInt32(split[2], 16), split[3]);
                    }
                    return(true);
                }
                #endregion
            }
            return(false);
        }
        public void processPacket(ClientConnection client, BasePacket packet)
        {
            if (packet.header.isCompressed == 0x01)
            {
                BasePacket.decryptPacket(client.blowfish, ref packet);
            }

            List <SubPacket> subPackets = packet.getSubpackets();

            foreach (SubPacket subpacket in subPackets)
            {
                if (subpacket.header.type == 0x01)
                {
                    packet.debugPrintPacket();
                    byte[] reply1Data =
                    {
                        0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x18, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFD, 0xFF, 0xFF,
                        0xE5, 0x6E, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x0
                    };

                    byte[] reply2Data =
                    {
                        0x01, 0x00, 0x00, 0x00, 0x28, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                        0x38, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x2B, 0x5F, 0x26,
                        0x66, 0x00, 0x00, 0x00, 0xC8, 0xD6, 0xAF, 0x2B, 0x38, 0x2B, 0x5F, 0x26, 0xB8, 0x8D, 0xF0, 0x2B,
                        0xC8, 0xFD, 0x85, 0xFE, 0xA8, 0x7C, 0x5B, 0x09, 0x38, 0x2B, 0x5F, 0x26, 0xC8, 0xD6, 0xAF, 0x2B,
                        0xB8, 0x8D, 0xF0, 0x2B, 0x88, 0xAF, 0x5E, 0x26
                    };

                    BasePacket reply1 = new BasePacket(reply1Data);
                    BasePacket reply2 = new BasePacket(reply2Data);

                    //Write Timestamp into Reply1
                    using (MemoryStream mem = new MemoryStream(reply1.data))
                    {
                        using (BinaryWriter binReader = new BinaryWriter(mem))
                        {
                            binReader.BaseStream.Seek(0x14, SeekOrigin.Begin);
                            binReader.Write((UInt32)Utils.UnixTimeStampUTC());
                        }
                    }

                    //Read in Actor Id that owns this connection
                    uint actorID = 0;
                    using (MemoryStream mem = new MemoryStream(packet.data))
                    {
                        using (BinaryReader binReader = new BinaryReader(mem))
                        {
                            try
                            {
                                byte[] readIn = new byte[12];
                                binReader.BaseStream.Seek(0x14, SeekOrigin.Begin);
                                binReader.Read(readIn, 0, 12);
                                actorID = UInt32.Parse(Encoding.ASCII.GetString(readIn));
                            }
                            catch (Exception)
                            { }
                        }
                    }

                    //Should never happen.... unless actor id IS 0!
                    if (actorID == 0)
                    {
                        break;
                    }

                    client.owner = actorID;

                    //Write Actor ID into reply2
                    using (MemoryStream mem = new MemoryStream(reply2.data))
                    {
                        using (BinaryWriter binReader = new BinaryWriter(mem))
                        {
                            binReader.BaseStream.Seek(0x10, SeekOrigin.Begin);
                            binReader.Write(actorID);
                        }
                    }

                    ConnectedPlayer player = null;

                    if (packet.header.connectionType == BasePacket.TYPE_ZONE)
                    {
                        while (!mPlayers.ContainsKey(client.owner))
                        {
                        }
                        player = mPlayers[client.owner];
                    }

                    //Create connected player if not created
                    if (player == null)
                    {
                        player            = new ConnectedPlayer(actorID);
                        mPlayers[actorID] = player;
                    }

                    player.setConnection(packet.header.connectionType, client);

                    if (packet.header.connectionType == BasePacket.TYPE_ZONE)
                    {
                        Log.debug(String.Format("Got {0} connection for ActorID {1} @ {2}.", "zone", actorID, client.getAddress()));
                    }
                    else if (packet.header.connectionType == BasePacket.TYPE_CHAT)
                    {
                        Log.debug(String.Format("Got {0} connection for ActorID {1} @ {2}.", "chat", actorID, client.getAddress()));
                    }

                    //Create player actor
                    reply1.debugPrintPacket();
                    client.queuePacket(reply1);
                    client.queuePacket(reply2);
                    break;
                }
                else if (subpacket.header.type == 0x07)
                {
                    BasePacket init = Login0x7ResponsePacket.buildPacket(BitConverter.ToUInt32(packet.data, 0x10), Utils.UnixTimeStampUTC());
                    //client.queuePacket(init);
                }
                else if (subpacket.header.type == 0x08)
                {
                    //Response, client's current [actorID][time]
                    packet.debugPrintPacket();
                }
                else if (subpacket.header.type == 0x03)
                {
                    ConnectedPlayer player = null;

                    if (mPlayers.ContainsKey(client.owner))
                    {
                        player = mPlayers[client.owner];
                    }

                    if (player == null)
                    {
                        return;
                    }

                    //Normal Game Opcode
                    switch (subpacket.gameMessage.opcode)
                    {
                    //Ping
                    case 0x0001:
                        //subpacket.debugPrintSubPacket();
                        PingPacket pingPacket = new PingPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(PongPacket.buildPacket(player.actorID, pingPacket.time), true, false));
                        player.ping();
                        break;

                    //Unknown
                    case 0x0002:

                        subpacket.debugPrintSubPacket();
                        client.queuePacket(_0x2Packet.buildPacket(player.actorID), true, false);

                        Server.GetWorldManager().DoLogin(player.getActor());


                        break;

                    //Chat Received
                    case 0x0003:
                        ChatMessagePacket chatMessage = new ChatMessagePacket(subpacket.data);
                        Log.info(String.Format("Got type-{5} message: {0} @ {1}, {2}, {3}, Rot: {4}", chatMessage.message, chatMessage.posX, chatMessage.posY, chatMessage.posZ, chatMessage.posRot, chatMessage.logType));
                        subpacket.debugPrintSubPacket();

                        if (chatMessage.message.StartsWith("!"))
                        {
                            if (cp.doCommand(chatMessage.message, player))
                            {
                                continue;
                            }
                        }

                        player.getActor().broadcastPacket(SendMessagePacket.buildPacket(player.actorID, player.actorID, chatMessage.logType, player.getActor().customDisplayName, chatMessage.message), false);

                        break;

                    //Langauge Code
                    case 0x0006:
                        LangaugeCodePacket langCode = new LangaugeCodePacket(subpacket.data);
                        player.languageCode = langCode.languageCode;
                        break;

                    //Unknown - Happens a lot at login, then once every time player zones
                    case 0x0007:
                        //subpacket.debugPrintSubPacket();
                        _0x07Packet unknown07 = new _0x07Packet(subpacket.data);
                        break;

                    //Update Position
                    case 0x00CA:
                        //Update Position
                        //subpacket.debugPrintSubPacket();
                        UpdatePlayerPositionPacket posUpdate = new UpdatePlayerPositionPacket(subpacket.data);
                        player.updatePlayerActorPosition(posUpdate.x, posUpdate.y, posUpdate.z, posUpdate.rot, posUpdate.moveState);
                        player.getActor().sendInstanceUpdate();

                        if (player.getActor().isInZoneChange())
                        {
                            player.getActor().setZoneChanging(false);
                        }

                        break;

                    //Set Target
                    case 0x00CD:
                        //subpacket.debugPrintSubPacket();

                        SetTargetPacket setTarget       = new SetTargetPacket(subpacket.data);
                        player.getActor().currentTarget = setTarget.actorID;
                        player.getActor().broadcastPacket(SetActorTargetAnimatedPacket.buildPacket(player.actorID, player.actorID, setTarget.actorID), true);
                        break;

                    //Lock Target
                    case 0x00CC:
                        LockTargetPacket lockTarget           = new LockTargetPacket(subpacket.data);
                        player.getActor().currentLockedTarget = lockTarget.actorID;
                        break;

                    //Start Event
                    case 0x012D:
                        subpacket.debugPrintSubPacket();
                        EventStartPacket eventStart = new EventStartPacket(subpacket.data);

                        /*
                         * if (eventStart.error != null)
                         * {
                         *  player.errorMessage += eventStart.error;
                         *
                         *  if (eventStart.errorIndex == eventStart.errorNum - 1)
                         *      Log.error("\n"+player.errorMessage);
                         *
                         *
                         *  break;
                         * }
                         */

                        Actor ownerActor = Server.getStaticActors(eventStart.scriptOwnerActorID);
                        if (ownerActor != null && ownerActor is Command)
                        {
                            player.getActor().currentCommand     = eventStart.scriptOwnerActorID;
                            player.getActor().currentCommandName = eventStart.triggerName;
                        }
                        else
                        {
                            player.getActor().currentEventOwner = eventStart.scriptOwnerActorID;
                            player.getActor().currentEventName  = eventStart.triggerName;
                        }

                        if (ownerActor == null)
                        {
                            //Is it a instance actor?
                            ownerActor = Server.GetWorldManager().GetActorInWorld(player.getActor().currentEventOwner);
                            if (ownerActor == null)
                            {
                                //Is it a Director?
                                if (player.getActor().currentDirector != null && player.getActor().currentEventOwner == player.getActor().currentDirector.actorId)
                                {
                                    ownerActor = player.getActor().currentDirector;
                                }
                                else
                                {
                                    Log.debug(String.Format("\n===Event START===\nCould not find actor 0x{0:X} for event started by caller: 0x{1:X}\nEvent Starter: {2}\nParams: {3}", eventStart.actorID, eventStart.scriptOwnerActorID, eventStart.triggerName, LuaUtils.dumpParams(eventStart.luaParams)));
                                    break;
                                }
                            }
                        }

                        LuaEngine.doActorOnEventStarted(player.getActor(), ownerActor, eventStart);

                        Log.debug(String.Format("\n===Event START===\nSource Actor: 0x{0:X}\nCaller Actor: 0x{1:X}\nVal1: 0x{2:X}\nVal2: 0x{3:X}\nEvent Starter: {4}\nParams: {5}", eventStart.actorID, eventStart.scriptOwnerActorID, eventStart.val1, eventStart.val2, eventStart.triggerName, LuaUtils.dumpParams(eventStart.luaParams)));
                        break;

                    //Unknown, happens at npc spawn and cutscene play????
                    case 0x00CE:
                        break;

                    //Event Result
                    case 0x012E:
                        subpacket.debugPrintSubPacket();
                        EventUpdatePacket eventUpdate = new EventUpdatePacket(subpacket.data);
                        Log.debug(String.Format("\n===Event UPDATE===\nSource Actor: 0x{0:X}\nCaller Actor: 0x{1:X}\nVal1: 0x{2:X}\nVal2: 0x{3:X}\nStep: 0x{4:X}\nParams: {5}", eventUpdate.actorID, eventUpdate.scriptOwnerActorID, eventUpdate.val1, eventUpdate.val2, eventUpdate.step, LuaUtils.dumpParams(eventUpdate.luaParams)));

                        //Is it a static actor? If not look in the player's instance
                        Actor updateOwnerActor = Server.getStaticActors(player.getActor().currentEventOwner);
                        if (updateOwnerActor == null)
                        {
                            updateOwnerActor = Server.GetWorldManager().GetActorInWorld(player.getActor().currentEventOwner);

                            if (player.getActor().currentDirector != null && player.getActor().currentEventOwner == player.getActor().currentDirector.actorId)
                            {
                                updateOwnerActor = player.getActor().currentDirector;
                            }

                            if (updateOwnerActor == null)
                            {
                                break;
                            }
                        }

                        LuaEngine.doActorOnEventUpdated(player.getActor(), updateOwnerActor, eventUpdate);

                        break;

                    case 0x012F:
                        subpacket.debugPrintSubPacket();
                        ParameterDataRequestPacket paramRequest = new ParameterDataRequestPacket(subpacket.data);
                        if (paramRequest.paramName.Equals("charaWork/exp"))
                        {
                            player.getActor().sendCharaExpInfo();
                        }
                        break;

                    /* RECRUITMENT */
                    //Start Recruiting
                    case 0x01C3:
                        StartRecruitingRequestPacket recruitRequestPacket = new StartRecruitingRequestPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(StartRecruitingResponse.buildPacket(player.actorID, true), true, false));
                        break;

                    //End Recruiting
                    case 0x01C4:
                        client.queuePacket(BasePacket.createPacket(EndRecruitmentPacket.buildPacket(player.actorID), true, false));
                        break;

                    //Party Window Opened, Request State
                    case 0x01C5:
                        client.queuePacket(BasePacket.createPacket(RecruiterStatePacket.buildPacket(player.actorID, true, true, 1), true, false));
                        break;

                    //Search Recruiting
                    case 0x01C7:
                        RecruitmentSearchRequestPacket recruitSearchPacket = new RecruitmentSearchRequestPacket(subpacket.data);
                        break;

                    //Get Recruitment Details
                    case 0x01C8:
                        RecruitmentDetailsRequestPacket currentRecruitDetailsPacket = new RecruitmentDetailsRequestPacket(subpacket.data);
                        RecruitmentDetails details = new RecruitmentDetails();
                        details.recruiterName = "Localhost Character";
                        details.purposeId     = 2;
                        details.locationId    = 1;
                        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(player.actorID, details), true, false));
                        break;

                    //Accepted Recruiting
                    case 0x01C6:
                        subpacket.debugPrintSubPacket();
                        break;

                    /* SOCIAL STUFF */
                    case 0x01C9:
                        AddRemoveSocialPacket addBlackList = new AddRemoveSocialPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(BlacklistAddedPacket.buildPacket(player.actorID, true, addBlackList.name), true, false));
                        break;

                    case 0x01CA:
                        AddRemoveSocialPacket removeBlackList = new AddRemoveSocialPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(BlacklistRemovedPacket.buildPacket(player.actorID, true, removeBlackList.name), true, false));
                        break;

                    case 0x01CB:
                        int offset1 = 0;
                        client.queuePacket(BasePacket.createPacket(SendBlacklistPacket.buildPacket(player.actorID, new String[] { "Test" }, ref offset1), true, false));
                        break;

                    case 0x01CC:
                        AddRemoveSocialPacket addFriendList = new AddRemoveSocialPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(FriendlistAddedPacket.buildPacket(player.actorID, true, (uint)addFriendList.name.GetHashCode(), true, addFriendList.name), true, false));
                        break;

                    case 0x01CD:
                        AddRemoveSocialPacket removeFriendList = new AddRemoveSocialPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(FriendlistRemovedPacket.buildPacket(player.actorID, true, removeFriendList.name), true, false));
                        break;

                    case 0x01CE:
                        int offset2 = 0;
                        client.queuePacket(BasePacket.createPacket(SendFriendlistPacket.buildPacket(player.actorID, new Tuple <long, string>[] { new Tuple <long, string>(01, "Test2") }, ref offset2), true, false));
                        break;

                    case 0x01CF:
                        client.queuePacket(BasePacket.createPacket(FriendStatusPacket.buildPacket(player.actorID, null), true, false));
                        break;

                    /* SUPPORT DESK STUFF */
                    //Request for FAQ/Info List
                    case 0x01D0:
                        FaqListRequestPacket faqRequest = new FaqListRequestPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(FaqListResponsePacket.buildPacket(player.actorID, new string[] { "Testing FAQ1", "Coded style!" }), true, false));
                        break;

                    //Request for body of a faq/info selection
                    case 0x01D1:
                        FaqBodyRequestPacket faqBodyRequest = new FaqBodyRequestPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(FaqBodyResponsePacket.buildPacket(player.actorID, "HERE IS A GIANT BODY. Nothing else to say!"), true, false));
                        break;

                    //Request issue list
                    case 0x01D2:
                        GMTicketIssuesRequestPacket issuesRequest = new GMTicketIssuesRequestPacket(subpacket.data);
                        client.queuePacket(BasePacket.createPacket(IssueListResponsePacket.buildPacket(player.actorID, new string[] { "Test1", "Test2", "Test3", "Test4", "Test5" }), true, false));
                        break;

                    //Request if GM ticket exists
                    case 0x01D3:
                        client.queuePacket(BasePacket.createPacket(StartGMTicketPacket.buildPacket(player.actorID, false), true, false));
                        break;

                    //Request for GM response message
                    case 0x01D4:
                        client.queuePacket(BasePacket.createPacket(GMTicketPacket.buildPacket(player.actorID, "This is a GM Ticket Title", "This is a GM Ticket Body."), true, false));
                        break;

                    //GM Ticket Sent
                    case 0x01D5:
                        GMSupportTicketPacket gmTicket = new GMSupportTicketPacket(subpacket.data);
                        Log.info("Got GM Ticket: \n" + gmTicket.ticketTitle + "\n" + gmTicket.ticketBody);
                        client.queuePacket(BasePacket.createPacket(GMTicketSentResponsePacket.buildPacket(player.actorID, true), true, false));
                        break;

                    //Request to end ticket
                    case 0x01D6:
                        client.queuePacket(BasePacket.createPacket(EndGMTicketPacket.buildPacket(player.actorID), true, false));
                        break;

                    default:
                        Log.debug(String.Format("Unknown command 0x{0:X} received.", subpacket.gameMessage.opcode));
                        subpacket.debugPrintSubPacket();
                        break;
                    }
                }
                else
                {
                    packet.debugPrintPacket();
                }
            }
        }