Ejemplo n.º 1
0
        /// <summary>
        ///     Empezar el handshake con el server
        /// </summary>
        /// <returns>True si todo salio bien</returns>
        private bool doHandShake()
        {
            try
            {
                var serverHandshakeLength = Encoding.ASCII.GetBytes(TgcSocketServer.SERVER_HANDSHAKE).Length;
                var data = new byte[serverHandshakeLength];
                var recv = clientSocket.Receive(data, data.Length, SocketFlags.None);
                if (recv > 0 && recv == serverHandshakeLength)
                {
                    var msg = Encoding.ASCII.GetString(data, 0, recv);
                    if (msg.Equals(TgcSocketServer.SERVER_HANDSHAKE))
                    {
                        //Server correcto, enviar informacion inicial
                        Status = TgcSocketClientInfo.ClientStatus.RequireInitialInfo;
                        var clientInitInfo = new TgcSocketInitialInfoClient();
                        clientInitInfo.clientName = ClientName;

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

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

            return(false);
        }
Ejemplo n.º 2
0
        /// <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
                var msg = TgcSocketMessages.receiveMessage(socket, TgcSocketMessageHeader.MsgType.InitialMessage);
                if (msg == null)
                {
                    return(false);
                }

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

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

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

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

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

                //Enviar OK final
                Status = TgcSocketClientInfo.ClientStatus.Connected;
                var sendMsg = new TgcSocketSendMsg();
                sendMsg.write(true);
                return(TgcSocketMessages.sendMessage(clientSocket, sendMsg,
                                                     TgcSocketMessageHeader.MsgType.InitialMessage));
            }
            catch (SocketException)
            {
                return(false);
            }
        }
Ejemplo n.º 4
0
 /// <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);
     }
 }
Ejemplo n.º 5
0
 /// <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 (var clientInfo in allClients)
     {
         sendToClient(clientInfo, msg);
     }
 }
Ejemplo n.º 6
0
        /// <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)
        {
            var clientInfo = getClientInfo(playerId);

            if (clientInfo != null)
            {
                sendToClient(clientInfo, msg);
            }
        }
Ejemplo n.º 7
0
 /// <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 (var clientInfo in allClients)
     {
         if (clientInfo.PlayerId != playerIdException)
         {
             sendToClient(clientInfo, msg);
         }
     }
 }
Ejemplo n.º 8
0
        /// <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
                var msgBytes = msg.getBytes();
                var data     = BitConverter.GetBytes(msgBytes.Length);
                socket.Send(data);

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

            return(true);
        }
Ejemplo n.º 9
0
 /// <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);
 }