def test_perimeter_goal(self, board_16x16): correct_scores = [(COLOUR_LIST[0], 2), (COLOUR_LIST[1], 5), (COLOUR_LIST[2], 4), (COLOUR_LIST[3], 5)] # Set up a goal for each colour and check results. for colour, expected in correct_scores: goal = PerimeterGoal(colour) assert goal.score(board_16x16) == expected
def test_combine_game_board(game_board, renderer): renderer.draw_board(_block_to_squares(game_board)) renderer.save_to_file('game_board1.png') game_board.children[0].children[3].combine() _flatten(game_board) renderer.clear() goal = PerimeterGoal(COLOUR_LIST[0]) goal.score(game_board) renderer.draw_board(_block_to_squares(game_board)) renderer.save_to_file('game_board_rotate_combine.png')
def test_smart_player(self, board_16x16) -> None: goal_smart = PerimeterGoal(COLOUR_LIST[1]) player_smart = SmartPlayer(1, goal_smart, 1) print(player_smart.difficulty) goal_random = PerimeterGoal(COLOUR_LIST[0]) player_random = RandomPlayer(10, goal_random) random_move = player_random.generate_move(board_16x16) #player_smart._proceed = True #x = player_smart.generate_move(board_16x16) assert 1
def __init__(self, max_depth: int, num_human: int, random_players: int, smart_players: List[int]) -> None: """Initialize this game, as described in the Assignment 2 handout. Precondition: 2 <= max_depth <= 5 """ self.max_depth = max_depth self.num_human = num_human self.random_players = random_players self.smart_players = smart_players self.num_players = num_human + random_players + len(smart_players) # 1 create a Renderer for this game self.renderer = Renderer(self.num_players) # 2 Generate a random goal typr, for all players to share potential_goal = [ BlobGoal(COLOUR_LIST[0]), PerimeterGoal(COLOUR_LIST[0]) ] self.goal = potential_goal[random.randint(0, 1)] # 3 Generate a random board, with the given maximum depth self.board = random_init(0, max_depth) self.board.update_block_locations((0, 0), 750) # 4 Generate the right number of human players, random players, # and smart players self.players = [] for human_id in range(num_human): self.players.append(HumanPlayer(self.renderer, human_id, self.goal)) for ran_id in range(num_human, num_human + random_players): self.players.append(RandomPlayer(self.renderer, ran_id, self.goal)) for smart_id in range(num_human + random_players, self.num_players): difficulty_level = smart_players[smart_id - num_human - random_players] self.players.append( SmartPlayer(self.renderer, smart_id, self.goal, difficulty_level)) for player in self.players: player.goal.colour = COLOUR_LIST[random.randint(0, 3)] if isinstance(self.goal, BlobGoal): player.goal = BlobGoal(player.goal.colour) else: player.goal = PerimeterGoal(player.goal.colour) if isinstance(player, HumanPlayer): self.renderer.display_goal(player) # 5 before returning, draw the board for player_id in range(len(self.players)): self.renderer.draw(self.board, player_id)
def __init__(self, max_depth: int, num_human: int, random_players: int, smart_players: List[int]) -> None: """Initialize this game, as described in the Assignment 2 handout. Precondition: 2 <= max_depth <= 5 """ self.board = random_init(0, max_depth) self.board.update_block_locations((0, 0), BOARD_WIDTH) num_players = num_human + random_players + len(smart_players) self.renderer = Renderer(num_players) self.players = [] if random.random() < 0.5: for i in range(num_human): target = \ COLOUR_LIST[int(random.random() * len(COLOUR_LIST))] self.players.append(HumanPlayer(self.renderer, \ len(self.players), \ BlobGoal(target))) for i in range(random_players): target = \ COLOUR_LIST[int(random.random() * len(COLOUR_LIST))] self.players.append(RandomPlayer(self.renderer, \ len(self.players), \ BlobGoal(target))) for i in smart_players: target = \ COLOUR_LIST[int(random.random() * len(COLOUR_LIST))] self.players.append(SmartPlayer(self.renderer, \ len(self.players), \ BlobGoal(target), \ i)) else: for i in range(num_human): target = \ COLOUR_LIST[int(random.random() * len(COLOUR_LIST))] self.players.append(HumanPlayer(self.renderer, \ len(self.players), \ PerimeterGoal(target))) for i in range(random_players): target = \ COLOUR_LIST[int(random.random() * len(COLOUR_LIST))] self.players.append(RandomPlayer(self.renderer, \ len(self.players), \ PerimeterGoal(target))) for i in smart_players: target = \ COLOUR_LIST[int(random.random() * len(COLOUR_LIST))] self.players.append(SmartPlayer(self.renderer, \ len(self.players), \ PerimeterGoal(target), \ i)) self.renderer.draw(self.board, 0)
def test_perimeter_goal_single_board(single_board) -> None: correct_scores = [ (COLOUR_LIST[0], 2), (COLOUR_LIST[1], 0), (COLOUR_LIST[2], 0), (COLOUR_LIST[3], 0) ] # Set up a goal for each colour and check the results for colour, expected in correct_scores: goal = PerimeterGoal(colour) assert goal.score(single_board) == expected
def test_perimeter_goal_board_16x16(board_16x16) -> None: correct_scores = [ (COLOUR_LIST[0], 5), (COLOUR_LIST[1], 9), (COLOUR_LIST[2], 8), (COLOUR_LIST[3], 10) ] # Set up a goal for each colour and check the results for colour, expected in correct_scores: goal = PerimeterGoal(colour) assert goal.score(board_16x16) == expected
def test_perimeter_goal(): """ Test the blob goal for the given board """ board, _ = construct_board() # On the hand-constructed board, these are the correct scores for # each colour. correct_scores = [(COLOUR_LIST[0], 2), (COLOUR_LIST[1], 5), (COLOUR_LIST[2], 4), (COLOUR_LIST[3], 5)] # Set up a goal for each colour and check results. for colour, score in correct_scores: goal = PerimeterGoal(colour) assert goal.score(board) == score
def __init__(self, max_depth: int, num_human: int, random_players: int, smart_players: List[int]) -> None: """Initialize this game, as described in the Assignment 2 handout. Each player has a random target colour, and all players share the same goal(Players might have same target colour.) Precondition: 2 <= max_depth <= 5 """ self.board = random_init(0, max_depth) self.board.update_block_locations((0, 0), BOARD_WIDTH) num_player = num_human + random_players + len(smart_players) self.renderer = Renderer(num_player) self.players = [] random_num = random.randint(0, 1) for i in range(num_player): if random_num == 0: goal = BlobGoal(COLOUR_LIST[random.randint(0, 3)]) else: goal = PerimeterGoal(COLOUR_LIST[random.randint(0, 3)]) if i < num_human: self.players.append(HumanPlayer(self.renderer, i, goal)) elif num_human <= i < num_human + random_players: self.players.append(RandomPlayer(self.renderer, i, goal)) else: self.players.append( SmartPlayer( self.renderer, i, goal, smart_players[i - (num_human + random_players)])) # Display each player's goal before starting game. for i in range(num_player): self.renderer.display_goal(self.players[i])
def _generate_players(self, num_players: int, player_type: str, goal_type: str, start_id: int) -> List[Player]: """Generate a list of players with the given number of players, of the given type, with the given <goal_type>, with ids incrementing from <start_id>. Preconditions: player_type == 'human', 'random', or 'smart' goal_type == 'blob', or 'perimeter' """ player_list = [] player_count = 0 id_count = start_id while player_count < num_players: # Generate a blob goal or a perimeter goal with a random colour if goal_type == 'blob': goal = BlobGoal(COLOUR_LIST[random.randint(0, 3)]) else: goal = PerimeterGoal(COLOUR_LIST[random.randint(0, 3)]) # Generate a player of the given type, using goal if player_type == 'human': player = HumanPlayer(self.renderer, id_count, goal) elif player_type == 'random': player = RandomPlayer(self.renderer, id_count, goal) else: player = SmartPlayer(self.renderer, id_count, goal) # Add player to the player list, iterate counts by one player_list.append(player) player_count += 1 id_count += 1 return player_list
def goal_playground(): from goal import generate_goals, _flatten, PerimeterGoal, BlobGoal goals = generate_goals(3) print([g.description() for g in goals]) b = block_three_level1() print(block_graph(b)) print(_flatten(b)) pg = PerimeterGoal(COLOUR_LIST[0]) print(pg.score(b)) bg = BlobGoal(COLOUR_LIST[0]) print(bg.score((b))) bg = BlobGoal(COLOUR_LIST[1]) print(bg.score((b)))
def test_perimeter_score(): g = PerimeterGoal(COLOUR_LIST[0]) # depth 0 b1 = Block((0, 0), 750, COLOUR_LIST[0], 0, 0) assert g.score(b1) == 4 # depth 1 b1 = Block((0, 0), 750, None, 0, 1) b2 = Block((0, 0), 375, COLOUR_LIST[0], 1, 1) b3 = Block((0, 0), 375, COLOUR_LIST[1], 1, 1) b4 = Block((0, 0), 375, COLOUR_LIST[2], 1, 1) b5 = Block((0, 0), 375, COLOUR_LIST[3], 1, 1) b1.children = [b2, b3, b4, b5] assert g.score(b1) == 2 b1.children = [b2, b2.create_copy(), b2.create_copy(), b2.create_copy()] assert g.score(b1) == 8 # depth 2 b6 = Block((0, 0), 375, None, 0, 2) b7 = Block((0, 0), 375, None, 1, 2) b8 = Block((0, 0), 375, COLOUR_LIST[2], 1, 2) b9 = Block((0, 0), 375, COLOUR_LIST[3], 1, 2) b10 = Block((0, 0), 375, COLOUR_LIST[0], 1, 2) b6.children = [b7, b8, b9, b10] b7a = Block((0, 0), 375, COLOUR_LIST[0], 2, 2) b8a = Block((0, 0), 375, COLOUR_LIST[2], 2, 2) b9a = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b10a = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b7.children = [b7a, b8a, b9a, b10a] assert g.score(b6) == 6 # 4 corners only b11 = Block((0, 0), 375, None, 0, 2) b12 = Block((0, 0), 375, None, 1, 2) b13 = Block((0, 0), 375, None, 1, 2) b14 = Block((0, 0), 375, None, 1, 2) b15 = Block((0, 0), 375, None, 1, 2) b11.children = [b12, b13, b14, b15] # top right b12a = Block((0, 0), 375, COLOUR_LIST[0], 2, 2) b13a = Block((0, 0), 375, COLOUR_LIST[2], 2, 2) b14a = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b15a = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b12.children = [b12a, b13a, b14a, b15a] # top left b12b = Block((0, 0), 375, COLOUR_LIST[1], 2, 2) b13b = Block((0, 0), 375, COLOUR_LIST[0], 2, 2) b14b = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b15b = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b13.children = [b12b, b13b, b14b, b15b] # bottom left b12c = Block((0, 0), 375, COLOUR_LIST[1], 2, 2) b13c = Block((0, 0), 375, COLOUR_LIST[2], 2, 2) b14c = Block((0, 0), 375, COLOUR_LIST[0], 2, 2) b15c = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b14.children = [b12c, b13c, b14c, b15c] # bottom right b12d = Block((0, 0), 375, COLOUR_LIST[1], 2, 2) b13d = Block((0, 0), 375, COLOUR_LIST[2], 2, 2) b14d = Block((0, 0), 375, COLOUR_LIST[3], 2, 2) b15d = Block((0, 0), 375, COLOUR_LIST[0], 2, 2) b15.children = [b12d, b13d, b14d, b15d] assert g.score(b11) == 8
def test_score_perimeter_goal() -> None: b = Block((0, 0), 500, None, 0, 2) b.children = [Block(b._children_positions()[0], 250, None, 1, 2), Block(b._children_positions()[1], 250, COLOUR_LIST[1], 1, 2), Block(b._children_positions()[2], 250, COLOUR_LIST[2], 1, 2), Block(b._children_positions()[3], 250, COLOUR_LIST[3], 1, 2)] b.children[0].children = [Block(b.children[0]._children_positions()[0], 125, COLOUR_LIST[2], 2, 2), Block(b.children[0]._children_positions()[1], 125, COLOUR_LIST[0], 2, 2), Block(b.children[0]._children_positions()[2], 125, COLOUR_LIST[2], 2, 2), Block(b.children[0]._children_positions()[3], 125, COLOUR_LIST[3], 2, 2)] P = PerimeterGoal(COLOUR_LIST[3]) assert P.score(b) == 5 b.children[0].children[0].paint(COLOUR_LIST[3]) assert P.score(b) == 7
def test_score_perimeter_goal() -> None: block1 = Block((0, 0), 16, None, 0, 2) c1 = Block((8, 0), 8, (1, 128, 181), 1, 2) c2 = Block((0, 0), 8, (199, 44, 58), 1, 2) c3 = Block((0, 8), 8, None, 1, 2) c4 = Block((8, 8), 8, None, 1, 2) block1.children = [c1, c2, c3, c4] b31 = Block((4, 8), 4, (1, 128, 181), 2, 2) b32 = Block((0, 8), 4, (199, 44, 58), 2, 2) b33 = Block((0, 12), 4, (255, 211, 92), 2, 2) b34 = Block((4, 12), 4, (199, 44, 58), 2, 2) c3.children = [b31, b32, b33, b34] b41 = Block((12, 8), 4, (255, 211, 92), 2, 2) b42 = Block((8, 8), 4, (199, 44, 58), 2, 2) b43 = Block((8, 12), 4, (255, 211, 92), 2, 2) b44 = Block((12, 12), 4, (199, 44, 58), 2, 2) c4.children = [b41, b42, b43, b44] block2 = Block((0, 0), 16, None, 0, 2) c1 = Block((8, 0), 8, (1, 128, 181), 1, 2) c2 = Block((0, 0), 8, (199, 44, 58), 1, 2) c3 = Block((0, 8), 8, (255, 211, 92), 1, 2) c4 = Block((8, 8), 8, (1, 128, 181), 1, 2) block2.children = [c1, c2, c3, c4] block3 = Block((0, 0), 16, None, 0, 2) c1 = Block((8, 0), 8, (1, 128, 181), 1, 2) c2 = Block((0, 0), 8, (199, 44, 58), 1, 2) c3 = Block((0, 8), 8, None, 1, 2) c4 = Block((8, 8), 8, (199, 44, 58), 1, 2) block3.children = [c1, c2, c3, c4] b31 = Block((4, 8), 4, (1, 128, 181), 2, 2) b32 = Block((0, 8), 4, (199, 44, 58), 2, 2) b33 = Block((0, 12), 4, (255, 211, 92), 2, 2) b34 = Block((4, 12), 4, (0, 0, 0), 2, 2) c3.children = [b31, b32, b33, b34] b41 = Block((12, 8), 4, (255, 211, 92), 2, 2) b42 = Block((8, 8), 4, (199, 44, 58), 2, 2) b43 = Block((8, 12), 4, (0, 0, 0), 2, 2) b44 = Block((12, 12), 4, (199, 44, 58), 2, 2) c4.children = [b41, b42, b43, b44] goal1 = PerimeterGoal((199, 44, 58)) goal2 = PerimeterGoal((255, 211, 92)) goal3 = PerimeterGoal((0, 0, 0)) assert goal1.score(block1) == 8 assert goal2.score(block1) == 4 assert goal2.score(block2) == 4 assert goal3.score(block3) == 2 assert goal3.score(block1) == 0
def test_JEN_smart_player_not_smart_moves(board_16x16) -> None: goal = PerimeterGoal((199, 44, 58)) player = SmartPlayer(3, goal, 10) player._proceed = True move = player.generate_move(board_16x16) assert move is not COMBINE assert move is not ROTATE_CLOCKWISE assert move is not ROTATE_COUNTER_CLOCKWISE assert move is not SWAP_HORIZONTAL assert move is not SWAP_VERTICAL assert move is PASS or SMASH
def __init__(self, max_depth: int, num_human: int, random_players: int, smart_players: List[int]) -> None: """Initialize this game, as described in the Assignment 2 handout. Precondition: 2 <= max_depth <= 5 """ self.players = [] num_players = num_human + random_players + len(smart_players) self.renderer = Renderer(num_players) decider = random.randint(0, 1) # the random value ( 0 or 1 ) which we use it to # determine the goal of the game for i in range(num_players): c = COLOUR_LIST[random.randint(0, len(COLOUR_LIST) - 1)] # creating the random colour to assign to the player if decider == 0: # determining the random goal to the game goal = BlobGoal(c) else: goal = PerimeterGoal(c) if i < num_human: # first adding the human players self.players.append(HumanPlayer(self.renderer, i, goal)) self.renderer.display_goal(self.players[i]) # shows the goal of the player to him/her elif i < num_human + random_players: # adding the random players self.players.append(RandomPlayer(self.renderer, i, goal)) self.renderer.display_goal(self.players[i]) # shows the goal of the player else: level = smart_players[i - (num_human + random_players)] # it determines the difficulty level of the smartplayer which # is actualy the value of the smartplayer[index] # adding the smart players self.players.append(SmartPlayer(self.renderer, i, goal, level)) self.renderer.display_goal(self.players[i]) # shows the goal of the player self.board = random_init(0, max_depth) # make the board game with the given max_depth self.board.update_block_locations((0, 0), BOARD_WIDTH)
def __init__(self, max_depth: int, num_human: int, random_players: int, smart_players: List[int]) -> None: """Initialize this game, as described in the Assignment 2 handout. Precondition: 2 <= max_depth <= 5 """ game_goal = [] self.players = [] num_players = num_human + random_players + len(smart_players) self.renderer = Renderer(num_players) # rand_num = random.randint(0, 1) # for i in range(num_players): # game_goal.append([ # PerimeterGoal( # COLOUR_LIST[random.randint(0, 3)] # ), # BlobGoal( # COLOUR_LIST[random.randint(0, 3)] # ) # ][rand_num] # ) if random.randint(0, 1) == 0: for i in range(num_players): game_goal.append( PerimeterGoal(COLOUR_LIST[random.randint(0, 3)])) else: for i in range(num_players): game_goal.append(BlobGoal(COLOUR_LIST[random.randint(0, 3)])) self.board = random_init(0, max_depth) self.board.update_block_locations((0, 0), BOARD_WIDTH) for i in range(num_players): if i < num_human: self.players.append(HumanPlayer(self.renderer, i, game_goal[i])) elif i < random_players + num_human: self.players.append( RandomPlayer(self.renderer, i, game_goal[i])) else: self.players.append( SmartPlayer(self.renderer, i, game_goal[i], smart_players[i - random_players - num_human])) for player in self.players: self.renderer.display_goal(player) # self.renderer.draw(self.board, 0) for i in range(num_players): self.renderer.draw(self.board, i)
def test_perimeter_goal_score() -> None: """ Test the score method of the PerimeterGoal class. """ goal = PerimeterGoal((255, 255, 255)) assert goal.score(Block((0, 0), 1000, (255, 255, 255), 0, 0)) == 4 assert goal.score(Block((0, 0), 1000, (0, 255, 255), 0, 0)) == 0 goal2 = PerimeterGoal((0, 0, 0)) b1 = Block((1000, 0), 500, None, 0, 2) b1.children = [Block((1250, 0), 250, (0, 0, 0), 1, 2), Block((0, 0), 250, (0, 0, 0), 1, 2), Block((0, 1250), 250, (55, 0, 0), 1, 2), Block((1250, 1250), 250, None, 1, 2)] b1.children[3].children = [Block((1375, 0), 125, (0, 255, 0), 2, 2), Block((1250, 0), 125, (0, 0, 0), 2, 2), Block((1250, 1375), 125, (155, 0, 0), 2, 2), Block((1375, 1375), 125, (0, 0, 0), 2, 2)] assert goal.score(b1) == 0 assert goal2.score(b1) == 10
def test_perimeter_goal_swap(self, board_32x32_swap0) -> None: goal = PerimeterGoal(COLOUR_LIST[1]) assert goal.score(board_32x32_swap0) == 12
def test_perimeter_goal_rotate(self, board_32x32_rotate1) -> None: goal1 = PerimeterGoal(COLOUR_LIST[2]) goal2 = PerimeterGoal(COLOUR_LIST[3]) assert goal1.score(board_32x32_rotate1) == 9 assert goal2.score(board_32x32_rotate1) == 10
def test_perimeter_description(self): perimeter = PerimeterGoal(COLOUR_LIST[0]) self.assertTrue(str(perimeter) != 'DESCRIPTION')
def test_moves_game_board2(game_board2, renderer): goal1 = PerimeterGoal(COLOUR_LIST[1]) goal2 = BlobGoal(COLOUR_LIST[1]) renderer.draw_board(_block_to_squares(game_board2)) renderer.save_to_file('game_board2_ref.png') assert goal1.score(game_board2) == 26 assert goal2.score(game_board2) == 4 * 3 + 3 * 2 + 4 * 4 + 2 * 4**3 lst_of_game_boards = [] for i in range(10): lst_of_game_boards.append(game_board2.create_copy()) lst_of_game_boards[0].rotate(1) renderer.clear() renderer.draw_board(_block_to_squares(lst_of_game_boards[0])) renderer.save_to_file("game_board_2_rotate1.png") assert goal1.score(lst_of_game_boards[0]) == 26 assert goal2.score( lst_of_game_boards[0]) == 3 * 2 + 4 * 3 + 4**2 + 2 * 4**3 renderer.clear() lst_of_game_boards[1].rotate(3) renderer.draw_board(_block_to_squares(lst_of_game_boards[1])) renderer.save_to_file("game_board_2_rotate3.png") assert goal1.score(lst_of_game_boards[1]) == 26 assert goal2.score( lst_of_game_boards[1]) == 3 * 2 + 4 * 3 + 4**2 + 2 * 4**3 renderer.clear() lst_of_game_boards[2].children[1].smash() renderer.draw_board(_block_to_squares(lst_of_game_boards[2])) renderer.save_to_file("game_board_2_smash.png") assert goal1.score(lst_of_game_boards[2]) == sum( [1, 2, 1, 1, 8, 7, 7, 2, 8]) assert goal2.score( lst_of_game_boards[2]) == 2 * 4**3 + 4 + 6 + 4**2 + 4 + 4 renderer.clear() lst_of_game_boards[3].swap(1) renderer.draw_board(_block_to_squares(lst_of_game_boards[3])) renderer.save_to_file("game_board_2_swap1.png") assert goal1.score(lst_of_game_boards[3]) == sum([8, 8, 8, 1, 1, 2, 1, 1]) assert goal2.score(lst_of_game_boards[3]) == 4 * 4 * 4 + 4 * 4 * 2 + 4 + 3 renderer.clear() lst_of_game_boards[4].swap(0) renderer.draw_board(_block_to_squares(lst_of_game_boards[4])) renderer.save_to_file("game_board_2_swap0.png") assert goal1.score(lst_of_game_boards[4]) == sum( [3, 3, 2, 4, 8, 8, 8, 4, 2]) assert goal2.score( lst_of_game_boards[4]) == 4 * 2 + 3 * 2 + 4**2 + 2 * 4**3 renderer.clear() assert lst_of_game_boards[5].children[0].children[0].children[0].children[ 0].paint(COLOUR_LIST[3]) == False lst_of_game_boards[5].children[0].children[0].children[0].children[ 0].children[0].paint(COLOUR_LIST[3]) renderer.draw_board(_block_to_squares(lst_of_game_boards[5])) renderer.save_to_file("game_board_2_paint.png") renderer.clear() lst_of_game_boards[6].children[2].children[3].children[1].children[ 3].combine() lst_of_game_boards[6].children[2].children[3].children[1].children[ 2].combine() renderer.draw_board(_block_to_squares(lst_of_game_boards[6])) renderer.save_to_file("game_board_2_combine.png") assert goal1.score(lst_of_game_boards[6]) == 26 assert goal2.score( lst_of_game_boards[6]) == 4 * 4 * 4 * 2 + 4 * 4 + 4 + 4 + 3 + 3 + 4
def test_big_block(): board = Block(0, children=[ Block(1, children=[ Block(2, r), Block(2, g), Block(2, g), Block(2, g) ]), Block(1, children=[ Block(2, r), Block(2, r), Block(2, r), Block(2, r) ]), Block(1, b), Block(1, children=[ Block(2, g), Block(2, b), Block(2, r), Block(2, b) ]) ]) board.max_depth = 2 board.children[0].max_depth = 2 board.children[1].max_depth = 2 board.children[2].max_depth = 2 board.children[3].max_depth = 2 board.children[0].children[0].max_depth = 2 board.children[0].children[1].max_depth = 2 board.children[0].children[2].max_depth = 2 board.children[0].children[3].max_depth = 2 board.children[1].children[0].max_depth = 2 board.children[1].children[1].max_depth = 2 board.children[1].children[2].max_depth = 2 board.children[1].children[3].max_depth = 2 board.children[3].children[0].max_depth = 2 board.children[3].children[1].max_depth = 2 board.children[3].children[2].max_depth = 2 board.children[3].children[3].max_depth = 2 assert board.flatten() == [[r, r, b, b], [r, r, b, b], [g, g, b, r], [r, g, g, b]] board.rotate(1) assert board.flatten() == [[b, b, r, b], [b, b, b, g], [r, r, g, g], [r, r, g, r]] board.rotate(3) assert board.flatten() == [[r, r, b, b], [r, r, b, b], [g, g, b, r], [r, g, g, b]] board.swap(0) assert board.flatten() == [[g, g, b, r], [r, g, g, b], [r, r, b, b], [r, r, b, b]] board.swap(0) assert board.flatten() == [[r, r, b, b], [r, r, b, b], [g, g, b, r], [r, g, g, b]] board.swap(1) assert board.flatten() == [[b, b, r, r], [b, b, r, r], [b, r, g, g], [g, b, r, g]] board.swap(1) assert board.flatten() == [[r, r, b, b], [r, r, b, b], [g, g, b, r], [r, g, g, b]] pr = PerimeterGoal(r) pg = PerimeterGoal(g) pb = PerimeterGoal(b) py = PerimeterGoal(y) br = BlobGoal(r) bg = BlobGoal(g) bb = BlobGoal(b) by = BlobGoal(y) assert pr.score(board) == 7 assert pg.score(board) == 3 assert pb.score(board) == 6 assert py.score(board) == 0 assert br.score(board) == 4 assert bg.score(board) == 4 assert bb.score(board) == 5 assert by.score(board) == 0
def test_single_block(): board = Block(0, r) assert board.flatten() == [[r]] board.rotate(1) assert board.flatten() == [[r]] board.rotate(3) assert board.flatten() == [[r]] board.swap(0) assert board.flatten() == [[r]] board.swap(1) assert board.flatten() == [[r]] board.smash() assert board.flatten() == [[r]] pr = PerimeterGoal(r) pg = PerimeterGoal(g) pb = PerimeterGoal(b) py = PerimeterGoal(y) br = BlobGoal(r) bg = BlobGoal(g) bb = BlobGoal(b) by = BlobGoal(y) assert pr.score(board) == 2 assert pg.score(board) == 0 assert pb.score(board) == 0 assert py.score(board) == 0 assert br.score(board) == 1 assert bg.score(board) == 0 assert bb.score(board) == 0 assert by.score(board) == 0
def test_generate_move_random_player() -> None: b2 = generate_board(3, 750) P = RandomPlayer(2, PerimeterGoal(COLOUR_LIST[2])) P._proceed = True assert P.generate_move(b2)[0] in ['swap', 'rotate', 'paint', 'combine', 'smash']
def test_score_perimeter_goal_no_children_max_depth_3() -> None: b = Block((0, 0), 500, COLOUR_LIST[1], 0, 3) P = PerimeterGoal(COLOUR_LIST[1]) assert P.score(b) == 32
def test_PG_no_corner(self) -> None: gol = PerimeterGoal(REAL_RED) borde = standard_borde() assert gol.score(borde) == 4
def test_mixed_big_block(): board = Block( 0, children=[Block(1, r), Block(1, r), Block(1, g), Block(1, r)]) board.max_depth = 1 board.children[0].max_depth = 1 board.children[1].max_depth = 1 board.children[2].max_depth = 1 board.children[3].max_depth = 1 print(board.flatten()) assert board.flatten() == [[r, g], [r, r]] board.rotate(1) assert board.flatten() == [[g, r], [r, r]] board.rotate(3) assert board.flatten() == [[r, g], [r, r]] board.swap(0) assert board.flatten() == [[r, r], [r, g]] board.swap(0) assert board.flatten() == [[r, g], [r, r]] board.swap(1) assert board.flatten() == [[g, r], [r, r]] board.swap(1) assert board.flatten() == [[r, g], [r, r]] board.smash() assert board.flatten() == [[r, g], [r, r]] pr = PerimeterGoal(r) pg = PerimeterGoal(g) pb = PerimeterGoal(b) py = PerimeterGoal(y) br = BlobGoal(r) bg = BlobGoal(g) bb = BlobGoal(b) by = BlobGoal(y) assert pr.score(board) == 6 assert pg.score(board) == 2 assert pb.score(board) == 0 assert py.score(board) == 0 assert br.score(board) == 3 assert bg.score(board) == 1 assert bb.score(board) == 0 assert by.score(board) == 0
def test_perimeter_goal_description() -> None: """ Test the PerimeterGoal class' description method. """ g1 = PerimeterGoal((1, 128, 181)) assert isinstance(g1.description(), str)
def test_PG_with_corner(self) -> None: gol = PerimeterGoal(DAFFODIL_DELIGHT) borde = standard_borde() assert gol.score(borde) == 10