def load_character_level_stats() -> dict:
"""
Return a dictionary holding information about the amount of stats that a character should get according
to the level he has just attained
"""
# Define these here as well. We can't import from constants because constants imports from here
KEY_LEVELUP_STATS_HEALTH = 'health'
KEY_LEVELUP_STATS_MANA = 'mana'
KEY_LEVELUP_STATS_STRENGTH = 'strength'
KEY_LEVELUP_STATS_ARMOR = 'armor'
KEY_LEVELUP_STATS_AGILITY = 'agility'
level_stats = {}
loaded_stats = session.query(LevelUpStatsSchema).all()
for stat in loaded_stats:
level = stat.level
health = parse_int(stat.health)
mana = parse_int(stat.mana)
strength = parse_int(stat.strength)
agility = parse_int(stat.agility)
armor = parse_int(stat.armor)
level_stats[level] = {
KEY_LEVELUP_STATS_HEALTH: health,
KEY_LEVELUP_STATS_MANA: mana,
KEY_LEVELUP_STATS_AGILITY: agility,
KEY_LEVELUP_STATS_STRENGTH: strength,
KEY_LEVELUP_STATS_ARMOR: armor
}
return level_stats
def test_parse_int_invalid_numbers(self):
"""
It should convert every invalid integer to 0
"""
self.assertEqual(parse_int(2.1), 2)
self.assertEqual(parse_int(None), 0)
self.assertEqual(parse_int('aa'), 0)
self.assertEqual(parse_int([]), 0)
def convert_to_paladin_spell_object(self) -> PaladinSpell:
"""
Converts the PaladinSpells schema object to a Paladin Spell object
"""
level: int = parse_int(self.level_required)
damage1: int = parse_int(self.damage1)
damage2: int = parse_int(self.damage2)
damage3: int = parse_int(self.damage3)
mana_cost: int = parse_int(self.mana_cost)
heal1: int = parse_int(self.heal1)
heal2: int = parse_int(self.heal2)
heal3: int = parse_int(self.heal3)
cooldown: int = parse_int(self.cooldown)
buff: 'BeneficialBuff' = self.buff.convert_to_beneficial_buff_object(
) if self.buff else None
harmful_effect: 'DoT' = self.dot.convert_to_dot_object(
level) if self.dot else None
return PaladinSpell(name=self.name,
rank=self.rank,
cooldown=cooldown,
beneficial_effect=buff,
harmful_effect=harmful_effect,
damage1=damage1,
damage2=damage2,
damage3=damage3,
heal1=heal1,
heal2=heal2,
heal3=heal3,
mana_cost=mana_cost)
def convert_to_beneficial_buff_object(self) -> BeneficialBuff:
"""
Convert it to a BeneficialBuff object
"""
buff_name: str = self.name
buff_stat1: str = self.stat1
buff_amount1: int = parse_int(self.amount1)
buff_stat2: str = self.stat2
buff_amount2: int = parse_int(self.amount2)
buff_stat3: str = self.stat3
buff_amount3: int = parse_int(self.amount3)
buff_duration: int = parse_int(self.duration)
buffs: [(str, int)] = [(buff_stat1, buff_amount1), (buff_stat2, buff_amount2), (buff_stat3, buff_amount3)]
return BeneficialBuff(name=buff_name, buff_stats_and_amounts=[(stat, amount) for stat, amount in buffs
if stat is not None and amount is not None],
duration=buff_duration)
def convert_to_living_thing_object(self) -> VendorNPC or FriendlyNPC or Monster:
""" Converts the Creature to whatever object he is according to his type column """
# TODO: move to creature_template.py
entry: int = self.creature_id
name: str = self.creature.name
type_: str = self.creature.type
level: int = parse_int(self.creature.level)
health: int = parse_int(self.creature.health)
mana: int = parse_int(self.creature.mana)
armor: int = parse_int(self.creature.armor)
min_dmg: int = parse_int(self.creature.min_dmg)
max_dmg: int = parse_int(self.creature.max_dmg)
quest_relation_id: int = parse_int(self.creature.quest_relation_id)
loot_table: 'LootTable' = self.creature.loot_table
gossip: str = self.creature.gossip
respawnable: bool = self.creature.respawnable
if type_ == "fnpc":
return FriendlyNPC(name=name, health=health,
mana=mana, level=level,
min_damage=min_dmg,
max_damage=max_dmg,
quest_relation_id=quest_relation_id,
loot_table=loot_table,
gossip=gossip)
elif type_ == "vendor":
vendor_inventory = self.creature.build_vendor_inventory()
return VendorNPC(name=name, entry=entry,
health=health, mana=mana, level=level,
min_damage=min_dmg,
max_damage=max_dmg,
quest_relation_id=quest_relation_id,
loot_table=loot_table,
inventory=vendor_inventory,
gossip=gossip)
elif type_ == "monster":
gold_to_give_range = (CREATURE_DEFAULT_VALUES[level]['min_gold_reward'],
CREATURE_DEFAULT_VALUES[level]['max_gold_reward'])
xp_to_give = CREATURE_DEFAULT_VALUES[level]['xp_reward']
armor = armor if armor else CREATURE_DEFAULT_VALUES[level]['armor']
return Monster(monster_id=entry,
name=name,
health=health,
mana=mana,
armor=armor,
level=level,
min_damage=min_dmg,
max_damage=max_dmg,
quest_relation_id=quest_relation_id,
loot_table=loot_table,
xp_to_give=xp_to_give,
gold_to_give_range=gold_to_give_range,
gossip=gossip,
respawnable=respawnable)
else:
raise Exception(f'{type_} is not a valid creature type!')
def convert_to_quest_object(self) -> Quest:
"""
Convert the QuestSchema object to a Quest object
The currently supported quest types are:
killquest = kill X amount of monster_required
fetchquest = obtain X amount of item_required.
:return: A KillQuest or FetchQuest object
"""
entry: int = self.entry
quest_name: str = self.name
quest_type: str = self.type
level_requirement: int = parse_int(self.level_required)
monster_required: str = self.monster_required
item_required: str = self.item_required
amount_required: int = parse_int(self.amount_required)
xp_reward: int = parse_int(self.xp_reward)
item_rewards: {str: 'Item'} = {item.name: item.convert_to_item_object()
for item in [self.reward1, self.reward2, self.reward3]
if item is not None}
item_choice_enabled = bool(self.item_choice_enabled)
if quest_type == "killquest":
return KillQuest(quest_name=quest_name,
quest_id=entry,
required_monster=monster_required,
required_kills=amount_required,
xp_reward=xp_reward,
item_reward_dict=item_rewards,
reward_choice_enabled=item_choice_enabled,
level_required=level_requirement)
elif quest_type == "fetchquest":
return FetchQuest(quest_name=quest_name,
quest_id=entry,
required_item=item_required,
required_item_count=amount_required,
xp_reward=xp_reward,
item_reward_dict=item_rewards,
reward_choice_enabled=item_choice_enabled,
level_required=level_requirement)
else:
raise Exception(f'The quest type {quest_type} is not supported!')
def test_parse_int_valid_numbers(self):
self.assertIsNotNone(parse_int(1))
self.assertTrue(isinstance(parse_int(5), int))
self.assertEqual(parse_int(1), 1)
self.assertEqual(parse_int(3), 3)
self.assertEqual(parse_int(5), 5)
self.assertEqual(parse_int(215), 215)
def convert_to_paladin_spell_object(self) -> PaladinSpell:
"""
Converts the PaladinSpells schema object to a Paladin Spell object
"""
level: int = parse_int(self.level_required)
damage1: int = parse_int(self.damage1)
damage2: int = parse_int(self.damage2)
damage3: int = parse_int(self.damage3)
mana_cost: int = parse_int(self.mana_cost)
heal1: int = parse_int(self.heal1)
heal2: int = parse_int(self.heal2)
heal3: int = parse_int(self.heal3)
cooldown: int = parse_int(self.cooldown)
buff: 'BeneficialBuff' = self.buff.convert_to_beneficial_buff_object() if self.buff else None
harmful_effect: 'DoT' = self.dot.convert_to_dot_object(level) if self.dot else None
return PaladinSpell(name=self.name, rank=self.rank, cooldown=cooldown, beneficial_effect=buff,
harmful_effect=harmful_effect, damage1=damage1, damage2=damage2, damage3=damage3,
heal1=heal1, heal2=heal2, heal3=heal3, mana_cost=mana_cost)
def convert_to_item_object(self) -> Item:
item_id: int = self.entry
item_name: str = self.name
item_type: str = self.type
item_buy_price: int = parse_int(self.buy_price)
item_sell_price: int = parse_int(self.sell_price)
if item_type == 'misc':
item_quest_id = self.quest_id
return Item(name=item_name, item_id=item_id, buy_price=item_buy_price, sell_price=item_sell_price,
quest_id=item_quest_id)
elif item_type in ['weapon', 'equipment']:
item_health: int = parse_int(self.health)
item_mana: int = parse_int(self.mana)
item_armor: int = parse_int(self.armor)
item_strength: int = parse_int(self.strength)
item_agility: int = parse_int(self.agility)
attributes: {str: int} = create_attributes_dict(bonus_health=item_health, bonus_mana=item_mana,
armor=item_armor, strength=item_strength,
agility=item_agility)
if item_type == 'weapon':
item_min_dmg: int = parse_int(self.min_dmg)
item_max_dmg: int = parse_int(self.max_dmg)
return Weapon(name=item_name, item_id=item_id, attributes=attributes,
buy_price=item_buy_price, sell_price=item_sell_price,
min_damage=item_min_dmg, max_damage=item_max_dmg)
else:
item_slot: str = self.sub_type
return Equipment(name=item_name, item_id=item_id, slot=item_slot, attributes=attributes,
buy_price=item_buy_price, sell_price=item_sell_price)
elif item_type == 'potion':
buff_id: int = self.effect
item_buff_effect: 'BeneficialBuff' = load_buff(buff_id)
return Potion(name=item_name, item_id=item_id, buy_price=item_buy_price, sell_price=item_sell_price,
buff=item_buff_effect)
else:
raise Exception(f'Unsupported item type {item_type}')