Exemplo n.º 1
0
class LevelGetRoomTest(TestCase):

    def setUp(self):
        self.level = Level()
        self.room_a = Room(width=2, height=3)
        self.room_a.x, self.room_a.y = 0, 0
        self.room_b = Room(width=2, height=1)
        self.room_b.x, self.room_b.y = 2, 3
        for room in (self.room_a, self.room_b):
            self.level.add(room)

    def test_get_nothing(self):
        self.assertEqual(self.level.get(x=128, y=128), set())

    def test_get_one_room(self):
        self.assertEqual(self.level.get(x=0, y=0), set([self.room_a]))

    def test_get_multiple_rooms(self):
        self.assertEqual(self.level.get(width=2),
                         set([self.room_a, self.room_b]))

    def test_get_with_nonexistent_kwargs(self):
        self.assertEqual(self.level.get(nonexistent_kwarg=True), set())
Exemplo n.º 2
0
class LevelAddRoomTest(TestCase):

    def setUp(self):
        self.level = Level()

    def test_empty_level(self):
        self.assertEqual(self.level.rooms, set())

    def test_level_with_one_room(self):
        room = Room(width=1, height=1)
        room.x, room.y = 0, 0
        self.level.add(room)
        self.assertEqual(self.level.rooms, set([room]))

    def test_add_room_without_coordinates(self):
        room = Room(width=1, height=1)
        with self.assertRaises(Level.RoomCoordinatesRequired):
            self.level.add(room)

    def test_add_an_overlapping_room_with_matching_coordinates(self):
        room = Room(width=1, height=1)
        room.x, room.y = 0, 0
        self.level.add(room)
        overlap_room = Room(width=1, height=1)
        overlap_room.x, overlap_room.y = 0, 0
        with self.assertRaises(Level.RoomOverlap):
            self.level.add(overlap_room)

    def test_add_an_overlapping_room_with_positive_shift(self):
        room = Room(width=3, height=3)
        room.x, room.y = 0, 0
        self.level.add(room)
        overlap_room = Room(width=2, height=2)
        overlap_room.x, overlap_room.y = 2, 2
        with self.assertRaises(Level.RoomOverlap):
            self.level.add(overlap_room)

    def test_add_an_overlapping_room_with_negative_shift(self):
        room = Room(width=3, height=3)
        room.x, room.y = 3, 3
        self.level.add(room)
        overlap_room = Room(width=2, height=2)
        overlap_room.x, overlap_room.y = 2, 2
        with self.assertRaises(Level.RoomOverlap):
            self.level.add(overlap_room)

    def test_level_with_two_non_adjacent_rooms(self):
        for x, y in [(0, 0), (3, 3)]:
            room = Room(width=1, height=1)
            room.x, room.y = x, y
            self.level.add(room)
        self.assertEqual(len(self.level.rooms), 2)

    def test_two_diagonaly_adjacent_rooms(self):
        """
        Rooms are not considered to be adjacent if they touch diagonaly.
        """
        for x, y in [(0, 0), (1, 1)]:
            room = Room(width=1, height=1)
            room.x, room.y = x, y
            self.level.add(room)
            turf = iter(room.get(x=0, y=0)).next()
            self.assertEqual(turf.exits, {})
        self.assertEqual(len(self.level.rooms), 2)

    def test_level_with_two_fully_adjacent_rooms(self):
        """Exits are added to adjacent turfs."""
        a, b = Room(width=1, height=1), Room(width=1, height=1)
        a.x, a.y, b.x, b.y = 0, 0, 1, 0
        self.level.add(a)
        self.level.add(b)
        turf_a = iter(a.get(x=0, y=0)).next()
        turf_b = iter(b.get(x=0, y=0)).next()
        self.assertEqual(len(self.level.rooms), 2)
        self.assertEqual(len(turf_a.exits), 1)
        self.assertEqual(len(turf_b.exits), 1)
        self.assertEqual(turf_a.exits[(1, 0)], turf_b)
        self.assertEqual(turf_b.exits[(-1, 0)], turf_a)

    def test_level_with_two_partially_adjacent_rooms(self):
        """Non-adjacent turfs do not become exits."""
        a, b = Room(width=3, height=3), Room(width=3, height=3)
        a.x, a.y, b.x, b.y = 3, 1, 0, 0
        self.level.add(a)
        self.level.add(b)
        exits = set([((0, 0), (2, 1)), ((0, 1), (2, 2))])
        for ((a_x, a_y), (b_x, b_y)) in exits:
            turf_a = iter(a.get(x=a_x, y=a_y)).next()
            turf_b = iter(b.get(x=b_x, y=b_y)).next()
            self.assertEqual(len(turf_a.exits), 1)
            self.assertEqual(len(turf_b.exits), 1)
            self.assertEqual(turf_a.exits[(-1, 0)], turf_b)
            self.assertEqual(turf_b.exits[(1, 0)], turf_a)
        no_exits = {
            a: set([(0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]),
            b: set([(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0)])}
        for room, coordinates in no_exits.items():
            for (x, y) in coordinates:
                turf = iter(room.get(x=x, y=y)).next()
                self.assertEqual(len(turf.exits), 0)

    def test_level_with_three_adjacent_rooms(self):
        a, b, c = Room(width=1, height=1), Room(1, 1), Room(1, 1)
        a.x, a.y, b.x, b.y, c.x, c.y = 0, 0, 1, 0, 0, 1
        for room in (a, b, c):
            self.level.add(room)
        turf_a = iter(a.get(x=0, y=0)).next()
        turf_b = iter(b.get(x=0, y=0)).next()
        turf_c = iter(c.get(x=0, y=0)).next()
        self.assertEqual(len(turf_a.exits), 2)
        for turf in (turf_b, turf_c):
            self.assertEqual(len(turf.exits), 1)
        self.assertEqual(turf_a.exits, {(1, 0): turf_b, (0, 1): turf_c})
        self.assertEqual(turf_b.exits[(-1, 0)], turf_a)
        self.assertEqual(turf_c.exits[(0, -1)], turf_a)