Exemplo n.º 1
0
        public async Task LeaveRoom(LeaveRoomRequest request)
        {
            try
            {
                var ctx     = new ValidationContext(request);
                var results = new List <ValidationResult>();
                Validator.TryValidateObject(request, ctx, results, true);
                if (results.Count > 0)
                {
                    throw new ApplicationError("[LeaveRoom]", 4);
                }

                var response = await _roomService.LeaveRoom(request);

                await Groups.RemoveFromGroupAsync(Context.ConnectionId, response.roomIdentifier.ToString());

                await Clients.OthersInGroup(response.roomIdentifier.ToString()).BrLeftRoom(response);

                //user who left the room does not care anymore about the others.
                response.users = null;
                await Clients.Caller.LeftRoom(response);
            }
            catch (Exception e)
            {
                var errorResponse = ApplicationError.GetError <JoinRoomResponse>(e, "[LeaveRoom]");
                _logger.LogError(e.Message);
                await Clients.Caller.JoinedRoom(errorResponse);
            }
        }
Exemplo n.º 2
0
        public void IfTheCreatorOfALobbyLeavesTheGameIsDestroyed()
        {
            var roomId = createRoom();

            // Have the host leave the lobby
            LeaveRoomRequest leaveRequest = new LeaveRoomRequest()
            {
                RoomId = roomId
            };

            LeaveRoomResponse leaveResponse = client.LeaveRoom(leaveRequest);

            Assert.AreEqual(leaveResponse.Status.IsSuccess, true);

            // Ensure that the player has left the game.
            // View open rooms.
            OpenLobbiesResponse openLobbiesResponsAfterLeave = client.GetOpenLobbies(new OpenLobbiesRequest());

            assertSuccessResponse(openLobbiesResponsAfterLeave.Status);
            Assert.AreEqual(0, openLobbiesResponsAfterLeave.Rooms.Count);

            // Ensure the player is not in the game.
            PlayerCurrentGamesResponse gamesResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());

            assertSuccessResponse(gamesResponse.Status);
            Assert.AreEqual(0, gamesResponse.Games.Count);
        }
        public void LeaveRoomTest()
        {
            //Arrange
            var player = default(Player);
            var room   = _user.CreateNewRoom(_level, _config, out player);
            LeaveRoomRequest request = new LeaveRoomRequest()
            {
                Player      = player.GetHashCode(),
                UserName    = _user.UserName,
                SecurityKey = _securityKey,
            };

            //Act
            var act        = _ctrl.LeaveRoom(request);
            var actContent = default(LeaveRoomResult);
            var hasContent = act.TryGetContentValue(out actContent);

            //Assert
            TestContext.WriteLine("error message: '{0}'", (actContent != null && actContent.ErrorMessage != "") ? actContent.ErrorMessage : "null");
            Assert.AreEqual(HttpStatusCode.OK, act.StatusCode, "status code");
            Assert.IsTrue(hasContent, "has contact");
            Assert.AreEqual("", actContent.ErrorMessage, "error message");
            Assert.AreEqual(true, actContent.Success, "success");
            Assert.AreEqual(false, _user.Players.Contains(player, new AddressComparer <Player>()));
            Assert.IsNotNull(actContent.UserStatistics, "user statistics not null");
        }
        public override async Task <LeaveRoomResponse> LeaveRoom(LeaveRoomRequest request, ServerCallContext context)
        {
            DbUserModel dbUserModel = context.UserState["user"] as DbUserModel;

            if (dbUserModel == null)
            {
                return new LeaveRoomResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.UNAUTHORIZED)
                       }
            }
            ;

            Room room = await Room.GetRoomFromGuid(request.RoomId);

            if (room == null)
            {
                return new LeaveRoomResponse()
                       {
                           Status = ResponseFactory.createResponse(ResponseType.ROOM_DOES_NOT_EXIST)
                       }
            }
            ;

            return(new LeaveRoomResponse()
            {
                Status = await room.LeaveRoom(dbUserModel)
            });
        }
Exemplo n.º 5
0
        /**
         * Leave a room the user is currently in.
         */
        public async Task <LeaveRoomResponse> LeaveRoom(LeaveRoomRequest payload)
        {
            try
            {
                var response = new LeaveRoomResponse();

                User user = await _userRepository.FindRoomOfUserById((Guid)payload.userIdentifier);

                if (user == null)
                {
                    throw new ApplicationError("[RoomService.LeaveRoom]", 1);
                }

                if (user.room == null)
                {
                    throw new ApplicationError("[RoomService.LeaveRoom]", 2);
                }

                var roomUsers = await _userRepository.FindAllByRoomId(user.room.id);

                user.room.users = roomUsers.Where(roomUser => roomUser.id != payload.userIdentifier).ToList();

                response.roomIdentifier = user.room.identifier;
                response.users          = user.room.users;

                await _unitOfWork.Save();

                return(response);
            }
            catch (Exception e)
            {
                throw e;
            }
        }
Exemplo n.º 6
0
        public LeaveRoomResult LeaveRoom(LeaveRoomRequest request)
        {
            var result = new LeaveRoomResult();

            try
            {
                var user = _cache.RefreshAndGet(
                    Users,
                    request.UserName,
                    new UserNotFoundException(string.Format("cannot find user name: {0}, please login again.", request.UserName))
                    );
                UserManager.SecurityCheck(request.SecurityKey, user);

                var player = _cache.RefreshAndGet(
                    Players,
                    request.Player,
                    new PlayerNotFoundException(string.Format("player id: {0} not found, please re-enter the room.", request.Player))
                    );

                user.ExitRoom(player);
                result.Success        = true;
                result.UserStatistics = user.UserStatistics;

                // update cache on removal
                Players.Remove(player.GetHashCode());
            }
            catch (PokerException e)
            {
                result.Success      = false;
                result.ErrorMessage = e.Message;
                Logger.Error(e, this);
            }

            return(result);
        }
Exemplo n.º 7
0
    /// <summary>
    /// Rời khỏi phòng nào đó (Chỉ sử dụng khi JoinGame) còn lại đã tự động hết rồi.
    /// </summary>
    public void DoLeaveRoom(int zoneId, int roomId)
    {
        LeaveRoomRequest leave = new LeaveRoomRequest();

        leave.ZoneId = zoneId;
        leave.RoomId = roomId;
        DoRequest(leave);
    }
Exemplo n.º 8
0
        public void IfTheCreatorOfALobbyLeavesTheGameNoPlayersAreStuckInTheLobby()
        {
            CreateRoomRequest createRequest = new CreateRoomRequest()
            {
                Anonymous          = false,
                Goal               = Goal.Domination,
                MaxPlayers         = 5,
                IsRanked           = false,
                RoomName           = "My Room!",
                AllowedSpecialists = { "a", "b", "c" },
            };

            CreateRoomResponse roomResponse = client.CreateNewRoom(createRequest);

            Assert.AreEqual(roomResponse.Status.IsSuccess, true);
            Assert.IsTrue(roomResponse.CreatedRoom.RoomId != null);
            var roomId = roomResponse.CreatedRoom.RoomId;

            // Have a player join the game
            authHelper.loginToAccount("userTwo");
            client.JoinRoom(new JoinRoomRequest()
            {
                RoomId = roomId,
            });

            authHelper.loginToAccount("userOne");
            // Have the host leave the lobby
            LeaveRoomRequest leaveRequest = new LeaveRoomRequest()
            {
                RoomId = roomId
            };

            LeaveRoomResponse leaveResponse = client.LeaveRoom(leaveRequest);

            Assert.AreEqual(leaveResponse.Status.IsSuccess, true);

            // Ensure that the player has left the game.
            // View open rooms.
            OpenLobbiesResponse openLobbiesResponsAfterLeave = client.GetOpenLobbies(new OpenLobbiesRequest());

            Assert.AreEqual(openLobbiesResponsAfterLeave.Status.IsSuccess, true);
            Assert.AreEqual(0, openLobbiesResponsAfterLeave.Rooms.Count);

            // Ensure the player is not in the game.
            PlayerCurrentGamesResponse gamesResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());

            Assert.AreEqual(gamesResponse.Status.IsSuccess, true);
            Assert.AreEqual(0, gamesResponse.Games.Count);

            authHelper.loginToAccount("userTwo");
            // Ensure the player is not in the game.
            PlayerCurrentGamesResponse gamesTwoResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());

            Assert.AreEqual(gamesTwoResponse.Status.IsSuccess, true);
            Assert.AreEqual(0, gamesTwoResponse.Games.Count);
        }
Exemplo n.º 9
0
        public void PlayerCanLeaveAGameRoom()
        {
            CreateRoomResponse roomResponse = client.CreateNewRoom(createRoomRequest("My room!"));

            Assert.AreEqual(roomResponse.Status.IsSuccess, true);
            Assert.IsTrue(roomResponse.CreatedRoom.Id != null);
            var roomId = roomResponse.CreatedRoom.Id;

            authHelper.loginToAccount("userTwo");

            // View open rooms.
            OpenLobbiesResponse openLobbiesResponse = client.GetOpenLobbies(new OpenLobbiesRequest());

            Assert.AreEqual(openLobbiesResponse.Status.IsSuccess, true);
            Assert.AreEqual(1, openLobbiesResponse.Rooms.Count);
            Assert.AreEqual(roomId, openLobbiesResponse.Rooms[0].Id);
            // Ensure the creator is a member of the game
            Assert.AreEqual(1, openLobbiesResponse.Rooms[0].Players.Count);
            Assert.AreEqual("userOne", openLobbiesResponse.Rooms[0].Players[0].Username);

            JoinRoomRequest joinRequest = new JoinRoomRequest()
            {
                RoomId = roomId,
            };

            JoinRoomResponse joinResponse = client.JoinRoom(joinRequest);

            Assert.AreEqual(joinResponse.Status.IsSuccess, true);

            // View open rooms.
            OpenLobbiesResponse openLobbiesResponsAfterJoin = client.GetOpenLobbies(new OpenLobbiesRequest());

            Assert.AreEqual(openLobbiesResponsAfterJoin.Status.IsSuccess, true);
            Assert.AreEqual(1, openLobbiesResponsAfterJoin.Rooms.Count);
            Assert.AreEqual(roomId, openLobbiesResponsAfterJoin.Rooms[0].Id);
            Assert.AreEqual(2, openLobbiesResponsAfterJoin.Rooms[0].Players.Count);

            LeaveRoomRequest leaveRequest = new LeaveRoomRequest()
            {
                RoomId = roomId
            };

            LeaveRoomResponse leaveResponse = client.LeaveRoom(leaveRequest);

            Assert.AreEqual(leaveResponse.Status.IsSuccess, true);

            // Ensure that the player has left the game.
            // View open rooms.
            OpenLobbiesResponse openLobbiesResponsAfterLeave = client.GetOpenLobbies(new OpenLobbiesRequest());

            Assert.AreEqual(openLobbiesResponsAfterLeave.Status.IsSuccess, true);
            Assert.AreEqual(1, openLobbiesResponsAfterLeave.Rooms.Count);
            Assert.AreEqual(roomId, openLobbiesResponsAfterLeave.Rooms[0].Id);
            Assert.AreEqual(1, openLobbiesResponsAfterLeave.Rooms[0].Players.Count);
        }
Exemplo n.º 10
0
        public void LeaveRoomRequest_Constructs_The_Correct_Message(string room)
        {
            var a   = new LeaveRoomRequest(room);
            var msg = a.ToByteArray();

            var reader = new MessageReader <MessageCode.Server>(msg);
            var code   = reader.ReadCode();

            Assert.Equal(MessageCode.Server.LeaveRoom, code);
            Assert.Equal(room, reader.ReadString());
        }
        public async ValueTask ExecuteAsync(LeaveRoomCommand command)
        {
            var request = new LeaveRoomRequest
            {
                SessionId = command.SessionId,
                Room      = command.Room ?? string.Empty
            };

            await m_MessageQueueService
            .RequestAsync("room.leave", request.ToByteArray())
            .ConfigureAwait(false);
        }
Exemplo n.º 12
0
        private void BackBTN_Click(object sender, RoutedEventArgs e)
        {
            if (app.admin)
            {
                CloseRoomRequest closeRoomRequest = new CloseRoomRequest();

                app.communicator.SocketSendReceive(JsonSerializer.serializeRequest(closeRoomRequest, Constants.CLOSE_ROOM_REQUEST)).ContinueWith(task =>
                {
                    ResponseInfo response = task.Result;
                    CloseRoomResponse closeRoomResponse = JsonDeserializer.deserializeResponse <CloseRoomResponse>(response.buffer);
                    switch (closeRoomResponse.status)
                    {
                    case Constants.CLOSE_ROOM_SUCCESS:
                        thr.Abort();
                        MyMessageQueue.Enqueue("You leaved the room successfuly.");
                        this.Dispatcher.Invoke(() =>
                        {
                            NavigationService ns = NavigationService.GetNavigationService(this);
                            ns.Navigate(new Uri("Menu.xaml", UriKind.Relative));
                        });

                        break;
                    }
                });
            }
            else
            {
                LeaveRoomRequest leaveRoomRequest = new LeaveRoomRequest();

                app.communicator.SocketSendReceive(JsonSerializer.serializeRequest(leaveRoomRequest, Constants.LEAVE_ROOM_REQUEST)).ContinueWith(task =>
                {
                    ResponseInfo response = task.Result;
                    LeaveRoomResponse leaveRoomResponse = JsonDeserializer.deserializeResponse <LeaveRoomResponse>(response.buffer);
                    switch (leaveRoomResponse.status)
                    {
                    case Constants.LEAVE_ROOM_SUCCESS:
                        thr.Abort();
                        MyMessageQueue.Enqueue("You left the room successfuly.");
                        this.Dispatcher.Invoke(() =>
                        {
                            NavigationService ns = NavigationService.GetNavigationService(this);
                            ns.Navigate(new Uri("Menu.xaml", UriKind.Relative));
                        });

                        break;
                    }
                });
            }
        }
Exemplo n.º 13
0
        public HttpResponseMessage LeaveRoom(LeaveRoomRequest request)
        {
            var result = new LeaveRoomResult();

            try
            {
                result = service.LeaveRoom(request);
            }
            catch (Exception e)
            {
                result.ErrorMessage = e.Message;
                result.Success      = false;
                return(Request.CreateResponse(HttpStatusCode.InternalServerError, result));
            }

            return(Request.CreateResponse(HttpStatusCode.OK, result));
        }
Exemplo n.º 14
0
        public HttpResponseMessage Leave([ModelBinder(typeof(JsonNetModelBinder))] LeaveRoomRequest request)
        {
            if (!Data.HasPlayer(request.PlayerId))
            {
                var leaveRoomFailedResponse = new LeaveRoomResponse()
                {
                    Result = false
                };
                return(new JsonNetResponseMessage(leaveRoomFailedResponse));
            }

            var player = Data.FindPlayer(request.PlayerId);

            if (player == null)
            {
                var leaveRoomFailedResponse = new LeaveRoomResponse()
                {
                    Result = false
                };
                return(new JsonNetResponseMessage(leaveRoomFailedResponse));
            }

            var  roomName = player.RoomName;
            Room room     = null;

            if (!Data.Rooms.TryGetValue(roomName, out room))
            {
                var leaveRoomFailedResponse = new LeaveRoomResponse()
                {
                    Result = false
                };
                return(new JsonNetResponseMessage(leaveRoomFailedResponse));
            }

            room.Players.Remove(player);

            var response = new LeaveRoomResponse()
            {
                Result = true
            };

            return(new JsonNetResponseMessage(response));
        }
Exemplo n.º 15
0
        public void IfTheCreatorOfALobbyLeavesTheGameNoPlayersAreStuckInTheLobby()
        {
            var roomId = createRoom();

            // Have a player join the game
            authHelper.loginToAccount("userTwo");
            client.JoinRoom(new JoinRoomRequest()
            {
                RoomId = roomId,
            });

            authHelper.loginToAccount("userOne");
            // Have the host leave the lobby
            LeaveRoomRequest leaveRequest = new LeaveRoomRequest()
            {
                RoomId = roomId
            };

            LeaveRoomResponse leaveResponse = client.LeaveRoom(leaveRequest);

            assertSuccessResponse(leaveResponse.Status);

            // Ensure that the player has left the game.
            // View open rooms.
            OpenLobbiesResponse openLobbiesResponsAfterLeave = client.GetOpenLobbies(new OpenLobbiesRequest());

            assertSuccessResponse(openLobbiesResponsAfterLeave.Status);
            Assert.AreEqual(0, openLobbiesResponsAfterLeave.Rooms.Count);

            // Ensure the player is not in the game.
            PlayerCurrentGamesResponse gamesResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());

            assertSuccessResponse(gamesResponse.Status);
            Assert.AreEqual(0, gamesResponse.Games.Count);

            authHelper.loginToAccount("userTwo");
            // Ensure the player is not in the game.
            PlayerCurrentGamesResponse gamesTwoResponse = client.GetPlayerCurrentGames(new PlayerCurrentGamesRequest());

            assertSuccessResponse(gamesTwoResponse.Status);
            Assert.AreEqual(0, gamesTwoResponse.Games.Count);
        }
Exemplo n.º 16
0
    void attemptToJoinGame(AvailGame ag)
    {
        waitingMessage = "User clicked " + ag.name;
        removeListeners();
        inLobby = false;
        Debug.Log("User clicked " + ag.name);
        // save the info about the game to be joined
        GameObject sharedES = GameObject.Find("SharedES");
        SharedElectroServer gm = (SharedElectroServer)sharedES.GetComponent<SharedElectroServer>();
        gm.gameToJoin = ag;

        // leave the Lobby room, but don't wait for the event about it
        LeaveRoomRequest lrr = new LeaveRoomRequest();
        lrr.ZoneId = room.ZoneId;
        lrr.RoomId = room.Id;

        _es.Engine.Send(lrr);
        room = null;

        // Start Coroutine to jump to game scene
        StartCoroutine(PollGameLevelLoaded());

        // Execute level load
        Application.LoadLevel("game");
    }
Exemplo n.º 17
0
    void returnToLobby()
    {
        waitingMessage = "Returning to Lobby";
        errorMessage = "";
        showReturnToLobbyButton = false;
        inGame = false;
        Debug.Log("Returning to Lobby");
        _es.Engine.JoinRoomEvent -= OnJoinRoom;
        _es.Engine.CreateOrJoinGameResponse -= OnCreateOrJoinGameResponse;

        /**
         * If you want to add chat in the game, you will need this line
         */
        //_es.Engine.PublicMessageEvent -= OnPublicMessage;

        _es.Engine.ConnectionClosedEvent -= OnConnectionClosedEvent;
        _es.Engine.GenericErrorResponse -= onGenericErrorResponse;
        _es.Engine.PluginMessageEvent -= onPluginMessageEvent;

        if (null != room)
        {
            LeaveRoomRequest lrr = new LeaveRoomRequest();
            lrr.RoomId = room.Id;
            lrr.ZoneId = room.ZoneId;
            _es.Engine.Send(lrr);
            room = null;
        }

        // Start Coroutine to jump to game scene
        StartCoroutine(PollGameLevelLoaded());

        // Execute level load
        Application.LoadLevel("lobby");

    }
Exemplo n.º 18
0
        public void LeaveRoomRequest_Instantiates_Properly(string room)
        {
            var a = new LeaveRoomRequest(room);

            Assert.Equal(room, a.RoomName);
        }
Exemplo n.º 19
0
        public LeaveRoomResponse LeaveRoom(LeaveRoomRequest request)
        {
            LeaveRoomResponse response = new LeaveRoomResponse();

              rwLock.EnterWriteLock();
              try
              {
            IPoLServerCallback channel = OperationContext.Current.GetCallbackChannel<IPoLServerCallback>();
            var ply = gameLobby.GetPlayerByChannel(channel);
            var room = gameLobby.Rooms.Values.FirstOrDefault(r => r.Players.Contains(ply));
            response.Success = room != null;
            if(response.Success)
            {
              room.Players.Remove(ply);
            }
              }
              finally
              {
            rwLock.ExitWriteLock();
              }

              return response;
        }
Exemplo n.º 20
0
        public void PlayerCanLeaveAGameRoom()
        {
            CreateRoomRequest createRequest = new CreateRoomRequest()
            {
                Anonymous          = false,
                Goal               = Goal.Domination,
                MaxPlayers         = 5,
                IsRanked           = false,
                RoomName           = "My Room!",
                AllowedSpecialists = { "a", "b", "c" },
            };

            CreateRoomResponse roomResponse = client.CreateNewRoom(createRequest);

            Assert.AreEqual(roomResponse.Status.IsSuccess, true);
            Assert.IsTrue(roomResponse.CreatedRoom.RoomId != null);
            var roomId = roomResponse.CreatedRoom.RoomId;

            authHelper.loginToAccount("userTwo");

            // View open rooms.
            OpenLobbiesResponse openLobbiesResponse = client.GetOpenLobbies(new OpenLobbiesRequest());

            Assert.AreEqual(openLobbiesResponse.Status.IsSuccess, true);
            Assert.AreEqual(1, openLobbiesResponse.Rooms.Count);
            Assert.AreEqual(roomId, openLobbiesResponse.Rooms[0].RoomId);
            // Ensure the creator is a member of the game
            Assert.AreEqual(1, openLobbiesResponse.Rooms[0].Players.Count);
            Assert.AreEqual("userOne", openLobbiesResponse.Rooms[0].Players[0].Username);

            JoinRoomRequest joinRequest = new JoinRoomRequest()
            {
                RoomId = roomId,
            };

            JoinRoomResponse joinResponse = client.JoinRoom(joinRequest);

            Assert.AreEqual(joinResponse.Status.IsSuccess, true);

            // View open rooms.
            OpenLobbiesResponse openLobbiesResponsAfterJoin = client.GetOpenLobbies(new OpenLobbiesRequest());

            Assert.AreEqual(openLobbiesResponsAfterJoin.Status.IsSuccess, true);
            Assert.AreEqual(1, openLobbiesResponsAfterJoin.Rooms.Count);
            Assert.AreEqual(roomId, openLobbiesResponsAfterJoin.Rooms[0].RoomId);
            Assert.AreEqual(2, openLobbiesResponsAfterJoin.Rooms[0].Players.Count);

            LeaveRoomRequest leaveRequest = new LeaveRoomRequest()
            {
                RoomId = roomId
            };

            LeaveRoomResponse leaveResponse = client.LeaveRoom(leaveRequest);

            Assert.AreEqual(leaveResponse.Status.IsSuccess, true);

            // Ensure that the player has left the game.
            // View open rooms.
            OpenLobbiesResponse openLobbiesResponsAfterLeave = client.GetOpenLobbies(new OpenLobbiesRequest());

            Assert.AreEqual(openLobbiesResponsAfterLeave.Status.IsSuccess, true);
            Assert.AreEqual(1, openLobbiesResponsAfterLeave.Rooms.Count);
            Assert.AreEqual(roomId, openLobbiesResponsAfterLeave.Rooms[0].RoomId);
            Assert.AreEqual(1, openLobbiesResponsAfterLeave.Rooms[0].Players.Count);
        }
Exemplo n.º 21
0
        public void LeaveRoom()
        {
            try
            {
                _sm.Session.RemoveHandler(typeof(MessageErrorPacket), new Session.PacketReceivedDelegate(IncomingMessage));
                _sm.Session.RemoveHandler(typeof(GroupChatMessage), new Session.PacketReceivedDelegate(IncomingMessage));
                _sm.Session.RemoveHandler(typeof(ChangeSubjectMessage), new Session.PacketReceivedDelegate(IncomingMessage));
                _sm.Session.RemoveHandler(typeof(AvailableRequest), new Session.PacketReceivedDelegate(IncomingPresence));
                _sm.Session.RemoveHandler(typeof(ErrorResponse), new Session.PacketReceivedDelegate(IncomingPresence));
                _sm.Session.RemoveHandler(typeof(OccupantAvailableResponse), new Session.PacketReceivedDelegate(IncomingPresence));
                _sm.Session.RemoveHandler(typeof(OccupantUnavailableResponse), new Session.PacketReceivedDelegate(IncomingPresence));

                LeaveRoomRequest l = new LeaveRoomRequest(_occupant);
                _sm.SendAndForget(l);

                if (this.LeftRoom != null)
                    this.LeftRoom(this, new EventArgs());
            }
            catch{}
        }