def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ players = [] colours = [] num_players = num_human + num_random + len(smart_players) for i in range(num_players): goal = generate_goals(1)[0] while goal.colour in colours: goal = generate_goals(1)[0] colours.append(goal.colour) if i < num_human: players.append(HumanPlayer(i, goal)) elif num_human <= i < num_human + num_random: players.append(RandomPlayer(i, goal)) else: difficulty = smart_players[i - num_human - num_random] players.append(SmartPlayer(i, goal, difficulty)) return players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ # TODO: Implement Me lst_players = [] for i in range(num_human): goals = generate_goals(1) human = HumanPlayer(i, goals[0]) lst_players.append(human) for j in range(num_random): goals = generate_goals(1) random_player = RandomPlayer(j + len(lst_players), goals[0]) lst_players.append(random_player) for k in range(len(smart_players)): goals = generate_goals(1) smart_player = SmartPlayer(k + len(lst_players), goals[0], smart_players[k]) lst_players.append(smart_player) return lst_players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ res = [] i = 0 for _ in range(num_human): res.append(HumanPlayer(i, generate_goals(1)[0])) i += 1 x = i for _ in range(num_random): res.append(RandomPlayer(x, generate_goals(1)[0])) x += 1 y = x for _ in range(len(smart_players)): res.append(SmartPlayer(y, generate_goals(1)[0], smart_players[y - x])) y += 1 return res
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ players = [] id_ = 0 for _ in range(num_human): goals = generate_goals(1) players.append(HumanPlayer(id_, goals[0])) id_ += 1 for _ in range(num_random): goals = generate_goals(1) players.append(RandomPlayer(id_, goals[0])) id_ += 1 for i in smart_players: goals = generate_goals(1) players.append(SmartPlayer(id_, goals[0], i)) id_ += 1 return players
def test_generate_goals() -> None: lst = generate_goals(2) assert len(lst) == 2 assert lst[0] != lst[1] t1 = type(lst[0]) t2 = type(lst[1]) assert t1 == t2 goals = generate_goals(3) assert goals[1].colour in COLOUR_LIST
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ goals = generate_goals(num_human + num_random + len(smart_players)) player_id = 0 goal_number = 0 difficulty_level = 0 lst_players = [] for _ in range(num_human): lst_players.append(HumanPlayer(player_id, goals[goal_number])) player_id += 1 goal_number += 1 for _ in range(num_random): lst_players.append(RandomPlayer(player_id, goals[goal_number])) player_id += 1 goal_number += 1 for _ in range(len(smart_players)): lst_players.append( SmartPlayer(player_id, goals[goal_number], smart_players[difficulty_level])) player_id += 1 goal_number += 1 difficulty_level += 1 return lst_players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ lst = [] n = num_human + num_random + len(smart_players) goals = generate_goals(n) for i in range(num_human): lst.append(HumanPlayer(i, goals[i])) for i in range(num_random): r = num_human + i lst.append(RandomPlayer(r, goals[r])) for i in range(len(smart_players)): s = num_human + num_random + i lst.append(SmartPlayer(s, goals[s], smart_players[i])) return lst
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ total_num_players = num_human + num_random + len(smart_players) ids = list(range(total_num_players)) goals = generate_goals(total_num_players) player_list = [] for i in range(num_human): player = HumanPlayer(ids[i], goals[i]) player_list.append(player) for i in range(num_random): j = num_human + i player = RandomPlayer(ids[j], goals[j]) player_list.append(player) for i, difficulty in enumerate(smart_players): j = num_human + num_random + i player = SmartPlayer(ids[j], goals[j], difficulty) player_list.append(player) return player_list
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ # TODO: Implement Me players = [] goals = generate_goals(num_human + num_random + len(smart_players)) for i in range(num_human): players.append(HumanPlayer(i, goals[i])) for i in range(num_random): players.append(RandomPlayer(num_human + i, goals[num_human + i])) base = num_human + num_random for i, x in enumerate(smart_players): players.append(SmartPlayer(base + i, goals[base + i], x)) return players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ # Reviewed 17/03/2020, though there may be a way to optimize this more... players = [] goals = generate_goals(num_human + num_random + len(smart_players)) id_ = 0 player_to_count = {HumanPlayer: num_human, RandomPlayer: num_random} for player in list(player_to_count): while player_to_count[player] > 0: goal = goals.pop(random.randrange(len(goals))) players.append(player(id_, goal)) id_ += 1 player_to_count[player] -= 1 for difficulty in smart_players: goal = goals.pop(random.randrange(len(goals))) players.append(SmartPlayer(id_, goal, difficulty)) id_ += 1 return players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ n = num_human + num_random + len(smart_players) goals = generate_goals(n) offset_smarts = num_human + num_random humans = [HumanPlayer(i, goals[i]) for i in range(num_human)] rands = [ RandomPlayer(i, goals[i]) for i in range(num_human, offset_smarts) ] smarts = [ SmartPlayer(i, goals[i], smart_players[i - offset_smarts]) for i in range(offset_smarts, n) ] return humans + rands + smarts
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human players, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ player_list = [] goals = generate_goals(num_human + num_random + len(smart_players)) i = 0 while i < num_human: # creates humans first player_list.append(HumanPlayer(i, goals[i])) i += 1 while i < num_random + num_human: # creating random players player_list.append((RandomPlayer(i, goals[i]))) i += 1 while i < num_random + num_human + len(smart_players): # smart players index = i - num_human - num_random player_list.append((SmartPlayer(i, goals[i], smart_players[index]))) i += 1 return player_list
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ player_lst = [] id_num = num_human + num_random + len(smart_players) goals = generate_goals(id_num) if id_num >= 4: id_num = 4 for i in range(0, id_num): if i < num_human and num_human > 0: player_lst.append(HumanPlayer(i, goals[i])) elif num_human - 1 < i <= (num_random + num_human - 1) and \ num_random > 0: player_lst.append(RandomPlayer(i, goals[i])) else: player_lst.append(SmartPlayer(i, goals[i], smart_players\ [i-num_human-num_random])) return player_lst
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human players, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ # Because we know the total amount of players and the total amount of each type: goals = generate_goals(num_human + num_random + len(smart_players)) players = [] for i in range(num_human): players.append(HumanPlayer(i, goals[i])) for i in range(num_human, num_human + num_random): players.append(RandomPlayer(i, goals[i])) for i in range(num_human + num_random, num_human + num_random + len(smart_players)): players.append(SmartPlayer(i, goals[i], i - num_human - num_random)) return players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ players = [] num_player = num_human + num_random + len(smart_players) goal = generate_goals(num_player) for player in range(num_human): players.append(HumanPlayer(player, goal[player])) for player in range(num_human, num_human + num_random): players.append(RandomPlayer(player, goal[player])) for player in range(num_human + num_random, num_player): new = num_human + num_random players.append(SmartPlayer(player, goal[player], smart_players[player - new])) return players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as[ the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ # With the rule that there are at most 4 players copy = smart_players[:] goals = generate_goals(num_human + num_random + len(smart_players)) players = [] for index, goal in enumerate(goals): if num_human > 0: players.append(HumanPlayer(index, goal)) num_human -= 1 elif num_random > 0: players.append(RandomPlayer(index, goal)) num_random -= 1 else: players.append(SmartPlayer(index, goal, copy.pop(0))) return players
def test_generate_goals() -> None: """Test generate_goals_method""" goal_list = generate_goals(4) assert len(goal_list) == 4 colour_list = [goal.colour for goal in goal_list] colour_set = set(colour_list) assert len(colour_list) == len(colour_set) for i in range(0, len(colour_list)): assert colour_list[i] in colour_set
def test_generate_goals() -> None: goals = generate_goals(4) assert len(goals) == 4 if type(goals[0]) == PerimeterGoal: for item in goals: assert type(item) == PerimeterGoal if type(goals[0]) == BlobGoal: for item in goals: assert type(item) == BlobGoal
def test_generate_goal_3(self): for i in range(1, 100): random_i = random.randint(1, len(COLOUR_LIST)) res = generate_goals(random_i) self.assertTrue(len(res) == random_i) transformed_type = list(map(lambda x: x.__class__ in [BlobGoal, PerimeterGoal], res)) transformed_count = list(map(lambda x: x.__class__, res)).count(res[0].__class__) transformed_colour = list(map(lambda x: x.colour, res)) colour_counts = [transformed_colour.count(colour) for colour in transformed_colour] self.assertTrue(all(transformed_type), "All the goal have to in one of BolbGoal or PerimeterGoal") self.assertTrue(transformed_count == len(res), "Every goal has to be the same type") self.assertTrue(max(colour_counts) == 1, "Every colour should be different")
def test_generate_goals() -> None: """Test generate_goals. - length is num_goals - all elements of the list is the same type of goal - each goal has a different colour """ goals = generate_goals(3) assert len(goals) == 3 colours = [] for goal in goals: colours.append(goal.colour) for colour in colours: assert colours.count(colour) == 1
def test_generate_goals() -> None: """ Test the generate_goals function. """ goals1 = generate_goals(1) assert len(goals1) == 1 assert goals1[0].colour in COLOUR_LIST assert isinstance(goals1[0], PerimeterGoal) or isinstance(goals1[0], BlobGoal) goals2 = generate_goals(4) assert len(goals2) == 4 colours = [] for goal in range(len(goals2)): assert goals2[goal].colour not in colours assert goals2[goal].colour in COLOUR_LIST assert isinstance(goals2[goal], type(goals2[goal - 1])) colours.append(goals2[goal].colour)
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ # TODO: Implement Me goals = generate_goals(1) # FIXME return [HumanPlayer(0, goals[0])] # FIXME
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 create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. """ players = [] total = num_human + num_random + len(smart_players) goals = generate_goals(total) for i in range(num_human): goal = random.choice(goals) goals.remove(goal) p = HumanPlayer(i, goal) players.append(p) for j in range(num_human, num_random + num_human): goal = random.choice(goals) goals.remove(goal) p = RandomPlayer(j, goal) players.append(p) for k in range(len(smart_players)): goal = random.choice(goals) goals.remove(goal) p = SmartPlayer(k + num_human + num_random, goal, smart_players[k]) players.append(p) return players
def create_players(num_human: int, num_random: int, smart_players: List[int]) \ -> List[Player]: """Return a new list of Player objects. <num_human> is the number of human player, <num_random> is the number of random players, and <smart_players> is a list of difficulty levels for each SmartPlayer that is to be created. The list should contain <num_human> HumanPlayer objects first, then <num_random> RandomPlayer objects, then the same number of SmartPlayer objects as the length of <smart_players>. The difficulty levels in <smart_players> should be applied to each SmartPlayer object, in order. >>> len(create_players(1, 1, [1])) == 3 True """ players = [] # create goals to make players total_players = num_human + num_random + len(smart_players) goals = generate_goals(total_players) # make human players i = 0 while i < num_human: players.append(HumanPlayer(i, goals[i])) i += 1 while i < num_human + num_random: players.append(RandomPlayer(i, goals[i])) i += 1 difficulty = 0 while i < total_players: players.append(SmartPlayer(i, goals[i], smart_players[difficulty])) i += 1 difficulty += 1 return players
def test_generate_goals_colours() -> None: goals = generate_goals(4) assert goals[0].colour in COLOUR_LIST
def test_generate_goals_colour(self) -> None: goals = generate_goals(3) for i in range(len(goals) - 1): for j in range(i + 1, len(goals)): assert goals[i].colour != goals[j].colour
def test_generate_goals(self) -> None: n = random.randint(1, 100) assert len(generate_goals(4)) == 4
def test_generate_goal_1(self): res = generate_goals(0) self.assertTrue(res == [])
def test_generate_goal_2(self): res = generate_goals(1) self.assertTrue(len(res) == 1) self.assertTrue(res[0].__class__ in [BlobGoal, PerimeterGoal]) self.assertTrue(res[0].colour in COLOUR_LIST)