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)
