def test_map():
# Door pending
# 0 1 2 3 4 5
# 0 # # . . . .
# 1 # # . . . .
# 2 . + . . . .
# 3 # # . . # .
# 4 # # . . # o
# 5 # # x . . @
new_map = gamemap.GameMap(width=6, height=6, fill_tile=tiles.floor)
walls = [
(0, 0),
(1, 0),
(0, 1),
(1, 1),
(0, 3),
(1, 3),
(4, 3),
(0, 4),
(1, 4),
(4, 4),
(0, 5),
(1, 5),
]
for x, y in walls:
new_map.tiles[x, y] = tiles.wall
# Create a player at 5, 5
new_player = player.Player()
new_map.place(new_player, 5, 5)
new_map.player = new_player
# Give the player items for testing
dagger = factory.make("dagger")
new_player.inventory.add_inv_item(dagger)
leather_armor = factory.make("leather vest")
new_player.inventory.add_inv_item(leather_armor)
health_vial = factory.make("healing vial")
new_player.inventory.add_inv_item(health_vial)
# Create a grid bug at 2, 5
factory.spawn("grid bug", new_map, 2, 5)
# Create a spider drone at 5, 4
factory.spawn("henchman", new_map, 5, 4)
return new_map
def test_hit_msg__enemy_hits_enemy():
# Arm the henchman with a dagger
henchman = factory.make("henchman")
dagger = factory.make('dagger')
henchman.inventory.add_item(dagger)
henchman.equipment.toggle_equip(dagger)
a = WeaponAttack(entity=henchman, dx=-1, dy=-1)
atk = dagger.equippable.offense.attacks[0]
dmg = 10
a.hit_msg(henchman, atk, dmg)
assert a.msg == f"The henchman hits the henchman with it's dagger for {dmg}! "
def test_sorted_dict__multiple_items():
pi = PlayerInventory(10)
pi.add_inv_item(factory.make("dagger"))
pi.add_inv_item(factory.make("leather vest"))
pi.add_inv_item(factory.make("bulletproof vest"))
pi.add_inv_item(factory.make("healing vial"))
result = pi.sorted_dict()
assert result == {
'/': ['a'],
'[': ['b', 'c'],
'!': ['d'],
}
def hidden_map():
# Door pending
# 0 1 2 3 4
# 0 # # . # #
# 1 # # b # # b=hidden banana trap
# 2 . + @ % . +=hidden door, and %=hidden corridor
# 3 # # ^ # # ^=hidden bear trap
# 4 # # . # #
new_map = gamemap.GameMap(width=6, height=6, fill_tile=tiles.wall)
floors = [(2, 0), (2, 1), (0, 2), (1, 2), (2, 2), (3, 2), (4, 2), (2, 3),
(2, 4)]
for x, y in floors:
new_map.tiles[x, y] = tiles.floor
# Create a player at 5, 5
new_player = player.Player()
new_map.place(new_player, 2, 2)
new_map.player = new_player
# Create bear trap at 2, 3
new_trap = factory.make("bear trap")
new_map.place(new_trap, 2, 3)
return new_map
def test_reduce_dmg__ac_reduces_dmg_below_0__returns_1():
stormdrone = factory.make("storm drone")
assert stormdrone.fighter.ac == -20
# Note: We'll only pass in 1 damage to test that damage can never be reduced below 1.
# With any -AC, the defender will always try to reduce it to 0.
result = AttackAction.reduce_dmg(stormdrone, 1)
assert result == 1
def test_Consumable_consume(test_player):
vial = factory.make('healing vial')
test_player.inventory.add_inv_item(vial) # Add potion to test_players inv.
vial.consumable.consume()
# Item should be removed from inventory
# assert test_player.inventory.rm_item(vial) is None
assert vial not in test_player.inventory.item_dict.values()
def test_perform(test_map):
player = test_map.player
armor = factory.make("leather vest")
assert not player.equipment.is_equipped(armor)
a = EquipAction(entity=player, item=armor)
a.perform()
assert player.equipment.is_equipped(armor)
def test_hit_msg__you_hit_enemy(player):
a = WeaponAttack(entity=player, dx=-1, dy=-1)
target = factory.make("henchman")
# TODO: Add reference to attacks in AttackActions? Cross link with it's weapon?
atk = player.equipment.slots['WEAPON'].equippable.offense.attacks[0]
dmg = 10
a.hit_msg(target, atk, dmg)
assert a.msg == f"You hit the henchman with your dagger for {dmg}! "
def test_get_names_at__multiple_visible(test_map):
vial = factory.make("healing vial")
assert test_map.place(vial, 5, 5)
# Set map tile to visible
test_map.visible[5, 5] = True
result = test_map.get_names_at(5, 5)
assert result == "Healing vial, Player"
def test_calc_target_number__negative_target_number(test_map):
player = test_map.player
a = AttackAction(entity=player, dx=-1, dy=-1)
target = factory.make("storm drone")
assert target.fighter.ac == -20
result = a.calc_target_number(target)
assert result >= 1
def test_calc_target_number__positive_ac(test_map):
player = test_map.player
a = AttackAction(entity=player, dx=-1, dy=-1)
target = factory.make("henchman")
assert target.fighter.ac == 6
result = a.calc_target_number(target)
expected = 10 + target.fighter.ac + player.level.current_level
assert result == expected
def test_execute_damage__no_weapon(test_map):
player = test_map.player
assert not player.equipment.slots['WEAPON']
a = AttackAction(entity=player, dx=-1, dy=-1)
target = factory.make("henchman")
atk = player.offense.attacks[0]
result = a.execute_damage(target, atk)
assert result >= atk.min_dmg()
assert result <= atk.max_dmg()
def test_execute_damage__with_weapon(test_map):
player = test_map.player
dagger = player.inventory.item_dict.get('a')
assert player.equipment.toggle_equip(dagger)
a = AttackAction(entity=player, dx=-1, dy=-1)
target = factory.make("henchman")
atk = player.equipment.slots['WEAPON'].equippable.offense.attacks[0]
result = a.execute_damage(target, atk)
assert result >= atk.min_dmg()
assert result <= atk.max_dmg()
def test_Consumable_get_action(test_player):
# This returns an ItemAction initialized with the consumer and this
# Consumables parent.
c = consumable.Consumable()
vial = factory.make("healing vial")
c.parent = vial
result = c.get_action(consumer=test_player)
assert isinstance(result, ItemAction)
assert result.entity == test_player
assert result.item == vial
def test_calc_target_number__negative_ac(test_map):
player = test_map.player
a = AttackAction(entity=player, dx=-1, dy=-1)
target = factory.make("giant leech")
assert target.fighter.ac == -2
result = a.calc_target_number(target)
max_expected = 10 - 1 + player.level.current_level
min_expected = 10 + target.fighter.ac + player.level.current_level
assert result >= min_expected
assert result <= max_expected
def test_init(test_map):
player = test_map.player
armor = factory.make("leather vest")
a = EquipAction(entity=player, item=armor)
assert a.entity == player
assert a.item == armor
def test_init__is_Action(test_map):
player = test_map.player
armor = factory.make("leather vest")
a = EquipAction(entity=player, item=armor)
assert isinstance(a, actions.Action)
def test_toggle_equip__non_equippable__raisesImpossible():
e = Equipment()
vial = factory.make("healing vial")
with pytest.raises(exceptions.Impossible):
e.toggle_equip(item=vial)
def test_toggle_equip__armor2armor__msg(leather_armor):
e = Equipment(leather_armor)
bp_vest = factory.make("bulletproof vest")
result = e.toggle_equip(item=bp_vest)
assert result == "You remove the leather vest. You equip the bulletproof vest. "
def test_get_actor_at__valid_actor(std_map):
e = factory.make("mouse")
std_map.place(e, 1, 1)
result = std_map.get_actor_at(1, 1)
assert result == e
def test_toggle_equip__weapon2weapon__msg(dagger):
e = Equipment(dagger)
baton = factory.make("riot baton")
result = e.toggle_equip(item=baton)
assert result == "You remove the dagger. You equip the riot baton. "
def test_toggle_equip__weapon2weapon(dagger):
e = Equipment(dagger)
baton = factory.make("riot baton")
e.toggle_equip(item=baton)
assert e.slots['WEAPON'] == baton
def leather_armor():
return factory.make("leather vest")
def test_equip_to_slot__non_equippable():
vial = factory.make("healing vial")
e = Equipment()
with pytest.raises(exceptions.Impossible):
e.equip_to_slot(slot="WEAPON", item=vial)
def dagger():
return factory.make("dagger")
def vials5():
vials = factory.make('healing vial')
vials.stackable.size = 5
return vials
def money():
cash = factory.make('money')
cash.stackable.size = 10
return cash
def test_toggle_equip__armor2armor(leather_armor):
e = Equipment(leather_armor)
bp_vest = factory.make("bulletproof vest")
e.toggle_equip(item=bp_vest)
assert e.slots['ARMOR'] == bp_vest
def vial():
return factory.make("healing vial")
def test_actors_property(std_map):
assert list(std_map.actors) == [] # None by default
f = factory.make("mouse")
std_map.add_entity(f)
assert f in std_map.actors
