def test_portal_has_icons(self): """ Test that portal created by adder has two icons set One to display and another to be used by opposite end """ level = Level(size = (20, 20), floor_type = self.floor_rock, wall_type = self.wall_empty) level_generator = mock(LevelGenerator) for loc_y in range(8, 12): for loc_x in range(8, 12): level.set_location_type((loc_x, loc_y), 'room') portal_adder = PortalAdder((1, 2), 'room', level_generator, self.rng) portal_adder.add_portal(level) portals = level.portals portal = level.portals[0] assert_that(portal.icon, is_(equal_to(1))) assert_that(portal.other_end_icon, is_(equal_to(2)))
def test_level_generator_is_created(self): """ Test that level generator is created for newly created portal """ level = Level(size = (20, 20), floor_type = self.floor_rock, wall_type = self.wall_empty) level_generator = mock(LevelGenerator) for loc_y in range(8, 12): for loc_x in range(8, 12): level.set_location_type((loc_x, loc_y), 'room') portal_adder = PortalAdder((1, 2), 'room', level_generator, self.rng) portal_adder.add_portal(level) portals = level.portals portal = level.portals[0] assert_that(portal.level_generator, is_(same_instance(level_generator)))
def setup(self): """ Setup the test case """ self.level = Level((20, 20), self.floor_rock, self.wall_ground) self.section = Section((5, 5), (15, 15), self.level, self.rng) self.generator = SquareRoomGenerator(self.floor_rock, self.wall_empty, ["crypt"])
def setup(self): """ Setup this test case """ self.rng = Random() self.item = (ItemBuilder() .build()) self.level = Level([20, 20]) self.character = (CharacterBuilder() .with_location((5, 5)) .with_level(self.level) .with_action_factory( ActionFactoryBuilder() .with_inventory_factory()) .build()) self.level.add_item(self.item, (5, 5)) self.dungeon = pyherc.data.dungeon.Dungeon() self.dungeon.levels = self.level self.model = pyherc.data.model.Model() self.model.dungeon = self.dungeon self.model.player = self.character
def generate_level(self, portal): """ Generate level :param portal: portal to link to this level :type portal: Portal """ new_level = Level(size = self.level_context.size, floor_type = self.level_context.floor_type, wall_type = self.level_context.wall_type, empty_floor = self.level_context.empty_floor, empty_wall = self.level_context.empty_wall) sections = self.partitioner.partition_level(new_level) for section in sections: generator = self.random_generator.choice(self.room_generators) generator.generate_room(section) self.decorator.decorate_level(new_level) for adder in self.portal_adders: adder.add_portal(new_level) # all this needs to be cleaned up if portal != None: rooms = new_level.get_locations_by_type('room') if len(rooms) > 0: new_portal = Portal(icons = (portal.other_end_icon, None), level_generator = None) location = self.random_generator.choice(rooms) new_level.add_portal(new_portal, location, portal) else: self.logger.warn('no location found, skipping') self.creature_adder.add_creatures(new_level) self.item_adder.add_items(new_level) self.logger.debug(new_level.dump_string()) return new_level
def setup(self): """ Setup the test case """ self.floor_empty = 0 self.floor_rock = 1 self.wall_empty = 10 self.wall_ground = 11 self.level = Level((10, 10), self.floor_empty, self.wall_empty) self.section = Section((0, 0), (10, 10), self.level, self.rng)
def build(self): """ Build level Returns: Level """ level = Level(size = self.level_size, floor_type = self.floor_tile, wall_type = self.wall_tile, empty_wall = self.empty_wall_tile) for wall in self.walls: level.walls[wall[0]][wall[1]] = self.solid_wall_tile for creature in self.characters: level.add_creature(creature) return level
def test_stair_linking(self): """ Test that stairs can be linked """ level1 = Level([20, 20], self.floor_rock, self.wall_empty) level2 = Level([20, 20], self.floor_rock, self.wall_empty) stairs1 = Portal((None, None), None) #TODO: beak link stairs1.icon = 200 level1.add_portal(stairs1, (10, 10)) stairs2 = Portal((None, None), None) level2.add_portal(stairs2, (5, 5), stairs1) assert(stairs1.level == level1) assert(stairs1.location == (10, 10)) assert(stairs1.other_end == stairs2) assert(stairs2.level == level2) assert(stairs2.location == (5, 5)) assert(stairs2.other_end == stairs1) assert(stairs1 in level1.portals) assert(stairs2 in level2.portals)
class TestSectionLevelAccess(object): """ Tests to ensure that client has access to portion of level via Section """ def __init__(self): """ Default constructor """ object.__init__(self) self.level = None self.section = None self.floor_empty = None self.floor_rock = None self.wall_empty = None self.wall_ground = None self.rng = random.Random() def setup(self): """ Setup the test case """ self.floor_empty = 0 self.floor_rock = 1 self.wall_empty = 10 self.wall_ground = 11 self.level = Level((10, 10), self.floor_empty, self.wall_empty) self.section = Section((0, 0), (10, 10), self.level, self.rng) def test_setting_floor(self): """ Test that floor can be set """ self.section.set_floor((5, 5), self.floor_rock, None) assert_that(self.level.floor[5][5], is_(equal_to(self.floor_rock))) def test_setting_wall(self): """ Test that walls can be set """ self.section.set_wall((2, 2), self.wall_ground, None) assert_that(self.level.walls[2][2], is_(equal_to(self.wall_ground))) def test_setting_location_type(self): """ Test that location type can be set correctly """ self.section.set_floor((2, 3), self.floor_rock, "corridor") assert_that(self.level.get_location_type((2, 3)), is_(equal_to("corridor")))
def setup(self): """ Setup the test case """ self.rng = random.Random() self.level = Level((60, 40)) self.level.set_location_type((10, 10), 'room') creature_config = CreatureConfigurations(self.rng) creature_config.add_creature( CreatureConfiguration(name = 'rat', body = 4, finesse = 12, mind = 2, hp = 2, speed = 2, icons = 1, attack = 2, ai = None)) creature_config.add_creature( CreatureConfiguration(name = 'dragon', body = 4, finesse = 12, mind = 2, hp = 2, speed = 2, icons = 1, attack = 2, ai = None)) self.mock_action_factory = mock() self.model = mock() self.creature_generator = CreatureGenerator(creature_config, self.model, self.mock_action_factory, self.rng) self.configuration = CreatureAdderConfiguration(['crypt']) self.configuration.add_creature(min_amount = 3, max_amount = 4, name = 'rat') self.configuration.add_creature(min_amount = 1, max_amount = 1, name = 'dragon', location = 'room') self.creature_adder = CreatureAdder(self.creature_generator, self.configuration, self.rng) self.creature_adder.add_creatures(self.level)
def test_add_stairs_to_room(self): """ Test that stairs can be added to a room """ level = Level(size = (20, 20), floor_type = self.floor_rock, wall_type = self.wall_empty) for loc_y in range(8, 12): for loc_x in range(8, 12): level.set_location_type((loc_x, loc_y), 'room') portal_adder = PortalAdder((1, 2), 'room', mock(), self.rng) portal_adder.add_portal(level) portals = level.portals assert_that(portals, has_length(1)) portal = level.portals[0] assert_that(located_in_room(portal), is_(True))
class TestSquareRoom: """ Tests for SquareRoomGenerator room generator """ def __init__(self): """ Default constructor """ self.level = None self.section = None self.generator = None self.floor_empty = 0 self.floor_rock = 1 self.wall_empty = 10 self.wall_ground = 11 self.rng = random.Random() def setup(self): """ Setup the test case """ self.level = Level((20, 20), self.floor_rock, self.wall_ground) self.section = Section((5, 5), (15, 15), self.level, self.rng) self.generator = SquareRoomGenerator(self.floor_rock, self.wall_empty, ["crypt"]) def test_generate_simple_room(self): """ Test that generator can create a simple room """ self.generator.generate_room(self.section) room_found = False for y_loc in range(20): for x_loc in range(20): if self.level.get_tile(x_loc, y_loc) != self.wall_empty: room_found = True assert_that(room_found, is_(True)) def test_room_connections_are_placed(self): """ Test that generating a square room will place 4 connectors """ self.generator.generate_room(self.section) assert_that(self.section.room_connections, has_length(4))
def setup(self): """ Setup for this test case """ self.item = (ItemBuilder() .with_name('banana') .build()) self.level = Level([20, 20]) self.character = (CharacterBuilder() .with_action_factory(ActionFactoryBuilder() .with_move_factory()) .with_level(self.level) .with_location((5, 5)) .build()) self.level.add_item(self.item, (5, 5))
def setup(self): """ Setup the test case """ self.floor_rock = 1 self.wall_ground = 2 self.wall_empty = 3 self.level = Level(size = (10, 10), floor_type = self.floor_rock, wall_type = self.wall_ground, empty_wall = self.wall_empty) self.rng = random.Random() self.section = Section(corner1 = (0, 0), corner2 = (10, 10), level = self.level, random_generator = self.rng)
def setup(self): """ Setup test case """ self.level = Level(size = (20, 10))
class TestLevel: """ Tests for Level """ def __init__(self): """ Default constructor """ self.level = None def setup(self): """ Setup test case """ self.level = Level(size = (20, 10)) def test_get_size(self): """ Test that Level can report size """ size = self.level.get_size() assert size == (21, 11) def test_get_rooms(self): """ Test that level can report what areas of it are marked as being room """ self.level.set_location_type((5, 5), 'room') self.level.set_location_type((5, 6), 'room') self.level.set_location_type((8, 8), 'room') self.level.set_location_type((9, 8), 'room') rooms = self.level.get_locations_by_type('room') assert_that(rooms, contains_inanyorder((5, 5), (5, 6), (8, 8), (9, 8))) def test_get_locations_by_type_does_not_report_all_locations(self): """ Test that getting locations by type does not return all locations """ self.level.set_location_type((5, 5), 'room') self.level.set_location_type((5, 6), 'room') self.level.set_location_type((8, 8), 'room') self.level.set_location_type((9, 8), 'room') self.level.set_location_type((6, 5), 'corridor') self.level.set_location_type((6, 6), 'corridor') self.level.set_location_type((6, 7), 'corridor') self.level.set_location_type((6, 8), 'corridor') rooms = self.level.get_locations_by_type('room') assert_that(rooms, contains_inanyorder((5, 5), (5, 6), (8, 8), (9, 8)))
class TestItemAdder(): """ Tests for ItemAdder """ def __init__(self): """ Default constructor """ self.rng = None self.level = None self.item_generator = None self.configuration = None self.item_adder = None self.floor_rock = None self.wall_empty = None def setup(self): """ Setup the test case """ self.floor_rock = 1 self.wall_empty = 2 self.rng = Random() self.level = Level((60, 40), self.floor_rock, self.wall_empty) self.level.set_location_type((10, 10), 'room') for x_loc in range(11, 30): self.level.set_location_type((x_loc, 10), 'corridor') item_config = ItemConfigurations(Random()) item_config.add_item( ItemConfiguration(name = 'dagger', cost = 2, weight = 1, icons = [500], types = ['weapon', 'light weapon', 'melee', 'simple weapon'], rarity = 'common', weapon_configration = WeaponConfiguration( damage = 2, critical_range = 11, critical_damage = 2, damage_types = ['piercing', 'slashing'], weapon_class = 'simple'))) item_config.add_item( ItemConfiguration(name = 'red potion', cost = 150, weight = 1, icons = [100], types = ['potion'], rarity = 'rare', effect_handles = [EffectHandle( trigger = 'on drink', effect = 'cure medium wounds', parameters = None, charges = 1)])) self.item_generator = ItemGenerator(item_config) self.configuration = ItemAdderConfiguration(['crypt']) self.configuration.add_item(min_amount = 3, max_amount = 4, name = 'dagger') self.configuration.add_item(min_amount = 1, max_amount = 1, type = 'potion', location = 'room') self.item_adder = ItemAdder(self.item_generator, self.configuration, self.rng) self.item_adder.add_items(self.level) def test_adding_items(self): """ Test basic case of adding items on the level """ assert_that(self.level.items, has_length(greater_than(3))) assert_that(self.level.items, has_length(less_than(6))) assert_that(self.level, does_have_item('dagger', greater_than_or_equal_to(3))) assert_that(self.level, does_have_item('red potion', 1)) def test_adding_to_location(self): """ Test that ItemAdder will use location types passed to it """ potion = [x for x in self.level.items if x.name == 'red potion'][0] location = potion.location assert_that(located_in_room(potion))
class TestCorridor(): """ Tests for Corridor """ def __init__(self): """ Default constructor """ self.level = None self.section = None self.rng = None self.floor_rock = None self.wall_ground = None self.wall_empty = None def setup(self): """ Setup the test case """ self.floor_rock = 1 self.wall_ground = 2 self.wall_empty = 3 self.level = Level(size = (10, 10), floor_type = self.floor_rock, wall_type = self.wall_ground, empty_wall = self.wall_empty) self.rng = random.Random() self.section = Section(corner1 = (0, 0), corner2 = (10, 10), level = self.level, random_generator = self.rng) def test_straight_horizontal(self): """ Test that straight horizontal corridor can be made """ edge_connection = Connection(connection = None, location = (10, 5), direction = "left", section = self.section) room_connection = Connection(connection = None, location = (5, 5), direction = "right", section = self.section) self.section.connections.append(edge_connection) self.section.room_connections.append(room_connection) generator = CorridorGenerator(start_point = edge_connection, end_point = room_connection, tile = self.wall_empty) generator.generate() for x_loc in range(5, 11): assert_that(self.level.get_tile(x_loc, 5), is_(equal_to(self.floor_rock))) def test_straight_vertical(self): """ Test that straight vertical corridor can be made """ edge_connection = Connection(connection = None, location = (5, 0), direction = "down", section = self.section) room_connection = Connection(connection = None, location = (5, 5), direction = "up", section = self.section) self.section.connections.append(edge_connection) self.section.room_connections.append(room_connection) generator = CorridorGenerator(start_point = edge_connection, end_point = room_connection, tile = self.wall_empty) generator.generate() for y_loc in range(0, 6): assert_that(self.level.get_tile(5, y_loc), is_(equal_to(self.floor_rock))) def test_bent_horizontal(self): """ Test that horizontal corridor with bend can be made """ edge_connection = Connection(connection = None, location = (10, 2), direction = "left", section = self.section) room_connection = Connection(connection = None, location = (5, 8), direction = "right", section = self.section) self.section.connections.append(edge_connection) self.section.room_connections.append(room_connection) generator = CorridorGenerator(start_point = edge_connection, end_point = room_connection, tile = self.wall_empty) generator.generate() assert_that(self.level.get_wall_tile(10, 2), is_(equal_to(self.wall_empty))) assert_that(self.level.get_wall_tile(5, 8), is_(equal_to(self.wall_empty))) assert_that(self.level, is_fully_accessible_via(self.wall_empty)) def test_bent_vertical(self): """ Test that horizontal corridor with bend can be made """ edge_connection = Connection(connection = None, location = (9, 0), direction = "down", section = self.section) room_connection = Connection(connection = None, location = (2, 9), direction = "up", section = self.section) self.section.connections.append(edge_connection) self.section.room_connections.append(room_connection) generator = CorridorGenerator(start_point = edge_connection, end_point = room_connection, tile = self.wall_empty) generator.generate() assert_that(self.level.get_wall_tile(9, 0), is_(equal_to(self.wall_empty))) assert_that(self.level.get_wall_tile(2, 9), is_(equal_to(self.wall_empty))) assert_that(self.level, is_fully_accessible_via(self.wall_empty))
class TestCreatureAdder(): """ Tests for CreatureAdder """ def __init__(self): """ Default constructor """ self.rng = None self.level = None self.mock_action_factory = None self.creature_generator = None self.configuration = None self.creature_adder = None def setup(self): """ Setup the test case """ self.rng = random.Random() self.level = Level((60, 40)) self.level.set_location_type((10, 10), 'room') creature_config = CreatureConfigurations(self.rng) creature_config.add_creature( CreatureConfiguration(name = 'rat', body = 4, finesse = 12, mind = 2, hp = 2, speed = 2, icons = 1, attack = 2, ai = None)) creature_config.add_creature( CreatureConfiguration(name = 'dragon', body = 4, finesse = 12, mind = 2, hp = 2, speed = 2, icons = 1, attack = 2, ai = None)) self.mock_action_factory = mock() self.model = mock() self.creature_generator = CreatureGenerator(creature_config, self.model, self.mock_action_factory, self.rng) self.configuration = CreatureAdderConfiguration(['crypt']) self.configuration.add_creature(min_amount = 3, max_amount = 4, name = 'rat') self.configuration.add_creature(min_amount = 1, max_amount = 1, name = 'dragon', location = 'room') self.creature_adder = CreatureAdder(self.creature_generator, self.configuration, self.rng) self.creature_adder.add_creatures(self.level) def test_adding_creatures(self): """ Test basic case of adding creatures on the level """ assert_that(self.level.creatures, has_length(greater_than(3))) assert_that(self.level.creatures, has_length(less_than(6))) assert_that(self.level, has_creature('rat', greater_than_or_equal_to(3))) assert_that(self.level, has_creature('dragon', 1)) def test_adding_to_location(self): """ Test that CreatureAdder will use location types passed to it """ dragon = [x for x in self.level.creatures if x.name == 'dragon'][0] location = dragon.location assert_that(located_in_room(dragon))
class TestItems(object): """ Tests for items """ def __init__(self): """ Default constructor """ super(TestItems, self).__init__() self.item = None self.level = None self.dungeon = None self.character = None def setup(self): """ Setup for this test case """ self.item = (ItemBuilder() .with_name('banana') .build()) self.level = Level([20, 20]) self.character = (CharacterBuilder() .with_action_factory(ActionFactoryBuilder() .with_move_factory()) .with_level(self.level) .with_location((5, 5)) .build()) self.level.add_item(self.item, (5, 5)) def test_wield_weapon(self): """ Test that character can wield a weapon (dagger) """ item = ItemBuilder().build() assert_that(item, is_not(is_in(self.character.weapons))) pyherc.rules.items.wield(mock(), self.character, item) assert_that(item, is_in(self.character.weapons)) def test_unwielding_item(self): """ Test that wielded item can be unwielded """ item = ItemBuilder().build() pyherc.rules.items.wield(mock(), self.character, item) assert_that(item, is_in(self.character.weapons)) pyherc.rules.items.unwield(mock(), self.character, item) assert_that(item, is_not(is_in(self.character.weapons))) def test_dual_wielding(self): """ Test that character can wield two weapons """ item1 = (ItemBuilder() .with_name('dagger') .with_tag('light weapon') .with_damage(1) .build()) item2 = (ItemBuilder() .with_name('sickle') .with_tag('light weapon') .with_damage(2) .build()) assert_that(item1, is_not(is_in(self.character.weapons))) assert_that(item2, is_not(is_in(self.character.weapons))) pyherc.rules.items.wield(mock(), self.character, item1) pyherc.rules.items.wield(mock(), self.character, item2, dual_wield = True) assert_that(item1, is_in(self.character.weapons)) assert_that(item2, is_in(self.character.weapons)) def test_dual_wielding_two_handed_weapons(self): #pylint: disable=C0103 """ Test that character can not dual wield two-handed weapon """ item1 = (ItemBuilder() .with_name('longspear') .with_tag('two-handed weapon') .with_tag('weapon') .build()) item2 = (ItemBuilder() .with_name('sickle') .with_tag('light weapon') .with_tag('weapon') .build()) assert_that(item1, is_not(is_in(self.character.weapons))) assert_that(item2, is_not(is_in(self.character.weapons))) pyherc.rules.items.wield(mock(), self.character, item2) pyherc.rules.items.wield(mock(), self.character, item1, dual_wield = True) assert_that(item1, is_not(is_in(self.character.weapons))) assert_that(item2, is_in(self.character.weapons)) def test_can_dual_wield(self): """ Test that system can determine if two items can be dual-wielded """ item1 = (ItemBuilder() .with_name('longspear') .with_tag('weapon') .with_damage(2) .build()) item2 = (ItemBuilder() .with_name('sickle') .with_tag('light weapon') .with_damage(1) .build()) assert(not pyherc.rules.items.can_dual_wield( mock(), self.character, item1, item2)) def test_dual_wieldable(self): """ Test that system can determine if item is dual-wieldable """ item1 = (ItemBuilder() .with_name('longspear') .with_tag('weapon') .with_damage(3) .build()) item2 = (ItemBuilder() .with_name('sickle') .with_tag('light weapon') .with_damage(1) .build()) assert(not pyherc.rules.items.is_dual_wieldable( mock(), self.character, item1)) assert(pyherc.rules.items.is_dual_wieldable( mock(), self.character, item2)) def test_dual_wieldable_apples(self): """ Test determing if item is dual-wieldable when using mundane items """ item = (ItemBuilder() .with_name('apple') .with_tag('food') .build()) assert(not pyherc.rules.items.is_dual_wieldable( mock(), self.character, item)) def test_tags(self): """ Test that different types of items have tags """ item = ItemBuilder().build() assert(item.get_tags() is not None) def test_main_type_basic(self): """ Test that main type can be retrieved """ self.item = (ItemBuilder() .with_tag('weapon') .build()) main_type = self.item.get_main_type() assert(main_type == 'weapon') self.item = (ItemBuilder() .with_tag('food') .build()) main_type = self.item.get_main_type() assert(main_type == 'food')
def setup(self): """ Setup the test case """ self.floor_rock = 1 self.wall_empty = 2 self.rng = Random() self.level = Level((60, 40), self.floor_rock, self.wall_empty) self.level.set_location_type((10, 10), 'room') for x_loc in range(11, 30): self.level.set_location_type((x_loc, 10), 'corridor') item_config = ItemConfigurations(Random()) item_config.add_item( ItemConfiguration(name = 'dagger', cost = 2, weight = 1, icons = [500], types = ['weapon', 'light weapon', 'melee', 'simple weapon'], rarity = 'common', weapon_configration = WeaponConfiguration( damage = 2, critical_range = 11, critical_damage = 2, damage_types = ['piercing', 'slashing'], weapon_class = 'simple'))) item_config.add_item( ItemConfiguration(name = 'red potion', cost = 150, weight = 1, icons = [100], types = ['potion'], rarity = 'rare', effect_handles = [EffectHandle( trigger = 'on drink', effect = 'cure medium wounds', parameters = None, charges = 1)])) self.item_generator = ItemGenerator(item_config) self.configuration = ItemAdderConfiguration(['crypt']) self.configuration.add_item(min_amount = 3, max_amount = 4, name = 'dagger') self.configuration.add_item(min_amount = 1, max_amount = 1, type = 'potion', location = 'room') self.item_adder = ItemAdder(self.item_generator, self.configuration, self.rng) self.item_adder.add_items(self.level)
class TestItemsInLevel: """ Tests performed with items that are placed on levels """ def __init__(self): """ Default constructor """ self.item = None self.level = None self.dungeon = None self.model = None self.character = None self.rng = None def setup(self): """ Setup this test case """ self.rng = Random() self.item = (ItemBuilder() .build()) self.level = Level([20, 20]) self.character = (CharacterBuilder() .with_location((5, 5)) .with_level(self.level) .with_action_factory( ActionFactoryBuilder() .with_inventory_factory()) .build()) self.level.add_item(self.item, (5, 5)) self.dungeon = pyherc.data.dungeon.Dungeon() self.dungeon.levels = self.level self.model = pyherc.data.model.Model() self.model.dungeon = self.dungeon self.model.player = self.character def test_picking_up(self): """ Test that item can be picked up """ assert(self.character.location == (5, 5)) assert(self.item.location == (5, 5)) self.character.pick_up(self.item) assert(self.item in self.character.inventory) assert(not self.item in self.level.items) assert(self.item.location == ()) def test_picking_up_not_correct_location(self): #pylint: disable=C0103 """ Test that item is not picked up from wrong location """ self.character.location = (6, 6) assert(self.character.location == (6, 6)) assert(self.item.location == (5, 5)) self.character.pick_up(self.item) assert(not self.item in self.character.inventory) assert(self.item in self.level.items) def test_dropping_item(self): """ Test that an item can be dropped from inventory """ self.character.pick_up(self.item) assert(self.item in self.character.inventory) assert(not self.item in self.level.items) self.character.location = (8, 8) pyherc.rules.items.drop(self.model, self.character, self.item) assert(not self.item in self.character.inventory) assert(self.item in self.level.items) assert(self.item.location == (8, 8)) def test_dropping_wielded_item(self): """ Test that wielded item is dropped correctly """ self.character.pick_up(self.item) pyherc.rules.items.wield(self.model, self.character, self.item) assert(self.item in self.character.inventory) assert(not self.item in self.level.items) assert(self.item in self.character.weapons) self.character.location = (8, 8) pyherc.rules.items.drop(self.model, self.character, self.item) assert(not self.item in self.character.inventory) assert(self.item in self.level.items) assert(self.item.location == (8, 8)) assert(not self.item in self.character.weapons) def test_finding_items(self): """ Test that level can be queried for items on a certain location """ item = (ItemBuilder() .with_name('apple') .build()) self.level.add_item(item, (5, 5)) item = (ItemBuilder() .with_name('kiwi') .build()) self.level.add_item(item, (3, 3)) items = self.level.get_items_at((5, 5)) assert(len(items) == 2) items = self.level.get_items_at((3, 3)) assert(len(items) == 1) items = self.level.get_items_at((12, 0)) assert(len(items) == 0)