def get_skill_tree(tree_name):
db.connect()
skills = Skill.select().where(Skill.skill_tree == tree_name)
if not skills:
raise peewee.DoesNotExist
tree = {
"skill_tree_name": tree_name,
"skills": [],
"decorations": {
"helpful": [],
"harmful": []
}
}
for skill in skills:
tree["skills"].append({
"name": skill.skill_name,
"points": skill.skill_value,
"description": skill.skill_description
})
skill_decos = get_decorations_for_skill(tree_name)
tree["decorations"]["harmful"] = skill_decos[0]
tree["decorations"]["helpful"] = skill_decos[1]
db.close()
return jsonify(tree)
def get_all_decorations():
db.connect()
decorations = {"decorations": []}
for deco in Decoration.select():
decorations["decorations"].append({
"name": deco.deco_name,
"url": url_for('.get_individual_decoration', name=deco.deco_name, _external=True)
})
db.close()
return jsonify(decorations)
def get_all_items():
db.connect()
items = {"items": []}
for item in Item.select():
items["items"].append({
"name": item.item_name,
"url": url_for('.get_individual_item', name=item.item_name, _external=True)
})
db.close()
return jsonify(items)
def get_all_skills():
db.connect()
skills = {"skills": []}
for skill in Skill.select(Skill.skill_tree).distinct():
skills["skills"].append(
url_for(".get_skill_tree",
tree_name=skill.skill_tree,
_external=True))
db.close()
return jsonify(skills)
def get_all_weapons_by_category(category):
category = category.lower()
db.connect()
weapons = {"weapons": []}
found_sets = []
if category == "blademaster":
for weapon in SwordValue.select():
if weapon.sword_set_name not in found_sets:
found_sets.append(weapon.sword_set_name)
weapons["weapons"].append({
"set":
weapon.sword_set_name,
"class":
weapon.sword_class,
"url":
url_for(".get_weapon",
_external=True,
category=category,
setname=weapon.sword_set_name)
})
elif category == "bow":
for weapon in Bow.select():
if weapon.bow_set_name not in found_sets:
found_sets.append(weapon.bow_set_name)
weapons["weapons"].append({
"set":
weapon.bow_set_name,
"url":
url_for(".get_weapon",
_external=True,
category=category,
setname=weapon.bow_set_name)
})
elif category == "bowgun":
for weapon in Bowgun.select():
if weapon.bg_set_name not in found_sets:
found_sets.append(weapon.bg_set_name)
weapons["weapons"].append({
"set":
weapon.bg_set_name,
"type":
weapon.bg_type,
"url":
url_for(".get_weapon",
_external=True,
category=category,
setname=weapon.bg_set_name)
})
db.close()
return jsonify(weapons)
def get_all_monsters():
db.connect()
monsters = {"monsters": []}
for monster in Monster.select():
monsters["monsters"].append({
"name":
monster.mon_name,
"url":
url_for('.get_individual_monster',
name=monster.mon_name,
_external=True)
})
db.close()
return jsonify(monsters)
def get_all_quests():
db.connect()
quests = {"quests": []}
for quest in Quest.select():
quests["quests"].append({
"name":
quest.quest_name,
"url":
url_for('.get_individual_quest',
name=re.sub(r"\[.*?\] ", "", quest.quest_name),
_external=True)
})
db.close()
return jsonify(quests)
def get_individual_palico_info(category, name):
db.connect()
if category == "weapons":
dbwep = PalicoWeapon.get(PalicoWeapon.pw_name == name)
weapon = {
"name": dbwep.pw_name,
"description": dbwep.pw_description,
"rarity": dbwep.pw_rarity,
"price": dbwep.pw_price,
"type": dbwep.pw_type,
"damage_type": dbwep.pw_damage_type,
"sharpness": dbwep.pw_sharpness.title(),
"melee_damage": dbwep.pw_damage,
"melee_affinity": dbwep.pw_affinity,
"melee_element": dbwep.pw_element.title(),
"melee_element_damage": dbwep.pw_element_amt,
"boomerang_damage": dbwep.pw_boomerang_damage,
"boomerang_affinity": dbwep.pw_boomerang_affinity,
"boomerang_element": dbwep.pw_boomerang_element.title(),
"boomerang_element_damage": dbwep.pw_boomerang_element_amt,
"defense": dbwep.pw_defense,
"crafting_materials": get_crafting_list("weapon", dbwep.pw_name)
}
db.close()
return jsonify(weapon)
elif category == "armor":
dbarm = PalicoArmor.get(PalicoArmor.pa_name == name)
armor = {
"name": dbarm.pa_name,
"description": dbarm.pa_description,
"rarity": dbarm.pa_rarity,
"price": dbarm.pa_price,
"defense": dbarm.pa_defense,
"fire_def": dbarm.pa_fire,
"water_def": dbarm.pa_water,
"thunder_def": dbarm.pa_thunder,
"ice_def": dbarm.pa_ice,
"dragon_def": dbarm.pa_dragon,
"crafting_materials": get_crafting_list("armor", dbarm.pa_name)
}
db.close()
return jsonify(armor)
elif category == "skills":
return jsonify({
"message":
f"There is no individual page for palico skills. If you need information for them, use this endpoint: {url_for('.get_all_palico_category_info', category='skills', _external=True)}"
})
return {"message": "That is not a valid palico item!"}
def get_all_palico_category_info(category):
db.connect()
if category == "weapons":
db_weapons = PalicoWeapon.select(PalicoWeapon.pw_name)
weapons = {
"weapons": [{
"name":
weapon.pw_name,
"url":
url_for(".get_individual_palico_info",
category="weapons",
name=weapon.pw_name,
_external=True)
} for weapon in db_weapons]
}
db.close()
return jsonify(weapons)
elif category == "armor":
db_armor = PalicoArmor.select(PalicoArmor.pa_name)
armor = {
"weapons": [{
"name":
armor.pa_name,
"url":
url_for(".get_individual_palico_info",
category="armor",
name=armor.pa_name,
_external=True)
} for armor in db_armor]
}
db.close()
return jsonify(armor)
elif category == "skills":
db_skills = PalicoSkill.select()
skills = {"skills": []}
for skill in db_skills:
skills["skills"].append({
"name": skill.ps_name,
"type": skill.ps_type,
"description": skill.ps_description,
"memory": skill.ps_memory_req,
"learn_level": skill.ps_learn_level
})
db.close()
return jsonify(skills)
db.close()
return jsonify({"message": "Invalid category!"})
def get_individual_skill(tree_name, name):
db.connect()
db_skill = Skill.get(Skill.skill_name == name)
skill = {
"name": db_skill.skill_name,
"points": db_skill.skill_value,
"description": db_skill.skill_description,
"decorations": {
"harmful": [],
"helpful": []
}
}
skill_decos = get_decorations_for_skill(tree_name)
skill["decorations"]["harmful"] = skill_decos[0]
skill["decorations"]["helpful"] = skill_decos[1]
db.close()
return jsonify(skill)
def get_individual_decoration(name):
db.connect()
db_deco = Decoration.get(Decoration.deco_name == name)
deco = {
"name": db_deco.deco_name,
"slots": db_deco.deco_slot_requirement,
"positive_skill": {
"name": db_deco.positive_skill_tree,
"skill_points": db_deco.positive_skill_effect,
"url": url_for("skills.get_skill_tree", tree_name=db_deco.positive_skill_tree, _external=True)
},
"negative_skill": {
"name": db_deco.negative_skill_tree,
"skill_points": db_deco.negative_skill_effect,
"url": url_for("skills.get_skill_tree", tree_name=db_deco.negative_skill_tree, _external=True)
},
"combinations": []
}
for combo in DecorationCombination.select().where(DecorationCombination.deco_id == db_deco.deco_id):
item_1 = Item.get_by_id(combo.item_1_id).item_name
item_2 = Item.get_by_id(combo.item_2_id).item_name
combination = [
{
"name": item_1,
"quantity": combo.item_1_quantity,
"url": url_for('items.get_individual_item', name=item_1, _external=True)
},
{
"name": item_2,
"quantity": combo.item_2_quantity,
"url": url_for('items.get_individual_item', name=item_2, _external=True)
}
]
if combo.item_3_id != -1:
item_3 = Item.get_by_id(combo.item_3_id).item_name
combination.append({
"name": item_3,
"quantity": combo.item_3_quantity,
"url": url_for('items.get_individual_item', name=item_3, _external=True)
})
deco["combinations"].append(combination)
db.close()
return jsonify(deco)
def get_hunter_arts():
db.connect()
arts = {"arts": []}
for art in HunterArt.select():
art_quests = HunterArtUnlock.select().where(
art.art_id == HunterArtUnlock.art_id)
quests = Quest.select(Quest.id, Quest.quest_name)
arts["arts"].append({
"name":
art.art_name,
"gauge_required":
art.art_gauge,
"description":
art.art_description,
"required_quests": [
quest.quest_name for art_quest in art_quests
for quest in quests.where(art_quest.quest_id == Quest.id)
]
})
db.close()
return jsonify(arts)
def get_weapon(category, setname):
category = category.lower()
db.connect()
weapons = {"weapons": []}
if category == "blademaster":
for wep in SwordValue.select().where(
SwordValue.sword_set_name == setname):
weapon = {
"name":
wep.sword_name,
"class":
wep.sword_class,
"damage":
wep.raw_dmg,
"affinity":
wep.affinity,
"slots":
wep.slots,
"rarity":
wep.rarity,
"description":
wep.description,
"price":
wep.price,
"monster":
"none",
"elements": [],
"upgrades_into": [
url_for('.get_weapon',
_external=True,
category="blademaster",
setname=upgrade.replace(' 1', ""))
for upgrade in wep.upgrades_into.split(' & ')
if upgrade != "none"
],
"sharpness": {},
"crafting_materials": [],
"scraps": [],
"defense":
0,
}
elements = ElementDamage.select().where(
ElementDamage.weapon_id == wep.sword_id)
if len(elements) > 0:
for element in elements:
if "Def" == element.elem_type:
weapon["defense"] = element.elem_amount
else:
weapon["elements"].append({
"element":
element.elem_type,
"element_damage":
element.elem_amount
})
if wep.monster_id != -1:
weapon["monster"] = Monster.get_by_id(wep.monster_id).mon_name
sharpness_bars = {
"normal": SharpnessValue.get_by_id(wep.sharp_0_id),
"sharpness+1": SharpnessValue.get_by_id(wep.sharp_1_id),
"sharpness+2": SharpnessValue.get_by_id(wep.sharp_2_id)
}
for key, value in sharpness_bars.items():
weapon["sharpness"][key] = {
"red_sharpness": value.red_sharpness_length,
"orange_sharpness": value.orange_sharpness_length,
"yellow_sharpness": value.yellow_sharpness_length,
"green_sharpness": value.green_sharpness_length,
"blue_sharpness": value.blue_sharpness_length,
"white_sharpness": value.white_sharpness_length
}
if wep.sword_class == "Hunting Horn":
weapon["notes"] = HuntingHorn.get(
HuntingHorn.sword_id == wep.sword_id).notes
if wep.sword_class in ["Charge Blade", "Switch Axe", "Gunlance"]:
weapon["phial_shell"] = PhialAndShellWeapon.get(
PhialAndShellWeapon.sword_id ==
wep.sword_id).phial_or_shell_type
weapon["crafting_materials"], weapon[
"scraps"] = get_crafting_items("Blademaster", wep.sword_id)
weapons["weapons"].append(weapon)
elif category == "bow":
for db_bow in Bow.select().where(Bow.bow_set_name == setname):
bow = {
"name":
db_bow.bow_name,
"damage":
db_bow.bow_damage,
"affinity":
db_bow.affinity,
"arc_type":
db_bow.arc_type,
"charge_shots": [
db_bow.level_one_charge, db_bow.level_two_charge,
db_bow.level_three_charge, db_bow.level_four_charge
],
"supported_coatings": [
BOW_COATINGS[coating]
for coating in db_bow.supported_coatings.split(', ')
],
"slots":
db_bow.slots,
"rarity":
db_bow.rarity,
"description":
db_bow.description,
"elements": [],
"defense":
0,
"monster":
"none"
}
bow["crafting_materials"], bow["scraps"] = get_crafting_items(
"Bow", db_bow.bow_id)
if db_bow.monster_id != -1:
bow["monster"] = Monster.get_by_id(db_bow.monster_id).mon_name
elements = ElementDamage.select().where(
ElementDamage.weapon_id == db_bow.bow_id)
if len(elements) > 0:
for element in elements:
if "Def" == element.elem_type:
bow["defense"] = element.elem_amount
else:
bow["elements"].append({
"element":
element.elem_type,
"element_damage":
element.elem_amount
})
weapons["weapons"].append(bow)
elif category == "bowgun":
for db_gun in Bowgun.select().where(Bowgun.bg_set_name == setname):
gun = {
"name": db_gun.bg_name,
"type": db_gun.bg_type,
"damage": db_gun.bg_damage,
"affinity": db_gun.affinity,
"reload_speed": db_gun.reload_speed,
"recoil": db_gun.recoil,
"deviation": db_gun.deviation,
"slots": db_gun.slots,
"rarity": db_gun.rarity,
"description": db_gun.description,
"shots": {
"regular": [],
"internal": [],
"special_fire": []
},
"defense": 0
}
if db_gun.monster_id != -1:
gun["monster"] = Monster.get_by_id(db_gun.monster_id).mon_name
gun["crafting_materials"], gun["scraps"] = get_crafting_items(
"Bowgun", db_gun.bg_id)
defense = ElementDamage.select().where(
ElementDamage.weapon_id == db_gun.bg_id).limit(1)
if len(defense) > 0:
# Bowguns do not have traditional elements, but they do have defense
gun["defense"] = defense[0].elem_amount
ammo = BowgunAmmo.get(BowgunAmmo.bowgun_id == db_gun.bg_id)
for shot, amount in ammo.__dict__["__data__"].items():
if shot == "ammo_id" or shot == "bowgun_id":
continue
gun["shots"]["regular"].append({
"ammo_name":
shot,
"amount":
int(amount[0]),
"skill_required":
True if "skill" in amount else False
})
for shot in SpecialBowgunAmmo.select().where(
SpecialBowgunAmmo.bowgun_id == db_gun.bg_id):
sp_shot = {
"ammo_name": shot.ammo_name,
"shots": shot.shots,
}
if shot.ammo_type == "Rapid Fire":
# Converting the multiplier to a value between 0 and 1
sp_shot["multiplier"] = float(shot.multiplier / 100)
sp_shot["wait"] = shot.wait
gun["shots"]["special_fire"].append(sp_shot)
for internal_ammo in InternalBowgunAmmo.select().where(
InternalBowgunAmmo.bowgun_id == db_gun.bg_id):
gun["shots"]["internal"].append({
"ammo_name":
internal_ammo.ammo_name,
"total_amount":
internal_ammo.total_ammo,
"load_amount":
internal_ammo.load_amt
})
weapons["weapons"].append(gun)
db.close()
return jsonify(weapons)
def get_individual_monster(name):
db.connect()
mon = Monster.get(Monster.mon_name == name.title().replace("_", " "))
monster = {
"name": mon.mon_name,
"base_hp": mon.base_hp,
"base_size": mon.base_size,
"crown_sizes": {
"small_gold": mon.small_size,
"silver": mon.silver_size,
"large_gold": mon.king_size
},
"parts": [],
"drops": {
"high": [],
"low": []
},
"quests": [],
"armor": [],
"weapons": {}
}
for part in MonsterPart.select().where(mon.id == MonsterPart.monsterid):
if not any(break_keyword in part.part_name
for break_keyword in BREAK_WORDS):
monster["parts"].append({
"part_name":
part.part_name,
"stagger_value":
part.stagger_value,
"extract_color":
part.extract_color if part.extract_color is not None else "N/A"
})
for drop in MonsterDrop.select().where(mon.id == MonsterDrop.monsterid):
if drop.rank == "Low":
monster["drops"]["low"].append({
"item_name":
Item.get(Item.id == drop.itemid).item_name,
"source":
MonsterPart.get(drop.sourceid == MonsterPart.id).part_name,
"rank":
drop.rank,
"drop_chance":
str(drop.drop_chance) + "%",
"quantity":
drop.quantity
})
else:
monster["drops"]["high"].append({
"item_name":
Item.get(Item.id == drop.itemid).item_name,
"source":
MonsterPart.get(drop.sourceid == MonsterPart.id).part_name,
"rank":
drop.rank,
"drop_chance":
str(drop.drop_chance) + "%",
"quantity":
drop.quantity
})
all_armor = [
armor.armor_set
for armor in Armor.select().where(mon.id == Armor.monster_id)
]
monster["armor"] = list(set(all_armor))
for quest in QuestMonster.select().where(mon.id == QuestMonster.monsterid):
monster["quests"].append({
"quest_name":
Quest.get(quest.questid == Quest.id).quest_name,
"amount":
quest.amount,
"special_attribute":
quest.isSpecial,
"monster_stats": {
"hp": quest.mon_hp,
"stagger_multiplier": quest.stag_multiplier,
"attack_multiplier": quest.atk_multiplier,
"defense_multiplier": quest.def_multiplier,
"exhaust_multiplier": quest.exh_multiplier,
"dizzy_multiplier": quest.diz_multiplier,
"mount_multiplier": quest.mnt_multiplier
}
})
weapons = {
"blademaster":
SwordValue.select().where(mon.id == SwordValue.monster_id),
"bow": Bow.select().where(mon.id == Bow.monster_id),
"bowgun": Bowgun.select().where(mon.id == Bowgun.monster_id)
}
for weapon in weapons["blademaster"]:
monster["weapons"].setdefault(
weapon.sword_class.lower().replace("&", "and").replace(" ", "_"),
[]).append(weapon.sword_set_name)
for weapon in weapons["bow"]:
monster["weapons"].setdefault("bow", []).append(weapon.bow_set_name)
for weapon in weapons["bowgun"]:
monster["weapons"].setdefault(weapon.bg_type.lower().replace(" ", "_"),
[]).append(weapon.bg_set_name)
for wpn_class in monster["weapons"].keys():
monster["weapons"][wpn_class] = list(set(
monster["weapons"][wpn_class]))
db.close()
return jsonify(monster)
def get_individual_item(name):
db.connect()
db_item = Item.get(Item.item_name == name.title().replace("_", " "))
item = {
"name": db_item.item_name,
"description": db_item.description,
"rarity": db_item.rarity,
"max_stack_size": db_item.max_stack,
"sell_price": db_item.sell_price,
"combination": db_item.combinations.split(' + '),
"crafting": {
"weapons": {
"create": [],
"upgrade": [],
"byproduct": []
},
"armor": {
"create": [],
"upgrade": [],
"byproduct": []
},
"decorations": [],
"palico": {
"armor": [],
"weapon": []
}
},
"quest_rewards": []
}
weapon_crafts = CraftItem.select().where(CraftItem.item_name == item["name"])
for craft in weapon_crafts:
weapon_name = ""
if craft.creation_type == "Blademaster":
weapon_name = SwordValue.get(SwordValue.sword_id == craft.creation_id).sword_name
elif craft.creation_type == "Bowgun":
weapon_name = Bowgun.get(Bowgun.bg_id == craft.creation_id).bg_name
else:
weapon_name = Bow.get(Bow.bow_id == craft.creation_id).bow_name
item["crafting"]["weapons"][craft.usage].append({
"name": weapon_name,
"quantity": craft.quantity,
"unlocks_creation": True if craft.unlocks_creation == "yes" else False
})
armor_crafts = ArmorCraftItem.select().where(ArmorCraftItem.item_name == item["name"])
for craft in armor_crafts:
item["crafting"]["armor"]["create"].append({
"name": Armor.get(Armor.armor_id == craft.armor_id).armor_name,
"quantity": craft.quantity,
"unlocks_armor": True if craft.unlocks_armor == 1 else False
})
upgrade_crafts = ArmorUpgradeItem.select().where(ArmorUpgradeItem.item_name == item["name"])
for craft in upgrade_crafts:
item["crafting"]["armor"]["upgrade"].append({
"name": Armor.get(Armor.armor_id == craft.armor_id).armor_name,
"quantity": craft.quantity,
"level": craft.upgrade_level
})
if "Scrap" in item["name"]:
reward_scraps = ArmorScrapReward.select().where(ArmorScrapReward.item_id == db_item.id)
for scrap in reward_scraps:
item["crafting"]["armor"]["byproduct"].append({
"name": Armor.get(Armor.armor_id == scrap.armor_id).armor_name,
"quantity": scrap.quantity,
"source": scrap.type,
"level": scrap.level
})
decocombos = DecorationCombination.select()
for combo in decocombos.where(DecorationCombination.item_1_id == db_item.id or DecorationCombination.item_2_id == db_item.id or DecorationCombination.item_3_id == db_item.id):
quantity = 0
if combo.item_1_id == db_item.id:
quantity = combo.item_1_quantity
elif combo.item_2_id == db_item.id:
quantity = combo.item_2_quantity,
else:
quantity = combo.item_3_quantity
item["crafting"]["decorations"].append({
"name": Decoration.get(combo.deco_id == Decoration.deco_id).deco_name,
"quantity": quantity
})
for craft in PalicoCraftItem.select().where(PalicoCraftItem.item_id == db_item.id):
item["crafting"]["palico"][craft.type].append({
"name": craft.palico_item,
"quantity": craft.quantity
})
for reward in QuestBoxItem.select().where(QuestBoxItem.itemid == db_item.id):
item["quest_rewards"].append({
"quest": Quest.get(Quest.id == reward.questid).quest_name,
"quantity": reward.quantity,
"box": reward.box_type,
"appearance_chance": reward.appear_chance
})
return jsonify(item)
def get_individual_quest(name):
db.connect()
# Some quests have the same name, so return a wrapper list
quests = {"quests": []}
for dbq in Quest.select().where(Quest.quest_name.contains(name)):
goals = [{
"zenny_reward": db_goal.zenny_reward,
"hrp_reward": db_goal.hrp_reward,
"wycadpts_reward": db_goal.wycadpts_reward,
"description": db_goal.goal_description
} for db_goal in [
QuestGoal.get_by_id(dbq.goalid),
QuestGoal.get_by_id(dbq.subgoalid)
]]
monsters = [{
"name": Monster.get_by_id(quest.monsterid).mon_name,
"amount": quest.amount,
"special_attribute": quest.isSpecial,
"monster_stats": {
"hp": quest.mon_hp,
"stagger_multiplier": quest.stag_multiplier,
"attack_multiplier": quest.atk_multiplier,
"defense_multiplier": quest.def_multiplier,
"exhaust_multiplier": quest.exh_multiplier,
"dizzy_multiplier": quest.diz_multiplier,
"mount_multiplier": quest.mnt_multiplier
}
} for quest in QuestMonster.select().where(
dbq.id == QuestMonster.questid)]
rewards = [{
"name":
Item.get_by_id(item.itemid).item_name,
"box":
item.box_type,
"quantity":
item.quantity,
"appear_chance":
item.appear_chance if item.box_type != "Supplies" else 100
} for item in QuestBoxItem.select().where(
dbq.id == QuestBoxItem.questid)]
quest = {
"name": dbq.quest_name,
"type": dbq.quest_type,
"description": dbq.quest_description,
"is_key": True if dbq.isKey == "yes" else False,
"is_prowler": True if dbq.isProwler == "yes" else False,
"is_unstable": True if dbq.isUnstable == "yes" else False,
"time_limit": dbq.timeLimit,
"contract_fee": dbq.contractFee,
"goal": goals[0],
"subgoal": goals[1],
"monsters": monsters,
"rewards": rewards,
"prerequisites": [],
"unlocks": [],
}
for que in QuestUnlock.select().where(dbq.id == QuestUnlock.questid):
if que.unlock_type == "prerequisite":
quest["prerequisites"].append({
"name":
que.quest_name,
"url":
url_for('.get_individual_quest',
name=re.sub(r"\[.*?\] ", "", que.quest_name),
_external=True)
})
else:
quest["unlocks"].append({
"name":
que.quest_name,
"url":
url_for('.get_individual_quest',
name=re.sub(r"\[.*?\] ", "", que.quest_name),
_external=True)
})
quests["quests"].append(quest)
db.close()
return jsonify(quests)
