def test_bag_has_item_type(self) -> None:
healing_item = get_random_item(tier='common', item_type='healing')
equipment_item = get_random_item(tier='legendary',
item_type='equipment')
recovery_item = get_random_item(tier='common', item_type='recovery')
self.bag.add_item(healing_item)
self.bag.add_item(equipment_item)
self.bag.add_item(recovery_item)
self.assertTrue(self.bag.has_item_type(is_usable=True))
self.assertTrue(self.bag.has_item_type(is_equipment=True))
def test_bag_weight_measurement(self) -> None:
item = get_random_item(tier='common', item_type='healing')
before_new_item_weight = self.bag.weight
self.bag.add_item(item)
after_item_add_weight = self.bag.weight
self.assertEqual(self.bag.weight, before_new_item_weight + item.weight)
self.bag.remove_item(item)
self.assertEqual(self.bag.weight, after_item_add_weight - item.weight)
def distribute_random_items(self) -> None:
"""
Function to coordinate distribution of random items in the map
The items will be placed in the half of the quantity of the walkable nodes in the map, and with the
probabilities for each tier of item configured in the conf file, the quantity for each tier will be determined,
and finally a random items will be picked for the respective quantities of each tier, and placed in some random
places.
:rtype: None
"""
walkable_nodes = self.graph.get_walkable_nodes()
number_of_walkable_nodes = len(walkable_nodes)
number_of_items = floor(number_of_walkable_nodes / 2)
probabilities = get_configuration('item_probabilities')
common_items_number = round(number_of_items *
probabilities.get('common', 0.6))
uncommon_items_number = round(number_of_items *
probabilities.get('uncommon', 0.2))
rare_items_number = round(number_of_items *
probabilities.get('rare', 0.15))
legendary_items_number = round(number_of_items *
probabilities.get('legendary', 0.05))
item_type_distribution = {
'common':
['healing'] * 45 + ['equipment'] * 30 + ['recovery'] * 25,
'uncommon': ['healing'] * 50 + ['equipment'] * 50,
'rare': ['healing'] * 20 + ['equipment'] * 80,
'legendary': ['equipment'] * 80
}
for i in range(common_items_number + uncommon_items_number +
rare_items_number + legendary_items_number):
key = random.choice(list(walkable_nodes.keys()))
walkable_nodes.pop(key)
tier = ''
if common_items_number > 0:
tier = 'common'
common_items_number = common_items_number - 1
elif uncommon_items_number > 0:
tier = 'uncommon'
uncommon_items_number = uncommon_items_number - 1
elif rare_items_number > 0:
tier = 'rare'
rare_items_number = rare_items_number - 1
elif legendary_items_number > 0:
tier = 'legendary'
legendary_items_number = legendary_items_number - 1
item_type = random.choice(item_type_distribution.get(tier))
item = get_random_item(tier, item_type)
self.add_item_to_map(key, item)
def wrapper(func):
item = get_random_item(tier, 'recovery')
setattr(func, 'mock_recovery_item', item)
return func
def test_bag_get_usable_items(self) -> None:
item = get_random_item(tier='common', item_type='healing')
self.bag.add_item(item)
self.assertGreater(len(self.bag.get_usable_items()), 0)
def test_bag_get_equipments(self) -> None:
equipment_item = get_random_item(tier='legendary',
item_type='equipment')
self.bag.add_item(equipment_item)
self.assertGreater(len(self.bag.get_equipments()), 0)
def test_get_random_recoverable(self) -> None:
item = get_random_item(tier='common', item_type='recovery')
self.assertIsInstance(item, IRecoveryItem)
def test_get_random_equipment(self) -> None:
item = get_random_item(tier='legendary', item_type='equipment')
self.assertIsInstance(item, IEquipmentItem)
def test_get_random_healing(self) -> None:
item = get_random_item(tier='rare', item_type='healing')
self.assertIsInstance(item, IHealingItem)
def test_get_random_item(self) -> None:
item = get_random_item(tier='common', item_type='healing')
self.assertIsInstance(item, IItem)
def wrapper(func):
item = get_random_item(tier, 'healing')
setattr(func, 'mock_healing_item', item)
return func
def wrapper(func):
item = get_random_item(tier, 'equipment')
setattr(func, 'mock_equipment_item', item)
return func
