KemoFureApi/loaders/Kingdom/kemono.py

import re
import math

def get_skill_materials(friend, kfk_kemono_skill, kfk_en_item):
    items_total = []
    kfk_skill = sorted(filter(lambda s: s["kemonosn"] == friend["sn"] and s["type"] == 2, kfk_kemono_skill.indexed_data.values()), key = lambda s: s["sn"])
    for idx, s in enumerate(kfk_skill):
        if len(s["item"]) == 0:
            continue
        items_total.append(
            {
                "lvl": s["skilllevel"],
                "awakenReq": s["wakenlevel"],
                "lvlReq": s["kemonolevel"],
                "items": list([{"count": num, "name": kfk_en_item.get(item)["name"]} for item, num in zip(s["item"], s["itemnum"])])
            }
        )
    return items_total

def get_awaken_materials(friend, kfk_kemono_waken, kfk_en_item):
    items_total = []
    kfk_waken = sorted(filter(lambda s: s["kemonosn"] == friend["sn"], kfk_kemono_waken.indexed_data.values()), key = lambda s: s["sn"])
    for idx, s in enumerate(kfk_waken):
        if len(s["item"]) == 0:
            continue
        items_total.append(
            {
                "lvl": idx+1,
                "items": list([{"count": num, "name": kfk_en_item.get(item)["name"]} for item, num in zip(s["item"], s["itemnum"])])
            }
        )
    return items_total

def calculate_stats(friend, awaken : int, level : int, trust_percent = 0, trustAttri = None):
    stats_array = friend["attrScriptParam"]
    max_levels = friend["maxLvl"]
    max_awaken = friend["maxAwaken"] 

    awaken_step = max_awaken + 2  

    atk_ptr = 1 * awaken_step
    satk_ptr = 2 * awaken_step
    pdef_ptr = 3 * awaken_step
    sdef_ptr = 4 * awaken_step
    hp_ptr = 5 * awaken_step
    speed_ptr = 6 * awaken_step

    stats = {"patk":stats_array[atk_ptr], "satk":stats_array[satk_ptr], "pdef":stats_array[pdef_ptr], "sdef":stats_array[sdef_ptr], "hp":stats_array[hp_ptr], "speed":stats_array[speed_ptr]}
    for i in range(awaken + 1):
        if i == awaken:
            max_level = level
        else:
            max_level = max_levels[i]

        stats["patk"] += stats_array[atk_ptr + 1 + i] * (max_level-1)
        stats["satk"] += stats_array[satk_ptr + 1 + i] * (max_level-1)
        stats["pdef"] += stats_array[pdef_ptr + 1 + i] * (max_level-1)
        stats["sdef"] += stats_array[sdef_ptr + 1 + i] * (max_level-1)
        stats["hp"] += stats_array[hp_ptr + 1 + i] * (max_level-1)
        stats["speed"] += stats_array[speed_ptr + 1 + i] * (max_level-1)

    if trust_percent > 0 and trustAttri != None:
        if trustAttri["attribute1"] == 1001:
            stats["hp"] += trustAttri["attributeValue1"][trust_percent]
        elif trustAttri["attribute1"] == 1021:
            stats["patk"] += trustAttri["attributeValue1"][trust_percent]
        elif trustAttri["attribute1"] == 1031:
            stats["satk"] += trustAttri["attributeValue1"][trust_percent]
        else:
            print(trustAttri["attribute1"])
            
        if trustAttri["attribute2"] == 1001:
            stats["hp"] += trustAttri["attributeValue2"][trust_percent]
        elif trustAttri["attribute2"] == 1021:
            stats["patk"] += trustAttri["attributeValue2"][trust_percent]
        elif trustAttri["attribute2"] == 1031:
            stats["satk"] += trustAttri["attributeValue2"][trust_percent]
        else:
            print(trustAttri["attribute2"])

    stats["patk"] = int(round(stats["patk"]))
    stats["satk"] = int(round(stats["satk"]))
    stats["pdef"] = int(round(stats["pdef"]))
    stats["sdef"] = int(round(stats["sdef"]))
    stats["hp"] = int(round(stats["hp"]))
    stats["speed"] = int(round(stats["speed"]))

    return stats

def clean_skill_string(input_string):
    if input_string is None:
        return None

    color_tags_pattern = r"<color=#[A-Fa-f0-9]+>(.*?)<\/color>"
    output_string = re.sub(color_tags_pattern, r"\1", input_string)

    link_tags_pattern = r"<link=\".*?\">(.*?)<\/link>"
    output_string = re.sub(link_tags_pattern, r"\1", output_string)

    return output_string

def fill_miracle(input_string, miracle_level = 1, kemono_level = 0):
    if input_string is None:
        return ""
    
    pattern = r"\{\{(.*?)\}\}"
    def replace_match(match):
        key : str = match.group(1).strip()

        if key.startswith("skill | SkillDesc:"):
            values = key.replace("skill | SkillDesc:", "").split(',')
            values = [float(value) for value in values]
            level_up_values = [
                    values[1],
                    values[1],
                    values[1],
                    values[2],
                    values[2],
                    values[2],
                    values[3],
                    values[3],
                    values[3],
                    values[4],
                    values[4],
                    values[4],
                ]
            base_value = values[0]
            level_up_value = sum(level_up_values[0:miracle_level-1]) + values[5]
            level_bonus = (kemono_level - values[7]) * values[6]
            return str(math.floor(base_value + level_up_value + level_bonus))

        return "{{" + key + "}}"

    output_string = re.sub(pattern, replace_match, input_string)

    return clean_skill_string(output_string)