def test_uniform_noise_4_bots_no_noise_manhattan():
test_layout = (""" ##################
# #. . # . 2 #
# ##### #####3#
# 0 . # . .#1#
################## """)
parsed = parse_layout(test_layout)
expected_0 = [(1, 1), (3, 1), (4, 1), (5, 1), (6, 1), (1, 2), (1, 3),
(2, 3), (3, 3), (4, 3), (5, 3), (6, 3), (7, 3), (7, 2)]
position_bucket_0 = collections.defaultdict(int)
expected_2 = [(13, 1)]
position_bucket_2 = {(13, 1): 0}
for i in range(200):
noised = gf.noiser(walls=parsed['walls'],
bot_position=parsed['bots'][1],
enemy_positions=parsed['bots'][0::2])
assert noised['is_noisy'] == [True, False]
position_bucket_0[noised['enemy_positions'][0]] += 1
position_bucket_2[noised['enemy_positions'][1]] += 1
assert 200 == sum(position_bucket_0.values())
assert 200 == sum(position_bucket_2.values())
# Since this is a randomized algorithm we need to be a bit lenient with
# our tests. We check that each position was selected at least once.
assert set(position_bucket_0.keys()) == set(expected_0)
assert set(position_bucket_2.keys()) == set(expected_2)
def test_uniform_noise_manhattan(noise_radius, expected, test_layout=None):
# Test how bot 1 observes bot 0
if not test_layout:
test_layout = (""" ##################
# #. . # . #
# ##### ##### #
# 0 . # . .#1#
################## """)
parsed = parse_layout(test_layout)
position_bucket = collections.defaultdict(int)
for i in range(200):
noised = gf.noiser(walls=parsed['walls'],
bot_position=parsed['bots'][1],
enemy_positions=[parsed['bots'][0]],
noise_radius=noise_radius)
if noise_radius == 0:
assert noised['is_noisy'] == [False]
else:
assert noised['is_noisy'] == [True]
noised_pos = noised['enemy_positions'][0]
position_bucket[noised_pos] += 1
assert 200 == sum(position_bucket.values())
# Since this is a randomized algorithm we need to be a bit lenient with
# our tests. We check that each position was selected at least once.
assert set(position_bucket.keys()) == set(expected)
def test_noiser_noising_at_noise_radius_extreme(ii):
""" It is the any team's turn, and the noiser should
still noise within confines of maze, despite extreme radius """
gamestate = make_gamestate()
gamestate["turn"] = random.randint(0, 3)
team_id = gamestate["turn"] % 2
old_bots = gamestate["bots"]
team_bots = old_bots[team_id::2]
enemy_bots = old_bots[1 - team_id::2]
noised = gf.noiser(walls=gamestate["walls"],
shape=gamestate["shape"],
bot_position=gamestate["bots"][gamestate["turn"]],
enemy_positions=enemy_bots,
noise_radius=50,
sight_distance=5,
rnd=None)
assert all(noised["is_noisy"])
for noised_pos in noised["enemy_positions"]:
# check that the noised position is legal
assert noised_pos not in gamestate["walls"]
assert 0 <= noised_pos[0] < max(gamestate["walls"])[0]
assert 0 <= noised_pos[1] < max(gamestate["walls"])[1]
def test_noiser_no_negative_coordinates(bot_id):
gamestate = make_gamestate()
old_bots = gamestate["bots"][:]
walls = gamestate['walls']
bot_position = gamestate['bots'][bot_id]
enemy_group = 1 - (bot_id // 2)
enemy_positions = gamestate['bots'][enemy_group::2]
noised = gf.noiser(walls,
bot_position=bot_position,
enemy_positions=enemy_positions,
noise_radius=5,
sight_distance=5,
rnd=None)
new_bots = noised["enemy_positions"]
print(noised)
test_1 = all(item[0] > 0 for item in new_bots)
test_2 = all(item[1] > 0 for item in new_bots)
assert test_1 and test_2
def test_noise_manhattan_failure():
test_layout = (""" ##################
########## . 2 #
########## #####3#
###0###### . . 1#
################## """)
# we test what bot 1 sees
# bot 0 should not be noised
# bot 2 should not be noised
parsed = parse_layout(test_layout)
expected = parsed['food'] + [parsed['bots'][0]]
position_bucket = collections.defaultdict(int)
# check a few times
for i in range(5):
noised = gf.noiser(walls=parsed['walls'],
bot_position=parsed['bots'][1],
enemy_positions=parsed['bots'][0::2])
assert noised['is_noisy'] == [False, False]
noised_pos = noised['enemy_positions']
assert noised_pos == parsed['bots'][0::2]
def test_uniform_noise_manhattan_graphical_distance(test_layout, is_noisy):
# Test how bot 1 observes bot 0
# the expected locations are where the food is placed
parsed = parse_layout(test_layout)
expected = parsed['food'] + [parsed['bots'][0]]
position_bucket = collections.defaultdict(int)
NUM_TESTS = 400
for i in range(NUM_TESTS):
noised = gf.noiser(walls=parsed['walls'],
bot_position=parsed['bots'][1],
enemy_positions=[parsed['bots'][0]])
# use default values for radius and distance
# noise_radius=5, sight_distance=5
assert noised['is_noisy'] == [is_noisy]
noised_pos = noised['enemy_positions'][0]
position_bucket[noised_pos] += 1
assert NUM_TESTS == sum(position_bucket.values())
# Since this is a randomized algorithm we need to be a bit lenient with
# our tests. We check that each position was selected at least once.
assert set(position_bucket.keys()) == set(expected)
