public bool DoStep(NetworkClient networkClient, GameClient client)
        {
            bool chatStarted = false;
            networkClient.OutLogMessage("Starting chat...");

            //Get chat info
            string getInfo = Packet.BuildPacket(FromClient.CHAT_CTRL, Chat.START);
            networkClient.SendData(getInfo);

            //Start chat
            Packet chat = networkClient.InputQueue.Pop(FromServer.CHAT_CTRL);
            if (chat != null)
            {
                string chatServer = chat["@server"];
                string sessionId = (string)client.AdditionalData[ObjectPropertyName.SESSION_ID][0];
                chatStarted = networkClient.StartChat(chatServer, sessionId);
                if (chatStarted)
                {
                    //1: Session ID, 2: Login
                    string chatAuth = Packet.BuildPacket(FromClient.CHAT_CTRL, Chat.AUTH,
                        sessionId, client.Login);
                    networkClient.SendChatData(chatAuth);
                }
            }

            networkClient.OutLogMessage(!chatStarted
                ? "WARNING: chat wasn`t started"
                : "Chat was successfully started");

            return true;
        }

 public override void OnStartClient(NetworkClient client)
 {
     HideLobbyCamera();
     pauseMenu.SetActive(true);
     ShowHUD();
     Cursor.lockState = CursorLockMode.Locked; // keep confined in the game window
 }

        public override void InitializeScene(ICanvas canvas)
        {
            // Connect with simulator
            connection = new NetworkClient();
            if (!connection.Connect("ganberg2", 9999))
            {
                throw new ApplicationException("Unable to establish connection with host.");
            }
            else
            {
                connection.Subscribe("TimeTick");
                connection.Subscribe("ViewProUpdate");
            }

            // Create and initialize Gameboard.
            background = new Obj_Sprite(texture_file, SpriteFlags.SortTexture | SpriteFlags.AlphaBlend);
            background.Initialize(canvas);
            background.Position = new Vector3(0, 0, 0);
            background.Rotation = new Vector3(0, 0, 0);
            background.Scaling = new Vector3(1, 1, 1);
            background.Texture(canvas);

            // Initialize and create Font;
            this._myFont = canvas.CreateFont(new System.Drawing.Font("Arial", 10));
            message = string.Empty;

            //f16 = new Obj_Sprite("f16.png", SpriteFlags.AlphaBlend);
            //f16.Initialize(canvas);
            //f16.Texture(canvas);
            //f16.Position = new Vector3(0, 0, 0);
            //f16.Rotation = new Vector3(0, 0, 0);
            //f16.Scaling = new Vector3(1, 1, 1);

        }

        public static EventListener UniqueInstance(NetworkClient server)
        {
            if (_uniqueInstance == null)
                _uniqueInstance = new EventListener(server);

            return _uniqueInstance;
        }

        /// <summary>
        /// Sends a CharacterCreate packet to a CityServer.
        /// </summary>
        /// <param name="LoginArgs">Arguments used to log onto the CityServer.</param>
        /// <param name="Character">The character to create on the CityServer.</param>
        public static void SendCharacterCreateCity(NetworkClient Client, UISim Character)
        {
            PacketStream Packet = new PacketStream((byte)PacketType.CHARACTER_CREATE_CITY, 0);

            MemoryStream PacketData = new MemoryStream();
            BinaryWriter Writer = new BinaryWriter(PacketData);

            Writer.Write((byte)Client.ClientEncryptor.Username.Length);
            Writer.Write(Encoding.ASCII.GetBytes(Client.ClientEncryptor.Username), 0,
                Encoding.ASCII.GetBytes(Client.ClientEncryptor.Username).Length);

            Writer.Write(PlayerAccount.CityToken);
            Writer.Write(Character.Timestamp);
            Writer.Write(Character.Name);
            Writer.Write(Character.Sex);
            Writer.Write(Character.Description);
            Writer.Write((ulong)Character.HeadOutfitID);
            Writer.Write((ulong)Character.BodyOutfitID);
            Writer.Write((byte)Character.Avatar.Appearance);

            Packet.WriteBytes(PacketData.ToArray());
            Writer.Close();

            Client.SendEncrypted((byte)PacketType.CHARACTER_CREATE_CITY, Packet.ToArray());
        }

        public bool DoStep(NetworkClient networkClient, GameClient client)
        {
            if (IsReadyForAction)
            {
                _gameItemsGroups = Instance.GameItemsGroups;

                //Current location must be quction, check it
                string locationIdent = Helper.GetCurrentLocationIdent(client);
                if (Locations.Auctions.Contains(locationIdent))
                {
                    //Sell items from auc
                    DoSellingItemsFromAuc(networkClient, client);

                    //Sell items from inventory
                    DoSellingItemsFromInv(networkClient, client);
                }

                //Clear auction items cache
                _auctionItems.Clear();

                _prewSellingTime = Environment.TickCount;
                return true;
            }

            return false;
        }

 // Create a client and connect to the server port
 public void SetupClient()
 {
     myClient = new NetworkClient();
     myClient.RegisterHandler(MsgType.Connect, OnConnected);
     myClient.RegisterHandler(MyMsgType.Info, OnInfo);
     myClient.Connect("10.250.235.162", 3000);
 }

    public void OnMatchJoined(JoinMatchResponse matchJoin)
    {
        if (matchJoin.success)
        {
            Debug.Log("Join match succeeded");
            if (_lobby.matchCreated)
            {
                Debug.LogWarning("Match already set up, aborting...");
                return;
            }

            MatchInfo matchInfo = new MatchInfo(matchJoin);
            Utility.SetAccessTokenForNetwork(matchJoin.networkId, new NetworkAccessToken(matchJoin.accessTokenString));
            _client = new NetworkClient();
            _client.RegisterHandler(MsgType.Connect, OnConnected);
            _client.RegisterHandler(MsgType.Disconnect, OnDisconnect);
            _client.RegisterHandler(MsgType.Error, OnError);
            _client.RegisterHandler(MsgType.AddPlayer, AddPlayerMessage);
            //_client.RegisterHandler(MsgType.Owner, OwnerMes);
            _client.RegisterHandler(100, MesFromServer);

            NetworkManager.singleton.StartClient(matchInfo);
            //_client.Connect(matchInfo);
        }
        else
        {
            Debug.LogError("Join match failed.");

        }
    }

        public bool DoStep(NetworkClient networkClient, GameClient client)
        {
            if (IsReadyForAction)
            {
                DateTime now = DateTime.Now;

                //Collect garbage
                IEnumerable<Packet> packets = networkClient.InputQueue.PeakAll(null).
                    Where(p => now.Subtract(p.ReceiveTime).TotalSeconds >= TTL_OF_PACKER_SEC);
                networkClient.InputQueue.RemoveAll(packets);

                //Generate list of unknown packets
                Packet[] unkPackets = packets.Where(p => !_sysPackets.Contains(p.Type)).ToArray();
                if (unkPackets.Length > 0)
                {
                    //Generate log message
                    StringBuilder message = new StringBuilder();
                    foreach (Packet packet in unkPackets)
                    {
                        message.AppendFormat("{0}{1}", message.Length == 0 ? "" : ", ",
                            packet.Type);
                    }
                    message.Insert(0, "GC -> unknown packets: ");

                    //Send log message
                    networkClient.OutLogMessage(message.ToString());
                }

                _prewGCCollectTime = Environment.TickCount;
            }
            return true;
        }

 public void SetupClient()
 {
     myClient = new NetworkClient();
     myClient.RegisterHandler(MsgType.Connect, OnConnected);
     myClient.Connect("192.16.7.21", 8888);
     isAtStartup = false;
 }

        public static void MainX(string[] args)
        {
            ServiceHost service = new ServiceHost(NetworkInput.Instance);

            ServiceEndpoint endpoint = service.AddServiceEndpoint(
                typeof(XnaSpace.Input.INetworkInputService),
                new NetTcpBinding(),
                args[0]);
            Console.WriteLine(endpoint.ListenUri);
            service.Open();
            Console.WriteLine("Create Another");
            Console.ReadLine();
            Binding binding = new NetTcpBinding();
            EndpointAddress endpointAddress = new EndpointAddress(args[1]);
            NetworkClient client = new NetworkClient(binding, endpointAddress);
            client.Open();
            using (Space game = new Space(client))
            {
                game.Run();
            }
            try
            {
                client.Close();
                service.Close();
            }
            catch (Exception)
            {
            }
        }

        public SetSubnetRouteTableTests()
        {
            this.networkingClientMock = new Mock<INetworkManagementClient>();
            this.computeClientMock = new Mock<IComputeManagementClient>();
            this.managementClientMock = new Mock<IManagementClient>();
            this.mockCommandRuntime = new MockCommandRuntime();
            this.client = new NetworkClient(
                networkingClientMock.Object,
                computeClientMock.Object,
                managementClientMock.Object,
                mockCommandRuntime);

            this.networkingClientMock
                .Setup(c => c.Routes.GetRouteTableForSubnetAsync(
                    VirtualNetworkName,
                    SubnetName,
                    It.IsAny<CancellationToken>()))
                .Returns(Task.Factory.StartNew(() =>
                    new Models.GetRouteTableForSubnetResponse()
                    {
                        RouteTableName = RouteTableName
                    }));

            this.networkingClientMock
                .Setup(c => c.Routes.AddRouteTableToSubnetAsync(
                    VirtualNetworkName,
                    SubnetName,
                    It.Is<Models.AddRouteTableToSubnetParameters>(
                        p => string.Equals(p.RouteTableName, RouteTableName)),
                    It.IsAny<CancellationToken>()))
                .Returns(Task.Factory.StartNew(() => new Azure.OperationStatusResponse()));
        }

        public SetIPForwardingTests()
        {
            this.networkingClientMock = new Mock<INetworkManagementClient>();
            this.computeClientMock = new Mock<IComputeManagementClient>();
            this.managementClientMock = new Mock<IManagementClient>();
            this.mockCommandRuntime = new MockCommandRuntime();
            this.client = new NetworkClient(
                networkingClientMock.Object,
                computeClientMock.Object,
                managementClientMock.Object,
                mockCommandRuntime);

            this.computeClientMock
                .Setup(c => c.Deployments.GetBySlotAsync(ServiceName, DeploymentSlot.Production, It.IsAny<CancellationToken>()))
                .Returns(Task.Factory.StartNew(() => new DeploymentGetResponse()
                {
                    Name = DeploymentName
                }));

            this.networkingClientMock
                .Setup(c => c.IPForwarding.SetOnRoleAsync(
                    ServiceName,
                    DeploymentName,
                    RoleName,
                    It.IsAny<IPForwardingSetParameters>(),
                    It.IsAny<CancellationToken>()))
                .Returns(Task.Factory.StartNew(() => new Azure.OperationStatusResponse()));
        }

        public bool DoStep(NetworkClient networkClient, GameClient client)
        {
            networkClient.OutLogMessage("Getting a servers list...");

            //Send greeting
            string greeting = Packet.BuildPacket(FromClient.GREETING);
            networkClient.SendData(greeting);

            //Get response
            Packet packet = networkClient.InputQueue.Pop();

            if (packet != null)
            {
                //Get available servers
                List<string> servers = packet.GetValues("S/@host");

                //Log message
                StringBuilder sServers = new StringBuilder();

                //Store available servers
                foreach (string server in servers)
                {
                    sServers.AppendFormat("{0}{1}", sServers.Length > 0 ? ", " : "", server);
                    client.AdditionalData.Add(ObjectPropertyName.GAME_SERVER, server);
                }

                networkClient.OutLogMessage(sServers.Insert(0, "Available servers: ").ToString());
                return true;
            }

            networkClient.ThrowError("Failed to getting a servers list or the connection was terminated");
            return false;
        }

        public bool DoStep(NetworkClient networkClient, GameClient client)
        {
            int curTickCount = Environment.TickCount;

            //Just started
            if (_prewPingTime == 0)
            {
                _prewPingTime = curTickCount;
                return false;
            }

            if (curTickCount - _prewPingTime >= PING_DELAY_MS)
            {
                //Query params: 0: is a first time ping?, [1]: I1, [2]: ID2, [3]: ID1
                string ping = Packet.BuildPacket(FromClient.PING,
                    _firstTime,
                    client.AdditionalData[ObjectPropertyName.I1][0],
                    client.AdditionalData[ObjectPropertyName.ID2][0],
                    client.AdditionalData[ObjectPropertyName.ID1][0]);
                networkClient.SendData(ping);
                networkClient.SendChatData(ping);

                _firstTime = false;
                _prewPingTime = Environment.TickCount;
                return true;
            }

            return false;
        }

 public bool DoStep(NetworkClient networkClient, GameClient client)
 {
     Packet[] packets = networkClient.InputQueue.PopAll(FromServer.ERROR);
     foreach (Packet packet in packets)
     {
         string errorCode = packet["@code"];
         string errorMessage = Errors.GameError.GetErrorMessage(errorCode);
         switch (errorCode)
         {
             case Errors.GameError.E_USER_HAS_DROPPED:
             case Errors.GameError.E_PLAYER_ON_ANOTHER_SERVER:
             case Errors.GameError.E_CONNECTION_ERROR:
                 {
                     networkClient.ThrowError(errorMessage);
                     break;
                 }
             default:
                 {
                     networkClient.OutLogMessage(string.Format("ERROR: {0}", errorMessage));
                     break;
                 }
         }
     }
     return true;
 }

 //automatically called when starting a client
 public override void OnStartClient(NetworkClient mClient)
 {
     Debug.Log ("onstartclient called");
     base.OnStartClient(mClient);
     mClient.RegisterHandler((short)MyMessages.MyMessageTypes.CHAT_MESSAGE, OnClientChatMessage);
     mClient.RegisterHandler((short)MyMessages.MyMessageTypes.USER_INFO, OnClientUserInfo);
 }

        public static void OnCharacterCreationStatus(NetworkClient Client, ProcessedPacket Packet)
        {
            CharacterCreationStatus CCStatus = (CharacterCreationStatus)Packet.ReadByte();

            switch (CCStatus)
            {
                case CharacterCreationStatus.Success:
                    Guid CharacterGUID = new Guid();

                    //CityToken didn't exist, so transition to CityServer hasn't happened yet.
                    if (PlayerAccount.CityToken == "")
                    {
                        CharacterGUID = new Guid(Packet.ReadPascalString());
                        PlayerAccount.CityToken = Packet.ReadPascalString();
                    }

                    NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);

                    if(PlayerAccount.CityToken == "")
                        PlayerAccount.CurrentlyActiveSim.AssignGUID(CharacterGUID.ToString());

                    break;
                case CharacterCreationStatus.ExceededCharacterLimit:
                    NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);
                    break;
                case CharacterCreationStatus.NameAlreadyExisted:
                    NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);
                    break;
                case CharacterCreationStatus.GeneralError:
                    NetworkFacade.Controller._OnCharacterCreationStatus(CCStatus);
                    break;
                default:
                    break;
            }
        }

        public bool DoStep(NetworkClient networkClient, GameClient client)
        {
            DateTime now = DateTime.Now;
            ChatMessage[] outChatMessages = _outChatMessages.Where(cm => cm.MessageTime <= now ).ToArray();

            if (outChatMessages.Length > 0)
            {
                foreach (ChatMessage chatMessage in outChatMessages)
                {
                    _outChatMessages.Remove(chatMessage);

                    //1: From, 2: To, 3: Type, 4: Message
                    string message = Packet.BuildPacket(FromClient.CHAT_MESSAGE,
                        Chat.POST, client.Login, chatMessage.Sender, chatMessage.Type,
                        chatMessage.Message);
                    networkClient.SendChatData(message);

                    //Play notification for private message
                    _soundPlayer.Play();

                    //Out chat message
                    string logMessage = string.Format("[{0}] {1} [{2}] {3}",
                        client.Login,
                        chatMessage.Type == ChatMessageType.Pivate ? "private" : "to",
                        chatMessage.Sender, chatMessage.Message);
                    networkClient.OutChatMessage(logMessage);
                }
                return true;
            }

            return false;
        }

        void Client_ConnectionStatusChanged( NetworkClient sender, NetworkConnectionStatuses status )
        {
            switch( status )
            {
            case NetworkConnectionStatuses.Disconnected:
                {
                    string text = string.Format( "Disconnected. Reason: \"{0}\"",
                        sender.DisconnectionReason );
                    Log( text );
                    Disconnect();
                }
                break;

            case NetworkConnectionStatuses.Connecting:
                Log( "Connecting..." );
                break;

            case NetworkConnectionStatuses.Connected:
                Log( "Connected" );
                Log( "Server: \"{0}\"", sender.RemoteServerName );
                foreach( string serviceName in sender.ServerConnectedNode.RemoteServices )
                    Log( "Server service: \"{0}\"", serviceName );

                buttonConnect.Enabled = false;
                buttonDisconnect.Enabled = true;
                textBoxUserName.ReadOnly = true;
                textBoxAddress.ReadOnly = true;
                textBoxEnterText.ReadOnly = false;
                buttonSend.Enabled = true;
                break;
            }
        }