public void StopServer()
        {
            TransportEventData data = new TransportEventData();

            data.type = ENetworkEvent.DisconnectEvent;
            serverData.Enqueue(data);
        }
예제 #2
0
        public virtual void OnClientReceive(TransportEventData eventData)
        {
            switch (eventData.type)
            {
            case ENetworkEvent.ConnectEvent:
                if (Manager.LogInfo)
                {
                    Logging.Log(LogTag, "OnPeerConnected");
                }
                Manager.OnClientConnected();
                break;

            case ENetworkEvent.DataEvent:
                ReadPacket(eventData.connectionId, eventData.reader);
                break;

            case ENetworkEvent.DisconnectEvent:
                if (Manager.LogInfo)
                {
                    Logging.Log(LogTag, "OnPeerDisconnected peer. disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
                }
                Manager.StopClient();
                Manager.OnClientDisconnected(eventData.disconnectInfo);
                break;

            case ENetworkEvent.ErrorEvent:
                if (Manager.LogError)
                {
                    Logging.LogError(LogTag, "OnNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketError);
                }
                Manager.OnClientNetworkError(eventData.endPoint, eventData.socketError);
                break;
            }
        }
        public virtual void OnServerReceive(TransportEventData eventData)
        {
            switch (eventData.type)
            {
            case ENetworkEvent.ConnectEvent:
                if (Manager.LogInfo)
                {
                    Logging.Log(LogTag, "OnPeerConnected peer.ConnectionId: " + eventData.connectionId);
                }
                ConnectionIds.Add(eventData.connectionId);
                Manager.OnPeerConnected(eventData.connectionId);
                break;

            case ENetworkEvent.DataEvent:
                ReadPacket(eventData.connectionId, eventData.reader);
                break;

            case ENetworkEvent.DisconnectEvent:
                if (Manager.LogInfo)
                {
                    Logging.Log(LogTag, "OnPeerDisconnected peer.ConnectionId: " + eventData.connectionId + " disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
                }
                ConnectionIds.Remove(eventData.connectionId);
                Manager.OnPeerDisconnected(eventData.connectionId, eventData.disconnectInfo);
                break;

            case ENetworkEvent.ErrorEvent:
                if (Manager.LogError)
                {
                    Logging.LogError(LogTag, "OnPeerNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketError + " errorMessage " + eventData.errorMessage);
                }
                Manager.OnPeerNetworkError(eventData.endPoint, eventData.socketError);
                break;
            }
        }
예제 #4
0
        public override void OnClientReceive(TransportEventData eventData)
        {
            switch (eventData.type)
            {
            case ENetworkEvent.ConnectEvent:
                if (Manager.LogInfo)
                {
                    Debug.Log("[" + Manager.name + "] LiteNetLibClient::OnPeerConnected");
                }
                Manager.OnClientConnected();
                break;

            case ENetworkEvent.DataEvent:
                ReadPacket(eventData.connectionId, eventData.reader);
                break;

            case ENetworkEvent.DisconnectEvent:
                if (Manager.LogInfo)
                {
                    Debug.Log("[" + Manager.name + "] LiteNetLibClient::OnPeerDisconnected peer. disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
                }
                Manager.StopClient();
                Manager.OnClientDisconnected(eventData.disconnectInfo);
                break;

            case ENetworkEvent.ErrorEvent:
                if (Manager.LogError)
                {
                    Debug.LogError("[" + Manager.name + "] LiteNetLibClient::OnNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketErrorCode);
                }
                Manager.OnClientNetworkError(eventData.endPoint, eventData.socketErrorCode);
                break;
            }
        }
        private void OnReceiveMessage(TransportEventData eventData)
        {
            switch (eventData.type)
            {
            case ENetworkEvent.ConnectEvent:
                //if (LogInfo) Debug.Log("[" + name + "] ::OnPeerConnected peer.ConnectionId: " + eventData.connectionId);
                PeerConnectedEvent(eventData.connectionId);
                break;

            case ENetworkEvent.DataEvent:
                msgManager.ReadPacket(eventData.connectionId, eventData.reader);
                break;

            case ENetworkEvent.DisconnectEvent:
                if (LogInfo)
                {
                    Debug.Log("[" + name + "] ::OnPeerDisconnected peer.ConnectionId: " + eventData.connectionId + " disconnectInfo.Reason: " + eventData.disconnectInfo.Reason);
                }
                DisconnectedEvent(eventData.connectionId, eventData.disconnectInfo);
                break;

            case ENetworkEvent.ErrorEvent:
                if (LogError)
                {
                    Debug.LogError("[" + name + "] ::OnNetworkError endPoint: " + eventData.endPoint + " socketErrorCode " + eventData.socketError);
                }
                PeerNetworkErrorEvent(eventData.endPoint, eventData.socketError);
                break;

            case ENetworkEvent.DiscoveryEvent:
                //if (LogInfo) Debug.Log("[" + name + "] LiteNetLibServer::DiscoveryEvent endPoint: " + eventData.endPoint);
                DiscoverServer(eventData.endPoint, eventData.reader.GetString());
                break;
            }
        }
        public void StopClient()
        {
            TransportEventData data = new TransportEventData();

            data.type = ENetworkEvent.DisconnectEvent;
            clientData.Enqueue(data);
        }
예제 #7
0
        public bool ServerReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
#if !UNITY_WEBGL || UNITY_EDITOR
            if (!IsServerStarted)
            {
                return(false);
            }
            if (!secure)
            {
                if (wsServer.EventQueue.Count == 0)
                {
                    return(false);
                }
                return(wsServer.EventQueue.TryDequeue(out eventData));
            }
            else
            {
                if (wssServer.EventQueue.Count == 0)
                {
                    return(false);
                }
                return(wssServer.EventQueue.TryDequeue(out eventData));
            }
#else
            return(false);
#endif
        }
예제 #8
0
 public bool ClientReceive(out TransportEventData eventData)
 {
     eventData = default(TransportEventData);
     if (client == null)
     {
         return(false);
     }
     if (dirtyIsConnected != client.IsConnected)
     {
         dirtyIsConnected = client.IsConnected;
         if (client.IsConnected)
         {
             // Connect state changed to connected, so it's connect event
             eventData.type = ENetworkEvent.ConnectEvent;
         }
         else
         {
             // Connect state changed to not connected, so it's disconnect event
             eventData.type = ENetworkEvent.DisconnectEvent;
         }
         return(true);
     }
     else
     {
         tempBuffers = client.Recv();
         if (tempBuffers != null)
         {
             eventData.type   = ENetworkEvent.DataEvent;
             eventData.reader = new NetDataReader(tempBuffers);
             return(true);
         }
     }
     return(false);
 }
        public bool ServerDisconnect(long connectionId)
        {
            TransportEventData data = new TransportEventData();

            data.type = ENetworkEvent.DisconnectEvent;
            serverData.Enqueue(data);
            return(false);
        }
예제 #10
0
        public bool ClientSend(byte dataChannel, DeliveryMethod deliveryMethod, NetDataWriter writer)
        {
            TransportEventData data = new TransportEventData();

            data.type   = ENetworkEvent.DataEvent;
            data.reader = new NetDataReader(writer.CopyData());
            clientData.Enqueue(data);
            return(true);
        }
예제 #11
0
        public bool ServerSend(long connectionId, byte dataChannel, DeliveryMethod deliveryMethod, NetDataWriter writer)
        {
            TransportEventData data = new TransportEventData();

            data.type   = ENetworkEvent.DataEvent;
            data.reader = new NetDataReader(writer.CopyData());
            serverData.Enqueue(data);
            return(true);
        }
        public bool StartClient(string address, int port)
        {
            clientData.Clear();
            TransportEventData data = new TransportEventData();

            data.type = ENetworkEvent.ConnectEvent;
            clientData.Enqueue(data);
            return(true);
        }
예제 #13
0
 public bool ClientReceive(out TransportEventData eventData)
 {
     eventData = default(TransportEventData);
     if (serverData.Count == 0)
     {
         return(false);
     }
     eventData = serverData.Dequeue();
     return(true);
 }
예제 #14
0
 public bool ServerReceive(out TransportEventData eventData)
 {
     eventData = default(TransportEventData);
     if (server == null)
     {
         return(false);
     }
     server.PollEvents();
     if (serverEventQueue.Count == 0)
     {
         return(false);
     }
     eventData = serverEventQueue.Dequeue();
     return(true);
 }
예제 #15
0
 public bool ClientReceive(out TransportEventData eventData)
 {
     eventData = default(TransportEventData);
     if (client == null)
     {
         return(false);
     }
     client.PollEvents();
     if (clientEventQueue.Count == 0)
     {
         return(false);
     }
     eventData = clientEventQueue.Dequeue();
     return(true);
 }
        public bool ClientReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
#if UNITY_WEBGL
            if (wsClient == null)
            {
                return(false);
            }
            if (wsDirtyIsConnected != wsClient.IsConnected)
            {
                wsDirtyIsConnected = wsClient.IsConnected;
                if (wsClient.IsConnected)
                {
                    // Connect state changed to connected, so it's connect event
                    eventData.type = ENetworkEvent.ConnectEvent;
                }
                else
                {
                    // Connect state changed to not connected, so it's disconnect event
                    eventData.type = ENetworkEvent.DisconnectEvent;
                }
                return(true);
            }
            else
            {
                tempBuffers = wsClient.Recv();
                if (tempBuffers != null)
                {
                    eventData.type   = ENetworkEvent.DataEvent;
                    eventData.reader = new NetDataReader(tempBuffers);
                    return(true);
                }
            }
            return(false);
#else
            if (client == null)
            {
                return(false);
            }
            client.PollEvents();
            if (clientEventQueue.Count == 0)
            {
                return(false);
            }
            eventData = clientEventQueue.Dequeue();
            return(true);
#endif
        }
 public bool ServerReceive(out TransportEventData eventData)
 {
     eventData = default(TransportEventData);
     if (clientData.Count == 0)
     {
         return(false);
     }
     eventData = clientData.Dequeue();
     if (eventData.type == ENetworkEvent.ConnectEvent)
     {
         TransportEventData data = new TransportEventData();
         data.type = ENetworkEvent.ConnectEvent;
         serverData.Enqueue(data);
         peerCount++;
     }
     return(true);
 }
예제 #18
0
        public bool ClientReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
#if UNITY_WEBGL
            return(wsClient.ClientReceive(out eventData));
#else
            if (Client == null)
            {
                return(false);
            }
            Client.PollEvents();
            if (clientEventQueue.Count == 0)
            {
                return(false);
            }
            return(clientEventQueue.TryDequeue(out eventData));
#endif
        }
예제 #19
0
        public bool ServerReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
#if !UNITY_WEBGL || UNITY_EDITOR
            if (!IsServerStarted())
            {
                return(false);
            }
            if (serverEventQueue.Count == 0)
            {
                return(false);
            }
            eventData = serverEventQueue.Dequeue();
            return(true);
#else
            return(false);
#endif
        }
예제 #20
0
        public bool Receive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
            if (netManager == null)
            {
                return(false);
            }

            netManager.PollEvents();
            if (qEventQueue.Count == 0)
            {
                return(false);
            }
            eventData = qEventQueue.Dequeue();



            return(true);
        }
        public bool ServerReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
#if UNITY_WEBGL
            // Don't integrate server networking to WebGL clients
            return(false);
#else
            if (wsServer == null || server == null)
            {
                return(false);
            }
            server.PollEvents();
            if (serverEventQueue.Count == 0)
            {
                return(false);
            }
            eventData = serverEventQueue.Dequeue();
            return(true);
#endif
        }
예제 #22
0
        public bool ClientReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
#if !UNITY_WEBGL || UNITY_EDITOR
            if (clientEventQueue.Count == 0)
            {
                return(false);
            }
            return(clientEventQueue.TryDequeue(out eventData));
#else
            int eventType = GetSocketEventType(wsNativeInstance);
            if (eventType < 0)
            {
                return(false);
            }
            switch ((ENetworkEvent)eventType)
            {
            case ENetworkEvent.DataEvent:
                eventData.type   = ENetworkEvent.DataEvent;
                eventData.reader = new NetDataReader(GetSocketData());
                break;

            case ENetworkEvent.ConnectEvent:
                eventData.type = ENetworkEvent.ConnectEvent;
                break;

            case ENetworkEvent.DisconnectEvent:
                eventData.type           = ENetworkEvent.DisconnectEvent;
                eventData.disconnectInfo = GetDisconnectInfo(GetSocketErrorCode(wsNativeInstance));
                break;

            case ENetworkEvent.ErrorEvent:
                eventData.type         = ENetworkEvent.ErrorEvent;
                eventData.errorMessage = GetErrorMessage(GetSocketErrorCode(wsNativeInstance));
                break;
            }
            SocketEventDequeue(wsNativeInstance);
            return(true);
#endif
        }
예제 #23
0
        public bool ServerReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
#if UNITY_WEBGL
            // Don't integrate server networking to WebGL clients
            return(false);
#else
            if (!IsServerStarted)
            {
                return(false);
            }

            if (!webSocketSecure)
            {
                if (wsServer.EventQueue.Count > 0)
                {
                    return(wsServer.EventQueue.TryDequeue(out eventData));
                }
            }
            else
            {
                if (wssServer.EventQueue.Count > 0)
                {
                    return(wssServer.EventQueue.TryDequeue(out eventData));
                }
            }

            Server.PollEvents();
            if (serverEventQueue.Count > 0)
            {
                return(serverEventQueue.TryDequeue(out eventData));
            }

            return(false);
#endif
        }
예제 #24
0
        public bool ServerReceive(out TransportEventData eventData)
        {
            eventData = default(TransportEventData);
            if (clientData.Count == 0)
            {
                return(false);
            }
            eventData = clientData.Dequeue();
            switch (eventData.type)
            {
            case ENetworkEvent.ConnectEvent:
                TransportEventData data = new TransportEventData();
                data.type = ENetworkEvent.ConnectEvent;
                serverData.Enqueue(data);
                ServerPeersCount++;
                break;

            case ENetworkEvent.DisconnectEvent:
                ServerPeersCount--;
                IsClientStarted = false;
                break;
            }
            return(true);
        }
예제 #25
0
 public bool ClientReceive(out TransportEventData eventData)
 {
     return(wsClient.ClientReceive(out eventData));
 }
예제 #26
0
 public virtual void OnClientReceive(TransportEventData eventData)
 {
 }
예제 #27
0
 public virtual void OnServerReceive(TransportEventData eventData)
 {
 }