Ejemplo n.º 1
0
        private void ReadMessages(NetServer server)
        {
            NetIncomingMessage msg;

            while ((msg = server.ReadMessage()) != null)
            {
                switch (msg.MessageType)
                {
                case NetIncomingMessageType.Data:
                    HandleIncomingMessage(MessageHandler.Decode(msg), msg);
                    break;

                case NetIncomingMessageType.VerboseDebugMessage:
                case NetIncomingMessageType.DebugMessage:
                case NetIncomingMessageType.WarningMessage:
                case NetIncomingMessageType.ErrorMessage:
                    Console.WriteLine(msg.ReadString());
                    break;

                case NetIncomingMessageType.StatusChanged:
                    var status = (NetConnectionStatus)msg.ReadByte();
                    switch (status)
                    {
                    case NetConnectionStatus.Connected:
                        Console.WriteLine("Connection Established " + msg.SenderConnection.RemoteUniqueIdentifier);
                        break;

                    case NetConnectionStatus.Disconnected:
                        Console.WriteLine("User Disconnected" + msg.SenderConnection.RemoteUniqueIdentifier);
                        _room.RemovePlayer(msg.SenderConnection);
                        break;

                    default:
                        Console.WriteLine("Connection Status: " + status.ToString());
                        break;
                    }
                    break;

                case NetIncomingMessageType.ConnectionApproval:
                    ConnectionApprovalMessage approval = MessageHandler.Decode(msg) as ConnectionApprovalMessage;
                    Console.WriteLine(approval.Name);
                    if (IsApproved(approval))
                    {
                        msg.SenderConnection.Approve();
                        _room.AddPlayer(msg.SenderConnection, approval);
                    }
                    else
                    {
                        msg.SenderConnection.Deny();
                    }
                    break;

                default:
                    Console.WriteLine("Unhandled type: " + msg.MessageType);
                    break;
                }

                server.Recycle(msg);
            }
        }
Ejemplo n.º 2
0
        public void AddPlayer(NetConnection connection, ConnectionApprovalMessage approval)
        {
            var player = new Player {
                Connection = connection, Name = approval.Name
            };

            player.Tank = new Tank();
            _players[connection.RemoteUniqueIdentifier] = player;
            Broadcast(new PlayerConnectedMessage {
                PlayerID = connection.RemoteUniqueIdentifier
            }, NetDeliveryMethod.ReliableOrdered);
        }
Ejemplo n.º 3
0
    // Use this for initialization
    void Start()
    {
        var approval = new ConnectionApprovalMessage
        {
            Name = "James"
        };

        var config = new NetPeerConfiguration("Tanks2");

        _client         = new NetClient(config);
        _messageHandler = new GameMessageHandler(_client);
        _client.Start();
        _client.Connect("localhost", 4200, _messageHandler.Encode(approval));
    }
Ejemplo n.º 4
0
 private void ConfigureConnectionApproval(ConnectionApprovalMessage msg, NetIncomingMessage im)
 {
     if (msg.Password == password)
     {
         im.SenderConnection.Approve();
         server.Out.Info($"Approved {msg.Sender} with Endpoint: {im.SenderEndPoint}");
         im.SenderConnection.Tag = msg.Sender;
         server.SendToAllExcept(server.ConvertToOutgoingMessage(
                                    new ServerNotification {
             Message = $"Say welcome to {msg.Sender}"
         }),
                                im.SenderConnection);
     }
     else
     {
         im.SenderConnection.Deny();
         server.Out.Info($"Denied {msg.Sender} : {im.SenderEndPoint}");
     }
 }
Ejemplo n.º 5
0
    // Update is called once per frame
    void Update()
    {
        NetIncomingMessage msg;

        while ((msg = _client.ReadMessage()) != null)
        {
            ProcessMessage(msg);
            _client.Recycle(msg);
        }

        var mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
        var controls = new PlayerInput(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), mousePos.x, mousePos.y);

        var approval = new ConnectionApprovalMessage
        {
            Name = "Test"
        };

        _client.SendMessage(_messageHandler.Encode(new PlayerControlUpdateMessage {
            Controls = controls
        }), NetDeliveryMethod.UnreliableSequenced, (int)GameMessageType.PlayerControls);
    }
Ejemplo n.º 6
0
        /// <summary>
        /// Processes the server incoming messages by using the GemServer's active configuration
        /// </summary>
        public void ProcessNetworkMessages()
        {
            NetIncomingMessage im;

            server.Wait();

            while ((im = this.server.ReadMessage()) != null)
            {
                switch (im.MessageType)
                {
                case NetIncomingMessageType.ConnectionApproval:
                    var approvalMsg = new ConnectionApprovalMessage(im);
                    GemNetworkDebugger.Append.Info("Incoming Connection");
                    GemServer.ServerConfiguration[GemNetwork.ActiveProfile].OnIncomingConnection(server, im.SenderConnection, approvalMsg);
                    break;

                case NetIncomingMessageType.StatusChanged:
                    switch ((NetConnectionStatus)im.ReadByte())
                    {
                    case NetConnectionStatus.Connected:
                        //im.SenderConnection.Approve();
                        GemNetworkDebugger.Append.Info("{0} Connected", im.SenderConnection);
                        break;

                    case NetConnectionStatus.Disconnected:
                        GemNetworkDebugger.Append.Info(im.SenderConnection + " status changed. " + (NetConnectionStatus)im.SenderConnection.Status);
                        GemServer.ServerConfiguration[GemNetwork.ActiveProfile].OnClientDisconnect(server, im.SenderConnection, im.ReadString());
                        break;

                    case NetConnectionStatus.RespondedConnect:
                        GemNetworkDebugger.Append.Info(im.SenderConnection + " status changed. " + (NetConnectionStatus)im.SenderConnection.Status);
                        break;
                    }
                    break;

                case NetIncomingMessageType.Data:
                    byte id = im.ReadByte();

                    if (id == GemNetwork.NotificationByte)
                    {
                        GemServer.ServerConfiguration[GemNetwork.ActiveProfile].HandleNotifications(server, im.SenderConnection, new Notification(im));
                    }
                    else if (GemServer.MessageFlow[GemNetwork.ActiveProfile, MessageType.Data].HasKey(id))
                    {
                        GemServer.MessageFlow[GemNetwork.ActiveProfile, MessageType.Data, id]
                        .HandleIncomingMessage(im);
                    }
                    else
                    {
                        var msg = server.CreateMessage();
                        msg.Write(im);
                        server.SendAndExclude(msg, im.SenderConnection);
                    }
                    break;

                case NetIncomingMessageType.VerboseDebugMessage:
                case NetIncomingMessageType.DebugMessage:
                case NetIncomingMessageType.WarningMessage:
                    GemNetworkDebugger.Append.Warn(im.ReadString());
                    break;

                case NetIncomingMessageType.ErrorMessage:
                    GemNetworkDebugger.Append.Error(im.ReadString());
                    break;

                case NetIncomingMessageType.DiscoveryRequest:
                    //notify the client
                    break;
                }
                this.server.Recycle(im);
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Connect to the server
        /// </summary>
        public void Connect(ConnectionConfig connectionDetails, PackageConfig packageConfig, ConnectionApprovalMessage approvalMessage)
        {
            this.connectionDetails = connectionDetails;
            this.PackageConfig     = packageConfig;

            var config = new NetPeerConfiguration(connectionDetails.ServerName);

            config.EnableMessageType(NetIncomingMessageType.Data);
            config.EnableMessageType(NetIncomingMessageType.WarningMessage);
            config.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
            config.EnableMessageType(NetIncomingMessageType.ErrorMessage);
            config.EnableMessageType(NetIncomingMessageType.Error);
            config.EnableMessageType(NetIncomingMessageType.DebugMessage);
            config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);

            client = new NetClient(config);
            client.Start();

            //encrypt passwords ?
            //INetEncryption algo = new NetTripleDESEncryption(encryptionKey);
            //handshake.Encrypt(algo);

            //Create the approval message
            var handshake = CreateMessage();

            approvalMessage.Encode(handshake);

            client.Connect(connectionDetails.ServerIP, handshake);
        }
Ejemplo n.º 8
0
 private bool IsApproved(ConnectionApprovalMessage approval)
 {
     return(approval.Name.Trim() != "");
 }
Ejemplo n.º 9
0
 public void ConnectClient(ConnectionApprovalMessage message)
 {
     client.Connect("localhost", 1234, message);
 }