Esempio n. 1
0
    //protected void WritePlayerData(NetDataWriter writer)
    //{
    //    writer.Put(id);
    //    writer.Put(displayName);
    //    writer.Put(this.settings.gameKey);
    //    writer.Put(this.settings.gameVersion);
    //    writer.Put(this.settings.platform);
    //}


    private void Listener_NetworkReceiveEvent(NetPeer peer, NetPacketReader packetReader, DeliveryMethod deliveryMethod)
    {
        byte clientInstruction = packetReader.GetByte();

        if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_LIST)
        {
            if (roomList == null)
            {
                roomList = new LNSRoomList();
            }
            JsonUtility.FromJsonOverwrite(packetReader.GetString(), roomList);
            if (onRoomListReceived != null)
            {
                threadDispatcher.Add(() => onRoomListReceived(roomList));
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_CREATED)
        {
            isInActiveRoom     = true;
            _lastConnectedRoom = packetReader.GetString();


            if (onRoomCreated != null)
            {
                threadDispatcher.Add(() => onRoomCreated());
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_DISCONNECTED)
        {
            if (onDisconnectedFromRoom != null)
            {
                threadDispatcher.Add(() => onDisconnectedFromRoom());
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_CREATE)
        {
            byte reason = packetReader.GetByte();
            if (onRoomCreateFailed != null)
            {
                threadDispatcher.Add(() => onRoomCreateFailed((ROOM_FAILURE_CODE)reason));
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_JOIN)
        {
            byte reason = packetReader.GetByte();
            if (onRoomJoinFailed != null)
            {
                threadDispatcher.Add(() => onRoomJoinFailed((ROOM_FAILURE_CODE)reason));
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_REJOIN)
        {
            byte reason = packetReader.GetByte();
            if (onRoomRejoinFailed != null)
            {
                threadDispatcher.Add(() => onRoomRejoinFailed((ROOM_FAILURE_CODE)reason));
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_JOINED)
        {
            isInActiveRoom     = true;
            _lastConnectedRoom = packetReader.GetString();

            if (onRoomJoined != null)
            {
                threadDispatcher.Add(() => onRoomJoined());
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_REJOINED)
        {
            isInActiveRoom     = true;
            _lastConnectedRoom = packetReader.GetString();
            if (onRoomRejoined != null)
            {
                threadDispatcher.Add(() => onRoomRejoined());
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_FAILED_RANDOM_JOIN)
        {
            isInActiveRoom = false;
            if (onRandomRoomJoinFailed != null)
            {
                threadDispatcher.Add(() => onRandomRoomJoinFailed());
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_MASTERCLIENT_CHANGED)
        {
            _lastConnectedRoomMasterClient = packetReader.GetString();
            localClient.isMasterClient     = isLocalPlayerMasterClient = (_lastConnectedRoomMasterClient == id);
            if (onMasterClientUpdated != null)
            {
                try
                {
                    if (isLocalPlayerMasterClient)
                    {
                        threadDispatcher.Add(() =>
                        {
                            onMasterClientUpdated(localClient);
                        });
                    }
                    else
                    {
                        for (int i = 0; i < clients.Count; i++)
                        {
                            if (clients[i].id == _lastConnectedRoomMasterClient)
                            {
                                clients[i].isMasterClient = true;
                                LNSClient client = clients[i];
                                threadDispatcher.Add(() =>
                                {
                                    onMasterClientUpdated(client);
                                });
                            }
                            else
                            {
                                clients[i].isMasterClient = false;
                            }
                        }
                    }
                }catch (System.Exception ex)
                {
                    Debug.LogError(ex.Message + " " + ex.StackTrace);
                }
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_PLAYER_CONNECTED)
        {
            string          client_id          = packetReader.GetString();
            string          client_displayName = packetReader.GetString();
            CLIENT_PLATFORM client_platform    = (CLIENT_PLATFORM)packetReader.GetByte();
            int             client_netID       = packetReader.GetInt();
            LNSClient       client             = null;
            for (int i = 0; i < clients.Count; i++)
            {
                if (clients[i].id == client_id)
                {
                    client             = clients[i];
                    client.displayName = client_displayName;
                    client.platform    = client_platform;
                    client.networkID   = client_netID;
                    break;
                }
            }

            if (client == null)
            {
                client             = new LNSClient();
                client.id          = client_id;
                client.displayName = client_displayName;
                client.platform    = client_platform;
                client.networkID   = client_netID;

                clients.Add(client);
            }
            client.isConnected = true;

            if (onPlayerConnected != null)
            {
                threadDispatcher.Add(() =>
                {
                    onPlayerConnected(client);
                });
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_PLAYER_DISCONNECTED)
        {
            string client_id = packetReader.GetString();

            for (int i = 0; i < clients.Count; i++)
            {
                if (clients[i].id == client_id)
                {
                    clients[i].isConnected = false;
                    if (onPlayerDisconnected != null)
                    {
                        threadDispatcher.Add(() =>
                        {
                            onPlayerDisconnected(clients[i]);
                        });
                    }
                    return;
                }
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_CACHE_DATA)
        {
            LNSReader reader = LNSReader.GetFromPool();
            string    key    = packetReader.GetString();
            byte[]    data   = packetReader.GetRemainingBytes();
            reader.SetSource(data);

            if (persistentData.ContainsKey(key))
            {
                persistentData[key] = data;
            }
            else
            {
                persistentData.Add(key, data);
            }

            if (dataReceiver != null)
            {
                threadDispatcher.Add(() =>
                {
                    try
                    {
                        dataReceiver.OnCachedDataReceived(key, reader);
                    }
                    catch (System.Exception ex)
                    {
                        Debug.LogError(ex.Message + " " + ex.StackTrace);
                    }
                    reader.Recycle();
                });
            }
        }
        else if (clientInstruction == LNSConstants.CLIENT_EVT_ROOM_RAW)
        {
            string fromid = packetReader.GetString();

            for (int i = 0; i < clients.Count; i++)
            {
                if (fromid == clients[i].id)
                {
                    if (dataReceiver != null)
                    {
                        ushort    eventCode = packetReader.GetUShort();
                        LNSReader reader    = LNSReader.GetFromPool();


                        LNSClient      fromClient      = clients[i];
                        DeliveryMethod _deliveryMethod = deliveryMethod;

                        reader.SetSource(packetReader.GetRemainingBytes());

                        threadDispatcher.Add(() =>
                        {
                            try
                            {
                                dataReceiver.OnEventRaised(fromClient, eventCode, reader, _deliveryMethod);
                            }
                            catch (System.Exception ex) {
                                Debug.LogError(ex.Message + " " + ex.StackTrace);
                            }
                            reader.Recycle();
                        });
                    }
                    break;
                }
            }
        }
        packetReader.Recycle();
    }
Esempio n. 2
0
    public void Start()
    {
        new Thread(() =>
        {
            EventBasedNetListener listener = new EventBasedNetListener();
            NetManager server = new NetManager(listener);
            server.Start(this.port);
            Debug.Log("Server Started");
            listener.ConnectionRequestEvent += request =>
            {
                Debug.Log("connection request recieved");

                lock (thelock)
                {
                    string clientKey = request.Data.GetString();
                    if (clientKey == "RJPROZ_IS_MASTER")
                    {
                    }
                    else if (clientKey != this.key)
                    {
                        NetDataWriter writer = new NetDataWriter(false, 1);
                        writer.Put(LNSConstants.CLIENT_EVT_UNAUTHORIZED_CONNECTION);
                        request.Reject(writer);
                    }
                    else
                    {
                        try
                        {
                            string userid      = request.Data.GetString();
                            string displayName = request.Data.GetString();
                            string gameKey     = request.Data.GetString();
                            string version     = request.Data.GetString();


                            CLIENT_PLATFORM platform = (CLIENT_PLATFORM)request.Data.GetByte();


                            if (string.IsNullOrEmpty(gameKey) || !gameKey.Contains("hybriona") || string.IsNullOrEmpty(userid))
                            {
                                NetDataWriter writer = new NetDataWriter();
                                writer.Put(LNSConstants.CLIENT_EVT_UNAUTHORIZED_GAME);
                                request.Reject(writer);
                            }
                            else if (connectedClientIds.Contains(userid))
                            {
                                NetDataWriter writer = new NetDataWriter(false, 1);
                                writer.Put(LNSConstants.CLIENT_EVT_USER_ALREADY_CONNECTED);
                                request.Reject(writer);
                            }
                            else
                            {
                                NetPeer peer     = request.Accept();
                                LNSClient client = null;
                                if (!clients.ContainsKey(peer.Id))
                                {
                                    client = new LNSClient(peer);
                                    clients.Add(peer.Id, client);
                                }
                                else
                                {
                                    client      = clients[peer.Id];
                                    client.peer = peer;
                                }
                                client.networkid   = peer.Id;
                                client.id          = userid;
                                client.displayname = displayName;
                                client.gameKey     = gameKey;
                                client.gameVersion = version;
                                client.platform    = platform;
                                connectedClientIds.Add(userid);
                                Debug.Log("Connected : " + peer.Id + " | Total clients: " + clients.Count);

                                Log(string.Format("Connected {0} {1} {2} {3}", gameKey, displayName, platform, userid));
                            }
                        }
                        catch
                        {
                            NetDataWriter writer = new NetDataWriter(false, 1);
                            writer.Put(LNSConstants.CLIENT_EVT_SERVER_EXECEPTION);
                            request.Reject(writer);
                        }
                    }
                }
            };

            //listener.PeerConnectedEvent += peer =>
            //{
            //    lock (thelock)
            //    {
            //        try
            //        {


            //        }
            //        catch(System.Exception ex)
            //        {
            //            Debug.LogError(ex.Message + " - "+ex.StackTrace);
            //        }
            //    }


            //};

            listener.NetworkReceiveEvent += (NetPeer peer, NetPacketReader reader, DeliveryMethod deliveryMethod) =>
            {
                int peerId       = peer.Id;
                LNSClient client = clients[peerId];
                byte instruction = reader.GetByte();

                if (client.connectedRoom == null)
                {
                    string gameKey           = client.gameKey;
                    string version           = client.gameVersion;
                    CLIENT_PLATFORM platform = client.platform;



                    LNSGame game = null;
                    if (games.ContainsKey(gameKey))
                    {
                        game = games[gameKey];
                    }
                    else
                    {
                        game = new LNSGame(gameKey, this);
                        games.Add(game.gameKey, game);
                    }

                    Dictionary <string, LNSRoom> rooms = game.rooms;
                    if (instruction == LNSConstants.SERVER_EVT_CREATE_ROOM)
                    {
                        //Debug.Log("Create room");
                        string roomid = reader.GetString();
                        LNSCreateRoomParameters roomParameters = LNSCreateRoomParameters.FromReader(reader);

                        lock (thelock)
                        {
                            if (rooms.ContainsKey(roomid.ToLower()))
                            {
                                client.SendFailedToCreateRoomEvent(ROOM_FAILURE_CODE.ROOM_ALREADY_EXIST); //: Room creation failed
                            }
                            else
                            {
                                LNSRoom room = new LNSRoom(roomid);

                                room.gameKey         = gameKey;
                                room.gameVersion     = version;
                                room.primaryPlatform = (byte)platform;
                                room.roomParameters  = roomParameters;



                                room.assocGame = game;
                                room.Prepare();

                                rooms.Add(roomid.ToLower(), room);
                                client.connectedRoom = room;
                                client.SendRoomCreatedEvent(); //: Room created
                                room.AddPlayer(client);


                                Log("Room created " + room.id, client);
                            }
                        }
                    }
                    else if (instruction == LNSConstants.SERVER_EVT_CREATE_OR_JOIN_ROOM)
                    {
                        string roomid  = reader.GetString();
                        int maxPlayers = reader.GetInt();
                        lock (thelock)
                        {
                            if (!rooms.ContainsKey(roomid.ToLower()))
                            {
                                LNSRoom room = new LNSRoom(roomid);

                                room.gameKey                   = gameKey;
                                room.gameVersion               = version;
                                room.primaryPlatform           = (byte)platform;
                                room.roomParameters            = new LNSCreateRoomParameters();
                                room.roomParameters.maxPlayers = maxPlayers;
                                room.assocGame                 = game;
                                room.Prepare();
                                rooms.Add(roomid.ToLower(), room);
                                client.connectedRoom = room;
                                client.SendRoomCreatedEvent();  //: Room created Event
                                room.AddPlayer(client);

                                Log("Room created " + room.id, client);
                            }
                            else
                            {
                                LNSRoom room = rooms[roomid.ToLower()];
                                if (room.gameVersion != client.gameVersion)
                                {
                                    client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.VERSION_MISMATCH);
                                }
                                else if (!room.isOpen)
                                {
                                    client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.ROOM_LOCKED); // Room join failed
                                }

                                else if (room.playerCount >= room.roomParameters.maxPlayers)
                                {
                                    client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.ROOM_FULL);
                                }

                                else
                                {
                                    client.connectedRoom = room;
                                    client.SendRoomJoinedEvent();//: Room joined
                                    room.AddPlayer(client);

                                    Log("Room joined " + room.id, client);
                                }
                            }
                        }
                    }
                    else if (instruction == LNSConstants.SERVER_EVT_JOIN_ROOM)
                    {
                        string roomid    = reader.GetString();
                        bool hasPassword = reader.GetBool();
                        string password  = null;
                        if (hasPassword)
                        {
                            password = reader.GetString();
                        }


                        lock (thelock)
                        {
                            if (rooms.ContainsKey(roomid.ToLower()))
                            {
                                LNSRoom room = rooms[roomid.ToLower()];

                                if (room.gameVersion != client.gameVersion)
                                {
                                    client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.VERSION_MISMATCH);
                                }
                                else if ((room.hasPassword && password == null) || (room.hasPassword && room.roomParameters.password != password))
                                {
                                    client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.PASSWORD_MISMATCH);
                                }
                                else if (!room.isOpen)
                                {
                                    client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.ROOM_LOCKED);
                                }
                                else if (room.playerCount >= room.roomParameters.maxPlayers)
                                {
                                    client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.ROOM_FULL);
                                }

                                else
                                {
                                    client.connectedRoom = room;
                                    client.SendRoomJoinedEvent(); //: Room Joined
                                    room.AddPlayer(client);

                                    Log("Room joined " + room.id, client);
                                }
                            }
                            else
                            {
                                client.SendRoomFailedToJoinEvent(ROOM_FAILURE_CODE.ROOM_DOESNT_EXIST); // Room join failed
                            }
                        }
                    }
                    else if (instruction == LNSConstants.SERVER_EVT_JOIN_RANDOM_ROOM)
                    {
                        LNSJoinRoomFilter filter = LNSJoinRoomFilter.FromReader(reader);
                        lock (thelock)
                        {
                            bool found = false;
                            foreach (var roomKV in rooms)
                            {
                                LNSRoom room = roomKV.Value;
                                //Debug.Log("is room param null " + (room.roomParameters == null));
                                if (room.roomParameters.isPublic && room.gameVersion == client.gameVersion && !room.hasPassword && room.isOpen && room.playerCount < room.roomParameters.maxPlayers)
                                {
                                    if (filter == null || room.IsFilterMatch(filter))
                                    {
                                        client.connectedRoom = room;
                                        client.SendRoomJoinedEvent(); //: Room Joined
                                        room.AddPlayer(client);

                                        Log("Room random joined " + room.id, client);

                                        found = true;
                                        break;
                                    }
                                }
                            }

                            if (!found)
                            {
                                client.SendRoomFailedToRandomJoin(); // Room join failed
                            }
                        }
                    }
                    else if (instruction == LNSConstants.SERVER_EVT_REJOIN_ROOM)
                    {
                        string roomid = reader.GetString();

                        lock (thelock)
                        {
                            if (rooms.ContainsKey(roomid.ToLower()))
                            {
                                LNSRoom room = rooms[roomid.ToLower()];

                                if (room.playerCount >= room.roomParameters.maxPlayers)
                                {
                                    client.SendRoomFailedToReJoinEvent(ROOM_FAILURE_CODE.ROOM_FULL);
                                }
                                else if (!room.CanReconnect(client))
                                {
                                    client.SendRoomFailedToReJoinEvent(ROOM_FAILURE_CODE.REJOIN_NOT_AUTHORIZED);
                                }
                                else
                                {
                                    client.connectedRoom = room;
                                    client.SendRoomReJoinedEvent(); //: Room ReJoined
                                    room.AddPlayer(client);
                                    Log("Room rejoined " + room.id, client);
                                }
                            }
                            else
                            {
                                client.SendRoomFailedToReJoinEvent(ROOM_FAILURE_CODE.ROOM_DOESNT_EXIST); // Room join failed
                            }
                        }
                    }
                    else if (instruction == LNSConstants.SERVER_EVT_FETCH_ROOM_LIST)
                    {
                        LNSJoinRoomFilter filter = LNSJoinRoomFilter.FromReader(reader);

                        lock (thelock)
                        {
                            LNSRoomList roomList = new LNSRoomList();
                            int counter          = 0;
                            foreach (var roomKV in rooms)
                            {
                                LNSRoom room = roomKV.Value;
                                //Debug.Log("is room param null " + (room.roomParameters == null));
                                if (room.roomParameters.isPublic && room.gameVersion == client.gameVersion && room.isOpen && room.playerCount < room.roomParameters.maxPlayers)
                                {
                                    if (filter == null || room.IsFilterMatch(filter))
                                    {
                                        string roomid          = room.id;
                                        bool roomHasPassword   = room.hasPassword;
                                        int currentPlayerCount = room.playerCount;
                                        int maxPlayers         = room.roomParameters.maxPlayers;

                                        LNSRoomList.RoomData roomData = new LNSRoomList.RoomData();
                                        roomData.id          = roomid;
                                        roomData.hasPassword = roomHasPassword;
                                        roomData.playerCount = currentPlayerCount;
                                        roomData.maxPlayers  = maxPlayers;
                                        roomList.list.Add(roomData);
                                        counter++;
                                        if (counter >= 100)
                                        {
                                            break;
                                        }
                                    }
                                }
                            }

                            client.SendRoomList(roomList);
                            roomList.list = null;
                            roomList      = null;
                        }
                    }
                }
                else
                {
                    if (instruction == LNSConstants.SERVER_EVT_LEAVE_ROOM)
                    {
                        client.SendDisconnectEvent(true);
                        client.connectedRoom = null;
                    }
                    else
                    {
                        client.connectedRoom.ProcessReceivedData(client, instruction, reader, deliveryMethod);
                    }
                }


                reader.Recycle();
            };
            listener.PeerDisconnectedEvent += (NetPeer peer, DisconnectInfo disconnectInfo) =>
            {
                lock (thelock)
                {
                    int peerId = peer.Id;
                    if (clients.ContainsKey(peerId))
                    {
                        LNSClient client = clients[peerId];
                        client.SendDisconnectEvent(false);
                        if (connectedClientIds.Contains(client.id))
                        {
                            connectedClientIds.Remove(client.id);
                        }
                        client.Dispose();
                        clients.Remove(peerId);
                    }
                }
                Debug.Log("Disconnected : " + peer.Id);
            };


            while (true)
            {
                server.PollEvents();
                Thread.Sleep(threadWaitMilliseconds); // 30 times per second
            }
        }).Start();
    }