def move_action(self, move_string): # move_string must be of the format 'A3-A5', for piece on A3 moves to A5 start_location, finish_location = move_string.split('-') start_column, start_row = Board.location_string_to_corner( start_location) finish_column, finish_row = Board.location_string_to_corner( finish_location) start_corner = self.board.get_corner(start_column, start_row) if not start_corner.is_occupied(): raise KeyError( "Corner {} is unoccupied, so can't move from here!".format( start_location)) if start_corner.colour_of_occupant() != self.whose_turn: raise KeyError("It's {}'s turn but piece on {} is {}".format( self.whose_turn, start_location, start_corner.colour_of_occupant())) game_continues, losing_team = start_corner.get_occupant().move_piece( finish_column, finish_row) if self.whose_turn == 'red': self.whose_turn = 'black' else: self.whose_turn = 'red' print(self.board) time.sleep(2) return game_continues, losing_team, self.whose_turn, self.board
def print(self): print(f"num q_values = {len(self.cache.boards)}") for cells_bytes, value in self.cache.boards.items(): cells = np.frombuffer(cells_bytes, dtype=int) board = Board(cells) board.print() print(f"qvalue = {value}")
def setUp(self, text=None): random.seed(0) self.board = Board(size=9, batch=5, colsize=None, scrub_length=5, axes=None, logfile=None , drawing_callbacks=dict()) if text: self.board.init_test_graph(text)
def play(self, tetromino_seq): self.tetromino_spawner = TetrominoSpawner(tetromino_seq) for i in range( 1 ): # this range changes the number of times single game is played (more games are better in case of random spawning) self.is_game_over = False # TODO self.board = Board() while not self.is_game_over: # get situation of top two rows situation = self.board.get_situation() # get new tetromino tetromino: Tetromino = self.tetromino_spawner.spawn() rotations_num = self.gene.get_rotation(situation, tetromino.shape_num) tetromino.rotate(times=rotations_num) # check if last row is empty and end if not if not self.board.can_place_next_tetromino(tetromino): self.is_game_over = True break # place tetromino position = self.gene.get_position(situation, tetromino.shape_num) self.board.add_tetromino(tetromino, position) # remove full rows and add score removed_count = self.board.remove_full_rows_and_return_count() self.score += removed_count * 10000 # give 1000 pts for each row self.score += 1 # give score for each dropped tetromino 30 pieces > 1 row
def testAssignNakedSingles(self): board = Board(); board.boardFromString(self.NAKED_SINGLES) # Create a copy of the original board originalBoard = Board(board) easySolver = EasySolver(board) result = easySolver.assignNakedSingles() # Make sure all were assigned assert(result == 4) # Make sure that the board now has the naked singles assigned assert(board.getPosition(0, 8) == '3') assert(board.getPosition(0, 7) == '5') assert(board.getPosition(4, 3) == '6') assert(board.getPosition(6, 6) == '2') # Ensure the only changes to the board are the assigned singles assert(board != originalBoard) for y in xrange(board.getDimensions()): for x in xrange(board.getDimensions()): # Don't bother checking fields we know have changed if not (x, y) in [(0, 8), (0, 7), (4, 3), (6, 6)]: assert(board.getPosition(x, y) == originalBoard.getPosition(x, y))
class FourCornersGame(object): def __init__(self): self._players = [ Player(self, 0), Player(self, 1), Player(self, 2), Player(self, 3) ] self._board = Board(self._players) self._viewer = FourCornersViewer(moveEvent=self.makeMove) self._updateViewer() @property def board(self): return self._board ######################### Move Making ######################### def makeMove(self, piece, top_left_x, top_left_y): self._board.placePiece(piece, top_left_x, top_left_y) self._updateViewer() ######################### Viewer ######################### def mainViewerProcess(self): self._viewer.mainViewerLoop() def _updateViewer(self): self._viewer.updateBoard(self._board)
def __init__(self): super(GraphicsBoard, self).__init__() self.rows = 3 self.cols = 8 self.info_label = Label(text='Welcome!') self.board = Board() self._initialize_board()
def __game_loop(self): """Player moves are handled by this function.""" current_player = self.__player_one other_player = self.__player_two while True: print(self.__board.draw_board(self.__board.board)) player_col_choice = input(f"{current_player.name}, choose a move: ") move_coordinates = self.__board.player_move(current_player, player_col_choice) if not move_coordinates: continue else: win = self.__has_won(current_player, move_coordinates) draw = (not win) and self.__have_drawn() if win or draw: print(self.__board.draw_board(self.__board.board)) if win: print(f"{current_player.name} has won!") current_player.wins = 1 elif draw: print("Game drawn!") if not self.__continue_playing(): print(self.__statistics()) return else: self.__board = Board() else: current_player, other_player = other_player, current_player
class Game: def __init__(self, player_one: Player = None, player_two: Player = None, verbose: bool = True) -> None: self._move_counter = 0 self._board = Board(MAX_ROWS, MAX_COLUMNS) self._players = ( player_one if player_one is not None else Player( SIGN_PLAYER_ONE, 'magenta'), player_two if player_two is not None else Player( SIGN_PLAYER_TWO, 'cyan') ) self._verbose = verbose # WHY Optional[tuple[list, int]] DID NOT WORK? def run(self, return_log_boards: bool = False) -> Optional[tuple]: board_log = [] while(judge.is_game_over(self._board) is not True): current_player = self._players[self._move_counter % 2] self._print(self._board) self._print(' 1 2 3 4 5 6 7') move = current_player.make_move(self._board) - 1 if judge.is_valid_move(self._board, move) is not True: self._print('bad move!') continue self.make_move(current_player, move) if return_log_boards == True: board_log.append(self._board.get_array_by_signs(PLAYER_SIGNS)) self._move_counter += 1 self._print(self._board) board_log = np.array(board_log) if judge.is_winning(self._board, SIGN_PLAYER_ONE): self._print('{} is a winner!'.format(SIGN_PLAYER_ONE)) return (board_log, 1) elif judge.is_winning(self._board, SIGN_PLAYER_TWO): self._print('{} is a winner!'.format(SIGN_PLAYER_TWO)) return (board_log, -1) else: self._print('Draw') return (board_log, 0) def make_move(self, player: Player, column: int): for row in reversed(range(MAX_ROWS)): if self._board.is_empty(column, row): self._board.put_piece(column, row, player.get_piece()) return def _print(self, text: str): if self._verbose == True: print(text)
def test_row(mark): board = Board() board._rows = [[' ', ' ', ' '], [' ', mark, mark], [' ', mark, ' ']] for _ in range(100): player = RandomComputer(mark) row, column = player.turn(board) assert board.is_cell_empty(row, column)
def test_second_turn_center_opening(player_mark): other_mark = Game.FIRST_PLAYER_MARK ai = AI(player_mark) board = Board() board._rows = [[' ', ' ', ' '], [' ', other_mark, ' '], [' ', ' ', ' ']] for _ in range(100): assert ai._second_turn(board.representation()) in product((0, 2), (0, 2))
def __init__(self, upper_player, lower_player): """Instantiate a Mancala game.""" self.board = Board() self._upper_player = upper_player self._lower_player = lower_player self._current_player = self._upper_player
def __init__(self): self.whose_turn = 'red' self.board = Board() self.setup_board(self.board) print(self.board) self.artificial_players = {'red': None, 'black': None}
def is_winning(board: Board, sign: str) -> bool: if board.get_move_counter() < 7: return False board = board.get_array(sign) for kernel in kernels: if (convolve2d(board, kernel, mode='valid') == 4).any(): return True return False
def game(): global MAP_TYPE board = Board(MAP_TYPE) screen = board.display_board_hide() width_pressed, height_pressed = 0, 0 posX_pressed, posY_pressed = 0, 0 running, r_pressed, escape_pressed = True, False, False while running: try: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False pygame.quit() quit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_r: r_pressed = True running = False elif event.key == pygame.K_ESCAPE: escape_pressed = True running = False main() if not board.visible: if event.type == pygame.MOUSEBUTTONUP: button_pressed = board.matrix[posY_pressed][ posX_pressed] board.action(button_pressed, event, screen) elif event.type == pygame.MOUSEBUTTONDOWN: width_pressed = event.pos[0] height_pressed = event.pos[1] posX_pressed = int(width_pressed / 40) posY_pressed = int(height_pressed / 40) button_pressed = board.matrix[posY_pressed][ posX_pressed] if button_pressed.content.status_celd() == "Invisible": pic = picture.get_picture(0) pic = pygame.transform.scale( pic, (button_pressed.width, button_pressed.height)) screen.blit(pic, (button_pressed.x, button_pressed.y)) pygame.display.flip() except pygame.error: pass if r_pressed: game() if escape_pressed: main()
def __init__(self, host, port): self.HANDLER = Handler self.board = Board(7, 7) asyncore.dispatcher.__init__(self) self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.bind((host, port)) self.listen(5) print('Waiting for connection...') self.connections = []
def main(): root = Tk() root.title("Othello") root.geometry("800x800") b = Board() b.init_board('init.csv') g = GuiBoard(board=b, master=root) g.display_gui_board() root.mainloop()
def __init__(self, player_one: Player = None, player_two: Player = None, verbose: bool = True) -> None: self._move_counter = 0 self._board = Board(MAX_ROWS, MAX_COLUMNS) self._players = ( player_one if player_one is not None else Player( SIGN_PLAYER_ONE, 'magenta'), player_two if player_two is not None else Player( SIGN_PLAYER_TWO, 'cyan') ) self._verbose = verbose
def __init__(self): self._players = [ Player(self, 0), Player(self, 1), Player(self, 2), Player(self, 3) ] self._board = Board(self._players) self._viewer = FourCornersViewer(moveEvent=self.makeMove) self._updateViewer()
def __init__(self, player_x_type, player_o_type): """Instantiate a tic-tac-toe game. :param player_x_type: type of the first player (player x) :type player_x_type: Player :param player_o_type: type of the second player (player o) :type player_o_type: Player """ self.board = Board() self.player_x = player_x_type(self.FIRST_PLAYER_MARK) self.player_o = player_o_type(self.SECOND_PLAYER_MARK)
class test_board_1_lines_gen(unittest.TestCase): def setUp(self): random.seed(0) self.board=Board() self.board.init(9,5,None,5) def test_lines(self): for i in range(5): self.board.next_move() lines =self.board.get_lines() pprint(lines)
class test_board_2_candidates(unittest.TestCase): def setUp(self): random.seed(2) self.board=Board() self.board.init(9,1,None,5) def test_candidates(self): for i in range(10): self.board.next_move() # import pdb;pdb.set_trace() cand=self.board.candidates() pprint(cand)
def __init__(self, fn = 'games.json'): try: with open(fn) as fh: self._games = json.load(fh) except FileNotFoundError: self._games = [] self._logger = Console() self._board = Board() self._user = User(self._board) self._computer = Computer(self._board, self._user ) self._first = None self._game_over = False self._games_file = fn
def main(): b = Board() b.generate_tile_row(3, 0) b.generate_tile_row(4, 1) b.generate_tile_row(5, 2) b.generate_tile_row(4, 3) b.generate_tile_row(3, 4) print('Done')
def test_second_turn_corner_opening(player_mark): other_mark = Game.FIRST_PLAYER_MARK ai = AI(player_mark) board = Board() board._rows = [[other_mark, ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']] assert ai._second_turn(board.representation()) == (1, 1) board._rows = [[' ', ' ', other_mark], [' ', ' ', ' '], [' ', ' ', ' ']] assert ai._second_turn(board.representation()) == (1, 1) board._rows = [[' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', other_mark]] assert ai._second_turn(board.representation()) == (1, 1) board._rows = [[' ', ' ', ' '], [' ', ' ', ' '], [other_mark, ' ', ' ']] assert ai._second_turn(board.representation()) == (1, 1)
def test_winRow(self): board = Board() board.getBoard()[0] = [1, 1, 1, 1, 1, 0] b = board.checkWinRow() self.assertTrue(b, "Not true") board.getBoard()[0] = [0, 1, 1, 1, 1, 1] b = board.checkWinRow() self.assertTrue(b, "Not true")
def new_game(self, lobby: Lobby): group_code = lobby.get_group_code() players = initialise_players(lobby.get_players()) tile_repo = TileRepo.get_repo_from_config(TILE_CONFIG_PATH) board = Board.from_config(BOARD_CONFIG_PATH, tile_repo) dice_roll = DiceRoll.generate_dice(2, 6) game = Game(board, players, 0, dice_roll, ROLL) self.__games[group_code] = game
def start_ui(): board = Board(6, 6) strategy = Strategy() p1 = Human('x', board) p2 = Computer("0", board, strategy) minimax = Minimax() game = Game(p1, p2, board, minimax) game.start()
def play_training_game(self, opponent, epsilon): move_history = deque() board = Board() player_one = self if self.turn == 1 else opponent player_two = self if self.turn == 2 else opponent while not board.is_game_over(): player = player_two if board.whose_turn() == 1: player = player_one if player is self: board = self.training_move(board, epsilon, move_history) else: player.move(board) self.post_training_game_update(board, move_history)
def test_win(player_mark): ai = AI(player_mark) board = Board() board._rows = [[player_mark, ' ', player_mark], [' ', ' ', ' '], [' ', ' ', ' ']] assert ai.turn(board.representation()) == (0, 1) board._rows = [[' ', player_mark, ' '], [' ', player_mark, ' '], [' ', ' ', ' ']] assert ai.turn(board.representation()) == (2, 1) board._rows = [[' ', ' ', ' '], [' ', player_mark, ' '], [' ', ' ', player_mark]] assert ai.turn(board.representation()) == (0, 0) board._rows = [[' ', ' ', player_mark], [' ', ' ', ' '], [player_mark, ' ', ' ']] assert ai.turn(board.representation()) == (1, 1)
def testFindNakedSingles(self): board = Board() board.boardFromString(self.NAKED_SINGLES) easySolver = EasySolver(board) singles = easySolver.findNakedSingles() # Check we found all the expected results assert(len(singles) == 4) # Validate the value of the single found assert((0, 8) in singles) assert(singles[(0, 8)] == '3') assert((0, 7) in singles) assert(singles[(0, 7)] == '5') assert((4, 3) in singles) assert(singles[(4, 3)] == '6') assert((6, 6) in singles) assert(singles[(6, 6)] == '2')
def restart(self): global root self.gui_board.container.destroy() self.gui_board = GuiBoard(Board(3, 3), root) self.gui_board.draw() self.initialize_buttons() # self.init_two_players_game() self.two_players_button.grid() self.init_two_players_game()
def testFindHiddenSingles(self): board = Board() board.boardFromString(self.NAKED_SINGLES) easySolver = EasySolver(board) singles = easySolver.findHiddenSingles() # Check we found all the expected results assert(len(singles) == 6) # Validate the value of the single found assert((5, 5) in singles) assert(singles[(5, 5)] == '3') assert((7, 6) in singles) assert(singles[(7, 6)] == '3') assert((3, 6) in singles) assert(singles[(3, 6)] == '5') assert((2, 0) in singles) assert(singles[(2, 0)] == '6') assert((8, 7) in singles) assert(singles[(8, 7)] == '7') assert((4, 1) in singles) assert(singles[(4, 1)] == '7')
def print_board(grid): print grid[0:3] print grid[3:6] print grid[6:9] if __name__ == "__main__": starter = raw_input("Pick player 1(1) or 2(2) (Player 1 starts...): ") while starter not in ['1', '2']: starter = raw_input("Invalid: Pick either 1 or 2: ") opponent = raw_input("Do you want to play X(X) or O(O): ") while opponent not in ['X', 'O']: opponent = raw_input("Invalid: Pick either X or O: ") board = Board() rules = Rules(board) player = ArtificialIntelligence(board) ai_mark = 'O' if opponent == 'X' else 'X' next_play = opponent if starter == '1' else ai_mark #initialize rules.next_play = next_play player.set_mark(ai_mark) #computer's mark (i.e., X) end_game = False while not end_game: print_board(board.grid) mark = rules.get_current_player()
''' from board.board import Board from solver.easysolver import EasySolver from board.boardutils import * import logging IMPOSSIBLE_STRING = '1.......2.9.4...5...6...7...5.9.3.......7.......85..4.7.....6...3...9.8...2.....1' HARD_STRING = '6.5..2..8...1...7..9.5..6....2736.8....485....3.9217....4..3.9..5...4...3..8..1.2' EASY_STRING = '79....3.......69..8...3..76.....5..2..54187..4..7.....61..9...8..23.......9....54' logger = logging.getLogger('sudoku') logging.basicConfig(level=logging.INFO) board = Board() board.boardFromString(HARD_STRING) logger.info('\n' + boardToString(board)) easySolver = EasySolver(board) assigned = -1 while assigned != 0: if easySolver.getAvailableMap().getUnassigned() == 0: break assigned = 0 assignedNakedSingles = 0 assignedHiddenSingles = 0 assignedNakedSingles += easySolver.assignNakedSingles() logger.info('Found ' + str(assignedNakedSingles) + ' naked singles')
def testBoardToSimpleSudokuClipboard(self): board = Board() board.boardFromString(self.SUDOKU_STRING) result = boardToSimpleSudokuClipboard(board) assert(self.SIMPLE_SUDOKU == result)