//--------------------------------------------------------  
 | 
//    [Author]:           YYL  
 | 
//    [  Date ]:           Friday, August 22, 2025  
 | 
//--------------------------------------------------------  
 | 
  
 | 
using System.Collections.Generic;  
 | 
using System;  
 | 
using UnityEngine;  
 | 
using LitJson;  
 | 
  
 | 
public partial class FightPowerRatioConfig : ConfigBase<int, FightPowerRatioConfig>  
 | 
{  
 | 
    static FightPowerRatioConfig()  
 | 
    {  
 | 
        // 访问过静态构造函数  
 | 
        visit = true;   
 | 
    }  
 | 
  
 | 
    public int LV;  
 | 
    public float AtkRatio;  
 | 
    public float MaxHPRatio;  
 | 
    public float DefRatio;  
 | 
    public float StunRateRatio;  
 | 
    public float SuperHitRateRatio;  
 | 
    public float ComboRateRatio;  
 | 
    public float MissRateRatio;  
 | 
    public float ParryRateRatio;  
 | 
    public float SuckHPPerRatio;  
 | 
    public float StunRateDefRatio;  
 | 
    public float SuperHitRateDefRatio;  
 | 
    public float ComboRateDefRatio;  
 | 
    public float MissRateDefRatio;  
 | 
    public float ParryRateDefRatio;  
 | 
    public float SuckHPPerDefRatio;  
 | 
    public float FinalDamPerRatio;  
 | 
    public float FinalDamPerDefRatio;  
 | 
    public float PhyDamPerRatio;  
 | 
    public float PhyDamPerDefRatio;  
 | 
    public float MagDamPerRatio;  
 | 
    public float MagDamPerDefRatio;  
 | 
    public float NormalSkillPerRatio;  
 | 
    public float NormalSkillPerDefRatio;  
 | 
    public float AngerSkillPerRatio;  
 | 
    public float AngerSkillPerDefRatio;  
 | 
    public float SuperDamPerRatio;  
 | 
    public float SuperDamPerDefRatio;  
 | 
    public float CurePerRatio;  
 | 
    public float CurePerDefRatio;  
 | 
    public float ShieldPerRatio;  
 | 
    public float ShieldPerDefRatio;  
 | 
    public float DOTPerRatio;  
 | 
    public float DOTPerDefRatio;  
 | 
    public float WeiFinalDamPerRatio;  
 | 
    public float WeiFinalDamPerDefRatio;  
 | 
    public float ShuFinalDamPerRatio;  
 | 
    public float ShuFinalDamPerDefRatio;  
 | 
    public float WuFinalDamPerRatio;  
 | 
    public float WuFinalDamPerDefRatio;  
 | 
    public float QunFinalDamPerRatio;  
 | 
    public float QunFinalDamPerDefRatio;  
 | 
  
 | 
    public override int LoadKey(string _key)  
 | 
    {  
 | 
        int key = GetKey(_key);  
 | 
        return key;  
 | 
    }  
 | 
  
 | 
    public override void LoadConfig(string input)  
 | 
    {  
 | 
        try {  
 | 
        string[] tables = input.Split('\t');  
 | 
        int.TryParse(tables[0],out LV);   
 | 
  
 | 
            float.TryParse(tables[1],out AtkRatio);   
 | 
  
 | 
            float.TryParse(tables[2],out MaxHPRatio);   
 | 
  
 | 
            float.TryParse(tables[3],out DefRatio);   
 | 
  
 | 
            float.TryParse(tables[4],out StunRateRatio);   
 | 
  
 | 
            float.TryParse(tables[5],out SuperHitRateRatio);   
 | 
  
 | 
            float.TryParse(tables[6],out ComboRateRatio);   
 | 
  
 | 
            float.TryParse(tables[7],out MissRateRatio);   
 | 
  
 | 
            float.TryParse(tables[8],out ParryRateRatio);   
 | 
  
 | 
            float.TryParse(tables[9],out SuckHPPerRatio);   
 | 
  
 | 
            float.TryParse(tables[10],out StunRateDefRatio);   
 | 
  
 | 
            float.TryParse(tables[11],out SuperHitRateDefRatio);   
 | 
  
 | 
            float.TryParse(tables[12],out ComboRateDefRatio);   
 | 
  
 | 
            float.TryParse(tables[13],out MissRateDefRatio);   
 | 
  
 | 
            float.TryParse(tables[14],out ParryRateDefRatio);   
 | 
  
 | 
            float.TryParse(tables[15],out SuckHPPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[16],out FinalDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[17],out FinalDamPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[18],out PhyDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[19],out PhyDamPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[20],out MagDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[21],out MagDamPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[22],out NormalSkillPerRatio);   
 | 
  
 | 
            float.TryParse(tables[23],out NormalSkillPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[24],out AngerSkillPerRatio);   
 | 
  
 | 
            float.TryParse(tables[25],out AngerSkillPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[26],out SuperDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[27],out SuperDamPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[28],out CurePerRatio);   
 | 
  
 | 
            float.TryParse(tables[29],out CurePerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[30],out ShieldPerRatio);   
 | 
  
 | 
            float.TryParse(tables[31],out ShieldPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[32],out DOTPerRatio);   
 | 
  
 | 
            float.TryParse(tables[33],out DOTPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[34],out WeiFinalDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[35],out WeiFinalDamPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[36],out ShuFinalDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[37],out ShuFinalDamPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[38],out WuFinalDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[39],out WuFinalDamPerDefRatio);   
 | 
  
 | 
            float.TryParse(tables[40],out QunFinalDamPerRatio);   
 | 
  
 | 
            float.TryParse(tables[41],out QunFinalDamPerDefRatio);   
 | 
        }  
 | 
        catch (Exception exception)  
 | 
        {  
 | 
            Debug.LogError(exception);  
 | 
        }  
 | 
    }  
 | 
}  
 |