public void TestGetGameBoard() { TicTacToe game = new TicTacToe("Player1", "Player2"); //GameBoard á ekki að vera tómt CollectionAssert.AreNotEqual(game.GameBoard, null); }
public void TestTicTacToeConstructor() { TicTacToe game = new TicTacToe("Testguy", "Testgal"); Assert.IsNotNull(game); //TicTacToe g2; //Assert.IsNull(g2 = new TicTacToe("ble",null),"villa"); // Bera saman upphafsborð, ath hvort smiður búi til rétt borð í upphafi leiks int i = 0; Play[] pArr = {0,0,0,0,0,0,0,0,0}; foreach (var item in pArr) { Assert.AreEqual(game.GameBoard[i], pArr[i]); i++; } // Ath fjölda reita í borði i verður 9 = 10 reitir, einum of mikið. Lykkjan bætir einum við en hættir keyrslu á réttum stað Assert.AreEqual(i, 9); // Ath hvort að vinningsstöður séu réttar í _winningCombinations CollectionAssert.AreEqual(new int[,] { { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 0, 3, 6 }, { 1, 4, 7 }, { 2, 5, 8 }, { 0, 4, 8 }, { 2, 4, 6 } }, game._winningCombinations); }
public void CurrentPlayerPlaceOOnBoard() { TicTacToe controller = new TicTacToe(); int[,] boardArray = controller.CreateBoard(); controller.MakeMove("x", "o", "o", boardArray, 0); Assert.AreEqual(2, boardArray[0, 1]); }
public void NotThrowPlayerNotPlayingGameException_WhenPlayerWhoPlaysIsInTheGame() { var fakeFirstPlayer = new Mock <IPlayer>(); var fakeSecondPlayer = new Mock <IPlayer>(); var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object); Assert.DoesNotThrow(() => game.PlayTurn(fakeFirstPlayer.Object, 1)); }
public void MoveOFail() { var game = new TicTacToe(state); var move = new TicTacToeMove(TicTacToePlayer.O, new TicTacToeCell(0, 1)); var newState = game.MakeMove(move); Assert.IsNull(newState); }
public void ShouldNotMarkTheSameStep() { var game = new TicTacToe(); game.Mark(1, 1); Assert.IsFalse(game.CanMark(1, 1)); game.Mark(1, 1); }
public void testMovingBumpsLevelByOne() { TicTacToe t1 = new TicTacToe(); int level = t1.getLevel(t1.getState()); Assert.assertEquals(0, level); t1.makeMove(0, 0); level = t1.getLevel(t1.getState()); Assert.assertEquals(1, level); }
public void T3NeitherPlayerHasThreeInARow() { TicTacToe ticTacToe = new TicTacToe(); const char expectet = ' '; char actual = ticTacToe.Validate(); Assert.AreEqual(expectet, actual); }
public void TokenAlreadyExists() { state.Cells[1, 1] = TicTacToePlayer.X; var game = new TicTacToe(state); Assert.IsNull(game.State.Winner); Assert.IsNull(game.MakeMove(new TicTacToeMove(TicTacToePlayer.O, new TicTacToeCell(1, 1)))); }
public void playerOMarker() { TicTacToe board = new TicTacToe(); board.CreateBoard(); board.switchPlayer(); board.MakeMove(0); Assert.AreEqual(2, board.newBoard[0]); }
public void SetSecondPlayer() { var fakeFirstPlayer = new Mock <IPlayer>(); var fakeSecondPlayer = new Mock <IPlayer>(); var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object); Assert.AreEqual(game.SecondtPlayer, fakeSecondPlayer.Object); }
static void Main(string[] args) { // Diese Variante des TicTacToe-Spiels nutz Polymporphie mit Hilfe der Schnittstelle ISpieler TicTacToe ttt = new TicTacToe(); ttt.Spieler1 = WaehleSpieler('X'); ttt.Spieler2 = WaehleSpieler('O'); ttt.StarteSpiel(); }
public void CreateGameWhichIsNotOver() { var fakeFirstPlayer = new Mock <IPlayer>(); var fakeSecondPlayer = new Mock <IPlayer>(); var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object); Assert.IsFalse(game.IsOver); }
public void ReturnFalse_WhenAPostionIsAlreadyMarked() { var fakeFirstPlayer = new Mock <IPlayer>(); var fakeSecondPlayer = new Mock <IPlayer>(); var game = new TicTacToe(fakeFirstPlayer.Object, fakeSecondPlayer.Object); game.PlayTurn(fakeFirstPlayer.Object, 1); Assert.IsFalse(game.PlayTurn(fakeFirstPlayer.Object, 1)); }
public void Test_TicTacToe_3x3_P1Win_Diagonal() { gameboard_3x3 = new TicTacToe(3); gameboard_3x3.PlacePiece(0, 0, 1); gameboard_3x3.PlacePiece(1, 1, 1); var result = gameboard_3x3.PlacePiece(2, 2, 1); Assert.AreEqual(1, result); }
public void board_size_is_3x3() { TicTacToe game = new TicTacToe(); int expectedWIDTH = 3; int expectedHEIGHT = 3; Assert.That(TicTacToe.WIDTH, Is.EqualTo(expectedWIDTH)); Assert.That(TicTacToe.HEIGHT, Is.EqualTo(expectedHEIGHT)); }
public void Should_Next_Next_Player() { TicTacToe t = new TicTacToe(); t.Next(); t.Next(); Assert.AreEqual(t.GetCurrentPlayer(), 1); }
static void Main(string[] args) { // Diese Variante des TicTacToe nutzt Polymporhie mit Hilfe der abstrakten Klasse Spieler TicTacToe ttt = new TicTacToe(); ttt.Spieler1 = WaehleSpieler('X'); ttt.Spieler2 = WaehleSpieler('O'); ttt.StarteSpiel(); }
// Use this for initialization void Awake() { audioSrc = GetComponent <AudioSource>(); manager = FindObjectOfType <TicTacToe>(); myRenderer = GetComponent <SpriteRenderer>(); empty = Resources.Load("box", typeof(Sprite)) as Sprite; circled = Resources.Load("boxCircled", typeof(Sprite)) as Sprite; crossed = Resources.Load("boxCrossed", typeof(Sprite)) as Sprite; }
public void Deveria_criar_inteligencia() { return; using (TicTacToe ticTacToe = new TicTacToe('O', 'X')) { ticTacToe.AutomaticPlay(); } }
public void GivenThisNextFullBoard(Table table) { _game = new TicTacToe(_gameManager.Object, null, _fileWriter.Object); var board = new Board(); board.SetFromTable(table); _game.setBoard(board); }
// This is only called when the game is first started public void OnGet() { // We need a game object, becausde the Razor page always // displays what's in the game object's game grid game = new TicTacToe(); // We need to clear out the game grid when we start a new game HttpContext.Session.Clear(); }
public void Test_TicTacToe_3x3_P2Win_Horizontal() { gameboard_3x3 = new TicTacToe(3); gameboard_3x3.PlacePiece(0, 0, 2); gameboard_3x3.PlacePiece(0, 1, 2); var result = gameboard_3x3.PlacePiece(0, 2, 2); Assert.AreEqual(2, result); }
public void WillThrowExceptionIfWinCheckerReturnsNULL() { Mock <IWinChecker> mockChecker = new Mock <IWinChecker>(MockBehavior.Strict); CompositeGame game = new TicTacToe(mockChecker.Object); game.setBoard(new List <List <BoardGame> >()); mockChecker.Setup(x => x.checkForWin(game)).Returns((PlayerColour?)null); game.getWinner(); }
static void Main(string[] args) { var memory = new MemoryRepository(); var output = new ConsoleDisplay(); var input = new ConsoleController(); var game = new TicTacToe(memory, output, input); game.Start(); }
public void TestVerticalWin() { Char[,] board = { { '.', '.', 'O' }, { '.', '.', 'O' }, { '.', '.', 'O' } }; TicTacToe game = new TicTacToe(board); Assert.AreEqual(game.checkWinVertical(), true); }
public void TestHorizontalWin() { Char[,] board = { { 'X', 'X', 'X' }, { '.', '.', '.' }, { '.', '.', '.' } }; TicTacToe game = new TicTacToe(board); Assert.AreEqual(game.checkWinHorizontal(), true); }
public void TestDraw() { Char[,] board = { { 'O', 'X', 'O' }, { 'X', 'X', 'O' }, { 'O', 'O', 'X' } }; TicTacToe game = new TicTacToe(board); Assert.AreEqual(game.checkDraw(), true); }
public void TestDiagonalWinBottomLeftToTopRight() { Char[,] board = { { '.', '.', 'O' }, { '.', 'O', '.' }, { 'O', '.', '.' } }; TicTacToe game = new TicTacToe(board); Assert.AreEqual(game.checkWinDiagonal(), true); }
public void TestValidMove() { Char[,] board = { { '.', 'X', 'O' }, { 'X', 'X', 'O' }, { 'O', 'O', 'X' } }; TicTacToe game = new TicTacToe(board); Assert.AreEqual(game.takeTurn(1, 1, 'X'), true); }
public void spieler_test() { var spieler = TicTacToe.Spieler_festlegen("neu", "A"); Assert.AreEqual(spieler, "X"); spieler = TicTacToe.Spieler_festlegen("A1", "X"); Assert.AreEqual(spieler, "O"); }
public void ValidInputTest() { TicTacToe ticTacToe = new TicTacToe(); Assert.AreEqual(ticTacToe.ValidInput("0"), true); Assert.AreEqual(ticTacToe.ValidInput("1"), true); Assert.AreEqual(ticTacToe.ValidInput("2"), true); Assert.AreEqual(ticTacToe.ValidInput("something else"), false); }
public override void AcademyStep() { TicTacToe game = TicTacToe.Instance; if (game.getWinner() != TicTacToe.DefVal || !game.isPlayable()) { done = true; } }
public void WillReturnEmptyListIfGameIsWon() { TicTacToe game = new TicTacToe(null); game.owner = 0; List <Move> result = game.getAvailableMoves(); Assert.IsTrue(result.Count == 0); }
public static void Main( string [] args ) { TicTacToe T = new TicTacToe(); if( args.Length != 1 ) { T.usage(); } if ((args[0] != "1") & (args[0] != "2")) { T.usage(); } T.turn( args[0] ); }
public void TestSetPlayedSquare() { TicTacToe game = new TicTacToe("Player1", "Player2"); game.SetPlayedSquare(0, "Player1"); game.SetPlayedSquare(8, "Player2"); Play[] temp = new Play[9] { Play.Player1, 0, 0, 0, 0, 0, 0, 0, Play.Player2 }; CollectionAssert.AreEqual(game.GameBoard, temp); }
public void TestCheckIfAvailable() { TicTacToe game = new TicTacToe("Player1", "Player2"); //Kannað hvort gildi sem sett var á ákveðinn stað í myllu sé rétt og á réttum stað game.GameBoard[3] = Play.Player1; game.GameBoard[3] = Play.Player2; //Ath hvort nokkuð hafi verið breytt á reitnum Assert.AreEqual(game.GameBoard[3], Play.Player2); }
public void TestCheckForWinner() { TicTacToe game = new TicTacToe("Player1", "Player2"); // Ath vinningsstöðuna [0, 1, 2] game.PlayAction(game.Player1, 0); Assert.AreEqual(game.CheckForWinner(), null); game.PlayAction(game.Player1, 1); game.PlayAction(game.Player1, 2); Assert.AreEqual(game.Player1.Name, game.CheckForWinner().Name); }
public void ShouldStartNew() { var game = new TicTacToe(); Assert.IsTrue(game.IsNew); game.Mark(1,1); Assert.IsFalse(game.IsNew); game.StartNew(); Assert.IsTrue(game.IsNew); }
public void ShouldPrintGame() { var printMessage = MockRepository.GenerateStub<IPrintMessage>(); var game = new TicTacToe(printMessage); game.Mark(1, 1); game.Mark(2, 2); game.Mark(3, 3); game.Print("|"); printMessage.AssertWasCalled(x => x.Print("X| | \n |O| \n | |X")); }
public void TestPlayAction() { TicTacToe game = new TicTacToe("Player1", "Player2"); //Player1 setur sitt merki á nokkra reiti game.PlayAction(game.Player1, 0); game.PlayAction(game.Player1, 5); game.PlayAction(game.Player1, 6); //Kannað hvort reitirnir sem player1 valdi hafi skilað sér á borðið Assert.AreEqual(game.GameBoard[0], Play.Player1); Assert.AreEqual(game.GameBoard[5], Play.Player1); Assert.AreEqual(game.GameBoard[6], Play.Player1); }
public void testGivenABoardNUmberOfPossibleMovesCalculatedCorrectly() { TicTacToe t3 = new TicTacToe(); Assert.assertEquals(9, t3.getMoves(t3.getState()).size()); Assert.assertEquals("X", t3.getPlayerToMove(t3.getState())); t3.makeMove(t3.getState(), 0, 0); Assert.assertEquals(8, t3.getMoves(t3.getState()).size()); Assert.assertEquals("O", t3.getPlayerToMove(t3.getState())); // try illegal move t3.makeMove(t3.getState(), 0, 0); Assert.assertEquals(8, t3.getMoves(t3.getState()).size()); Assert.assertEquals("O", t3.getPlayerToMove(t3.getState())); t3.makeMove(t3.getState(), 1, 1); Assert.assertEquals(7, t3.getMoves(t3.getState()).size()); Assert.assertEquals("X", t3.getPlayerToMove(t3.getState())); }
public void ShouldCheckIsWinner() { { var game = new TicTacToe(); game.Mark(1, 1); //X game.Mark(2, 1); //O game.Mark(1, 2); //X game.Mark(2, 2); //O game.Mark(1, 3); //X Assert.IsTrue(game.IsWinner("X")); } { var game = new TicTacToe(); game.Mark(1, 1); //X game.Mark(1, 2); //O game.Mark(2, 2); //X game.Mark(2, 3); //O game.Mark(3, 3); //X Assert.IsTrue(game.IsWinner("X")); } { var game = new TicTacToe(); game.Mark(1, 1); //X game.Mark(1, 2); //O game.Mark(2, 3); //X game.Mark(2, 2); //O game.Mark(3, 3); //X game.Mark(3, 2); //O Assert.IsTrue(game.IsWinner("O")); } }
public void testGenerateSuccessors() { TicTacToe t3 = new TicTacToe(); ArrayList successors = t3.getSuccessorStates(t3.getState()); Assert.assertEquals(9, successors.size()); checkSuccessorList(successors, "O", 8); ArrayList successors2 = t3.getSuccessorStates((GameState) successors .get(0)); checkSuccessorList(successors2, "X", 7); ArrayList successors3 = t3.getSuccessorStates((GameState) successors2 .get(0)); checkSuccessorList(successors3, "O", 6); }
public void testMiniMax15() { TicTacToe t1 = new TicTacToe(); t1.makeMove(0, 0); int minimax1 = t1.getMiniMaxValue(t1.getState()); TicTacToe t2 = new TicTacToe(); t2.makeMove(0, 2); int minimax2 = t2.getMiniMaxValue(t2.getState()); TicTacToe t3 = new TicTacToe(); t3.makeMove(2, 0); int minimax3 = t3.getMiniMaxValue(t3.getState()); TicTacToe t4 = new TicTacToe(); int minimax4 = t4.getMiniMaxValue(t4.getState()); t4.makeMove(2, 2); Assert.assertEquals(minimax1, minimax2); }
public void testTerminalStateDetection() { TicTacToe t3 = new TicTacToe(); t3.makeMove(0, 0); t3.makeMove(0, 1); t3.makeMove(0, 2); t3.makeMove(1, 0); t3.makeMove(1, 1); t3.makeMove(1, 2); Assert.assertEquals(1, t3.getMiniMaxValue(t3.getState())); }
public void Mark_ShouldWitnIn3X3() { var game = new TicTacToe(); Assert.IsFalse(game.CanMark(4, 0)); game.Mark(4, 0); }
static void Main() { TicTacToe field = new TicTacToe(); field.InitializeField(); field.Solve(0, 0); Console.WriteLine(TicTacToe.playerXWins); Console.WriteLine(TicTacToe.draws); Console.WriteLine(TicTacToe.playerOWins); }
// // PRIVATE METHODS // private void checkSuccessorList(ArrayList successorList, String playerToMove, int sizeOfSuccessors) { for (int i = 0; i < successorList.size(); i++) { GameState h = (GameState) successorList.get(i); ArrayList successors2 = new TicTacToe().getSuccessorStates(h); Assert.assertEquals(sizeOfSuccessors, successors2.size()); Assert.assertEquals(playerToMove, new TicTacToe() .getPlayerToMove(h)); } }
public void tesMiniMax4() { TicTacToe t3 = new TicTacToe(); Assert.assertEquals(0, t3.getMiniMaxValue(t3.getState())); }
public void Mark_ShouldNotAllowedWithTheGameIsOver() { { var game = new TicTacToe(); game.Mark(1, 1); //X game.Mark(1, 2); //O game.Mark(2, 2); //X game.Mark(2, 3); //O game.Mark(3, 3); //X game.Mark(3, 1); //O Assert.IsTrue(game.IsGameOver()); Assert.IsFalse(game.CanMark(3, 2)); game.Mark(3, 2); } }
public void testCreation() { TicTacToe t3 = new TicTacToe(); Assert.assertEquals(9, t3.getMoves(t3.getState()).size()); Assert.assertEquals("X", t3.getPlayerToMove(t3.getState())); }
public void testAlphaBeta() { TicTacToe t1 = new TicTacToe(); int alphabeta0 = t1.getAlphaBetaValue(t1.getState()); Assert.assertEquals(0, alphabeta0); t1.makeMove(0, 0); int alphabeta1 = t1.getAlphaBetaValue(t1.getState()); Assert.assertEquals(0, alphabeta1); TicTacToe t2 = new TicTacToe(); t2.makeMove(0, 2); int alphabeta2 = t2.getAlphaBetaValue(t2.getState()); Assert.assertEquals(0, alphabeta2); TicTacToe t3 = new TicTacToe(); t3.makeMove(2, 0); int alphabeta3 = t3.getAlphaBetaValue(t3.getState()); Assert.assertEquals(0, alphabeta3); TicTacToe t4 = new TicTacToe(); int alphabeta4 = t4.getAlphaBetaValue(t4.getState()); t4.makeMove(2, 2); Assert.assertEquals(0, alphabeta4); }
/// <summary> /// Plays the game, create new board, asks the user for input /// </summary> private void playGame() { ITicTacToe Ittt = new TicTacToe(user1, user2); Play[] board = Ittt.GetGameBoard(); for (int i = 0; i < board.Length; i++) { DrawGameBoard(board); if (player1ToDo) { GetPlayerInput(user1, Ittt); player1ToDo = false; // koma í veg fyrir að hægt sé að velja sama reit oftar en 1 sinni (player1) player1Move: // goto playerMove if(board[selectedSquare - 1].Equals(Play.NotPlayed)) { board[selectedSquare - 1] = Play.Player1; } else { Console.WriteLine("This square is already selected, please choose another one"); GetPlayerInput(user1, Ittt); goto player1Move; } } else { GetPlayerInput(user2, Ittt); player1ToDo = true; // koma í veg fyrir að hægt sé að velja sama reit oftar en 1 sinni (player2) player2Move: // goto playerMove if (board[selectedSquare - 1].Equals(Play.NotPlayed)) { board[selectedSquare - 1] = Play.Player2; } else { Console.WriteLine("This square is already selected, please choose another one"); GetPlayerInput(user2, Ittt); goto player2Move; } } // Check for a winner or if nobody has yet won at the end of the game var check = Ittt.CheckForWinner(); if (i >= 4 && check != null) { DrawGameBoard(board); Console.WriteLine("Player: {0} won the game! woohoo", check.Name); break; } else if (i == 8) { DrawGameBoard(board); Console.WriteLine("Nobody won the game, booo"); break; } } Console.WriteLine("Do you want to play again? Press N to quit or any other key to continue"); playAgain = Console.ReadKey().KeyChar; }
public void testMiniMax6() { TicTacToe t3 = new TicTacToe(); t3.makeMove(0, 0); t3.makeMove(0, 1); t3.makeMove(0, 2); t3.makeMove(2, 2); t3.makeMove(1, 2); t3.makeMove(2, 1); t3.makeMove(1, 1); Assert.assertEquals(-1, t3.getMiniMaxValue(t3.getState())); }
public void testCalculateUtilityOfABoard() { // game 1 TicTacToe t3 = new TicTacToe(); t3.makeMove(t3.getState(), 0, 0); Assert.assertEquals(0, t3.getUtility(t3.getState())); t3.makeMove(t3.getState(), 2, 2); Assert.assertEquals(0, t3.getUtility(t3.getState())); t3.makeMove(t3.getState(), 2, 0); Assert.assertEquals(0, t3.getUtility(t3.getState())); t3.makeMove(t3.getState(), 1, 0); Assert.assertEquals(0, t3.getUtility(t3.getState())); t3.makeMove(t3.getState(), 0, 2); Assert.assertEquals(0, t3.getUtility(t3.getState())); t3.makeMove(t3.getState(), 0, 1); Assert.assertEquals(0, t3.getUtility(t3.getState())); t3.makeMove(t3.getState(), 1, 1); Assert.assertEquals(1, t3.computeUtility((t3.getState()))); // game 2 TicTacToe t4 = new TicTacToe(); t4.makeMove(t4.getState(), 0, 0); Assert.assertEquals(0, t4.getUtility(t4.getState())); t4.makeMove(t4.getState(), 0, 1); Assert.assertEquals(0, t4.getUtility(t4.getState())); t4.makeMove(t4.getState(), 0, 2); Assert.assertEquals(0, t4.getUtility(t4.getState())); t4.makeMove(t4.getState(), 1, 0); Assert.assertEquals(0, t4.getUtility(t4.getState())); t4.makeMove(t4.getState(), 1, 1); Assert.assertEquals(0, t4.getUtility(t4.getState())); t4.makeMove(t4.getState(), 1, 2); Assert.assertEquals(0, t4.getUtility(t4.getState())); t4.makeMove(t4.getState(), 2, 0); Assert.assertEquals(1, t4.computeUtility(t4.getState())); }
// Use this for initialization void Start () { gm = GameObject.Find ("_GameManager").GetComponent<TicTacToe>(); buttonAnim = this.GetComponentInChildren<Animator> (); }
public void testAlphaBetaMinValueCalculation() { // board x o x , o o x,- x - TicTacToe t = new TicTacToe(); t.makeMove(0, 0); // x t.makeMove(0, 1); // o t.makeMove(0, 2); // x t.makeMove(1, 0); // o t.makeMove(1, 2); // x t.makeMove(1, 1); // o t.makeMove(2, 1); // x int minValue = t.minValue(t.getState(), new AlphaBeta( Integer.MIN_VALUE, Integer.MAX_VALUE)); Assert.assertEquals(0, minValue); }
public void ShouldCheckIfTheGameIsOver() { { var game = new TicTacToe(); game.Mark(1, 1); //X game.Mark(1, 2); //O game.Mark(2, 2); //X game.Mark(2, 3); //O game.Mark(3, 3); //X Assert.IsTrue(game.IsGameOver()); } { var game = new TicTacToe(); game.Mark(1, 1); //X game.Mark(2, 1); //O game.Mark(3, 1); //X game.Mark(2, 2); //O game.Mark(1, 2); //X game.Mark(3, 2); //O game.Mark(2, 3); //X game.Mark(1, 3); //O game.Mark(3, 3); //O Assert.IsTrue(game.IsGameOver()); Assert.IsTrue(game.IsGameDraw()); } }