def test_fill_ellipse(self):
e = Tiles.empty
w = Tiles.wall
layer = np.full((8, 8), e)
Drawing.fill_ellipse(layer, (2, 2), 2, 2, w)
expected_layer = np.array([[e, w, w, w, e, e, e, e],
[w, w, w, w, w, e, e, e],
[w, w, w, w, w, e, e, e],
[w, w, w, w, w, e, e, e],
[e, w, w, w, e, e, e, e],
[e, e, e, e, e, e, e, e],
[e, e, e, e, e, e, e, e],
[e, e, e, e, e, e, e, e]])
# Test normal circle
self.assertTrue((layer == expected_layer).all())
layer = np.full((8, 8), e)
Drawing.fill_ellipse(layer, (7, 5), 5, 3, w)
expected_layer = np.array([[e, e, e, e, e, e, e, e],
[e, e, e, e, e, e, e, e],
[e, e, e, e, w, w, w, e],
[e, e, e, w, w, w, w, w],
[e, e, e, w, w, w, w, w],
[e, e, w, w, w, w, w, w],
[e, e, w, w, w, w, w, w],
[e, e, w, w, w, w, w, w]])
# Test ellipse clipping off side
self.assertTrue((layer == expected_layer).all())
def generate(level, size):
level.upper_layer = np.full(size, Tiles.empty)
Drawing.draw_rectangle(level.upper_layer, (0, 0),
np.array(size) - 1, Tiles.wall)
for y in range(1, size[0] - 1):
for x in range(1, size[1] - 1):
level.upper_layer[y, x] = RandomGenerator.random_tile()
player_position = RandomGenerator.get_random_position_in_level(size)
level.upper_layer[player_position] = Tiles.player
finish_offsets = [
np.array([-1, 0]),
np.array([1, 0]),
np.array([0, -1]),
np.array([0, 1]),
np.array([0, 0])
]
finish_tiles = [
Tiles.wall, Tiles.required_collectable_barrier, Tiles.wall,
Tiles.wall, Tiles.finish
]
RandomGenerator.place_feature(level, size, finish_tiles,
finish_offsets)
RandomGenerator.place_feature(level, size, [Tiles.flippers],
np.array([0, 0]))
# RandomGenerator.place_feature(level, size, [Tiles.monster], np.array([0,0]))
level.required_collectable_count = np.count_nonzero(
level.upper_layer == Tiles.collectable)
def add_random_rectangles(level, size, level_space_aesthetic):
for _ in range(level_space_aesthetic.rectangle_count):
p0 = LevelSpaceGenerator.get_random_positions(size, 1)[0]
rect_max = level_space_aesthetic.rectangle_max - level_space_aesthetic.rectangle_min
p1 = p0 + LevelSpaceGenerator.get_random_positions(
np.array([rect_max, rect_max]),
1)[0] + level_space_aesthetic.rectangle_min
Drawing.fill_rectangle(level.upper_layer, p0 + 1, p1 - 1,
Tiles.empty)
Drawing.draw_rectangle(level.upper_layer, p0, p1, Tiles.wall)
def test_ensure_min_max_correct(self):
a, b = Drawing.ensure_max_min_correct([0, 0], [3, 3])
self.assertTrue((a == np.array([0, 0])).all())
self.assertTrue((b == np.array([3, 3])).all())
a, b = Drawing.ensure_max_min_correct([5, 0], [3, 2])
self.assertTrue((a == np.array([3, 0])).all())
self.assertTrue((b == np.array([5, 2])).all())
a, b = Drawing.ensure_max_min_correct([3, 5], [3, 2])
self.assertTrue((a == np.array([3, 2])).all())
self.assertTrue((b == np.array([3, 5])).all())
def generate(level, size, level_space_aesthetic):
level.upper_layer = np.full(size, Tiles.empty)
level.lower_layer = np.full(size, Tiles.empty)
LevelSpaceGenerator.add_random_rectangles(level, size,
level_space_aesthetic)
LevelSpaceGenerator.add_random_noise(level, size,
level_space_aesthetic)
Drawing.draw_rectangle(level.upper_layer, (0, 0), size - 1, Tiles.wall)
LevelSpaceGenerator.mirror_level(
level, level_space_aesthetic.x_mirror_probability,
level_space_aesthetic.y_mirror_probability)
def test_draw_rectangle(self):
e = Tiles.empty
w = Tiles.wall
layer = np.full((5, 5), e)
Drawing.draw_rectangle(layer, (0, 0), (3, 2), w)
expected_layer = np.array([[w, w, w, e, e], [w, e, w, e, e],
[w, e, w, e, e], [w, w, w, e, e],
[e, e, e, e, e]])
# Test normal rectangle
self.assertTrue((layer == expected_layer).all())
layer = np.full((5, 5), e)
Drawing.draw_rectangle(layer, (2, 3), (8, 6), w)
expected_layer = np.array([[e, e, e, e, e], [e, e, e, e, e],
[e, e, e, w, w], [e, e, e, w, e],
[e, e, e, w, e]])
# Test rectangle clipping off side
self.assertTrue((layer == expected_layer).all())
def test_draw_line(self):
e = Tiles.empty
w = Tiles.wall
layer = np.full((5, 5), e)
Drawing.draw_line(layer, (0, 0), (4, 4), w)
expected_layer = np.array([[w, e, e, e, e], [e, w, e, e, e],
[e, e, w, e, e], [e, e, e, w, e],
[e, e, e, e, w]])
# Test normal line
self.assertTrue((layer == expected_layer).all())
layer = np.full((5, 5), e)
Drawing.draw_line(layer, (-2, 1), (11, 6), w)
expected_layer = np.array([[e, e, w, e, e], [e, e, w, e, e],
[e, e, e, w, e], [e, e, e, w, e],
[e, e, e, w, e]])
# Test line clipping off side
self.assertTrue((layer == expected_layer).all())
def dig_dungeons(level, size, positions, adjacency_matrix):
level.upper_layer = np.full(size, Tiles.wall)
Drawing.draw_rectangle(level.upper_layer, (0, 0),
np.array(size) - 1, Tiles.wall)
level.lower_layer = np.full(size, Tiles.empty)
for position in positions:
# Drawing.fill_ellipse(level.upper_layer, position, 3, 3, Tiles.empty)
Drawing.fill_rectangle(level.upper_layer, position - 2,
position + 2, Tiles.empty)
count, _ = positions.shape
for i in range(count):
for j in range(count):
if adjacency_matrix[i, j] == 1:
p1 = positions[i]
p2 = positions[j]
Drawing.draw_line(level.upper_layer, p1, p2, Tiles.empty)
Drawing.draw_line(level.upper_layer, (p1[0] - 1, p1[1]),
(p2[0] - 1, p2[1]), Tiles.empty)