def test_stair_linking(self): """ Test that stairs can be linked """ level1 = (LevelBuilder() .with_size((20, 20)) .with_floor_tile(self.floor_rock) .with_wall_tile(self.wall_empty) .build()) level2 = (LevelBuilder() .with_size((20, 20)) .with_floor_tile(self.floor_rock) .with_wall_tile(self.wall_empty) .build()) stairs1 = Portal((None, None), None) stairs1.icon = 'stairs' add_portal(level1, (10, 10), stairs1) stairs2 = Portal((None, None), None) add_portal(level2, (5, 5), stairs2, stairs1) assert(stairs1.level == level1) assert(stairs1.location == (10, 10)) assert(stairs1.get_other_end() == stairs2) assert(stairs2.level == level2) assert(stairs2.location == (5, 5)) assert(stairs2.get_other_end() == stairs1) assert get_portal(level1, (10, 10)) == stairs1 assert get_portal(level2, (5, 5)) == stairs2
def test_that_convoluted_case_works(self): """ Test a convoluted case with 3 open areas and 2 of them being connected to border """ self.level = (LevelBuilder().with_size((10, 10)).with_floor_tile( self.floor_rock).with_wall_tile(self.wall_ground).build()) wall_tile(self.level, (2, 5), self.wall_empty) wall_tile(self.level, (2, 6), self.wall_empty) wall_tile(self.level, (2, 7), self.wall_empty) wall_tile(self.level, (2, 8), self.wall_empty) wall_tile(self.level, (2, 9), self.wall_empty) wall_tile(self.level, (2, 10), self.wall_empty) wall_tile(self.level, (5, 8), self.wall_empty) wall_tile(self.level, (5, 2), self.wall_empty) wall_tile(self.level, (6, 2), self.wall_empty) wall_tile(self.level, (7, 2), self.wall_empty) wall_tile(self.level, (8, 2), self.wall_empty) wall_tile(self.level, (9, 2), self.wall_empty) wall_tile(self.level, (10, 2), self.wall_empty) all_points = self.matcher.get_all_points(self.level, self.wall_empty) connected_points = self.matcher.get_connected_points( self.level, all_points[0], self.wall_empty, []) assert_that(self.matcher._matches(self.level), is_(equal_to(False)))
def setup(self): """ Setup the test case """ self.action_factory = ActionFactoryBuilder().with_move_factory().build() self.character = (CharacterBuilder() .with_action_factory(self.action_factory) .build()) self.level1 = (LevelBuilder() .with_wall_at((1, 0)) .build()) self.level2 = LevelBuilder().build() self.portal1 = Portal((None, None), None) self.portal1.icon = 1 self.portal2 = Portal((None, None), None) self.portal2 = Portal((None, None), None) self.level1.add_portal(self.portal1, (5, 5)) self.level2.add_portal(self.portal2, (10, 10), self.portal1) self.level1.add_creature(self.character, (5, 5))
def setup(self): """ Setup test case """ self.effect = (EffectBuilder() .with_duration(None) .with_frequency(None) .with_tick(None) .build()) self.model = Model() self.character1 = (CharacterBuilder() .as_player_character() .with_model(self.model) .with_tick(10) .build()) self.character2 = (CharacterBuilder() .with_model(self.model) .with_tick(8) .with_effect(self.effect) .build()) (LevelBuilder().with_character(self.character1, (2, 2)) .with_character(self.character2, (5, 5)) .build()) self.model.player = self.character1
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 = (LevelBuilder().with_size((20, 20)).with_floor_tile( self.floor_rock).with_wall_tile(self.wall_empty).build()) level_generator = mock() for loc_y in range(8, 12): for loc_x in range(8, 12): add_location_tag(level, (loc_x, loc_y), 'room') portal_adder = PortalAdder((1, 2), 'room', level_generator, False, self.rng) portal_adder.add_portal(level) portals = [] for loc_y in range(8, 12): for loc_x in range(8, 12): temp = get_portal(level, (loc_x, loc_y)) if temp: portals.append(temp) portal = portals[0] assert_that(portal.icon, is_(equal_to(1))) assert_that(portal.other_end_icon, is_(equal_to(2)))
def test_add_stairs_to_room(self): """ Test that stairs can be added to a room """ level = (LevelBuilder().with_size((20, 20)).with_floor_tile( self.floor_rock).with_wall_tile(self.wall_empty).build()) for loc_y in range(8, 12): for loc_x in range(8, 12): add_location_tag(level, (loc_x, loc_y), 'room') portal_adder = PortalAdder((1, 2), 'room', mock(), False, self.rng) portal_adder.add_portal(level) portals = [] for loc_y in range(8, 12): for loc_x in range(8, 12): temp = get_portal(level, (loc_x, loc_y)) if temp: portals.append(temp) assert_that(portals, has_length(1)) portal = portals[0] assert_that(located_in_room(portal), is_(True))
def setup(self): """ Setup tests """ self.level = (LevelBuilder().with_size((20, 20)).build()) self.rng = random.Random() self.partitioner = grid_partitioning((20, 20), 2, 1, self.rng)
def setup(self): """ Setup the test cases """ self.rng = random.Random() self.connector = RandomConnector(self.rng) self.level = (LevelBuilder().build())
def setup(self): """ Setup test cases """ self.model = Model() self.listener = mock() self.level = LevelBuilder().build() self.model.register_event_listener(self.listener)
def Level(): """ Creates a level :returns: fully initialised level :rtype: Level """ level = (LevelBuilder().build()) return level
def setup(self): """ Setup the tests """ self.wall_empty = None self.floor_rock = 2 self.wall_ground = 3 self.level = (LevelBuilder().with_size((20, 10)).with_floor_tile( self.floor_rock).with_wall_tile(self.wall_ground).build()) self.matcher = MapConnectivity()
def setup(self): """ Setup the test case """ self.level = (LevelBuilder().with_size((20, 20)).with_floor_tile( self.floor_rock).with_wall_tile(self.wall_ground).build()) self.section = new_section((5, 5), (15, 15), self.level, self.rng) self.generator = SquareRoomGenerator(self.floor_rock, self.wall_empty, self.floor_rock, ['crypt'])
def setup(self): """ Setup the test case """ self.floor_rock = 1 self.wall_empty = None self.rng = Random() self.level = (LevelBuilder().with_size((60, 40)).with_floor_tile( self.floor_rock).with_wall_tile(self.wall_empty).build()) add_location_tag(self.level, (10, 10), 'room') for x_loc in range(11, 30): add_location_tag(self.level, (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, 'piercing'), (2, 'slashing')], critical_range=11, critical_damage=2, 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 = [ item_by_name(3, 4, 'dagger'), item_by_type(1, 1, 'potion') ] self.item_adder = ItemAdder(self.item_generator, self.configuration, self.rng) self.item_adder.add_items(self.level)
def setup(self): """ Setup test cases """ self.empty_wall = None self.empty_floor = None self.wall = 'wall' self.floor = 'floor' self.ornamentation = 'candles' self.level = (LevelBuilder().with_size((10, 10)).with_floor_tile( self.floor).with_wall_tile(self.empty_wall).build())
def setup(self): """ Setup test cases """ self.level = LevelBuilder().build() self.character = (CharacterBuilder() .with_level(self.level) .with_location((5, 5)) .build()) self.spell_generator = SpellGeneratorBuilder().build()
def test_simple_level_creation(self): """ Test that simple level creation works """ level = (LevelBuilder() .with_size((20, 20)) .with_floor_tile(self.floor_rock) .with_wall_tile(self.wall_empty) .build()) assert not (level is None) assert(floor_tile(level, (5, 5)) == self.floor_rock) assert(wall_tile(level, (0, 0)) == self.wall_empty)
def setup(self): """ Setup the test case """ self.character = (CharacterBuilder().with_model(Model()).build()) self.level1 = (LevelBuilder().with_floor_tile("floor").with_wall_at( (1, 0)).build()) self.level2 = (LevelBuilder().with_floor_tile("floor").build()) self.portal1 = Portal((None, None), None) self.portal1.icon = 1 self.portal2 = Portal(("stairs", "stairs"), None) self.portal2 = Portal(("stairs", "stairs"), None) add_portal(self.level1, (5, 5), self.portal1) add_portal(self.level2, (10, 10), self.portal2, self.portal1) add_character(self.level1, (5, 5), self.character) set_action_factory(ActionFactoryBuilder().build())
def test_simple_path(self): """ Test that a simple path can be found """ level = (LevelBuilder().with_floor_tile(FLOOR_TILE).with_wall_tile( EMPTY_TILE).with_solid_wall_tile(WALL_TILE).build()) path, connections, updated = a_star( start=(1, 1), goal=(5, 1), a_map=level, adjacent_nodes=free_locations_around) assert_that(path, contains((1, 1), (2, 1), (3, 1), (4, 1), (5, 1)))
def setup(self): """ Setup test cases """ self.caster = ( CharacterBuilder().with_name('Carth the Caster').build()) self.target1 = ( CharacterBuilder().with_name('Tammy the Target1').build()) self.level = (LevelBuilder().with_character( self.caster, (10, 5)).with_character( self.target1, (5, 5)).with_floor_tile(FLOOR).with_wall_tile( EMPTY_WALL).with_solid_wall_tile(SOLID_WALL).with_size( (20, 20)).build())
def test_translating_to_section(self): """ Test that Connection can be translated to section coordinates """ level = LevelBuilder().build() section = new_section((10, 10), (20, 20), level, random.Random()) connection = Connection(connection=None, location=(20, 20), direction="right", section=section) translated_connection = connection.translate_to_section() assert_that(translated_connection.location, is_(equal_to((10, 10))))
def setup(self): """ Setup the test case """ self.wall_empty = 1 self.level = (LevelBuilder().with_size((10, 15)).with_floor_tile( FLOOR_NATURAL).with_wall_tile(WALL_NATURAL).build()) for loc_y in range(2, 8): for loc_x in range(2, 8): wall_tile(self.level, (loc_x, loc_y), self.wall_empty) self.config = WallBuilderDecoratorConfig( ['crypt'], {WALL_NATURAL: WALL_CONSTRUCTED}, self.wall_empty) self.decorator = WallBuilderDecorator(self.config)
def setup(self): """ Setup test case """ self.model = Model() self.character = (CharacterBuilder().with_model( self.model).with_location((1, 1)).build()) self.model.dungeon = (LevelBuilder().with_character( self.character).build()) self.listener = mock() self.model.register_event_listener(self.listener) set_action_factory(ActionFactoryBuilder().build())
def setup(self): """ Test setup """ self.level = LevelBuilder().build() self.monster_1 = (CharacterBuilder().with_name('Pete').build()) self.monster_2 = (CharacterBuilder().with_name('Uglak').build()) self.monster_1.artificial_intelligence = lambda: None self.monster_2.artificial_intelligence = lambda: None add_character(self.level, (5, 5), self.monster_1) add_character(self.level, (6, 5), self.monster_2) set_action_factory(ActionFactoryBuilder().build())
class TestStatues(object): """ Test handling of statues (mainly mimicing items) """ def __init__(self): """ Default constructor """ super(TestStatues, self).__init__() def test_deactivating_creature(self): """ Test that activated character can deactivate """ self.model = Model() creature = (CharacterBuilder() .with_model(self.model) .with_name('Mimic') .build()) item = (ItemBuilder() .with_name('Chest') .build()) creature.set_mimic_item(item) self.model.dungeon = Dungeon() self.level1 = LevelBuilder().build() self.model.dungeon.levels = self.level1 self.level1.add_creature(creature, self.level1.find_free_space()) location = creature.location creatures = self.level1.get_creature_at(location) items = self.level1.get_items_at(location) assert_that(creatures, is_(same_instance(creature))) assert_that(len(items), is_(equal_to(0))) deactivate(self.model, creature) creatures = self.level1.get_creature_at(location) items = self.level1.get_items_at(location) assert_that(creatures, is_(none())) assert_that(len(items), is_(equal_to(1)))
def setup(self): """ Setup the test case """ self.floor_rock = 1 self.wall_ground = 2 self.level = (LevelBuilder() .with_size((10, 10)) .with_floor_tile(self.floor_rock) .with_wall_tile(self.wall_ground) .build()) self.rng = random.Random() self.section = new_section((0, 0), (10, 10), self.level, self.rng)
def setup(self): """ Setup test case """ self.model = mock() effects = get_effect_creator({'poison': {'type': Poison, 'duration': 12, 'frequency': 3, 'tick': 3, 'damage': 5, 'icon': 101, 'title': 'poison', 'description': 'Causes damage'}}) pyherc.vtable['\ufdd0:create-effect'] = effects set_action_factory(ActionFactoryBuilder() .with_effect_factory(effects) .build()) self.attacker = (CharacterBuilder() .with_location((5, 5)) .with_effect_handle(EffectHandleBuilder() .with_trigger('on attack hit') .with_effect('poison')) .with_model(self.model) .build()) self.defender = (CharacterBuilder() .with_location((5, 4)) .with_hit_points(50) .with_model(self.model) .build()) (LevelBuilder().with_character(self.attacker) .with_character(self.defender) .build())
def setup(self): """ Setup test cases """ self.item = (ItemBuilder() .build()) self.model = Model() self.level = LevelBuilder().build() self.character = (CharacterBuilder() .with_location((5, 5)) .with_level(self.level) .with_model(self.model) .build()) add_item(self.level, (5, 5), self.item) set_action_factory(ActionFactoryBuilder() .with_inventory_factory() .build())
def test_going_around_wall(self): """ Test that path can be found around a wall """ level = (LevelBuilder().with_floor_tile(FLOOR_TILE).with_wall_tile( EMPTY_TILE).with_solid_wall_tile(WALL_TILE).with_wall_at( (12, 8)).with_wall_at((12, 9)).with_wall_at( (12, 10)).with_wall_at((12, 11)).with_wall_at( (12, 12)).with_size((20, 20)).build()) path, connections, updated = a_star( start=(10, 10), goal=(15, 10), a_map=level, adjacent_nodes=free_locations_around) assert_that( path, is_( continuous_path(start=(10, 10), destination=(15, 10), level=level)))
def setup(self): """ Setup for testcases """ self.model = Model() self.action_factory = (ActionFactoryBuilder() .with_attack_factory() .build()) self.character1 = (CharacterBuilder() .with_model(self.model) .with_action_factory(self.action_factory) .with_speed(1) .with_tick(1) .with_hit_points(10) .with_attack(3) .with_body(5) .build()) self.character2 = (CharacterBuilder() .with_model(self.model) .with_action_factory(self.action_factory) .with_speed(1) .with_tick(1) .with_hit_points(10) .with_attack(3) .with_body(5) .build()) self.model.dungeon = Dungeon() self.level = LevelBuilder().build() self.model.dungeon.levels = self.level self.level.add_creature(self.character1, (5, 5)) self.level.add_creature(self.character2, (6, 5))
def test_deactivating_creature(self): """ Test that activated character can deactivate """ self.model = Model() creature = (CharacterBuilder() .with_model(self.model) .with_name('Mimic') .build()) item = (ItemBuilder() .with_name('Chest') .build()) creature.set_mimic_item(item) self.model.dungeon = Dungeon() self.level1 = LevelBuilder().build() self.model.dungeon.levels = self.level1 self.level1.add_creature(creature, self.level1.find_free_space()) location = creature.location creatures = self.level1.get_creature_at(location) items = self.level1.get_items_at(location) assert_that(creatures, is_(same_instance(creature))) assert_that(len(items), is_(equal_to(0))) deactivate(self.model, creature) creatures = self.level1.get_creature_at(location) items = self.level1.get_items_at(location) assert_that(creatures, is_(none())) assert_that(len(items), is_(equal_to(1)))
def setup(self): """ Setup for testcases """ self.model = Model() set_action_factory(ActionFactoryBuilder().build()) self.character1 = (CharacterBuilder().with_model( self.model).with_hit_points(10).with_attack(3).with_body( 5).build()) self.effect = DamageModifier(modifier=1, damage_type='crushing', duration=None, frequency=None, tick=None, icon=101, title='Weakness against crushing', description='This character is weak') self.effect.multiple_allowed = True self.character2 = (CharacterBuilder().with_model( self.model).with_hit_points(10).with_attack(3).with_body( 5).with_effect(self.effect).build()) self.model.dungeon = Dungeon() self.level = (LevelBuilder().with_character(self.character1, at_(5, 5)).with_character( self.character2, at_(6, 5)).build()) self.model.dungeon.levels = self.level self.rng = mock() when(self.rng).randint(1, 6).thenReturn(1)
def setup(self): """ Setup the test case """ self.level = (LevelBuilder().with_size( (10, 10)).with_floor_tile('floor').with_wall_tile( self.empty_wall).build()) wall_tile(self.level, (1, 1), self.wall) wall_tile(self.level, (2, 1), self.wall) wall_tile(self.level, (3, 1), self.wall) wall_tile(self.level, (1, 2), self.wall) wall_tile(self.level, (1, 3), self.wall) wall_tile(self.level, (2, 3), self.wall) wall_tile(self.level, (3, 3), self.wall) wall_tile(self.level, (3, 2), self.wall) self.config = DirectionalWallDecoratorConfig( level_types=['crypt'], east_west='east-west', east_north='east-north', east_south='east-south', west_north='west-north', west_south='west-south', north_south='north-south', east_west_north='east-west-north', east_west_south='east-west-south', east_north_south='east-north-south', west_north_south='west-north-south', four_way='four-way', wall=self.wall) self.decorator = DirectionalWallDecorator(self.config)
def setup(self): """ Setup test cases """ self.character = (CharacterBuilder().with_hit_points(10).build()) self.target = (CharacterBuilder().with_hit_points(10).build()) self.level = (LevelBuilder().build()) add_character(self.level, (2, 2), self.character) add_character(self.level, (5, 2), self.target) bow = (ItemBuilder().with_name('bow').with_required_ammunition_type( 'arrow').with_damage(1, 'crushing').build()) self.arrows = (ItemBuilder().with_name('arrows').with_ammunition_type( 'arrow').with_range_damage(3, 'piercing').with_count(10).build()) self.character.inventory.append(bow) self.character.inventory.append(self.arrows) self.character.inventory.weapon = bow self.character.inventory.projectiles = self.arrows set_action_factory(ActionFactoryBuilder().build())
def setup(self): """ Setup test case """ self.level = (LevelBuilder().with_size((20, 10)).build())
class TestMeleeCombat(object): """ Class for testing melee combat related rules """ def __init__(self): """ Default constructor """ super(TestMeleeCombat, self).__init__() self.level = None self.modle = None self.character1 = None self.character2 = None self.action_factory = None def setup(self): """ Setup for testcases """ self.model = Model() self.action_factory = (ActionFactoryBuilder() .with_attack_factory() .build()) self.character1 = (CharacterBuilder() .with_model(self.model) .with_action_factory(self.action_factory) .with_speed(1) .with_tick(1) .with_hit_points(10) .with_attack(3) .with_body(5) .build()) self.character2 = (CharacterBuilder() .with_model(self.model) .with_action_factory(self.action_factory) .with_speed(1) .with_tick(1) .with_hit_points(10) .with_attack(3) .with_body(5) .build()) self.model.dungeon = Dungeon() self.level = LevelBuilder().build() self.model.dungeon.levels = self.level self.level.add_creature(self.character1, (5, 5)) self.level.add_creature(self.character2, (6, 5)) def test_get_unarmed_action(self): """ Test that unarmed combat action can be generated """ rng = mock() action = self.action_factory.get_action(AttackParameters( self.character1, 3, 'unarmed', rng)) assert_that(action, is_(instance_of(AttackAction))) assert_that(action.attack_type, is_(equal_to('unarmed'))) def test_events_in_unarmed_combat(self): """ Test that attacking raises events """ character1 = (CharacterBuilder() .with_model(self.model) .with_action_factory(self.action_factory) .with_attack(12) .with_speed(1) .with_tick(0) .build()) self.level.add_creature(character1, (2, 2)) character2 = mock(Character) character2.hit_points = 20 self.level.add_creature(character2, (2, 3)) character1.perform_attack(5) verify(character2).receive_event(any())
class TestMoving(object): """ Tests for moving """ def __init__(self): """ Default constructor """ super(TestMoving, self).__init__() self.action_factory = None self.character = None self.level1 = None self.level2 = None self.portal1 = None self.portal2 = None self.model = None def setup(self): """ Setup the test case """ self.action_factory = ActionFactoryBuilder().with_move_factory().build() self.character = (CharacterBuilder() .with_action_factory(self.action_factory) .build()) self.level1 = (LevelBuilder() .with_wall_at((1, 0)) .build()) self.level2 = LevelBuilder().build() self.portal1 = Portal((None, None), None) self.portal1.icon = 1 self.portal2 = Portal((None, None), None) self.portal2 = Portal((None, None), None) self.level1.add_portal(self.portal1, (5, 5)) self.level2.add_portal(self.portal2, (10, 10), self.portal1) self.level1.add_creature(self.character, (5, 5)) def test_simple_move(self): """ Test that taking single step is possible """ assert(self.character.location == (5, 5)) self.character.move(3) assert(self.character.location == (6, 5)) def test_walking_to_walls(self): """ Test that it is not possible to walk through walls """ self.character.location = (1, 1) self.character.move(1) assert(self.character.location == (1, 1)) def test_entering_portal(self): """ Test that character can change level via portal """ assert(self.character.location == (5, 5)) assert(self.character.level == self.level1) self.character.move(9) assert(self.character.location == (10, 10)) assert(self.character.level == self.level2) def test_entering_portal_adds_character_to_creatures(self): """ Test that entering portal will add character to the creatures list """ assert self.character.level == self.level1 assert self.character in self.level1.creatures self.character.move(9) assert self.character.level == self.level2 assert self.character in self.level2.creatures def test_entering_portal_removes_character_from_old_level(self): """ Test that entering portal will remove character from level """ assert self.character.level == self.level1 assert self.character in self.level1.creatures self.character.move(9) assert self.character not in self.level1.creatures def test_entering_non_existent_portal(self): """ Test that character can not walk through floor """ self.character.location = (6, 3) assert(self.character.level == self.level1) self.character.move(9) assert(self.character.location == (6, 3)) assert(self.character.level == self.level1) def test_moving_uses_time(self): """ Test that moving around uses time """ tick = self.character.tick self.character.move(3) assert self.character.tick > tick