public void ShouldReturnTrueOnMatch_HasWon(int x, int y)
{
var sut = new GuessModel(y);
sut.GuessNumber(x);
Assert.True(sut.HasWon());
}
public void ShouldReturnActual_GetActual(int m)
{
var sut = new GuessModel(m);
var actual = sut.GetActual();
Assert.Equal(m, actual);
}
public void ShouldReturnFalse_HasWon(int x, int y)
{
var sut = new GuessModel(y);
sut.GuessNumber(x);
Assert.False(sut.HasWon());
}
private static void Play(Game game)
{
var guessService = new GuessService();
GuessResult result = null;
Console.WriteLine($"Gissa ett tal mellan {game.MinRandomNumber} och {game.MaxRandomNumber}");
while (game.GameState == GameState.OnGoing)
{
var guesses = new List <int>();
for (var i = 0; i < game.Players; i++)
{
Console.WriteLine($"Spelare {i + 1} gissar");
guesses.Add(ReadInteger(game.MinRandomNumber, game.MaxRandomNumber));
}
result = guessService.Guess(GuessModel.Create(game, guesses.ToArray()));
if (game.GameState == GameState.OnGoing)
{
Console.WriteLine($"Spelare {result.PlayerId} var närmast");
}
}
Console.WriteLine($"Spelare {result.PlayerId} vann och var närmast {game.CorrectNumber}");
}
public IHttpActionResult Guess(int id, GuessModel model)
{
var userId = this.User.Identity.GetUserId();
var author = this.data.Users.Find(userId);
var newGuess = new Guess
{
UserId = userId,
User = author,
GameId = id,
Number = model.Number,
DateMade = DateTime.Now,
CowsCount = 0,
BullsCount = 0
};
this.data.Guesses.Add(newGuess);
this.data.SaveChanges();
var guessModel = new GuessModel(newGuess);
// Send Notification to the guess maker
string notificationMessage = "You have made new guess (" + model.Number + ") on game №: " + id;
SendNotification(id, userId, "GuessMade", notificationMessage);
return(Ok(guessModel));
}
public async Task <IActionResult> Guess(Guid id, [FromBody] GuessModel guess)
{
try
{
var game = await _store.GetGame(id);
if (game.IsComplete)
{
return(BadRequest("This game has ended"));
}
game.Guesses.Add(guess.Guess);
if (game.GuessMatches(guess.Guess))
{
game.Won = true;
}
else if (game.GuessesCountAsQuestions && game.QuestionsTaken >= game.TotalQuestions)
{
game.Lost = true;
}
await _store.UpdateGame(game);
var response = game.ToResponseModel();
await GameHub.SendUpdate(_clients, id, response);
return(Ok(response));
}
catch (NotFoundException)
{
return(NotFound());
}
}
public ActionResult GameWin()
{
GuessModel model = new GuessModel();
model.Message = "Success! You guessed the random number!";
return(View(model));
}
public ActionResult GameLost()
{
GuessModel model = new GuessModel();
model.Message = "You could not guess the number in 3 attempts. Sorry";
return(View(model));
}
public IActionResult Index(GuessModel model)
{
if (ModelState.IsValid)
{
bool itsRight = _secretWordOptions.Value.SecretWord == model.Word;
ViewData["guess"] = itsRight ? "right" : "wrong";
}
return(View(model));
}
public void ShouldReturnFalseOnMismatch_HasWon(int x, int y, int z, int m)
{
var sut = new GuessModel(m);
sut.GuessNumber(x);
sut.GuessNumber(y);
sut.GuessNumber(z);
Assert.False(sut.HasWon());
}
public void ShouldReturnRemaining_GetRemainingGuesses(int x, int m)
{
var sut = new GuessModel(m);
sut.GuessNumber(x);
var actual = sut.SetRemainingGuesses();
Assert.Equal(10, actual);
}
public HttpResponseMessage MakeGuess(string sessionKey, [FromBody] GuessModel guess)
{
var response = this.PerformOperation(() =>
{
var userId = UsersRepository.LoginUser(sessionKey);
GuessRepository.MakeGuess(userId, guess);
});
return(response);
}
public static GuessModel CreateGuessModel(Guess g)
{
GuessModel model = new GuessModel();
model.Id = g.Id;
model.MatchId = g.MatchId;
model.UserId = g.UserId;
model.HomeScore = g.HomeScore;
model.AwayScore = g.AwayScore;
return(model);
}
public void Guess_ShouldReturnClosestGuest()
{
var rngServiceMock = new Mock <IRngService>();
rngServiceMock.Setup(x => x.Generate(It.IsAny <int>(), It.IsAny <int>())).Returns(10);
IGameFactory gameFactory = new GameFactory(rngServiceMock.Object);
var game = gameFactory.Create(null);
IGuessService guessService = new GuessService();
var result = guessService.Guess(GuessModel.Create(game, 1, 9));
Assert.AreEqual(2, result.PlayerId);
}
/* public members */
public static void MakeGuess(int userId, GuessModel guessModel)
{
ValidateUserNumber(guessModel.Number);
var context = new BullsAndCowsEntities();
using (context)
{
var user = GetUser(userId, context);
var game = GetGame(guessModel.GameId, context);
if (game.GameStatus != context.GameStatuses.First((st) => st.Status == GameStatusInProgress))
{
throw new ServerErrorException("Game is not in progress", "INV_OP_GAME_STAT");
}
ValidateUserInGame(game, user);
var guessNumber = guessModel.Number.ToString();
string otherUserNumber = GetOtherUserNumber(game, user);
int bullsCount, cowsCount;
CountBullsAndCows(guessNumber, otherUserNumber, out bullsCount, out cowsCount);
var guess = new Guess()
{
Bulls = bullsCount,
Cows = cowsCount,
Game = game,
Number = guessModel.Number,
User = user
};
context.Guesses.Add(guess);
var otherUser = (game.RedUser == user) ? game.BlueUser : game.RedUser;
if (bullsCount == UserNumberLength)
{
FinishGame(user, otherUser, game, context);
}
else
{
game.UserInTurn = otherUser.Id;
MessageType guessMadeMessageType = context.MessageTypes.First(mt => mt.Type == MessageTypeGuessMade);
string messageText = string.Format(MessageTextGuessMade, user.Nickname, guessNumber, game.Title);
SendMessage(messageText, otherUser, game, guessMadeMessageType, context);
}
context.SaveChanges();
}
}
public void Guess_TurnsLeftShouldCountDown()
{
var rngServiceMock = new Mock <IRngService>();
rngServiceMock.Setup(x => x.Generate(It.IsAny <int>(), It.IsAny <int>())).Returns(10);
IGameFactory gameFactory = new GameFactory(rngServiceMock.Object);
var game = gameFactory.Create(null);
IGuessService guessService = new GuessService();
guessService.Guess(GuessModel.Create(game, 1, 9));
Assert.AreEqual(2, game.TurnsLeft);
}
public void Guess_CorrectGuess_GameStateEqualsCompleted()
{
var rngServiceMock = new Mock <IRngService>();
rngServiceMock.Setup(x => x.Generate(It.IsAny <int>(), It.IsAny <int>())).Returns(10);
IGameFactory gameFactory = new GameFactory(rngServiceMock.Object);
var game = gameFactory.Create(null);
IGuessService guessService = new GuessService();
guessService.Guess(GuessModel.Create(game, 1, 10));
Assert.AreEqual(GameState.Completed, game.GameState);
}
// GET: Home
public ActionResult Index()
{
GuessModel model = new GuessModel();
model.MinValue = 10; //hard coded
model.MaxValue = 20; //hard coded
model.randomNumber = RandomNumberGenertor.RandomNumber(model.MinValue, model.MaxValue);
Session["random"] = model.randomNumber;
model.Message = "Please, input your guess between " + model.MinValue + " and " + model.MaxValue + model.randomNumber;
Session["attempts"] = 0;
return(View(model));
}
public ActionResult Index(GuessModel model)
{
if (model.Guess == (int)Session["random"])
{
return(RedirectToAction("GameWin", "Home"));
}
Session["attempts"] = ((int)Session["attempts"]) + 1;
if ((int)Session["attempts"] == 3)
{
return(RedirectToAction("GameLost", "Home"));
}
model.Message = "Hi, you have " + (3 - (int)Session["attempts"]) + " attempts left.";
return(View(model));
}
public void Guess_AllTurnsUsed_GameStateEqualsCompleted()
{
var rngServiceMock = new Mock <IRngService>();
rngServiceMock.Setup(x => x.Generate(It.IsAny <int>(), It.IsAny <int>())).Returns(10);
IGameFactory gameFactory = new GameFactory(rngServiceMock.Object);
var game = gameFactory.Create(null);
IGuessService guessService = new GuessService();
var turns = game.TurnsLeft;
for (int i = 0; i < turns; i++)
{
guessService.Guess(GuessModel.Create(game, 1, 9));
}
Assert.AreEqual(GameState.Completed, game.GameState);
}
public ActionResult <GameModel> Post(int gameId, GuessModel guess)
{
var letter = guess.Letter.ToUpper();
CurrentGame = gameRepository.Get(gameId);
// is it a valid guess? game still going, letter not guessed before?
var isValidGuessResult = IsValidGuess(letter);
if (isValidGuessResult != null)
{
return(isValidGuessResult);
}
// if letter isn't in word, then increase the number of incorrect guesses
if (!CurrentGame.WordToGuess.Word.ToUpper().Contains(letter))
{
CurrentGame.NrOfIncorrectGuesses++;
}
CurrentGame.GuessedLetters.Add(new GuessedLetterModel {
Letter = letter
});
// has the word been solved?
if (HasWordBeenGuessed())
{
CurrentGame.WordGuessed = true;
}
// note end time if word has been guessed or if this was the final incorrect guess
if (HasWordBeenGuessed() ||
CurrentGame.NrOfIncorrectGuesses == gameConfig.MaxNrOfGuesses)
{
CurrentGame.EndTime = DateTime.Now;
}
gameRepository.Update(CurrentGame);
return(CurrentGame);
}
public GuessResult Guess(GuessModel guessModel)
{
var closestGuess = guessModel.PlayerGuess.OrderBy(x => Math.Abs(guessModel.Game.CorrectNumber - x.Guess))
.FirstOrDefault();
guessModel.Game.TurnsLeft -= 1;
if (guessModel.Game.TurnsLeft == 0)
{
guessModel.Game.GameState = GameState.Completed;
}
if (closestGuess.Guess == guessModel.Game.CorrectNumber)
{
guessModel.Game.GameState = GameState.Completed;
}
return(new GuessResult
{
PlayerId = closestGuess.Id
});
}
/// <summary>
/// Handle thie incoming message, destination from: ReadMessage();
/// </summary>
/// <param name="stringMessage"></param>
private void HandleMessage(string stringMessage)
{
Message message = JsonConvert.DeserializeObject <Message>(stringMessage);
switch (message.Type)
{
case MessageTypes.Inform:
GuessModel guessModel = JsonConvert.DeserializeObject <GuessModel>(message.Data);
DrawHandler.GetInstance().WriteMessage(guessModel.Word);
break;
case MessageTypes.SendDrawing:
DrawPoint drawPoint = JsonConvert.DeserializeObject <DrawPoint>(message.Data);
DrawHandler.GetInstance().DrawLine(drawPoint);
break;
case MessageTypes.NewDrawer:
DrawHandler.GetInstance().CheckDrawer(JsonConvert.DeserializeObject <ClientModel>(message.Data));
break;
case MessageTypes.NewHost:
ClientHandler.GetInstance().SetHost(JsonConvert.DeserializeObject <ClientModel>(message.Data));
break;
case MessageTypes.JoinRoom:
RoomModel room = JsonConvert.DeserializeObject <RoomModel>(message.Data);
ClientHandler.GetInstance().SetRoomname(room.Name);
ClientHandler.GetInstance().SetRoomSize(room.AmountOfPlayers);
break;
case MessageTypes.StartGame:
GameModel gameModel = JsonConvert.DeserializeObject <GameModel>(message.Data);
ClientHandler.GetInstance().SetWordSize(gameModel.LengthOfWord);
ClientHandler.GetInstance().SetRoundLabel(gameModel.CurrentRound);
DrawHandler.GetInstance().HideHostGrid();
DrawHandler.GetInstance().HideWinners();
break;
case MessageTypes.EndGame:
EndGameModel endGameModel = JsonConvert.DeserializeObject <EndGameModel>(message.Data);
ClientHandler.GetInstance().ShowWinners(endGameModel);
ClientHandler.GetInstance().EndGame();
break;
case MessageTypes.GuessWord:
ClientHandler.GetInstance().SetWord(JsonConvert.DeserializeObject <GuessModel>(message.Data).Word);
break;
case MessageTypes.NewRound:
gameModel = JsonConvert.DeserializeObject <GameModel>(message.Data);
ClientHandler.GetInstance().SetWordSize(gameModel.LengthOfWord);
ClientHandler.GetInstance().SetRoundLabel(gameModel.CurrentRound);
DrawHandler.GetInstance().ClearCanvas();
break;
case MessageTypes.UsernameCheck:
bool validName = JsonConvert.DeserializeObject <ClientModel>(message.Data).ValidName;
ClientHandler.GetInstance().CheckUsername(validName);
break;
case MessageTypes.Ping:
this.sendMessage(new Message(MessageTypes.Pong, ""));
break;
default:
break;
}
}
public IHttpActionResult MakeGuess(int id, GuessModel model)
{
var existingGame = this.data.Games.All()
.FirstOrDefault(g => g.Id == id);
if (existingGame.GameState == GameState.Finnished)
{
return(this.BadRequest("You can't join finnished game!"));
}
if (existingGame.GameState == GameState.WaitingForOpponent)
{
return(this.BadRequest("This game hasn't started yet!"));
}
var currentUser = this.data.Users.All().FirstOrDefault(u => u.UserName == this.User.Identity.Name);
var currentUserName = currentUser.UserName;
if (existingGame.Red != currentUserName && existingGame.Blue != currentUserName)
{
return(this.BadRequest("You're not part of this game"));
}
if ((existingGame.Blue == currentUserName && existingGame.GameState != GameState.BlueInTurn) ||
(existingGame.Red == currentUserName && existingGame.GameState != GameState.RedInTurn))
{
return(this.BadRequest("It's not your turn"));
}
if (!this.ValidNumber(model.Number))
{
return(this.BadRequest("The number isn't valid"));
}
var bullsCount = 0;
var cowsCount = 0;
var userInTurn = this.data.Users.All().FirstOrDefault(u => u.UserName == existingGame.Blue);
if (existingGame.Red == currentUserName)
{
var blueNumber = existingGame.BlueNumber;
if (blueNumber != model.Number)
{
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
if (model.Number[i] == blueNumber[j])
{
if (i == j)
{
bullsCount++;
}
else
{
cowsCount++;
}
}
}
}
existingGame.GameState = GameState.BlueInTurn;
}
else
{
bullsCount = 4;
existingGame.GameState = GameState.Finnished;
var winningPlayer = this.data.Users.All().FirstOrDefault(u => u.UserName == existingGame.Red);
var loosingPlayer = this.data.Users.All().FirstOrDefault(u => u.UserName == existingGame.Blue);
var winNotification = CreateWinNotification(existingGame, winningPlayer, loosingPlayer);
var looseNotification = CreateLooseNotification(existingGame, winningPlayer, loosingPlayer);
var scoreWinningPlayer = this.data.Score.All().FirstOrDefault(s => s.UserName == winningPlayer.UserName);
this.WinScore(winningPlayer, scoreWinningPlayer);
var scoreLoosingPlayer = this.data.Score.All().FirstOrDefault(s => s.UserName == loosingPlayer.UserName);
this.LooseScore(loosingPlayer, scoreLoosingPlayer);
this.data.Notifications.Add(winNotification);
this.data.Notifications.Add(looseNotification);
}
}
else
{
var redNumber = existingGame.RedNumber;
if (redNumber != model.Number)
{
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
if (model.Number[i] == redNumber[j])
{
if (i == j)
{
bullsCount++;
}
else
{
cowsCount++;
}
}
}
}
existingGame.GameState = GameState.RedInTurn;
userInTurn = this.data.Users.All().FirstOrDefault(u => u.UserName == existingGame.Red);
}
else
{
bullsCount = 4;
existingGame.GameState = GameState.Finnished;
var winningPlayer = this.data.Users.All().FirstOrDefault(u => u.UserName == existingGame.Blue);
var loosingPlayer = this.data.Users.All().FirstOrDefault(u => u.UserName == existingGame.Blue);
var winNotification = CreateWinNotification(existingGame, winningPlayer, loosingPlayer);
var looseNotification = CreateLooseNotification(existingGame, winningPlayer, loosingPlayer);
var scoreWinningPlayer = this.data.Score.All().FirstOrDefault(s => s.UserName == winningPlayer.UserName);
this.WinScore(winningPlayer, scoreWinningPlayer);
var scoreLoosingPlayer = this.data.Score.All().FirstOrDefault(s => s.UserName == loosingPlayer.UserName);
this.LooseScore(loosingPlayer, scoreLoosingPlayer);
this.data.Notifications.Add(winNotification);
this.data.Notifications.Add(looseNotification);
}
}
var turnNotification = CreateTurnNotification(existingGame, userInTurn);
this.data.Notifications.Add(turnNotification);
var newGuess = new Guess
{
Game = existingGame,
GameId = existingGame.Id,
Number = model.Number,
UserId = currentUser.Id,
DateMade = DateTime.Now,
UserName = currentUser.UserName,
User = currentUser,
BullsCount = bullsCount,
CowsCount = cowsCount
};
this.data.Guesses.Add(newGuess);
this.data.SaveChanges();
var newModel = new GuessResponceModel
{
Id = newGuess.Id,
UserId = newGuess.UserId,
UserName = newGuess.UserName,
GameId = newGuess.GameId,
Number = model.Number,
DateMade = newGuess.DateMade.ToString(),
CowsCount = newGuess.CowsCount,
BullsCount = newGuess.BullsCount
};
return(this.Ok(newModel));
}
public void ShouldReturnFalse_isTooHigh(int x, int y)
{
var sut = new GuessModel(x);
Assert.False(sut.IsTooHigh(y));
}
public void ShouldReturnTrue_isTooHigh(int x)
{
var sut = new GuessModel(x);
Assert.True(sut.IsTooHigh(200));
}
public IHttpActionResult MakeGuess(int id, GuessModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
if (model.Number.ToString().Length != 4)
{
return(this.BadRequest("Please enter number with 4 digits"));
}
if (ContainsDuplicates(model.Number))
{
return(this.BadRequest("Your number should consist of 4 different digits"));
}
var currentGame = this.ApplicationData.Games.Find(id);
if (currentGame.isFinished)
{
return(this.BadRequest("The game has already finished"));
}
var currentUserId = this.User.Identity.GetUserId();
var currentUserColor = currentGame.BluePlayer.Id == currentUserId ? "blue" : "red";
if (currentGame.BluePlayer.Id != currentUserId && currentGame.RedPlayer.Id != currentUserId)
{
return(this.BadRequest("You must be either blue or red player in this game to see details"));
}
if (currentGame.GameState == GameState.BlueInTurn)
{
if (currentUserColor == "red")
{
return(this.BadRequest("It is not your turn"));
}
}
if (currentGame.GameState == GameState.RedInTurn)
{
if (currentUserColor == "blue")
{
return(this.BadRequest("It is not your turn"));
}
}
var guessedNumber = model.Number;
int?enemyPlayerNumber = currentUserColor == "blue" ? currentGame.RedPlayerNumber : currentGame.BluePlayerNumber;
var cows = this.CheckForCows(guessedNumber, enemyPlayerNumber);
var bulls = this.CheckForBulls(guessedNumber, enemyPlayerNumber);
var guess = new Guess
{
UserId = currentUserId,
GameId = currentGame.Id,
Number = model.Number,
DateMade = DateTime.Now,
CowsCount = cows,
BullsCount = bulls
};
if (currentUserColor == "blue")
{
currentGame.BluePlayerGuesses.Add(guess);
if (bulls == 4)
{
currentGame.isFinished = true;
currentGame.BluePlayer.WinsCount++;
currentGame.RedPlayer.LossesCount--;
currentGame.BluePlayer.Rank += 100;
currentGame.RedPlayer.Rank += 15;
currentGame.GameState = GameState.Finished;
}
else
{
currentGame.GameState = GameState.RedInTurn;
}
}
else
{
currentGame.RedPlayerGuesses.Add(guess);
if (bulls == 4)
{
currentGame.isFinished = true;
currentGame.RedPlayer.WinsCount++;
currentGame.BluePlayer.LossesCount--;
currentGame.RedPlayer.Rank += 100;
currentGame.BluePlayer.Rank += 15;
currentGame.GameState = GameState.Finished;
}
else
{
currentGame.GameState = GameState.BlueInTurn;
}
}
var addedGuess = this.ApplicationData.Guesses.Add(guess);
this.ApplicationData.SaveChanges();
model.Id = addedGuess.Id;
model.UserId = addedGuess.UserId;
model.Username = this.User.Identity.Name;
model.GameId = addedGuess.GameId;
model.DateMade = addedGuess.DateMade;
model.CowsCount = addedGuess.CowsCount;
model.BullsCount = addedGuess.BullsCount;
return(Ok(model));
}
public IHttpActionResult MakeGuess(int id, MakeGuessModel guessMade)
{
// Check if the number is valid...no need to continue if it's not;
if (!IsValidNumber(guessMade.Number))
{
return(this.BadRequest("Invalid Number"));
}
// Get the game
var currentGame = this.data.Games.Find(id);
if (currentGame == null)
{
return(this.BadRequest(string.Format(INVALID_ITEM_FORMAT, "game")));
}
// Check if game can be played
if (currentGame.GameState != GameState.InProgress)
{
return(this.BadRequest("This game is not in progress! You can't play in this game!"));
}
// Get the user
var userId = this.userIdProvider.GetUserId();
var currentUser = this.data.Users.Find(userId);
if (currentUser == null)
{
return(this.BadRequest(string.Format(INVALID_ITEM_FORMAT, "user")));
}
// Check if the user is in this game
if (currentUser.UserName != currentGame.Red.UserName && currentUser.UserName != currentGame.Blue.UserName)
{
return(this.BadRequest("This is not your game!"));
}
// Process turn
if (currentGame.PlayerInTurn == PlayerInTurn.Red)
{
if (currentUser.UserName != currentGame.Red.UserName)
{
return(this.BadRequest("It's not your turn!"));
}
var result = CalculateGuessResult(guessMade.Number, currentGame.BluePlayerNumber);
if (result.BullsCount == 4)
{
// Finish the game
currentGame.GameState = GameState.Finished;
// Notifcation for both players
// Blue
var notificationForBlue = new Notification()
{
Message = string.Format("{0} beat you in game \"{1}\"", currentUser.UserName, currentGame.Name),
Game = currentGame,
Type = NotificationType.GameLost,
User = currentGame.Blue,
DateCreated = DateTime.Now,
State = NotificationState.Unread
};
// Calculate Rank
currentGame.Blue.Losses++;
currentGame.Blue.Rank = (currentGame.Blue.Wins * 100) + (currentGame.Blue.Losses * 15);
// Red
var notificationForRed = new Notification()
{
Message = string.Format("You beat {0} in game \"{1}\"", currentGame.Blue.UserName, currentGame.Name),
Game = currentGame,
Type = NotificationType.GameWon,
User = currentGame.Red,
DateCreated = DateTime.Now,
State = NotificationState.Unread
};
// Calculate Rank
currentGame.Red.Wins++;
currentGame.Red.Rank = (currentGame.Red.Wins * 100) + (currentGame.Red.Losses * 15);
this.data.Notifications.Add(notificationForBlue);
this.data.Notifications.Add(notificationForRed);
this.data.SaveChanges();
}
else
{
// Change Turn Notification
var notification = new Notification()
{
Message = string.Format("It is your turn in game \"{0}!\"", currentGame.Name),
Game = currentGame,
Type = NotificationType.YourTurn,
User = currentGame.Blue,
DateCreated = DateTime.Now,
State = NotificationState.Unread
};
this.data.Notifications.Add(notification);
// Change turn
currentGame.PlayerInTurn = PlayerInTurn.Blue;
this.data.SaveChanges();
}
var guessToSave = new Guess()
{
GuessNumber = guessMade.Number,
User = currentUser,
ForGame = currentGame,
BullsCount = result.BullsCount,
CowsCount = result.CowsCount,
DateMade = DateTime.Now,
};
this.data.Guesses.Add(guessToSave);
this.data.SaveChanges();
var guessToReturn = new GuessModel()
{
UserName = currentUser.UserName,
BullsCount = result.BullsCount,
CowsCount = result.CowsCount,
UserId = currentUser.Id,
GameId = currentGame.Id,
DateMade = DateTime.Now,
Number = guessMade.Number
};
return(this.Ok(guessToReturn));
}
else
{
if (currentUser.UserName != currentGame.Blue.UserName)
{
return(this.BadRequest("It's not your turn!"));
}
var result = CalculateGuessResult(guessMade.Number, currentGame.RedPlayerNumber);
if (result.BullsCount == 4)
{
// Finish the game
currentGame.GameState = GameState.Finished;
// Notifcation for both players
// Blue
var notificationForBlue = new Notification()
{
Message = string.Format("{0} beat you in game \"{1}\"", currentUser.UserName, currentGame.Name),
Game = currentGame,
Type = NotificationType.GameLost,
User = currentGame.Red,
DateCreated = DateTime.Now,
State = NotificationState.Unread
};
// Calculate Rank
currentGame.Red.Losses++;
currentGame.Red.Rank = (currentGame.Red.Wins * 100) + (currentGame.Red.Losses * 15);
// Red
var notificationForRed = new Notification()
{
Message = string.Format("You beat {0} in game \"{1}\"", currentGame.Red.UserName, currentGame.Name),
Game = currentGame,
Type = NotificationType.GameWon,
User = currentGame.Blue,
DateCreated = DateTime.Now,
State = NotificationState.Unread
};
// Calculate Rank
currentGame.Blue.Wins++;
currentGame.Blue.Rank = (currentGame.Blue.Wins * 100) + (currentGame.Blue.Losses * 15);
this.data.Notifications.Add(notificationForBlue);
this.data.Notifications.Add(notificationForRed);
this.data.SaveChanges();
}
else
{
// Change Turn Notification
var notification = new Notification()
{
Message = string.Format("It is your turn in game \"{0}!\"", currentGame.Name),
Game = currentGame,
Type = NotificationType.YourTurn,
User = currentGame.Red,
DateCreated = DateTime.Now,
State = NotificationState.Unread
};
this.data.Notifications.Add(notification);
// Change turn
currentGame.PlayerInTurn = PlayerInTurn.Red;
this.data.SaveChanges();
}
var guessToSave = new Guess()
{
GuessNumber = guessMade.Number,
User = currentUser,
ForGame = currentGame,
BullsCount = result.BullsCount,
CowsCount = result.CowsCount,
DateMade = DateTime.Now,
};
this.data.Guesses.Add(guessToSave);
this.data.SaveChanges();
var guessToReturn = new GuessModel()
{
UserName = currentUser.UserName,
BullsCount = result.BullsCount,
CowsCount = result.CowsCount,
UserId = currentUser.Id,
GameId = currentGame.Id,
DateMade = DateTime.Now,
Number = guessMade.Number
};
return(this.Ok(guessToReturn));
}
}
public async Task <GameResultModel> Guess([FromBody] GuessModel model)
{
return(_mapper.Map <Game, GameResultModel>(await _gameAppService.Guess(model.PlayerId, model.GameId, model.Sequence.ToUpper())));
}
