public CheckersGame(string i_player1Name, string i_player2Name, int i_gameBoardSize, eGameMode i_gameMode)
{
m_GameStatus = eGameStatus.ActiveGame;
m_GameMode = i_gameMode;
m_GameBoard = new Board(i_gameBoardSize);
InitializeTeams(i_player1Name, i_player2Name, i_gameMode);
}
private bool checkForQuitting(Player i_playerTurn, Player i_notPlayerTurn)
{
int playerTurnPoint = m_BoardGame.GetPointsOfPlayer(i_playerTurn.GetShapeType());
int NotplayerTurnPoint = m_BoardGame.GetPointsOfPlayer(i_notPlayerTurn.GetShapeType());
bool isValidQuit = (playerTurnPoint <= NotplayerTurnPoint);
if (isValidQuit)
{
if (playerTurnPoint == NotplayerTurnPoint)
{
m_GameStatus = eGameStatus.Draw;
}
else
{
if (i_playerTurn.GetShapeType() == eShapeType.X)
{
m_GameStatus = eGameStatus.Lose;
}
else
{
m_GameStatus = eGameStatus.Winner;
}
i_notPlayerTurn.Points += NotplayerTurnPoint - playerTurnPoint;
}
GameUI.PrintGamePointStatus(this);
}
return(isValidQuit);
}
private void gameOver(eGameStatus i_GameStatus)
{
DialogResult dialogResult = DialogResult.None;
switch (i_GameStatus)
{
case eGameStatus.TIE:
dialogResult = MessageBox.Show(string.Format("Tie!{0}Another Round?", Environment.NewLine), "Damka", MessageBoxButtons.YesNo);
break;
case eGameStatus.WIN_PLAYER1:
dialogResult = MessageBox.Show(string.Format("{0} Won!{1}Another Round?", m_GameController.Player1Name, Environment.NewLine), "Damka", MessageBoxButtons.YesNo);
break;
case eGameStatus.WIN_PLAYER2:
dialogResult = MessageBox.Show(string.Format("{0} Won{1}Another Round?", m_GameController.Player2Name, Environment.NewLine), "Damka", MessageBoxButtons.YesNo);
break;
}
if (dialogResult == DialogResult.Yes)
{
labelPlayer1.Text = string.Format("{0}: {1}", m_GameController.Player1Name, m_GameController.PointsPlayer1);
labelPlayer2.Text = string.Format("{0}: {1}", m_GameController.Player2Name, m_GameController.PointsPlayer2);
}
else if (dialogResult == DialogResult.No)
{
Application.Exit();
}
}
private bool determineNaturalCaseWinningPlayer()
{
bool player1NoAvailableSteps = r_Players[0].IsStepAvailableForPlayer();
bool player2NoAvailableSteps = r_Players[1].IsStepAvailableForPlayer();
bool isGameOverNaturally = false;
if (player1NoAvailableSteps && player2NoAvailableSteps)
{
m_GameStatus = eGameStatus.Draw;
}
else if (player1NoAvailableSteps || player2NoAvailableSteps)
{
if (player1NoAvailableSteps)
{
m_GameStatus = eGameStatus.Player2Win;
}
else
{
m_GameStatus = eGameStatus.Player1Win;
}
}
if (m_GameStatus != eGameStatus.GameOn)
{
isGameOverNaturally = true;
}
return(isGameOverNaturally);
}
public void GetBullsAndCows(List <T> i_Pins, out int o_Bulls, out int o_Cows)
{
o_Bulls = 0;
o_Cows = 0;
for (int i = 0; i < k_LengthOfTheCombination; i++)
{
if (List <T> .Equals(i_Pins[i], m_SecretSequence[i]))
{
o_Bulls++;
}
else if (m_SecretSequence.Contains(i_Pins[i]))
{
o_Cows++;
}
}
m_CurrentGuess++;
if (m_CurrentGuess == m_TotalGuessesToPlay)
{
m_CurrentGameStatus = eGameStatus.Off;
}
if (o_Bulls == k_LengthOfTheCombination)
{
m_CurrentGameStatus = eGameStatus.Off;
m_IsWin = eGameResult.Win;
}
}
public void CheckGameStatus()
{
m_firstPlayer.PlayerPossibleMoves(m_Board);
int PlayerOneMoveCounter = m_firstPlayer.GetPlayerPossibleMoves().Count;
m_opponent.PlayerPossibleMoves(m_Board);
int PlayerTwoMoveCount = m_opponent.GetPlayerPossibleMoves().Count;
if (PlayerOneMoveCounter == 0 && PlayerTwoMoveCount == 0)
{
m_CurrentGameStatus = eGameStatus.Draw;
}
else
{
if (PlayerOneMoveCounter > 0 && PlayerTwoMoveCount == 0)
{
m_CurrentGameStatus = eGameStatus.PlayerOneWin;
}
else
{
if (PlayerOneMoveCounter == 0 && PlayerTwoMoveCount > 0)
{
m_CurrentGameStatus = eGameStatus.PlayerTwoWin;
}
}
}
}
public Game(int i_ChoiseForBoardSize, bool i_IsOpponentComputer, string i_player1Name, string i_player2Name)
{
m_NumberOfGames = 0;
m_IsGameOver = !true;
m_IsMatchOver = !true;
m_GameStatus = Game.eGameStatus.Running;
m_CheckerBoard = new Board(i_ChoiseForBoardSize);
m_IsSecondPlayerComputer = i_IsOpponentComputer;
m_LeadingPlayer = "No Leading Player Yet";
if (i_player1Name == string.Empty)
{
// default value
i_player1Name = "Player 1";
}
if (i_player2Name == string.Empty)
{
// default value
i_player2Name = "Player 2";
}
else if (i_IsOpponentComputer)
{
i_player2Name = "Computer";
}
Player1 = new Player(i_player1Name, !true, 'O', (int)m_CheckerBoard.BoardSize, 1);
Player2 = new Player(i_player2Name, m_IsSecondPlayerComputer, 'X', (int)m_CheckerBoard.BoardSize, 2);
}
public eGameStatus ReturnGameStatus(bool i_Player1Status, bool i_Player2Status)
{
eGameStatus gameStatus = eGameStatus.Ongoing;
//// if both players are able to move then continue game
if (i_Player1Status && i_Player2Status)
{
gameStatus = eGameStatus.Ongoing;
}
else if (i_Player1Status == false && i_Player2Status == false)
{
//// if both players are unable to move then its a draw
gameStatus = eGameStatus.Draw;
}
else if (i_Player1Status == false)
{
//// if the first player is stuck then the second player automatically wins
gameStatus = eGameStatus.PlayerTwoWin;
}
else
{
//// if the second player is stuck then the first player automatically wins (i_Player2Status == false)
gameStatus = eGameStatus.PlayerOneWin;
}
return(gameStatus);
}
private void checkAndUpdateIfGameEnded()
{
bool[] playersHasMoves = new bool[m_Players.Count];
bool hasMovesToDo = false;
for (int i = 0; i < m_Players.Count; i++)
{
if (m_BoardManager.GetLegalMovesOfPlayer(m_Players[i]).Count != 0)
{
playersHasMoves[i] = true;
hasMovesToDo = true;
}
}
if (hasMovesToDo)
{
if (playersHasMoves[0] && !playersHasMoves[1])
{
m_LastWinner = m_Players[0];
updateWinnerScore(m_Players[0], m_Players[1]);
m_GameStatus = eGameStatus.Winner;
}
else if (!playersHasMoves[0] && playersHasMoves[1])
{
m_LastWinner = m_Players[1];
updateWinnerScore(m_Players[1], m_Players[0]);
m_GameStatus = eGameStatus.Winner;
}
}
else
{
m_GameStatus = eGameStatus.Tie;
}
}
public void ResetGame()
{
m_CurrentPlayer = Player1;
Player1.Score = 0;
Player2.Score = 0;
m_GameStatus = eGameStatus.InProcess;
}
/// <summary>
/// updates game result by reading game status and updating winner's game score
/// </summary>
private void updateGameResult(eGameStatus i_GameStatus, char[,] i_CheckersBoard, Player i_FirstPlayer, Player i_SecondPlayer, bool i_DidQuitOccur = false)
{
int score = 0;
if (i_GameStatus == eGameStatus.PlayerOneWin)
{
if (i_DidQuitOccur)
{
score = getGameScore(i_GameStatus, i_CheckersBoard, i_FirstPlayer);
}
else
{
score = getGameScore(i_GameStatus, i_CheckersBoard);
}
i_FirstPlayer.PlayerScore += score;
}
else
{
if (i_DidQuitOccur)
{
score = getGameScore(i_GameStatus, i_CheckersBoard, i_SecondPlayer);
}
else
{
score = getGameScore(i_GameStatus, i_CheckersBoard);
}
i_SecondPlayer.PlayerScore += score;
}
}
private string playFirstMoveOfGame()
{
string currentMoveString = GameUI.GetFirstMoveFromUser(m_Player1, m_BoardGame);
if (GameUI.IsQuitInput(currentMoveString))
{
m_GameStatus = eGameStatus.Draw;
GameUI.PrintGamePointStatus(this);
}
else
{
Move currentMove = getMoveFromString(currentMoveString);
while (!currentMove.CheckIsValidMove(m_Player1.GetShapeType()))
{
GameUI.PrintErrorOfMove(eTypeOfMove.Regular);
currentMoveString = GameUI.GetFirstMoveFromUser(m_Player1, m_BoardGame);
currentMove = getMoveFromString(currentMoveString);
}
currentMove.MoveOnBoard(m_BoardGame);
this.v_Turn = false;
}
return(currentMoveString);
}
public bool Forfeit(out eLastActionStatus o_ActionStatus)
{
const bool v_ForfeitSuccessful = true;
bool isForfeitSuccessful = !v_ForfeitSuccessful;
if (IsGameOver())
{
o_ActionStatus = eLastActionStatus.FailedGameOver;
}
else
{
switch (m_CurrentTurn)
{
case eTurns.Player1:
m_Player2.Score++;
m_GameStatus = eGameStatus.Player2Won;
break;
case eTurns.Player2:
m_Player1.Score++;
m_GameStatus = eGameStatus.Player1Won;
break;
}
o_ActionStatus = eLastActionStatus.Good;
isForfeitSuccessful = v_ForfeitSuccessful;
}
return(isForfeitSuccessful);
}
private void checkGameStatus()
{
List <Move> diagonalMovesOfPlayer1 = m_BoardGame.GetListOfPlayerDiagonalMoves(Player.eShapeType.X);
List <Move> diagonalMovesOfPlayer2 = m_BoardGame.GetListOfPlayerDiagonalMoves(Player.eShapeType.O);
List <Move> jumpsMovesOfPlayer1 = m_BoardGame.GetListOfPlayerJumps(Player.eShapeType.X);
List <Move> jumpsMovesOfPlayer2 = m_BoardGame.GetListOfPlayerJumps(Player.eShapeType.O);
if (diagonalMovesOfPlayer1.Count == 0 && diagonalMovesOfPlayer2.Count == 0 && jumpsMovesOfPlayer1.Count == 0 && jumpsMovesOfPlayer2.Count == 0)
{
this.m_GameStatus = eGameStatus.Draw;
}
else
{
if ((diagonalMovesOfPlayer1.Count == 0 && jumpsMovesOfPlayer1.Count == 0) || (m_BoardGame.GetPointsOfPlayer(m_Player1.GetShapeType()) == 0))
{
this.m_GameStatus = eGameStatus.Lose;
m_Player2.Points = (m_BoardGame.GetPointsOfPlayer(m_Player2.GetShapeType()) - m_BoardGame.GetPointsOfPlayer(m_Player1.GetShapeType()));
}
else
{
if ((diagonalMovesOfPlayer2.Count == 0 && jumpsMovesOfPlayer2.Count == 0) || (m_BoardGame.GetPointsOfPlayer(m_Player2.GetShapeType()) == 0))
{
this.m_GameStatus = eGameStatus.Winner;
m_Player1.Points = (m_BoardGame.GetPointsOfPlayer(m_Player1.GetShapeType()) - m_BoardGame.GetPointsOfPlayer(m_Player2.GetShapeType()));
}
}
}
}
public void InitializeGame(GameConfiguration i_GameConfiguration)
{
m_GameStatus = eGameStatus.None;
m_LastWinner = null;
setPlayers(i_GameConfiguration.PlayerConfigurations);
m_BoardManager = new BoardManager(i_GameConfiguration.BoardSize, m_Players);
}
//// check the whole checkers board (matrix) if any moves are available for both players
public bool IsMovePossible(char[,] i_CheckersBoard, ref eGameStatus io_GameStatus)
{
bool isPlayer1MovePossible = false;
bool isPlayer2MovePossible = false;
bool isMovePossible = true;
//// if each player has at least one move available for them then the game continues
for (int row = 0; row < i_CheckersBoard.GetLength(0); row++)
{
for (int col = 0; col < i_CheckersBoard.GetLength(0); col++)
{
if (isPlayer1MovePossible == false)
{
isPlayer1MovePossible = player1PossibleMove(i_CheckersBoard, row, col);
}
if (isPlayer2MovePossible == false)
{
isPlayer2MovePossible = player2PossibleMove(i_CheckersBoard, row, col);
}
}
}
io_GameStatus = ReturnGameStatus(isPlayer1MovePossible, isPlayer2MovePossible); // update game status if either or both players is/are unable to move
//// returning a false value to signify that at least one player cannot move
if (io_GameStatus != eGameStatus.Ongoing)
{
isMovePossible = false;
}
return(isMovePossible);
}
private void concludeSingleGame(eGameStatus i_GameStatus, ePlayerPosition i_Winner)
{
r_UI.ClearScreen();
r_UI.PrintBoard(m_Board.BoardMatrix);
int player1Points = m_Board.GetPlayerScore(r_Player1.PlayerPosition);
int player2Points = m_Board.GetPlayerScore(r_Player2.PlayerPosition);
switch (i_GameStatus)
{
case eGameStatus.Draw:
r_UI.Draw();
break;
case eGameStatus.Win:
string winner = (r_Player1.PlayerPosition == i_Winner) ? r_Player1.Name : r_Player2.Name;
r_UI.Winning(winner);
break;
case eGameStatus.Forfit:
string forfiter = (r_Player1.PlayerPosition == i_Winner) ? r_Player2.Name : r_Player1.Name;
r_UI.PlayerForfited(forfiter);
break;
}
r_Player1.Points += player1Points;
r_Player2.Points += player2Points;
r_UI.PlayerRecivedPoints(r_Player1.Name, player1Points);
r_UI.PlayerRecivedPoints(r_Player2.Name, player2Points);
r_UI.PointStatus(r_Player1.Name, r_Player1.Points, r_Player2.Name, r_Player2.Points);
}
public void CheckIfMatchIsOver()
{
int numberOfPointToAddToTheWinner;
int winnerNumber = 0; // no winner yet
if (m_Player1.NumberOfActivePieces == 0 || m_Player2.NumberOfActivePieces == 0)
{
if (Player1.NumberOfActivePieces == 0)
{
winnerNumber = m_Player2.PlayerNumber;
}
else
{
winnerNumber = m_Player1.PlayerNumber;
}
m_IsMatchOver = true;
m_GameStatus = eGameStatus.Win;
}
else if ((m_Player1.PossiableMoves.Count == 0 && m_Player1.MustEatMoves.Count == 0) || (m_Player2.PossiableMoves.Count == 0 && m_Player2.MustEatMoves.Count == 0))
{
m_IsMatchOver = true;
if ((m_Player1.PossiableMoves.Count == 0 && m_Player1.MustEatMoves.Count == 0) && (m_Player2.PossiableMoves.Count == 0) && (m_Player2.MustEatMoves.Count == 0))
{
m_GameStatus = eGameStatus.Tie;
}
else if (m_Player1.PossiableMoves.Count == 0 && m_Player1.MustEatMoves.Count == 0)
{
m_GameStatus = eGameStatus.Win;
winnerNumber = m_Player2.PlayerNumber;
}
else
{
m_GameStatus = eGameStatus.Win;
winnerNumber = m_Player1.PlayerNumber;
}
}
if (m_GameStatus == eGameStatus.Win)
{
numberOfPointToAddToTheWinner = CalculateNumberOfPointsToAdd();
if (winnerNumber == m_Player1.PlayerNumber)
{
m_Player1.Score += numberOfPointToAddToTheWinner;
m_LeadingPlayer = m_Player1.Name;
}
else
{
m_Player2.Score += numberOfPointToAddToTheWinner;
m_LeadingPlayer = m_Player2.Name;
}
}
if (m_IsMatchOver == true)
{
m_NumberOfGames++;
}
}
public void NewGame()
{
m_firstPlayer = new Player(m_FirstPlayerName, "X", m_SizeOfBoard);
m_opponent = new Player(m_SecondPlayerName, "O", m_SizeOfBoard);
m_Board = new Board(m_SizeOfBoard, m_firstPlayer.GetPieces(), m_opponent.GetPieces());
m_currentTurn = "X";
m_CurrentGameStatus = eGameStatus.Playing;
}
public void CreateNewRound()
{
m_GameBoard.ClearBoard();
m_GameStatus = eGameStatus.InRound;
m_ActiveTeam = m_Player1;
m_InactiveTeam = m_Player2;
restoreTeams();
}
public CheckersGame(string i_Player1Name, string i_Player2Name, int i_GameBoardSize, eGameMode i_GameMode)
{
m_GameStatus = eGameStatus.ActiveGame;
m_GameMode = i_GameMode;
m_GameBoard = new Board(i_GameBoardSize);
initializeTeams(i_Player1Name, i_Player2Name, i_GameMode);
CreateNewRound();
}
private void quitCurrentPlayerFromGame()
{
int winnerPlayerIndex = getOpponentPlayerIndex();
m_GameStatus = eGameStatus.Winner;
m_LastWinner = m_Players[winnerPlayerIndex];
updateWinnerScore(m_Players[winnerPlayerIndex], m_Players[m_CurrentPlayerIndex]);
}
public GameManager(int i_MaxNumberOfTurns)
{
this.m_UserGuesses = new List <UserGuess>();
this.m_GoalSequence = Generate.GetRandomSequence(k_SequenceLength);
this.m_CurrentTurn = 0;
this.m_MaxNumberOfTurns = i_MaxNumberOfTurns;
this.m_GameStatus = eGameStatus.InProgress;
}
public BullsAndCowsGame()
{
m_BullsAndCowsLogic = new BullsAndCowsLogic(this);
m_BullsAndCowsUI = new BullsAndCowsUI(this);
m_eGameStatus = eGameStatus.NewGame;
r_ComputerRandomWord = m_BullsAndCowsLogic.getRandomWord();
m_eErrorStatus = eErrorStatus.NoError;
m_MinNumberOfGuesses = 4;
m_MaxNumberOfGuesses = 10;
}
public Game(string[] i_UserNames, ushort i_SelectedBoardSize, bool i_IsSecondPlayerAI)
{
bool initializeGameState;
r_Players = new Player[] { new Player(ePlayers.Player1, Constants.HUMAN_PLAYER, i_UserNames[(int)ePlayers.Player1]), new Player(ePlayers.Player2, i_IsSecondPlayerAI, i_UserNames[(int)ePlayers.Player2]) };
r_GameBoard = new Board(i_SelectedBoardSize, r_Players);
m_ActivePlayerReference = r_Players[(int)ePlayers.Player1];
m_GameStatus = eGameStatus.GameOn;
SyncGameState(out initializeGameState);
}
public void ChangePlayerTurn()
{
if (m_GameStatus == eGameStatus.Player1Turn)
{
m_GameStatus = eGameStatus.Player2Turn;
}
else if (m_GameStatus == eGameStatus.Player2Turn)
{
m_GameStatus = eGameStatus.Player1Turn;
}
}
public GameManager(string i_Player1, short i_BoardSize)
{
m_GameStatus = eGameStatus.NotFinished;
v_Turn = true;
m_Player1 = new Player(Player.eShapeType.X, i_Player1, Player.ePlayerType.Person);
m_Player2 = new Player(Player.eShapeType.O, "Computer", Player.ePlayerType.Computer);
m_BoardSize = i_BoardSize;
m_BoardGame = new BoardGame(m_BoardSize);
m_BoardGame.BuildBoard();
m_LegalJumps = new List <Move>();
}
public GameLogic(Player i_Player1, Player i_Player2, eGameMode i_GameMode)
{
r_Player1 = i_Player1;
r_Player2 = i_Player2;
r_GameMode = i_GameMode;
m_AI = null;
m_GameStatus = eGameStatus.InProcess;
m_CurrentPlayer = i_Player1;
m_Board = null;
m_HiddenPairCellsAmount = 0;
}
public eGameStatus CheckingScoreBoard()
{
eGameStatus whoWon = eGameStatus.Tie;
if (m_GameBoard.RedLinkedList.Count != m_GameBoard.YellowLinkedList.Count)
{
whoWon = m_GameBoard.RedLinkedList.Count > m_GameBoard.YellowLinkedList.Count ? eGameStatus.Player1Won : eGameStatus.Player2Won;
}
return(whoWon);
}
private void StartGame()
{
GameInterface.ShowWelcomeMessage();
string PlayerOneName = GameInterface.getPlayerName();
m_size = GameInterface.getBoardSize();
m_PlayerOne = new Player("User", PlayerOneName, ePlayerColor.White); // Create first player
m_PlayerTwo = GameInterface.getOpponent();
m_GameStatus = eGameStatus.Playing;
GameInterface.ShowRulesMessage();
}
