예제 #1
0
    void FixedUpdate()
    {
        if (runTest)
        {
            runTest = false;
        }
        int recHostId;
        int connectionId;
        int channelId;

        int  bufferSize = 1024;
        int  dataSize;
        byte error;

        bool loop = true;

        for (int i = 0; i < 10 && loop; ++i)
        {
            NetworkEventType recData = NetworkTransport.Receive(out recHostId, out connectionId, out channelId, recvBuffer, bufferSize, out dataSize, out error);
            //if(channelId == unreliableCHN) {
            //    Debug.Log("unreliable: " + dataSize);
            //}
            switch (recData)
            {
            case NetworkEventType.Nothing:             //1
                loop = false;
                break;

            case NetworkEventType.ConnectEvent:        //2
                serverConId = recHostId;
                Debug.Log("ConnectEvent datasize " + dataSize + " error " + error);
                break;

            case NetworkEventType.DataEvent:           //3
                decodeRawData(recvBuffer, synchronizedComponents);
                break;

            case NetworkEventType.DisconnectEvent:     //4
                Debug.Log(recData.ToString());
                break;
            }
        }
        sendRPCs();
    }
예제 #2
0
        private IEnumerator Receiver()
        {
            int  recSocketId, recConnectionId, recChannelId, recDataSize;
            byte error = 0;

            byte[] recBuffer = new byte[_bufferSize];

            while (true)
            {
                NetworkEventType netEventType = NetworkTransport.Receive
                                                (
                    out recSocketId,
                    out recConnectionId,
                    out recChannelId,
                    recBuffer,
                    _bufferSize,
                    out recDataSize,
                    out error
                                                );

                if (error != 0)
                {
                    Debug.Log($"Error ID -> {error}");
                }
                else
                {
                    switch (netEventType)
                    {
                    case NetworkEventType.Nothing:
                    {
                        yield return(null);

                        break;
                    }

                    case NetworkEventType.DataEvent:
                    {
                        OnDataReceived(recConnectionId, recChannelId, recBuffer, recDataSize);
                        break;
                    }

                    case NetworkEventType.ConnectEvent:
                    {
                        OnConnectedToServer(recConnectionId);
                        break;
                    }

                    case NetworkEventType.DisconnectEvent:
                    {
                        OnDisconnected(recSocketId, recConnectionId);
                        break;
                    }

                    default:
                    {
                        Debug.LogWarning($"Receiver -> Unrecognized Message Type [{netEventType.ToString()}]");
                        break;
                    }
                    }
                    if (error != 0)
                    {
                        Debug.Log($"Error ID -> {error}");
                    }
                }
            }
        }
예제 #3
0
        static void Start(RelayConfig rConfig)
        {
            RelayConfig.CurrentConfig = rConfig;
            Console.WriteLine("================================");
            Console.WriteLine("[INFO] Starting relay...");
            unet = new NetLibraryManager(rConfig.globalConfig);

            messageBuffer = new byte[RelayConfig.CurrentConfig.bufferSize];
            HostTopology hostTopology = new HostTopology(RelayConfig.CurrentConfig.connectionConfig, RelayConfig.CurrentConfig.maxConnections);

            unet.AddHost(hostTopology, RelayConfig.CurrentConfig.relayPort, null);
            Console.WriteLine("[INFO] Relay started!");
            Console.WriteLine("[INFO] Press [Q] to quit the application");
            while ((!Console.KeyAvailable || Console.ReadKey(true).Key != ConsoleKey.Q))
            {
                NetworkEventType @event = unet.Receive(out int hostId, out int connectionId, out int channelId, messageBuffer, RelayConfig.CurrentConfig.bufferSize, out int receivedSize, out byte errorByte);
                NetworkError     error  = (NetworkError)errorByte;

                if (error != NetworkError.Ok)
                {
                    ConsoleColor previousColor = Console.ForegroundColor;
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("[ERROR] Relay encountered UNET transport error \"" + error.ToString() + "\" during a \"" + @event.ToString() + "\" event.");
                    Console.ForegroundColor = previousColor;
                }

                switch (@event)
                {
                case NetworkEventType.DataEvent:
                {
                    MessageType mType = (MessageType)messageBuffer[receivedSize - 1];
                    switch (mType)
                    {
                    case MessageType.StartServer:
                    {
                        //Check if they are already connected or perhaps are already hosting, if so return
                        Client client;
                        Room   room = new Room(client = new Client()
                                {
                                    connectionId = (ushort)connectionId,
                                    hostId       = (byte)hostId,
                                    isServer     = true,
                                    connectTick  = DateTime.UtcNow.Ticks
                                });
                        rooms.Add(room);
                        unet.GetConnectionInfo(hostId, connectionId, out string address, out int port, out byte byteError);
                        if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
                        {
                            Console.WriteLine("[INFO] Server started from address " + address);
                        }
                        addressToRoom.Add(address + ":" + port, room);
                    }
                    break;

                    case MessageType.ConnectToServer:
                    {
                        //Check if they are already connected or perhaps are already hosting; if so, return
                        byte   addressLength  = (byte)(receivedSize - 1);             //messageBuffer[1]; // address length + ip type
                        string addressAndPort = Encoding.ASCII.GetString(messageBuffer, 0, addressLength);
                        addressAndPort = addressAndPort.AsIPv6CompatString();
                        if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
                        {
                            Console.WriteLine("[INFO] Connection requested to address " + addressAndPort);
                        }
                        if (addressToRoom.ContainsKey(addressAndPort))
                        {
                            if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
                            {
                                Console.WriteLine("[INFO] Connection approved");
                            }
                            Room   room   = addressToRoom[addressAndPort];
                            Client client = new Client()
                            {
                                connectionId = (ushort)connectionId,
                                hostId       = (byte)hostId,
                                isServer     = false,
                                connectTick  = DateTime.UtcNow.Ticks
                            };
                            room.HandleClientConnect(client);
                        }
                    }
                    break;

                    case MessageType.Data:
                    {
                        foreach (var room in rooms)
                        {
                            if (room.HasPeer((ushort)connectionId, out bool isServer))
                            {
                                // Found a matching client in room
                                if (isServer)
                                {
                                    ushort destination = (ushort)(messageBuffer[receivedSize - 3] | (messageBuffer[receivedSize - 2] << 8));
                                    //Safety check. Make sure who they want to send to ACTUALLY belongs to their room
                                    if (room.HasPeer(destination, out isServer) && !isServer)
                                    {
                                        // TODO: Use unsafe to make messageBuffer look smaller
                                        //ReverseOffset(messageBuffer, 2, receivedSize);
                                        messageBuffer[receivedSize - 3] = (byte)MessageType.Data;                          // [data, data, data, dest1, dest2, mtype_r, none, none, none] => [{data, data, data, mtype_s}, dest2, mtype_r, none, none, none]
                                        room.Send(hostId, destination, connectionId, channelId, messageBuffer, receivedSize - 2, out errorByte);
                                    }
                                }
                                else
                                {
                                    // Read client message
                                    //ForwardOffset(messageBuffer, 2, receivedSize);
                                    messageBuffer.ToBytes((ushort)connectionId, receivedSize - 1);            // Put connection id at the end of the recieved message (because optimization)
                                    messageBuffer[receivedSize + 1] = (byte)MessageType.Data;                 // Set message type
                                    room.Send(hostId, room.ServerID, connectionId, channelId, messageBuffer, receivedSize + 2, out errorByte);
                                }
                            }
                        }
                    }
                    break;

                    case MessageType.ClientDisconnect:
                    {
                        ushort cid = messageBuffer.FromBytes(1);
                        if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
                        {
                            Console.WriteLine("[INFO] Client disconnect request");
                        }
                        foreach (Room room in rooms)
                        {
                            if (room.HandleClientDisconnect((ushort)cid, true))
                            {
                                --connectedPeers;
                                break;
                            }
                        }
                    }
                    break;
                    }
                }
                break;

                case NetworkEventType.DisconnectEvent:
                {
                    if (RelayConfig.CurrentConfig.enableRuntimeMetaLogging)
                    {
                        Console.WriteLine("[INFO] Peer disconnected");
                    }
                    foreach (Room room in rooms)
                    {
                        if (room.HandleClientDisconnect((ushort)connectionId))
                        {
                            --connectedPeers;
                            break;
                        }
                    }
                }
                break;

                case NetworkEventType.Nothing:
                    Thread.Sleep(1);
                    break;

                case NetworkEventType.ConnectEvent:
                {
                    connectedPeers++;
                }
                break;
                }
                if (lastConnectedClients != connectedPeers && (DateTime.UtcNow.Ticks - lastPrintedConnectedClientsTick) > 30 * TimeSpan.TicksPerSecond)
                {
                    lastPrintedConnectedClientsTick = DateTime.UtcNow.Ticks;
                    lastConnectedClients            = connectedPeers;
                    PrintStatusUpdate();
                }
            }
            Console.WriteLine("[INFO] Relay shutting down...");
        }
예제 #4
0
    void FixedUpdate()
    {
        bool loop = true;

        int recHostId;
        int recConnectionId;
        int channelId;

        int  dataSize;
        byte error;

        newConnectionList.Clear();
        for (int i = 0; i < 10 && loop; ++i)
        {
            NetworkEventType recData = NetworkTransport.Receive(out recHostId, out recConnectionId, out channelId, recvBuffer, bufferSize, out dataSize, out error);
            if (dataSize >= bufferSize)
            {
                Debug.LogWarning("the data received exceeds the buffer size!");
            }
            //if (channelId == unreliableCHN) {
            //    Debug.Log("unreliable: " + dataSize);
            //}
            switch (recData)
            {
            case NetworkEventType.Nothing:             //1
                loop = false;
                break;

            case NetworkEventType.ConnectEvent:        //2
                Debug.Log("socket id " + recHostId + ", conn " + recConnectionId + ", channel " + channelId);
                newConnectionList.Add(recConnectionId);
                break;

            case NetworkEventType.DataEvent:           //3
                ClientTest.decodeRawData(recvBuffer, synchronizedComponents);
                break;

            case NetworkEventType.DisconnectEvent:     //4
                int idx = getIndexByConnectionId(recConnectionId);
                if (idx >= 0)
                {
                    Debug.Log("player " + recConnectionId + " disconnected.");
                    for (int j = 0; j < playerOwned.Count; ++j)
                    {
                        if (playerOwned[j].connectionId == recConnectionId)
                        {
                            //playerStates.RemoveAt(j);
                            //sendBuffers.RemoveAt(j * 2 + 1);
                            //sendBuffers.RemoveAt(j * 2);

                            List <GameObjectSpawnInfo> toRemove = playerOwned[j].gameObjectsOwned;
                            for (int k = 0; k < toRemove.Count; ++k)
                            {
                                GameObject.Destroy(toRemove[k].obj);
                            }
                            playerOwned.RemoveAt(j);
                            break;
                        }
                    }
                }
                Debug.Log(recData.ToString());
                break;
            }
        }
        for (int i = 0; i < newConnectionList.Count; ++i)
        {
            // create player state
            playerOwned.Add(new PlayerOwnedInfo(newConnectionList[i]));
            replicateExistingGameObjectsToNewClient(newConnectionList[i]);
            spawnReplicatedGameObject(newConnectionList[i], PlayerStatePrefabPath);
        }
        sendAllBuffers();
    }
예제 #5
0
        private IEnumerator Receiver()
        {
            int  recSocketId, recConnectionId, recChannelId, recDataSize;
            byte error = 0;

            byte[] recBuffer = new byte[_bufferSize];

            while (true)
            {
                NetworkEventType netEventType = NetworkTransport.Receive
                                                (
                    out recSocketId,
                    out recConnectionId,
                    out recChannelId,
                    recBuffer,
                    _bufferSize,
                    out recDataSize,
                    out error
                                                );

                if (error != 0)
                {
                    Debug.LogError($"@Client -> @Receiver : Error ID [{error}]");
                }
                else
                {
                    switch (netEventType)
                    {
                    case NetworkEventType.Nothing:
                    {
                        yield return(null);

                        break;
                    }

                    case NetworkEventType.DataEvent:
                    {
                        OnDataReceived(recChannelId, recBuffer, recDataSize);
                        break;
                    }

                    case NetworkEventType.ConnectEvent:
                    {
                        Debug.Log($"@Client -> Receiver.Connect : Socket[{recSocketId}], userId[{recConnectionId}]");
                        break;
                    }

                    case NetworkEventType.DisconnectEvent:
                    {
                        Debug.Log($"@Client -> Receiver.Disconnect : Socket[{recSocketId}], userId[{recConnectionId}]");
                        Application.Quit();
                        break;
                    }

                    default:
                    {
                        Debug.LogError($"@Client -> @Receiver : Unrecognized Message Type [{netEventType.ToString()}]");
                        break;
                    }
                    }
                }
            }
        }