def test_board_trap(self): """Create artificial traps and make pieces fall onto them to check their functionality""" # Start a new board game_board = board.Board(board.WHITE) # Create trap tiles board.Board.tiles[5][0].trap = True # Make a Pawn fall into trap, nothing changes piece: Piece = board.Board.get_piece(Coordinate(6, 0)) self.assertTrue(piece.__class__.__name__ is "Pawn") game_board.move_piece(piece.position, Coordinate(5, 0)) self.assertTrue(piece.__class__.__name__ is "Pawn") # Start a new board game_board = board.Board(board.WHITE) # Create trap tiles board.Board.tiles[5][0].trap = True piece: Piece = board.Board.get_piece(Coordinate(6, 0)) game_board.move_piece(piece.position, Coordinate(4, 0)) # Manually change to our turn and make a Rook fall in the trap game_board.turn = piece.color piece = board.Board.get_piece(Coordinate(7, 0)) self.assertTrue(piece.__class__.__name__ is "Rook") game_board.move_piece(piece.position, Coordinate(5, 0)) self.assertTrue(piece.__class__.__name__ is "Pawn")
def test_rook_movement(self): """Initialize a board, choose a rook piece and check the chess rules work correctly""" game_board = board.Board(board.WHITE) # Start a new board piece: Piece = board.Board.get_piece(Coordinate(7, 0)) self.assertTrue(piece.__class__.__name__ is "Rook") self.assertTrue(piece.position.x == 7) self.assertTrue(piece.position.y == 0) self.assertEqual(piece.color, board.WHITE) # Artificially remove the front pawn out of the way to allow rook movement board.Board.get_piece(Coordinate(6, 0)).active = False # First move, rook can advance forward legal_moves: List[Coordinate] = [ move for move in piece.get_legal_moves() if board.Board.get_piece(move) is None or board.Board.get_piece(move).color != piece.color or board.Board.get_piece(move).active is False ] self.assertIs(len(legal_moves), 6) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(2, 0)) self.assertTrue(piece.position.x == 2) self.assertTrue(piece.position.y == 0) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(2, 7)) self.assertTrue(piece.position.x == 2) self.assertTrue(piece.position.y == 7)
def buildPuzzle(puzzle: str, size: int = 3) -> Board.Board: board = Board.Board(size) data = structPuzzleData(puzzle, size) rows = [board.columns(i) for i in range(size * size)] for r, dr in zip(rows, data): for c, dc in zip(r, dr): if dc != '0': c.setValue(dc) return board
def test_king_movement(self): """Initialize a board, choose a king piece and check the chess rules work correctly""" game_board = board.Board(board.WHITE) # Start a new board piece: Piece = board.Board.get_piece(Coordinate(7, 4)) self.assertTrue(piece.__class__.__name__ is "King") self.assertTrue(piece.position.x == 7) self.assertTrue(piece.position.y == 4) self.assertEqual(piece.color, board.WHITE) # Fake move, king can not move because it is surrounded by other allies legal_moves: List[Coordinate] = [ move for move in piece.get_legal_moves() if board.Board.get_piece(move) is None or board.Board.get_piece(move).color != piece.color or board.Board.get_piece(move).active is False ] self.assertIs(len(legal_moves), 0) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(6, 3)) self.assertTrue(piece.position.x == 7) # Unchanged self.assertTrue(piece.position.y == 4) # Artificially remove the front and side pawns out of the way to allow king movement board.Board.get_piece(Coordinate(6, 3)).active = False board.Board.get_piece(Coordinate(6, 4)).active = False board.Board.get_piece(Coordinate(6, 5)).active = False # First move, king can move diagonally legal_moves = [ move for move in piece.get_legal_moves() if board.Board.get_piece(move) is None or board.Board.get_piece(move).color != piece.color or board.Board.get_piece(move).active is False ] self.assertIs(len(legal_moves), 3) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(6, 3)) self.assertTrue(piece.position.x == 6) self.assertTrue(piece.position.y == 3) # Second move, return home game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(7, 4)) self.assertTrue(piece.position.x == 7) self.assertTrue(piece.position.y == 4) # Third move, try moving forward game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(6, 4)) self.assertTrue(piece.position.x == 6) self.assertTrue(piece.position.y == 4)
def test_pawn_movement(self): """Initialize a board, choose a pawn piece and check the chess rules work correctly""" game_board = board.Board(board.WHITE) # Start a new board piece: Piece = board.Board.get_piece(Coordinate(6, 0)) self.assertTrue(piece.__class__.__name__ is "Pawn") self.assertTrue(piece.position.x == 6) self.assertTrue(piece.position.y == 0) self.assertEqual(piece.color, board.WHITE) # First move, pawn can advance two tiles or one legal_moves: List[Coordinate] = piece.get_legal_moves() self.assertIs(len(legal_moves), 2) game_board.move_piece(piece.position, Coordinate(4, 0)) self.assertTrue(piece.position.x == 4) self.assertTrue(piece.position.y == 0) self.assertTrue(piece.has_moved) # Nor first move, pawn can advance one tile legal_moves = piece.get_legal_moves() self.assertIs(len(legal_moves), 1) # This movement is ignored because after each move the board changes the player in control game_board.move_piece(piece.position, Coordinate(3, 0)) self.assertTrue(piece.position.x == 4) self.assertTrue(piece.position.y == 0) # Manually change to our turn game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(3, 0)) self.assertTrue(piece.position.x == 3) self.assertTrue(piece.position.y == 0) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(2, 0)) self.assertTrue(piece.position.x == 2) self.assertTrue(piece.position.y == 0) # Where are facing a line of pawns not, we can eat one of them legal_moves = piece.get_legal_moves() self.assertIs(len(legal_moves), 1) self.assertIs( board.Board.get_piece(Coordinate(1, 1)).color, board.BLACK) # Eat the pawn in 1, 1 game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(1, 1)) self.assertTrue(piece.position.x == 1) self.assertTrue(piece.position.y == 1) self.assertIs( board.Board.get_piece(Coordinate(1, 1)).color, board.WHITE)
def test_board_constructor(self): """Initialize a new game board and check the all inner data has been stored correctly""" game_board = board.Board(board.WHITE) # Start a new board self.assertEqual(board.WHITE, True) self.assertEqual(board.BLACK, False) self.assertEqual(game_board.turn, board.WHITE) self.assertEqual(game_board.player_side, board.WHITE) self.assertEqual(game_board.rival_side, board.BLACK) self.assertIs(len(game_board.previous_movements), 0) self.assertIs(len(game_board.future_movements), 0) self.assertEqual(game_board.white_king.__class__.__name__, "King") self.assertEqual(game_board.white_king.position, Coordinate(7, 4)) self.assertEqual(game_board.black_king.__class__.__name__, "King") self.assertEqual(game_board.black_king.position, Coordinate(0, 4))
def test_bishop_movement(self): """Initialize a board, choose a bishop piece and check the chess rules work correctly""" game_board = board.Board(board.WHITE) # Start a new board piece: Piece = board.Board.get_piece(Coordinate(7, 2)) self.assertTrue(piece.__class__.__name__ is "Bishop") self.assertTrue(piece.position.x == 7) self.assertTrue(piece.position.y == 2) self.assertEqual(piece.color, board.WHITE) # Artificially remove the front side pawns out of the way to allow bishop movement board.Board.get_piece(Coordinate(6, 1)).active = False board.Board.get_piece(Coordinate(6, 3)).active = False # First move, bishop diagonal legal_moves: List[Coordinate] = [ move for move in piece.get_legal_moves() if board.Board.get_piece(move) is None or board.Board.get_piece(move).color != piece.color or board.Board.get_piece(move).active is False ] self.assertIs(len(legal_moves), 7) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(5, 0)) self.assertTrue(piece.position.x == 5) self.assertTrue(piece.position.y == 0) # Second move, return home game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(7, 2)) self.assertTrue(piece.position.x == 7) self.assertTrue(piece.position.y == 2) # Third move, try the other diagonal game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(2, 7)) self.assertTrue(piece.position.x == 2) self.assertTrue(piece.position.y == 7)
def test_check(self): """ Create a game situation in which one of the kings is in check ('jaque') adn then checkmate ('jaque mate') to test the detection algorithm """ # Start a new board game_board = board.Board(board.WHITE) # Move pawn to let Rook exit piece: Piece = board.Board.get_piece(Coordinate(6, 0)) self.assertTrue(piece.__class__.__name__ is "Pawn") game_board.move_piece(piece.position, Coordinate(4, 0)) # Select rook piece: Piece = board.Board.get_piece(Coordinate(7, 0)) self.assertTrue(piece.__class__.__name__ is "Rook") # Manually change to our turn and make the Rook corner the enemy king game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(5, 0)) self.assertEqual(piece.position.x, 5) self.assertEqual(piece.position.y, 0) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(5, 4)) self.assertEqual(piece.position.x, 5) self.assertEqual(piece.position.y, 4) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(1, 4)) self.assertEqual(piece.position.x, 1) self.assertEqual(piece.position.y, 4) # The black king should be in check game_board.turn = piece.color self.assertTrue(game_board.check_check()) # Move rook backwards to create checkmate game_board.move_piece(piece.position, Coordinate(2, 4)) game_board.turn = piece.color self.assertTrue(game_board.check_checkmate(piece.get_legal_moves()))
def test_knight_movement(self): """Initialize a board, choose a knight piece and check the chess rules work correctly""" game_board = board.Board(board.WHITE) # Start a new board piece: Piece = board.Board.get_piece(Coordinate(7, 1)) self.assertTrue(piece.__class__.__name__ is "Knight") self.assertTrue(piece.position.x == 7) self.assertTrue(piece.position.y == 1) self.assertEqual(piece.color, board.WHITE) # First move, knight can advance in two ways legal_moves: List[Coordinate] = [ move for move in piece.get_legal_moves() if board.Board.get_piece(move) is None or board.Board.get_piece(move).color != piece.color or board.Board.get_piece(move).active is False ] self.assertIs(len(legal_moves), 2) game_board.move_piece(piece.position, Coordinate(5, 0)) self.assertTrue(piece.position.x == 5) self.assertTrue(piece.position.y == 0) self.assertTrue(piece.has_moved) # Manually change to our turn and check available moves game_board.turn = piece.color legal_moves = [ move for move in piece.get_legal_moves() if board.Board.get_piece(move) is None or board.Board.get_piece(move).color != piece.color or board.Board.get_piece(move).active is False ] self.assertIs(len(legal_moves), 3) game_board.move_piece(piece.position, Coordinate(5, 0)) self.assertTrue(piece.position.x == 5) self.assertTrue(piece.position.y == 0)
invalid_command: bool = True print_board: Union[bool, List[str]] = True while invalid_command is True: player_command: str = input(">> Run a command or type 'help' for information: ").lower() results = parse_and_run_command (player_command) invalid_command = results[0] print_board = results[1] if isinstance(print_board, list): # Special case when we are executing code from a file. Run each command. for command in print_board: print ("\t --> {}...".format(command)) parse_and_run_command(command) print ("FINISHED EXECUTING FILE COMMANDS:\n") print (game_board) if print_board is True: if game_board.turn == board.WHITE: print("Turn of " + Fore.BLUE + "white" + Fore.RESET) else: print("Turn of " + Fore.RED + "black" + Fore.RESET) print(game_board) # Beginning of the main script ---------------------------------------------- init() # Allow printing in color player_side: bool = ask_player_side() # Get player side command_prefix: str = "action_" # Define the nomenclature of the methods of the board the user can access game_board: board.Board = board.Board(player_side) # Start a new board run_game(game_board) # Start the interpreter
""" Script to play tic tac toe game """ import sys from board import board b = board.Board() while True: b.display_board() move = int(raw_input("Enter your move\n")) b.place_piece(move) if b.check_win(1): print "Player 0 won!" b.display_board(True) exit() elif b.check_win(-1): print "Player 1 won!" b.display_board(True) exit()
""" Initializes everything """ """ Import libraries """ import sys, pygame """ Import Classes """ from board import board from player import player from game import Game """ Init All The Things! """ # Declarations of game objects board = board.Board() playerW = player.Player("white") playerB = player.Player("black") game = Game({"white": playerW, "black": playerB}, board) # Constants START_X = 60 START_Y = 50 ADJUST = 110 """ Starting output """ """ print("Let's play chess! \n White goes first") while(playerW.lost != False or playerB.lost != False): game.turn() playerW.lost = True """ screen_size = (1000, 1000) screen = pygame.display.set_mode(screen_size) field_size = (800, 800) # field = pygame.display.set_mode(field_size) board = pygame.image.load("images/board.jpg")
def start(): print("Tic-Tac-Toe") try: new_board = board.Board() new_board.make_board(parameters.gridsize) new_locations = location.Locations() new_locations.set_cell_locations(parameters.locations) new_locations.set_winning_combo(parameters.winning_combo) token1 = tokens.Token() player1 = players.Player() player1.set_id(parameters.player1) token1.setType(player1.get_id()) player1.set_token(token1) token2 = tokens.Token() player2 = players.Player() player2.set_id(parameters.player2) token2.setType(player2.get_id()) player2.set_token(token2) except Exception as e: print('Error: ', e) exit(-1) new_board.draw_board() won = False current_player = 1 while won is False: if current_player == player1.get_id(): player_input = input( 'Player 1: Choose a cell in row,column format.\n') else: player_input = input( 'Player 2: Choose a cell in row,column format.\n') player_input = player_input.replace(" ", "") remove_check = new_locations.remove_cell(player_input) while remove_check is False: player_input = input( 'Invalid or location chosen already. Choose a cell in row,column format.\n' ) player_input = player_input.replace(" ", '') remove_check = new_locations.remove_cell(player_input) if current_player == player1.get_id(): new_board.set_board(token1.getType(), player_input) player1.set_player_choices(player_input) new_board.draw_board() won = new_locations.win_check(player1.get_player_choices()) current_player = player2.get_id() else: new_board.set_board(token2.getType(), player_input) player2.set_player_choices(player_input) new_board.draw_board() won = new_locations.win_check(player2.get_player_choices()) current_player = player1.get_id() if won is True: print('Wow you won?!') again = input('Wanna play again? Y or N\n') if again.upper() == 'Y' or again.upper() == 'YES': start() elif again.upper() == 'N' or again.upper() == 'NO': print('Peace dawg.') exit(0)
def test_undo_redo(self): """ Create a game situation in which undoing the previous action may cause one piece to be alive again, etc. and try redoing it as well """ # Start a new board game_board = board.Board(board.WHITE) self.assertFalse(game_board.action_undo()) self.assertFalse(game_board.action_redo()) # Move pawn to let Rook exit and check undo and redo work for just changes in position piece: Piece = board.Board.get_piece(Coordinate(6, 0)) self.assertTrue(piece.__class__.__name__ is "Pawn") game_board.move_piece(piece.position, Coordinate(4, 0)) self.assertEqual(piece.position.x, 4) self.assertEqual(piece.position.y, 0) game_board.action_undo() self.assertEqual(piece.position.x, 6) self.assertEqual(piece.position.y, 0) game_board.action_redo() self.assertEqual(piece.position.x, 4) self.assertEqual(piece.position.y, 0) # Select rook piece: Piece = board.Board.get_piece(Coordinate(7, 0)) self.assertTrue(piece.__class__.__name__ is "Rook") # Manually change to our turn and make the Rook corner the enemy king game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(5, 0)) self.assertEqual(piece.position.x, 5) self.assertEqual(piece.position.y, 0) game_board.turn = piece.color game_board.move_piece(piece.position, Coordinate(5, 4)) self.assertEqual(piece.position.x, 5) self.assertEqual(piece.position.y, 4) # Kill the black pawn game_board.turn = piece.color self.assertEqual(board.Board.tiles[1][4].piece.__class__.__name__, "Pawn") self.assertEqual(board.Board.get_piece(Coordinate(1, 4)).color, board.BLACK) game_board.move_piece(piece.position, Coordinate(1, 4)) self.assertEqual(piece.position.x, 1) self.assertEqual(piece.position.y, 4) self.assertEqual(board.Board.tiles[1][4].piece.__class__.__name__, "Rook") self.assertEqual(board.Board.get_piece(Coordinate(1, 4)).color, board.WHITE) # Undo the movement that killed the pawn game_board.action_undo() self.assertEqual(board.Board.tiles[1][4].piece.__class__.__name__, "Pawn") self.assertEqual(board.Board.get_piece(Coordinate(1, 4)).color, board.BLACK) self.assertEqual(board.Board.tiles[5][4].piece.__class__.__name__, "Rook") self.assertEqual(board.Board.get_piece(Coordinate(5, 4)).color, board.WHITE) # Redo the movement that killed the pawn game_board.action_redo() # The black king should be in check after that move game_board.turn = piece.color self.assertTrue(game_board.check_check())
s = section.Section() s.print() s.rows[0].cols[0].setValue(3) s.print() s.reduce() s.print() l = layout.BoardRow() c = l.columns(0) print(c) b = layout.Board() for i in range(9): start = i row = b.columns(i) for cell in row: cellValue = start % 9 cell.setValue(cellValue + 1) def displaySect(b, row, col): sec1 = b._boardRows[row]._sectionCols[col] sec1.print() displaySect(b, 0, 1)