public IHttpActionResult Join(int id, GameModel model)
{
// MAKE SURE YOU ARE NOT THE CREATOR OF THE GAME!
var currentUserId = this.User.Identity.GetUserId();
var game = this.data.Games
.All()
.Where(g => g.State == GameState.WaitingForOpponent && g.RedPlayerId != currentUserId)
.FirstOrDefault();
if (game == null)
{
return(NotFound());
}
var bluePlayer = this.data.Users.Find(currentUserId);
game.BluePlayerId = currentUserId;
game.BluePlayer = bluePlayer;
game.State = GameState.TurnBlue;
this.data.SaveChanges();
this.Guess(game.Id, new GuessModel {
Number = model.Number
});
var joinGameResultModel = new JoinGameModel(game.Name);
// Send notification to the creator of the game about new player Joining his game
string notificationMessage = bluePlayer.UserName + " joined your game " + game.Name;
SendNotification(game.Id, currentUserId, "GameJoined", notificationMessage);
return(Ok(joinGameResultModel));
}
public async Task JoinGame(JoinGameModel model)
{
var game = _games.Where(g => g.Id == model.GameId).FirstOrDefault();
if (game == null)
{
throw new Exception("Game does not exist");
}
if (game.IsPasswordProtected() && (game.Password != model.GamePassword))
{
throw new Exception("Game password is invalid");
}
if (!game.IsWaitingForSecondPlayer())
{
throw new Exception("Game is in progress or over");
}
if (game.Players[0].UserId == GetUserIdByCurrentConnectionId())
{
throw new Exception("You cannot join your own game");
}
game.SetSecondPlayer(model.UserName, GetUserIdByCurrentConnectionId());
game.Start();
var allPlayersConnections = GetAllConnectionsByUsersIds(game.GetPlayersUsersIds());
await SendMessageToClientsAsync("GameStart", allPlayersConnections, new GameStartMessage());
await SendGamesAwaitingForSecondPlayerToAllClientsAsync();
}
public static void JoinGame(int userId, JoinGameModel gameModel)
{
ValidateGamePassword(gameModel.Password);
ValidateUserNumber(gameModel.Number);
var context = new BullsAndCowsEntities();
using (context)
{
var game = GetGame(gameModel.Id, context);
ValidateOpenGameStatus(game.GameStatus);
if (game.Password != gameModel.Password)
{
throw new ServerErrorException("Incorrect game password", "INV_GAME_AUTH");
}
var blueUser = GetUser(userId, context);
game.BlueUser = blueUser;
game.BlueUserNumber = gameModel.Number;
var fullGameStatus = context.GameStatuses.First(st => st.Status == GameStatusFull);
game.GameStatus = fullGameStatus;
MessageType gameJoinedMessageType = context.MessageTypes.First(mt => mt.Type == MessageTypeGameJoined);
var msgText = string.Format(MessageTextJoinedGame, blueUser.Nickname, game.Title);
SendMessage(msgText, game.RedUser, game, gameJoinedMessageType, context);
context.SaveChanges();
}
}
public bool JoinGame([FromBody] JoinGameModel model)
{
var game = _gameService.GetGame(model.GameId);
game.AddPlayer(model.PlayerId);
return(game.IsRunning);
}
public HttpResponseMessage JoinGame(string sessionKey, [FromBody] JoinGameModel gameModel)
{
var response = this.PerformOperation(() =>
{
var userId = UsersRepository.LoginUser(sessionKey);
GamesRepository.JoinGame(userId, gameModel);
});
return(response);
}
public JsonResult JoinGame(JoinGameModel joinGameModel)
{
try
{
int gameId;
int.TryParse(joinGameModel.GameId, out gameId);
Game = Platform.GetGameInstanceById(gameId);
lock (Game)
{
if (Platform.IsUserLogged())
{
joinGameModel.Nick = User.Identity.Name;
}
joinGameModel.Validate();
Platform.GameAuthentication.CheckGamePassword(gameId, joinGameModel.Password);
if (!Platform.GameAuthentication.HasPermission(gameId))
{
Player player = new Player(joinGameModel.Nick, Permission.TYPE.Normal);
int playerId = Game.AddPlayer(player);
SaveGame(gameId);
Platform.GameAuthentication.AddPermission(gameId, playerId, joinGameModel.Nick, Crypto.HashPassword(joinGameModel.Password), Permission.TYPE.Normal);
}
return(Json(new Result(new { gameId = gameId }).AsSuccess()));
}
}
catch (FormatException)
{
return(Json(new Result(Resources.Errors.InvalidGameId).AsFailure()));
}
catch (Error.ValidationException validation)
{
return(Json(validation.Result));
}
catch (Error.AppError ex)
{
return(Json(new Result(ex.Message).AsFailure()));
}
}
public IHttpActionResult Join(JoinGameModel gameForJoin)
{
var currentUserId = this.userIdProvider.GetUserId();
var game = this.data.Games
.All()
.Where(g => g.Id.ToString() == gameForJoin.GameId && g.FirstPlayerId != currentUserId)
.FirstOrDefault();
if (game == null)
{
return(NotFound());
}
game.SecondPlayerId = currentUserId;
game.State = GameState.TurnX;
this.data.SaveChanges();
return(Ok(game.Id));
}
public async Task <IGame> Leave([FromBody] JoinGameModel model)
{
var player = await _playerService.GetPlayer(model.PlayerId);
if (player == null)
{
throw new PlayerDoesNotExistException(model.PlayerId);
}
var game = await _gameService.GetGame(model.GameCode);
var gameId = game.Id;
var mustCancelRound = !game.CanLeaveWithoutRoundCancellation;
var mustCancelGame = game.Host.Id == model.PlayerId;
var updatedGame = await _gameService.LeaveGame(game, player);
await _gameNotifier.SendPlayerJoined(updatedGame);
if (model.WasKicked)
{
await _gameNotifier.SendPlayerKicked(game.Id, player);
}
if (mustCancelGame)
{
await _gameNotifier.SendGameCancelled(gameId);
}
else if (mustCancelRound)
{
await _gameNotifier.SendRoundCancelled(updatedGame);
}
return(updatedGame);
}
public async Task <ActionResult <IGame> > Join([FromBody] JoinGameModel model)
{
var player = await _playerService.GetPlayer(model.PlayerId);
if (player == null)
{
throw new ApiException("Player does not exist");
}
var game = await _gameService.GetGame(model.GameCode);
try
{
var updatedGame = await _gameService.JoinGame(game, player);
await _gameNotifier.SendPlayerJoined(updatedGame);
return(Ok(updatedGame));
}
catch (PlayerWithSameNameAlreadyExistsException)
{
return(Conflict("Player with same name already exists in this game, please change your name to join."));
}
}
public IHttpActionResult Join(JoinGameModel gameForJoin)
{
var currentUserId = this.userIdProvider.GetUserId();
var game = this.data.Games
.All()
.Where(g => g.Id.ToString() == gameForJoin.GameId && g.FirstPlayerId != currentUserId)
.FirstOrDefault();
if (game == null)
{
return NotFound();
}
game.SecondPlayerId = currentUserId;
game.State = GameState.TurnX;
this.data.SaveChanges();
return Ok(game.Id);
}
public async Task <GameResultModel> JoinGame([FromBody] JoinGameModel model)
{
return(_mapper.Map <Game, GameResultModel>(await _gameAppService.Join(model.Nickname, model.GameId)));
}
