public void GuessWordOutOfTime()
{
//prep auth
string username = "******";
GameSessionModel gameSessionModel = new GameSessionModel()
{
Guesses = 5, Score = 10, LastGuess = new DateTime(2001, 10, 10)
};
var mockContext = new Mock <HttpContext>(MockBehavior.Strict);
mockContext.SetupGet(hc => hc.User.Identity.Name).Returns(username);
_gameController.ControllerContext = new ControllerContext()
{
HttpContext = mockContext.Object
};
_gameService.Setup(gs => gs.RetrieveGameSessionModelByUsername(username))
.Returns(gameSessionModel);
_gameService.Setup(gs => gs.GameOver(gameSessionModel)).Returns(false);
_gameService.Setup(gs => gs.InTime(gameSessionModel)).Returns(false);
OkObjectResult result = _gameController.GuessWord(new GuessWriteDto()) as OkObjectResult;
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual("You've waited too long your guess counter has been incremented please try again.", result.Value);
}
public void GuessWordNonMathingWordLengths()
{
string username = "******";
GameSessionModel gameSessionModel = new GameSessionModel()
{
Guesses = 5, Score = 10, LastGuess = DateTime.Now
};
GuessWriteDto guess = new GuessWriteDto()
{
Guess = "guess"
};
var mockContext = new Mock <HttpContext>(MockBehavior.Strict);
mockContext.SetupGet(hc => hc.User.Identity.Name).Returns(username);
_gameController.ControllerContext = new ControllerContext()
{
HttpContext = mockContext.Object
};
_gameService.Setup(gs => gs.RetrieveGameSessionModelByUsername(username))
.Returns(gameSessionModel);
_gameService.Setup(gs => gs.GameOver(gameSessionModel)).Returns(false);
_gameService.Setup(gs => gs.InTime(gameSessionModel)).Returns(true);
_gameService.Setup(gs => gs.MatchingWordLengths(gameSessionModel, guess.Guess)).Returns(false);
OkObjectResult result = _gameController.GuessWord(guess) as OkObjectResult;
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual("Your guessed word and the current word do not match in length.", result.Value);
}
public void CreateNewGameForUserTestNotFromDb()
{
//Using AAA template once to display understanding and usage won't be portrayed this way in future tests.
//Arrange
GameSessionModel game = new GameSessionModel()
{
Guesses = 0
};
_gameRepo.Setup(repo => repo.GetCurrentGame("username")).Returns((GameSessionModel)null);
_userService.Setup(service => service.GetUserByUsername("username"))
.Returns(new UserModel()
{
Username = "******"
});
_wordsRepo.Setup(repo => repo.GetFiveLetterWord()).Returns(new FiveLetterWordModel()
{
Word = "about"
});
_gameRepo.Setup(repo => repo.SaveChanges()).Returns(true);
//Act
int newGuesses = _gameService.CreateNewGameForUser("user").Guesses;
//Assert.
Assert.AreEqual(game.Guesses, newGuesses);
}
public void GuessWordGameOver()
{
//prep auth
string username = "******";
GameSessionModel gameSessionModel = new GameSessionModel()
{
Guesses = 5, Score = 10
};
var mockContext = new Mock <HttpContext>(MockBehavior.Strict);
mockContext.SetupGet(hc => hc.User.Identity.Name).Returns(username);
_gameController.ControllerContext = new ControllerContext()
{
HttpContext = mockContext.Object
};
_gameService.Setup(gs => gs.RetrieveGameSessionModelByUsername(username))
.Returns(gameSessionModel);
_gameService.Setup(gs => gs.GameOver(gameSessionModel)).Returns(true);
OkObjectResult result = _gameController.GuessWord(new GuessWriteDto()) as OkObjectResult;
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual("You've reached the maximum ammount of guesses please create a new game and try again." + $"\n You're score this game was {gameSessionModel.Score}", result.Value);
}
public void ServerBroadcastWeaponSwitched(string weaponName, string roomName)
{
GameSessionModel session = GameSessionManagerModel.Instance.GameSessionCollection.Find(m => m.Name == roomName);
if (session != null)
{
PlayerInSessionModel playerInGame = session.PlayersInSession.Find(m => m.Player.ConnectionId == Context.ConnectionId);
if (playerInGame != null)
{
//TODO: move strings to Consts
switch (weaponName)
{
case "acorn":
playerInGame.CurrentWeapon = Weapons.Acorn;
break;
case "pineCone":
playerInGame.CurrentWeapon = Weapons.PineCone;
break;
default:
playerInGame.CurrentWeapon = Weapons.Acorn;
break;
}
}
}
}
public int GetNewWordForGame(GameSessionModel currentgame)
{
int points = 0;
switch (currentgame.Currentword.Length)
{
case 5:
currentgame.Currentword = _wordsRepo.GetSixLetterWord().Word;
points = 1;
break;
case 6:
currentgame.Currentword = _wordsRepo.GetSevenLetterWord().Word;
points = 3;
break;
case 7:
currentgame.Currentword = _wordsRepo.GetFiveLetterWord().Word;
points = 5;
break;
}
currentgame.Score = currentgame.Score + points;
currentgame.Guesses = 0;
currentgame.LastGuess = DateTime.Now;
_gameRepo.UpdateGameSession(currentgame);
_gameRepo.SaveChanges();
return(currentgame.Currentword.Length);
}
public void IncreaseGuessTest()
{
GameSessionModel model = initObject();
model.IncreaseGuess();
Assert.AreEqual(model.Guesses, 1);
}
public bool IncrementGuessCounter(GameSessionModel currentgame)
{
currentgame.IncreaseGuess();
_gameRepo.UpdateGameSession(currentgame);
_gameRepo.SaveChanges();
return(GameOver(currentgame));
}
private GameSessionModel initObject()
{
GameSessionModel model = new GameSessionModel();
model.Guesses = 0;
model.LastGuess = DateTime.Now;
return(model);
}
public bool InTime(GameSessionModel currentgame)
{
bool intime = currentgame.GuessedIntime(DateTime.Now);
currentgame.LastGuess = DateTime.Now;
_gameRepo.UpdateGameSession(currentgame);
_gameRepo.SaveChanges();
return(intime);
}
public bool GameOver(GameSessionModel currentgame)
{
bool over = currentgame.Guesses >= 5;
if (over)
{
_highScoreService.AddNewHighScore(new HighScoreModel(currentgame.Score, currentgame.Player.Username));
}
return(over);
}
public IActionResult CreateNewGameSession()
{
GameSessionModel created = _gameService.CreateNewGameForUser(User.Identity.Name);
if (created != null)
{
return(Ok(_mapper.Map <GameSessionDtoRead>(created)));
}
return(BadRequest());
}
public void GuessWordHappyTest()
{
//prep auth
string username = "******";
GameSessionModel gameSession = new GameSessionModel()
{
Currentword = "word", Guesses = 3, LastGuess = DateTime.Now, Player = new UserModel(), Score = 5
};
GuessWriteDto guessWrite = new GuessWriteDto()
{
Guess = "word"
};
int newWordLength = 5;
var mockContext = new Mock <HttpContext>(MockBehavior.Strict);
mockContext.SetupGet(hc => hc.User.Identity.Name).Returns(username);
_gameController.ControllerContext = new ControllerContext()
{
HttpContext = mockContext.Object
};
_gameService.Setup(gs => gs.RetrieveGameSessionModelByUsername(username)).Returns(gameSession);
_gameService.Setup(gs => gs.GameOver(gameSession)).Returns(false);
_gameService.Setup(gs => gs.InTime(gameSession)).Returns(true);
_gameService.Setup(gs => gs.MatchingWordLengths(gameSession, "word")).Returns(true);
_gameService.Setup(gs => gs.AttemptGuess(gameSession, guessWrite.Guess)).Returns(new List <List <char> >()
{
new List <char>()
{
'a', 'a'
}, new List <char>()
{
'a', 'a'
}
});
_gameService.Setup(gs => gs.CorrectGuess(new List <char>()
{
'a', 'a'
})).Returns(true);
_gameService.Setup(gs => gs.GetNewWordForGame(gameSession)).Returns(newWordLength);
OkObjectResult result = _gameController.GuessWord(guessWrite) as OkObjectResult;
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual($"Congratulations you've correctly guessed the word! a new {newWordLength} letter word has been selected.", result.Value);
}
public async Task <GameSessionModel> CreateGameSession(Guid invitationId, UserModel invitedBy, UserModel invitedPlayer)
{
var session = new GameSessionModel
{
User1 = invitedBy,
User2 = invitedPlayer,
Id = invitationId,
ActiveUser = invitedBy
};
_sessions.Add(session);
return(session);
}
public Task <GameSessionModel> CreateGameSession(Guid invitationId, UserModel invitedBy, UserModel invitedPlayer)
{
GameSessionModel session = new GameSessionModel
{
User1 = invitedBy,
User2 = invitedPlayer,
Id = invitationId,
ActiveUser = invitedBy
};
_sessions.Add(session);
return(Task.FromResult(session));
}
public IActionResult GuessWord(GuessWriteDto guessWrite)
{
// verify if all valid preconditions are met
GameSessionModel userGame = _gameService.RetrieveGameSessionModelByUsername(User.Identity.Name);
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (userGame == null)
{
return(Conflict("User doesn't currently have any game."));
}
string score = $"\n You're score this game was {userGame.Score}";
if (_gameService.GameOver(userGame))
{
return(Ok("You've reached the maximum ammount of guesses please create a new game and try again." + score));
}
if (!_gameService.InTime(userGame))
{
if (_gameService.IncrementGuessCounter(userGame))
{
return(Ok("You've waited too long your guess counter got incremented to the max ammount of guesses please create a new game" + score));
}
return(Ok("You've waited too long your guess counter has been incremented please try again."));
}
if (!_gameService.MatchingWordLengths(userGame, guessWrite.Guess))
{
return(Ok("Your guessed word and the current word do not match in length."));
}
//progress the actual guess verification here.
List <List <char> > results = _gameService.AttemptGuess(userGame, guessWrite.Guess);
if (_gameService.CorrectGuess(results[1]))
{
return(Ok($"Congratulations you've correctly guessed the word! a new {_gameService.GetNewWordForGame(userGame)} letter word has been selected."));
}
if (!_gameService.CorrectGuess(results[1]))
{
return(Ok(results));
}
return(BadRequest());
}
public async Task <GameSessionModel> CreateGameSession(Guid invitationId, string invitedByEmail, string invitedPlayerEmail)
{
var invitedBy = await _UserService.GetUserByEmail(invitedByEmail);
var invitedPlayer = await _UserService.GetUserByEmail(invitedPlayerEmail);
GameSessionModel session = new GameSessionModel
{
User1 = invitedBy,
User2 = invitedPlayer,
Id = invitationId,
ActiveUser = invitedBy
};
_sessions.Add(session);
return(session);
}
public void ServerBroadcastStartGameFromGameHub(string roomName)
{
GameSessionModel session = GameSessionManagerModel.Instance.GameSessionCollection.Find(m => m.Name == roomName);
if (session == null)
{
return;
}
PlayerInSessionModel playerInGame = session.PlayersInSession.Find(m => m.Player.ConnectionId == Context.ConnectionId);
if (playerInGame == null)
{
return;
}
session.Map[playerInGame.NextPosition.Column, playerInGame.NextPosition.Row].IsTileUncoveredByPlayer[playerInGame.Player.seatNumber - 1] = true;
Clients.Caller.clientReceiveStartGame(playerInGame.NextPosition.Column, playerInGame.NextPosition.Row, playerInGame.Player.seatNumber);
}
private void UpdateOtherPlayerPosition(GameSessionModel session, PlayerInSessionModel playerInGame, PlayerInSessionModel otherPlayer, int col, int row)
{
bool nextTileOtherPlayerUncovered = session.Map[col, row].IsTileUncoveredByPlayer[otherPlayer.Player.seatNumber - 1];
bool prevTileOtherPlayerUncovered = session.Map[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].IsTileUncoveredByPlayer[otherPlayer.Player.seatNumber - 1];
if (nextTileOtherPlayerUncovered)
{
if (!prevTileOtherPlayerUncovered)
{
Clients.Client(otherPlayer.Player.ConnectionId).clientReceiveUpdateOtherPlayerPosition_changeAlphaOtherPlayer(playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row, playerInGame.NextPosition.Column, playerInGame.NextPosition.Row, playerInGame.Player.seatNumber, (.1));
}
else
{
Clients.Client(otherPlayer.Player.ConnectionId).clientReceiveUpdateOtherPlayerPosition(playerInGame.NextPosition.Column, playerInGame.NextPosition.Row, playerInGame.Player.seatNumber);
}
}
else if (!nextTileOtherPlayerUncovered && prevTileOtherPlayerUncovered)
{
Clients.Client(otherPlayer.Player.ConnectionId).clientReceiveUpdateOtherPlayerPosition_changeAlphaOtherPlayer(playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row, playerInGame.NextPosition.Column, playerInGame.NextPosition.Row, playerInGame.Player.seatNumber, -.1);
}
}
public void CreateNewGameForUserTestFromDb()
{
GameSessionModel game = new GameSessionModel()
{
Guesses = 0
};
_gameRepo.Setup(repo => repo.GetCurrentGame("username")).Returns(new GameSessionModel());
_userService.Setup(service => service.GetUserByUsername("username"))
.Returns(new UserModel()
{
Username = "******"
});
_wordsRepo.Setup(repo => repo.GetFiveLetterWord()).Returns(new FiveLetterWordModel()
{
Word = "about"
});
_gameRepo.Setup(repo => repo.SaveChanges()).Returns(true);
Assert.AreEqual(game.Guesses, _gameService.CreateNewGameForUser("username").Guesses);
}
public void ServerBroadcastPlaceTurretOnMap(int col, int row, string roomName)
{
GameSessionModel session = GameSessionManagerModel.Instance.GameSessionCollection.Find(m => m.Name == roomName);
if (session == null)
{
return;
}
PlayerInSessionModel playerInGame = session.PlayersInSession.Find(m => m.Player.ConnectionId == Context.ConnectionId);
if (playerInGame == null)
{
return;
}
//TODO: temporary
if (playerInGame.Player.seatNumber == 0)
{
return;
}
int tile = session.Map[col, row].Tile;
//switch ((TileKind)tile)
//{
// case TileKind.CoveredEmptyTile:
// {
// this.
// }
// case TileKind.UncoveredEmptyTile:
// {
// break;
// }
// default:
// {
// break;
// }
//}
}
/// <summary>
/// method generates a new gameSession instance for the user,
/// if they user has an existing session reset it to a new session.
/// </summary>
/// <param name="Username"></param>
/// <returns>gameSessionModel</returns>
public GameSessionModel CreateNewGameForUser(string Username)
{
// this is used to know wether we need to use the update or the add method as using the
// add method with an existing session will cause a primary key duplicate.
bool fromDb = true;
GameSessionModel gameSession = _gameRepo.GetCurrentGame(Username);
if (gameSession == null)
{
gameSession = new GameSessionModel();
fromDb = false;
}
gameSession.Player = _userService.GetUserByUsername(Username);
gameSession.Currentword = _wordsRepo.GetFiveLetterWord().Word;
gameSession.Guesses = 0;
gameSession.LastGuess = DateTime.Now;
gameSession.Score = 0;
if (fromDb)
{
_gameRepo.UpdateGameSession(gameSession);
_gameRepo.SaveChanges();
}
else
{
_gameRepo.AddGameSession(gameSession);
_gameRepo.SaveChanges();
}
if (_gameRepo.SaveChanges())
{
return(gameSession);
}
return(null);
}
Point three = new Point(142, 143); // bot
public GameSession(Server server, int champ)
{
Champ = champ;
Port = GetPort();
Server = server;
if (GameTimer != null)
{
GameTimer.Dispose();
}
GameTimerTry = 0;
GameTimer = new Timer(GameTimerCallback, null, 1000, Timeout.Infinite);
Logger.Log("Waiting for game to start...");
Server.SetInfoText("Waiting for game to start...");
Server.SetIndicator(IndicatorStates.Wait);
if (champ != 0)
{
items = Game.Champions.GetItems(champ);
}
if (GameState == null || GameState.Started == false)
{
GameState = new GameSessionModel();
}
}
public void ServerBroadcastHealPlayer(string roomName)
{
GameSessionModel session = GameSessionManagerModel.Instance.GameSessionCollection.Find(m => m.Name == roomName);
if (session == null)
{
return;
}
PlayerInSessionModel playerInGame = session.PlayersInSession.Find(m => m.Player.ConnectionId == Context.ConnectionId);
if (playerInGame == null)
{
return;
}
//TODO: temporary
if (playerInGame.Player.seatNumber == 0)
{
return;
}
if (playerInGame.UncoveredMines <= 0)
{
return;
}
int upperDmgLimit = (playerInGame.UncoveredMines * 10) + 10;
int lowerDmgLimit = (playerInGame.UncoveredMines * 5) + 10;
int healPoints = this.random.Next(lowerDmgLimit, upperDmgLimit);
playerInGame.Health += healPoints;
playerInGame.UncoveredMines--;
playerInGame.CurrentWeapon = Weapons.Acorn;
Clients.Client(playerInGame.Player.ConnectionId).clientReceiveHealPlayer(healPoints, playerInGame.Health, playerInGame.UncoveredMines);
}
public void GuessedIntimeTestOutOfTime()
{
GameSessionModel model = initObject();
Assert.IsFalse(model.GuessedIntime(model.LastGuess.AddSeconds(11)));
}
public void GuessedIntimeTestIntime()
{
GameSessionModel model = initObject();
Assert.IsTrue(model.GuessedIntime(model.LastGuess.AddSeconds(5)));
}
private void UpdateOtherPlayerPosition( GameSessionModel session, PlayerInSessionModel playerInGame, PlayerInSessionModel otherPlayer, int col, int row )
{
bool nextTileOtherPlayerUncovered = session.Map[col, row].IsTileUncoveredByPlayer[otherPlayer.Player.seatNumber - 1];
bool prevTileOtherPlayerUncovered = session.Map[playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row].IsTileUncoveredByPlayer[otherPlayer.Player.seatNumber - 1];
if (nextTileOtherPlayerUncovered)
{
if (!prevTileOtherPlayerUncovered)
{
Clients.Client( otherPlayer.Player.ConnectionId ).clientReceiveUpdateOtherPlayerPosition_changeAlphaOtherPlayer( playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row, playerInGame.NextPosition.Column, playerInGame.NextPosition.Row, playerInGame.Player.seatNumber, (.1) );
}
else
{
Clients.Client( otherPlayer.Player.ConnectionId ).clientReceiveUpdateOtherPlayerPosition( playerInGame.NextPosition.Column, playerInGame.NextPosition.Row, playerInGame.Player.seatNumber );
}
}
else if (!nextTileOtherPlayerUncovered && prevTileOtherPlayerUncovered)
{
Clients.Client( otherPlayer.Player.ConnectionId ).clientReceiveUpdateOtherPlayerPosition_changeAlphaOtherPlayer( playerInGame.CurrentPosition.Column, playerInGame.CurrentPosition.Row, playerInGame.NextPosition.Column, playerInGame.NextPosition.Row, playerInGame.Player.seatNumber, -.1 );
}
}
private TileKind PineConeHitsTile( int col, int row, PlayerInSessionModel player, GameSessionModel session, bool isMainPlayer )
{
//map
// 0 = covered tile
// 1 = uncovered tile
// 2 = covered Mine tile
// 3 = uncovered/destroyed Mine tile
// 4 = uncovered/scored Mine tile
// 5 = uncovered mine (not scored) uncovered by pineCone explosion
// 6 = uncovered tile by pineCone explosion
// 7 = coveredTurret
// 8 = uncoveredTurret
int tile = player.PrivateMap[col, row].Tile;
TileKind result;
switch ((TileKind)tile)
{
case TileKind.CoveredEmptyTile:
{
result = TileKind.UncoveredTileByPineConeExplosion;
if (isMainPlayer)
{
player.AmmoPoints += session.Map[col, row].Number;
}
break;
}
case TileKind.UncoveredEmptyTile:
{
result = TileKind.UncoveredTileByPineConeExplosion;
break;
}
case TileKind.CoveredMineTile:
{
result = TileKind.UncoveredMineByPineConeExplosionNotScored;
break;
}
case TileKind.UncoveredDestroyedMineTile:
{
result = TileKind.UncoveredDestroyedMineTile;
break;
}
case TileKind.UncoveredScoredMineTile:
{
result = TileKind.UncoveredScoredMineTile;
break;
}
default:
{
result = TileKind.UncoveredEmptyTile;
break;
}
}
player.PrivateMap[col, row].Tile = (int)result;
session.Map[col, row].IsTileUncoveredByPlayer[player.Player.seatNumber - 1] = true;
return result;
}
public void UpdateGameSession(GameSessionModel gameSession)
{
_context.GameSessions.Update(gameSession);
}
public void AddGameSession(GameSessionModel gameSession)
{
_context.GameSessions.Add(gameSession);
}
public bool MatchingWordLengths(GameSessionModel currentgame, string guessWord)
{
return(currentgame.Currentword.Length == guessWord.Length);
}
private void Shoot( PlayerInSessionModel playerInGame, PlayerInSessionModel opponent, Random rnd, GameSessionModel game )
{
int startCol = playerInGame.CurrentPosition.Column;
int startRow = playerInGame.CurrentPosition.Row;
int endCol = opponent.CurrentPosition.Column;
int endRow = opponent.CurrentPosition.Row;
if (playerInGame.AmmoPoints == 0)
{
playerInGame.IsShooting = false;
RemoveShootingHandler( playerInGame.ShootingQuarterSecondCounter, playerInGame.playerShootingHandler );
playerInGame.ShootingQuarterSecondCounter = 0;
Clients.Client( playerInGame.Player.ConnectionId ).clientReceivePlayerStopsShooting
( opponent.Player.seatNumber );
return;
}
ArrayList tiles;
if (ShootingPathIsClear( startCol, startRow, endCol, endRow, playerInGame.PrivateMap, out tiles ))
{
//TODO: move to separate class/module ie. (Damage Calculation Logic)
int upperBaseDmgLimit = (playerInGame.UncoveredMines * 2) + 10;
int upperDmgLimit = rnd.Next( 0, 9 ) == 9 ? upperBaseDmgLimit + rnd.Next( 1, upperBaseDmgLimit ) : upperBaseDmgLimit;
int lowerDmgLimit = rnd.Next( 0, 2 ) == 0 ? 0 : (playerInGame.UncoveredMines * 2);
int rndDamage = rnd.Next( lowerDmgLimit, upperDmgLimit );
opponent.Health -= rndDamage;
playerInGame.AmmoPoints -= 1;
//TODO: temporary
if (opponent.Health <= 0)
{
game.EndGame = true;
PositionModel uncoveredBulletTile = GetUncoveredBulletTile( tiles, game.Map, playerInGame.UncoveredBulletTile, opponent.Player.seatNumber - 1 );
Clients.Client( playerInGame.Player.ConnectionId ).clientReceivePlayerShootsOtherPlayer( rndDamage, playerInGame.AmmoPoints, opponent.Player.seatNumber, string.Format( "Player {0} has won the game by destroying player {1}. Hail to the king! Congratz {0}.", playerInGame.Player.Name, opponent.Player.Name ) );
Clients.Client( opponent.Player.ConnectionId ).clientReceivePlayerGetsShotByOtherPlayer( rndDamage, opponent.Health, uncoveredBulletTile, string.Format( "Player {0} has won the game by destroying player {1}. Hail to the king! Congratz {0}.", playerInGame.Player.Name, opponent.Player.Name ) );
playerInGame.IsShooting = false;
RemoveShootingHandler( playerInGame.ShootingQuarterSecondCounter, playerInGame.playerShootingHandler );
}
else
{
PositionModel uncoveredBulletTile = GetUncoveredBulletTile( tiles, game.Map, playerInGame.UncoveredBulletTile, opponent.Player.seatNumber - 1 );
Clients.Client( playerInGame.Player.ConnectionId ).clientReceivePlayerShootsOtherPlayer( rndDamage, playerInGame.AmmoPoints, opponent.Player.seatNumber );
Clients.Client( opponent.Player.ConnectionId ).clientReceivePlayerGetsShotByOtherPlayer( rndDamage, opponent.Health, uncoveredBulletTile );
}
}
else
{
playerInGame.IsShooting = false;
RemoveShootingHandler( playerInGame.ShootingQuarterSecondCounter, playerInGame.playerShootingHandler );
Clients.Client( playerInGame.Player.ConnectionId ).clientReceivePlayerStopsShooting
( opponent.Player.seatNumber );
}
}
public List <List <char> > AttemptGuess(GameSessionModel currentgame, string guessWord)
{
IncrementGuessCounter(currentgame);
return(GuessVerifier.CheckResult(currentgame.Currentword, guessWord));
}
