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)
