示例#1
0
    public override NetIncomingMessage ReadMessage()
    {
        if (!connected)
        {
            return(null);
        }
        if (messages.Count() > 0)
        {
            return(messages.Dequeue());
        }
        if (connected2)
        {
            while (tosend.Count() > 0)
            {
                INetOutgoingMessage msg = tosend.Dequeue();
                DoSendPacket(msg);
            }
        }

        EnetEventRef event_ = new EnetEventRef();

        if (platform.EnetHostService(host, 0, event_))
        {
            do
            {
                switch (event_.e.Type())
                {
                case EnetEventType.Connect:
                    connected2 = true;
                    break;

                case EnetEventType.Receive:
                    byte[] data       = event_.e.Packet().GetBytes();
                    int    dataLength = event_.e.Packet().GetBytesCount();
                    event_.e.Packet().Dispose();
                    NetIncomingMessage msg = new NetIncomingMessage();
                    msg.message       = data;
                    msg.messageLength = dataLength;
                    messages.Enqueue(msg);
                    break;
                }
            }while (platform.EnetHostCheckEvents(host, event_));
        }
        if (messages.Count() > 0)
        {
            return(messages.Dequeue());
        }
        return(null);
    }
示例#2
0
        public override NetIncomingMessage ReadMessage()
        {
            if (messages.Count() > 0)
            {
                return(messages.Dequeue());
            }

            ENet.Event e;
            bool       ret = ((EnetHostNative)host).host.Service(0, out e);

            event_ = new EnetEventNative(e);

            if (ret)
            {
                do
                {
                    switch (event_.Type())
                    {
                    case EnetEventType.Connect:
                    {
                        EnetPeer peer = event_.Peer();
                        peer.SetUserData(clientid++);
                        EnetNetConnection senderConnectionConnect = new EnetNetConnection();
                        senderConnectionConnect.peer = event_.Peer();
                        NetIncomingMessage message = new NetIncomingMessage();
                        message.SenderConnection = senderConnectionConnect;
                        message.Type             = NetworkMessageType.Connect;
                        messages.Enqueue(message);
                    }
                    break;

                    case EnetEventType.Receive:
                    {
                        byte[] data = event_.Packet().GetBytes();
                        event_.Packet().Dispose();
                        EnetNetConnection senderConnectionReceive = new EnetNetConnection();
                        senderConnectionReceive.peer = event_.Peer();
                        NetIncomingMessage message = new NetIncomingMessage();
                        message.SenderConnection = senderConnectionReceive;
                        message.message          = data;
                        message.Type             = NetworkMessageType.Data;
                        messages.Enqueue(message);
                    }
                    break;

                    case EnetEventType.Disconnect:
                    {
                        EnetNetConnection senderConnectionDisconnect = new EnetNetConnection();
                        senderConnectionDisconnect.peer = event_.Peer();
                        NetIncomingMessage message = new NetIncomingMessage();
                        message.SenderConnection = senderConnectionDisconnect;
                        message.Type             = NetworkMessageType.Disconnect;
                        messages.Enqueue(message);
                    }
                    break;
                    }

                    ret    = ((EnetHostNative)host).host.CheckEvents(out e);
                    event_ = new EnetEventNative(e);
                }while (ret);
            }
            if (messages.Count() > 0)
            {
                return(messages.Dequeue());
            }
            return(null);
        }