public void KickerCheck()
{
var table = new List <Card>()
{
new Card(Rank.Four, Suit.Diamonds),
new Card(Rank.Six, Suit.Hearts),
new Card(Rank.Seven, Suit.Diamonds),
new Card(Rank.Jack, Suit.Diamonds),
new Card(Rank.Five, Suit.Diamonds),
};
var hand1 = new List <Card>()
{
new Card(Rank.Seven, Suit.Spades),
new Card(Rank.Ace, Suit.Hearts),
};
var hands = new List <List <Card> >()
{
hand1,
new List <Card>()
{
new Card(Rank.Seven, Suit.Clubs),
new Card(Rank.King, Suit.Spades),
}
};
var winner = WinChecker.WinCheck(table, hands);
Assert.AreEqual(winner.Hands.Count, 1);
Assert.AreEqual(winner.Hands.Single(), hand1);
}
public ActionResult Get(int id)
{
count++;
int x = id / 10 - 1;
int y = id % 10 - 1;
int player = count % 2;
if (Board.board[x, y] == -1)
{
Board.board[x, y] = player;
WinChecker winChecker = new WinChecker();
if (winChecker.Won(player, x, y))
{
return(Ok("You win"));
}
}
else if (count == Board.board.Length)
{
return(Ok("DRAW"));
}
else
{
return(BadRequest("Place already taken"));
}
return(Ok());
}
public void NotDetermineWinnerIfWinConditionsAreNotMet(List<string> board)
{
var checker = new WinChecker();
var isWinner = checker.CheckWinCondition(board);
Assert.False(isWinner);
}
public void DetermineWinnerIfWinConditionsAreMet(List<string> winningBoard)
{
var checker = new WinChecker();
var isWinner = checker.CheckWinCondition(winningBoard);
Assert.True(isWinner);
}
public void IncrementCountIfSameElseReset()
{
const int currentCount = 1;
const int expected = 2;
var winChecker = new WinChecker();
var newCount = winChecker.GetCount(currentCount, 1, 1);
Assert.Equal(newCount, expected);
}
public void ReturnNaughtPlayerAsWinnerWithDiagonal()
{
var winChecker = new WinChecker();
Assert.IsTrue(winChecker.HasPlayerWon(
new[]
{
_, _, O,
_, O, _,
O, _, _
},
PlayerGlyph.Naught));
}
public void ReturnCrossPlayerAsWinnerWithDiagonal()
{
var winChecker = new WinChecker();
Assert.IsTrue(winChecker.HasPlayerWon(
new[]
{
X, _, _,
_, X, _,
_, _, X
},
PlayerGlyph.Cross));
}
public void IdentifyDiagonalStraightFromRightTop()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(2, 2));
moveList.AddMove(new Move(2, 3));
moveList.AddMove(new Move(1, 3));
moveList.AddMove(new Move(3, 1));
bool diagonal3InARow = winChecker.CheckForDiagonalWin(moveList.Moves);
Assert.True(diagonal3InARow);
}
public void IdentifyNotADiagonalWin()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(2, 1));
moveList.AddMove(new Move(2, 3));
moveList.AddMove(new Move(1, 1));
moveList.AddMove(new Move(3, 3));
var diagonal3InARow = winChecker.CheckForDiagonalWin(moveList.Moves);
Assert.False(diagonal3InARow);
}
public void IdentifyADiagonalWinFromLeftTop()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(2, 2));
moveList.AddMove(new Move(2, 3));
moveList.AddMove(new Move(1, 1));
moveList.AddMove(new Move(3, 3));
var didUserWin = winChecker.CheckForWin(moveList);
Assert.True(didUserWin);
}
public void Check_RightToLeftDiagonal()
{
var field = new char[][]
{
new char[] { ' ', ' ', 'X' },
new char[] { ' ', 'X', ' ' },
new char[] { 'X', ' ', ' ' },
};
var expectedWinner = 0;
var actualWinner = WinChecker.Check(field);
Assert.AreEqual(expectedWinner, actualWinner);
}
public void Check_LeftToRightDiagonal_O()
{
var field = new char[][]
{
new char[] { 'O', ' ', ' ' },
new char[] { ' ', 'O', ' ' },
new char[] { ' ', ' ', 'O' },
};
var expectedWinner = 1;
var actualWinner = WinChecker.Check(field);
Assert.AreEqual(expectedWinner, actualWinner);
}
public void Check_EmptyField_NobodyWins()
{
var field = new char[][]
{
new char[] { ' ', ' ', ' ' },
new char[] { ' ', ' ', ' ' },
new char[] { ' ', ' ', ' ' },
};
var expectedWinner = -1;
var actualWinner = WinChecker.Check(field);
Assert.AreEqual(expectedWinner, actualWinner);
}
public void IndenifyThisRandomWin()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(2, 4));
moveList.AddMove(new Move(4, 2));
moveList.AddMove(new Move(1, 3));
moveList.AddMove(new Move(3, 3));
bool diagonal3InARow = winChecker.CheckForDiagonalWin(moveList.Moves);
Assert.True(diagonal3InARow);
}
public void IndentifyAUserDidntWin()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(2, 2));
moveList.AddMove(new Move(2, 3));
moveList.AddMove(new Move(1, 3));
moveList.AddMove(new Move(3, 2));
var didUserWin = winChecker.CheckForWin(moveList);
Assert.False(didUserWin);
}
public void Check_SecondRow()
{
var field = new char[][]
{
new char[] { ' ', ' ', ' ' },
new char[] { 'X', 'X', 'X' },
new char[] { ' ', ' ', ' ' },
};
var expectedWinner = 0;
var actualWinner = WinChecker.Check(field);
Assert.AreEqual(expectedWinner, actualWinner);
}
public void IndentifyAHorizontalWin()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(2, 2));
moveList.AddMove(new Move(2, 3));
moveList.AddMove(new Move(1, 3));
moveList.AddMove(new Move(3, 3));
var didUserWin = winChecker.CheckForWin(moveList);
Assert.True(didUserWin);
}
public void CheckIfListContains3StraightInARow()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(1, 2));
moveList.AddMove(new Move(2, 2));
moveList.AddMove(new Move(1, 1));
moveList.AddMove(new Move(1, 3));
var listOfX = winChecker.AddXCoordinatesIntoSortedList(moveList.Moves);
var result = winChecker.ContainsStraightLine(listOfX);
Assert.True(result);
}
public void PutXCoordinatesIntoASortedIntegerList()
{
var moveList = new MoveList();
var winChecker = new WinChecker();
moveList.AddMove(new Move(1, 2));
moveList.AddMove(new Move(2, 2));
moveList.AddMove(new Move(1, 1));
moveList.AddMove(new Move(1, 3));
var result = winChecker.AddXCoordinatesIntoSortedList(moveList.Moves);
var expectedList = new List <int> {
1, 1, 1, 2
};
Assert.Equal(expectedList, result);
}
private int TestForBestPosition()
{
int[] posis = new int[Length];
for (int x = 0; x < Width; x++)
{
if (WinChecker.DoCheck(field, WinChecker.Directories.Down, ' ', new Vector2i(x, 0)) == Width)
{
posis[x]++;
}
}
for (int y = 0; y < Height; y++)
{
if (WinChecker.DoCheck(field, WinChecker.Directories.Right, ' ', new Vector2i(0, y)) == Height)
{
posis[y]++;
}
}
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
if (x + (Width - 1) < Width && y + (Width - 1) < Height)
{
if (WinChecker.DoCheck(field, WinChecker.Directories.RightDown, ' ', new Vector2i(x, y)) == Width)
{
posis[(x + 1) * (y + 1) - 1]++;
}
}
}
}
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
if (WinChecker.DoCheck(field, WinChecker.Directories.LeftDown, ' ', new Vector2i(x, y)) == Width)
{
posis[(x + 1) * (y + 1) - 1]++;
}
}
}
int ret = -1;
ret = posis.GetHighestIndex();
return(ret);
}
public void CheckIfWon_AnyWinningCombination_ReturnsFalse()
{
// Arrange
var fields = new List <FieldButton>
{
new FieldButton(new Coordinates(1, 1), null, 'X'),
new FieldButton(new Coordinates(2, 1), null, 'Y'),
new FieldButton(new Coordinates(3, 1), null, 'X')
};
var engine = new Mock <GameEngine>();
engine.Setup(en => en.CurrentPlayer).Returns(new Player('X', 1));
var winChecker = new WinChecker(fields, engine.Object);
// Act
var result = winChecker.CheckIfWon();
// Assert
Assert.IsFalse(result);
}
public void UpdateGameState()
{
GameTrace gameTrace = GetCurrentStep();
Vector2Int boardPos = new Vector2Int(gameTrace.x, gameTrace.y);
switch (GameState)
{
case GameState.BlackPlay:
_turn++;
if (WinChecker.CheckWin(_blackPlayTrace, boardPos))
{
_gameState = GameState.BlackWin;
}
else
{
_gameState = GameState.WhitePlay;
}
break;
case GameState.WhitePlay:
_turn++;
if (WinChecker.CheckWin(_whitePlayTrace, boardPos))
{
_gameState = GameState.WhiteWin;
}
else
{
_gameState = GameState.BlackPlay;
}
break;
case GameState.BlackWin:
break;
case GameState.WhiteWin:
break;
}
}
public void TestStraightCheck(int straightSize, bool assertTrue = true)
{
var lowestCards = new List <Card>()
{
new Card(Rank.Ace, Suit.Diamonds)
};
for (var r = Rank.Two; r < Rank.Two + straightSize - 1; r++)
{
lowestCards.Add(new Card(r, Suit.Diamonds));
}
Assert.IsTrue(WinChecker.StraightCheck(lowestCards).straight == assertTrue);
for (var r = Rank.Two; r <= Rank.Ace - straightSize + 1; r++)
{
var cards = new List <Card>();
for (var r2 = r; r2 < r + straightSize; r2++)
{
cards.Add(new Card(r2, Suit.Diamonds));
}
Assert.IsTrue(WinChecker.StraightCheck(cards).straight == assertTrue);
}
}
public void TestFourOfAKind1()
{
var table = new List <Card>()
{
new Card(Rank.Ace, Suit.Diamonds),
new Card(Rank.Ace, Suit.Hearts),
new Card(Rank.Queen, Suit.Diamonds),
new Card(Rank.Jack, Suit.Diamonds),
new Card(Rank.Five, Suit.Diamonds),
};
var hands = new List <List <Card> >()
{
new List <Card>()
{
new Card(Rank.Ace, Suit.Clubs),
new Card(Rank.Ace, Suit.Spades),
}
};
var winner = WinChecker.WinCheck(table, hands);
Assert.AreEqual(WinType.FourOfAKind, winner.WinType);
}
public void TestRoyalFlush()
{
var table = new List <Card>()
{
new Card(Rank.Ace, Suit.Diamonds),
new Card(Rank.King, Suit.Diamonds),
new Card(Rank.Queen, Suit.Diamonds),
new Card(Rank.Jack, Suit.Diamonds),
new Card(Rank.Five, Suit.Diamonds),
};
var hands = new List <List <Card> >()
{
new List <Card>()
{
new Card(Rank.Four, Suit.Diamonds),
new Card(Rank.Ten, Suit.Diamonds),
}
};
var winner = WinChecker.WinCheck(table, hands);
Assert.AreEqual(WinType.RoyalFlush, winner.WinType);
}
public void TestStraight1()
{
var table = new List <Card>()
{
new Card(Rank.Ace, Suit.Hearts),
new Card(Rank.Two, Suit.Diamonds),
new Card(Rank.Queen, Suit.Clubs),
new Card(Rank.Three, Suit.Hearts),
new Card(Rank.Five, Suit.Diamonds),
};
var hands = new List <List <Card> >()
{
new List <Card>()
{
new Card(Rank.Four, Suit.Spades),
new Card(Rank.Ten, Suit.Diamonds),
}
};
var winner = WinChecker.WinCheck(table, hands);
Assert.AreEqual(WinType.Straight, winner.WinType);
}
public void TestHighCard1()
{
var table = new List <Card>()
{
new Card(Rank.Ace, Suit.Diamonds),
new Card(Rank.Six, Suit.Hearts),
new Card(Rank.Seven, Suit.Diamonds),
new Card(Rank.Jack, Suit.Diamonds),
new Card(Rank.Five, Suit.Diamonds),
};
var hands = new List <List <Card> >()
{
new List <Card>()
{
new Card(Rank.Three, Suit.Clubs),
new Card(Rank.Two, Suit.Spades),
}
};
var winner = WinChecker.WinCheck(table, hands);
Assert.AreEqual(WinType.HighCard, winner.WinType);
}
private void Start()
{
ConvertBoardToMultiArray();
DragAndDropController.PlayerMovesAllowed = true;
winchecker = new WinChecker(this);
}
public WinCheckerShould()
{
_winChecker = new WinChecker();
_board = new Board();
}
static void Main()
{
var isNewGame = true;
while (isNewGame)
{
var game = new GameSetup();
var checker = new WinChecker();
var computerPlayer = new ComputerPlayer("x");
var humanPlayer = new HumanPlayer("o");
var moveValidator = new PlayerMoveValidator();
//var solver = new Solver();
var renderer = new Renderer();
var board = game.NewBoard();
while (!game.IsFinished(board))
{
if (checker.CheckWinCondition(board) || game.IsFinished(board))
{
Console.WriteLine(renderer.Render(board));
break;
}
//var solve = solver.Solve(board);
var computerMove = computerPlayer.Move(board);
Console.WriteLine("Computer (x) moves at " + computerMove);
if (checker.CheckWinCondition(board) || game.IsFinished(board))
{
Console.WriteLine(renderer.Render(board));
break;
}
Console.WriteLine(renderer.Render(board));
Console.WriteLine("To make a move, please enter a number from 0-8");
var userInput = Console.ReadLine();
var validInput = game.IsValidInput(userInput);
ValidInputPrompt(game, ref userInput, ref validInput, board, renderer);
var userMove = Convert.ToInt32(userInput);
while (!moveValidator.IsValidMove(board, userMove))
{
Console.WriteLine("Sorry invalid move, please choose an empty space");
Console.WriteLine(renderer.Render(board));
userInput = Console.ReadLine();
validInput = game.IsValidInput(userInput);
ValidInputPrompt(game, ref userInput, ref validInput, board, renderer);
userMove = Convert.ToInt32(userInput);
}
userMove = Convert.ToInt32(userInput);
humanPlayer.Move(board);
Console.WriteLine("player (o) at " + userInput);
}
if (game.IsFinished(board))
{
Console.WriteLine("Draw!");
}
if (checker.CheckWinCondition(board))
{
Console.WriteLine("Winner!");
}
Console.WriteLine("Play again? y/n");
var gamePlayIntent = Console.ReadLine();
isNewGame = gamePlayIntent == "y";
}
}
