/// <summary>
 /// Enviar mensaje a cliente, solo si esta conectado
 /// </summary>
 private void sendToClient(TgcSocketClientInfo clientInfo, TgcSocketSendMsg msg)
 {
     if (clientInfo.Status == TgcSocketClientInfo.ClientStatus.Connected)
     {
         TgcSocketMessages.sendMessage(clientInfo.Socket, msg, TgcSocketMessageHeader.MsgType.RegularMessage);
     }
 }
 /// <summary>
 /// Envia un mensaje a todos los clientes conectados al servidor
 /// </summary>
 /// <param name="msg">Mensaje a enviar</param>
 public void sendToAll(TgcSocketSendMsg msg)
 {
     foreach (TgcSocketClientInfo clientInfo in allClients)
     {
         sendToClient(clientInfo, msg);
     }
 }
        /// <summary>
        /// Recibir información inicial del cliente
        /// </summary>
        /// <returns>True si todo salio bien</returns>
        private bool getClientInitialInfo(TgcSocketClientInfo clientInfo, Socket socket)
        {
            try
            {
                //Recibir info inicial del cliente
                TgcSocketRecvMsg msg = TgcSocketMessages.receiveMessage(socket, TgcSocketMessageHeader.MsgType.InitialMessage);
                if (msg == null)
                {
                    return(false);
                }

                //Guardar sus datos y cambiar su estado
                TgcSocketInitialInfoClient clientInitInfo = (TgcSocketInitialInfoClient)msg.readNext();
                clientInfo.Name   = clientInitInfo.clientName;
                clientInfo.Status = TgcSocketClientInfo.ClientStatus.WaitingClientOk;

                //Asignar Player ID a cliente
                TgcSocketInitialInfoServer serverInitInfo = new TgcSocketInitialInfoServer();
                serverInitInfo.serverName = serverName;
                serverInitInfo.playerId   = playerIdCounter;
                clientInfo.PlayerId       = serverInitInfo.playerId;
                playerIdCounter++;

                //Enviar info inicial del server
                TgcSocketSendMsg sendMsg = new TgcSocketSendMsg();
                sendMsg.write(serverInitInfo);
                TgcSocketMessages.sendMessage(socket, sendMsg, TgcSocketMessageHeader.MsgType.InitialMessage);

                return(true);
            }
            catch (SocketException)
            {
                return(false);
            }
        }
        /// <summary>
        /// Recibir informacion inicial del server
        /// </summary>
        /// <returns>True si todo salio bien</returns>
        private bool getServerInitialInfo()
        {
            try
            {
                //Recibir info inicial del server
                TgcSocketRecvMsg msg = TgcSocketMessages.receiveMessage(clientSocket, TgcSocketMessageHeader.MsgType.InitialMessage);
                if (msg == null)
                {
                    return(false);
                }

                //Guardar sus datos y cambiar su estado
                TgcSocketInitialInfoServer serverInitInfo = (TgcSocketInitialInfoServer)msg.readNext();
                serverInfo.Name = serverInitInfo.serverName;
                playerId        = serverInitInfo.playerId;

                //Enviar OK final
                this.status = TgcSocketClientInfo.ClientStatus.Connected;
                TgcSocketSendMsg sendMsg = new TgcSocketSendMsg();
                sendMsg.write(true);
                return(TgcSocketMessages.sendMessage(clientSocket, sendMsg, TgcSocketMessageHeader.MsgType.InitialMessage));
            }
            catch (SocketException)
            {
                return(false);
            }
        }
        /// <summary>
        /// Empezar el handshake con el server
        /// </summary>
        /// <returns>True si todo salio bien</returns>
        private bool doHandShake()
        {
            try
            {
                int    serverHandshakeLength = Encoding.ASCII.GetBytes(TgcSocketServer.SERVER_HANDSHAKE).Length;
                byte[] data = new byte[serverHandshakeLength];
                int    recv = clientSocket.Receive(data, data.Length, SocketFlags.None);
                if (recv > 0 && recv == serverHandshakeLength)
                {
                    string msg = Encoding.ASCII.GetString(data, 0, recv);
                    if (msg.Equals(TgcSocketServer.SERVER_HANDSHAKE))
                    {
                        //Server correcto, enviar informacion inicial
                        status = TgcSocketClientInfo.ClientStatus.RequireInitialInfo;
                        TgcSocketInitialInfoClient clientInitInfo = new TgcSocketInitialInfoClient();
                        clientInitInfo.clientName = clientName;

                        TgcSocketSendMsg sendMsg = new TgcSocketSendMsg();
                        sendMsg.write(clientInitInfo);
                        TgcSocketMessages.sendMessage(clientSocket, sendMsg, TgcSocketMessageHeader.MsgType.InitialMessage);

                        return(true);
                    }
                }
            }
            catch (SocketException)
            {
                //Handshake incorrecto
                return(false);
            }

            return(false);
        }
        /// <summary>
        /// Envia un mensaje a un cliente particular
        /// </summary>
        /// <param name="playerId">ID del cliente</param>
        /// <param name="msg">Mensaje a enviar</param>
        public void sendToClient(int playerId, TgcSocketSendMsg msg)
        {
            TgcSocketClientInfo clientInfo = getClientInfo(playerId);

            if (clientInfo != null)
            {
                sendToClient(clientInfo, msg);
            }
        }
 /// <summary>
 /// Envia un mensaje a todos los clientes conectados al servidor, a excepción
 /// de uno.
 /// </summary>
 /// <param name="playerIdException">ID de cliente al que no se le va a mandar el mensaje</param>
 /// <param name="msg">Mensaje a enviar</param>
 public void sendToAllExceptOne(int playerIdException, TgcSocketSendMsg msg)
 {
     foreach (TgcSocketClientInfo clientInfo in allClients)
     {
         if (clientInfo.PlayerId != playerIdException)
         {
             sendToClient(clientInfo, msg);
         }
     }
 }
        /// <summary>
        /// Enviar un mensaje de TGC por un socket
        /// </summary>
        /// <param name="socket">Socket por el cual enviar</param>
        /// <param name="msg">Mensaje a enviar</param>
        /// <param name="msgType">Tipo de mensaje a enviar</param>
        /// <returns>True si lo pudo hacer bien</returns>
        public static bool sendMessage(Socket socket, TgcSocketSendMsg msg, TgcSocketMessageHeader.MsgType msgType)
        {
            try
            {
                //Enviar Header
                byte[] msgBytes = msg.getBytes();
                byte[] data     = BitConverter.GetBytes(msgBytes.Length);
                socket.Send(data);

                //Enviar msg
                socket.Send(msgBytes);
            }
            catch (Exception)
            {
                return(false);
            }

            return(true);
        }
        /// <summary>
        /// Enviar un mensaje de TGC por un socket
        /// </summary>
        /// <param name="socket">Socket por el cual enviar</param>
        /// <param name="msg">Mensaje a enviar</param>
        /// <param name="msgType">Tipo de mensaje a enviar</param>
        /// <returns>True si lo pudo hacer bien</returns>
        public static bool sendMessage(Socket socket, TgcSocketSendMsg msg, TgcSocketMessageHeader.MsgType msgType)
        {
            try
            {
                //Enviar Header
                byte[] msgBytes = msg.getBytes();
                byte[] data = BitConverter.GetBytes(msgBytes.Length);
                socket.Send(data);

                //Enviar msg
                socket.Send(msgBytes);
            }
            catch (Exception)
            {
                return false;
            }
            
            return true;
        }
        /// <summary>
        /// Empezar el handshake con el server
        /// </summary>
        /// <returns>True si todo salio bien</returns>
        private bool doHandShake()
        {
            try
            {
                int serverHandshakeLength = Encoding.ASCII.GetBytes(TgcSocketServer.SERVER_HANDSHAKE).Length;
                byte[] data = new byte[serverHandshakeLength];
                int recv = clientSocket.Receive(data, data.Length, SocketFlags.None);
                if (recv > 0 && recv == serverHandshakeLength)
                {
                    string msg = Encoding.ASCII.GetString(data, 0, recv);
                    if (msg.Equals(TgcSocketServer.SERVER_HANDSHAKE))
                    {
                        //Server correcto, enviar informacion inicial
                        status = TgcSocketClientInfo.ClientStatus.RequireInitialInfo;
                        TgcSocketInitialInfoClient clientInitInfo = new TgcSocketInitialInfoClient();
                        clientInitInfo.clientName = clientName;

                        TgcSocketSendMsg sendMsg = new TgcSocketSendMsg();
                        sendMsg.write(clientInitInfo);
                        TgcSocketMessages.sendMessage(clientSocket, sendMsg, TgcSocketMessageHeader.MsgType.InitialMessage);

                        return true;
                    }
                }
            }
            catch (SocketException)
            {
                //Handshake incorrecto
                return false;
            }

            return false;
        }
        public override void render(float elapsedTime)
        {
            Device d3dDevice = GuiController.Instance.D3dDevice;

            //Actualizar siempre primero todos los valores de red.
            //Esto hace que el cliente y el servidor reciban todos los mensajes y actualicen su es
            networkingMod.updateNetwork();

            //Si el server está online, analizar sus mensajes
            if (networkingMod.Server.Online)
            {
                //Analizar los mensajes recibidos
                for (int i = 0; i < networkingMod.Server.ReceivedMessagesCount; i++)
                {
                    //Leer el siguiente mensaje, cada vez que llamamos a nextReceivedMessage() consumimos un mensaje pendiente.
                    TgcSocketClientRecvMesg msg = networkingMod.Server.nextReceivedMessage();

                    //Obtenter el primer elemento del mensaje, un string en este caso
                    string strMsg = (string)msg.Msg.readNext();

                    //Mostrar mensaje recibido en consola
                    GuiController.Instance.Logger.log(strMsg, Color.Green);
                }

            }

            //Si el cliente está online, analizar sus mensajes
            if (networkingMod.Client.Online)
            {
                //Mandamos un mensaje al server cada 1 segundo
                acumulatedTime += elapsedTime;
                if (acumulatedTime > 1)
                {
                    acumulatedTime = 0;

                    //Crear nuevo mensaje a enviar
                    TgcSocketSendMsg msg = new TgcSocketSendMsg();

                    //Agregar un dato al mensaje, un string en este caso
                    msg.write("Hello world - ElapsedTime: " + elapsedTime);

                    //Enviar mensaje al server
                    networkingMod.Client.send(msg);
                }
            }
        }
 /// <summary>
 /// Enviar un mensaje al server
 /// </summary>
 /// <param name="msg">Mensaje a enviar</param>
 public void send(TgcSocketSendMsg msg)
 {
     TgcSocketMessages.sendMessage(clientSocket, msg, TgcSocketMessageHeader.MsgType.RegularMessage);
 }
 /// <summary>
 /// Envia un mensaje a todos los clientes conectados al servidor
 /// </summary>
 /// <param name="msg">Mensaje a enviar</param>
 public void sendToAll(TgcSocketSendMsg msg)
 {
     foreach (TgcSocketClientInfo clientInfo in allClients)
     {
         sendToClient(clientInfo, msg);
     }
 }
        /// <summary>
        /// Recibir informacion inicial del server
        /// </summary>
        /// <returns>True si todo salio bien</returns>
        private bool getServerInitialInfo()
        {
            try
            {
                //Recibir info inicial del server
                TgcSocketRecvMsg msg = TgcSocketMessages.receiveMessage(clientSocket, TgcSocketMessageHeader.MsgType.InitialMessage);
                if (msg == null)
                {
                    return false;
                }

                //Guardar sus datos y cambiar su estado
                TgcSocketInitialInfoServer serverInitInfo = (TgcSocketInitialInfoServer)msg.readNext();
                serverInfo.Name = serverInitInfo.serverName;
                playerId = serverInitInfo.playerId;

                //Enviar OK final
                this.status = TgcSocketClientInfo.ClientStatus.Connected;
                TgcSocketSendMsg sendMsg = new TgcSocketSendMsg();
                sendMsg.write(true);
                return TgcSocketMessages.sendMessage(clientSocket, sendMsg, TgcSocketMessageHeader.MsgType.InitialMessage);
            }
            catch (SocketException)
            {
                return false;
            }
        }
 /// <summary>
 /// Envia un mensaje a todos los clientes conectados al servidor, a excepción
 /// de uno.
 /// </summary>
 /// <param name="playerIdException">ID de cliente al que no se le va a mandar el mensaje</param>
 /// <param name="msg">Mensaje a enviar</param>
 public void sendToAllExceptOne(int playerIdException, TgcSocketSendMsg msg)
 {
     foreach (TgcSocketClientInfo clientInfo in allClients)
     {
         if (clientInfo.PlayerId != playerIdException)
         {
             sendToClient(clientInfo, msg);
         }
     }
 }
 /// <summary>
 /// Envia un mensaje a un cliente particular
 /// </summary>
 /// <param name="playerId">ID del cliente</param>
 /// <param name="msg">Mensaje a enviar</param>
 public void sendToClient(int playerId, TgcSocketSendMsg msg)
 {
     TgcSocketClientInfo clientInfo = getClientInfo(playerId);
     if (clientInfo != null)
     {
         sendToClient(clientInfo, msg);
     }
 }
        /// <summary>
        /// Recibir información inicial del cliente
        /// </summary>
        /// <returns>True si todo salio bien</returns>
        private bool getClientInitialInfo(TgcSocketClientInfo clientInfo, Socket socket)
        {
            try
            {
                //Recibir info inicial del cliente
                TgcSocketRecvMsg msg = TgcSocketMessages.receiveMessage(socket, TgcSocketMessageHeader.MsgType.InitialMessage);
                if (msg == null)
                {
                    return false;
                }

                //Guardar sus datos y cambiar su estado
                TgcSocketInitialInfoClient clientInitInfo = (TgcSocketInitialInfoClient)msg.readNext();
                clientInfo.Name = clientInitInfo.clientName;
                clientInfo.Status = TgcSocketClientInfo.ClientStatus.WaitingClientOk;

                //Asignar Player ID a cliente
                TgcSocketInitialInfoServer serverInitInfo = new TgcSocketInitialInfoServer();
                serverInitInfo.serverName = serverName;
                serverInitInfo.playerId = playerIdCounter;
                clientInfo.PlayerId = serverInitInfo.playerId;
                playerIdCounter++;

                //Enviar info inicial del server
                TgcSocketSendMsg sendMsg = new TgcSocketSendMsg();
                sendMsg.write(serverInitInfo);
                TgcSocketMessages.sendMessage(socket, sendMsg, TgcSocketMessageHeader.MsgType.InitialMessage);

                return true;
            }
            catch (SocketException)
            {
                return false;
            }
        }
 /// <summary>
 /// Enviar un mensaje al server
 /// </summary>
 /// <param name="msg">Mensaje a enviar</param>
 public void send(TgcSocketSendMsg msg)
 {
     TgcSocketMessages.sendMessage(clientSocket, msg, TgcSocketMessageHeader.MsgType.RegularMessage);
 }
 /// <summary>
 /// Enviar mensaje a cliente, solo si esta conectado
 /// </summary>
 private void sendToClient(TgcSocketClientInfo clientInfo, TgcSocketSendMsg msg)
 {
     if (clientInfo.Status == TgcSocketClientInfo.ClientStatus.Connected)
     {
         TgcSocketMessages.sendMessage(clientInfo.Socket, msg, TgcSocketMessageHeader.MsgType.RegularMessage);
     }
 }