using CodeStage.AntiCheat.ObscuredTypes;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public static class MyValue
{
    public static string OnestoreURL = "https://onesto.re/0000759501";

    public static int UTC = 9, MaxNote = 5, NoteTime = 1800;

    public static ChoiceMapData MyChoiceMapData = new ChoiceMapData { n_MapID = 1, n_PortalIndex = 0 };
    public static RealCamera _RealCamera;
    public static RealCamera m_RealCamera
    {
        get
        {
            if (_RealCamera == null && Camera.main) _RealCamera = Camera.main.GetComponent<RealCamera>();
            return _RealCamera; 
        }
    }

    public static Dictionary<eDungeon, string> dic_Leaderboard = new Dictionary<eDungeon, string>
    { {eDungeon.d2_Maze, "Rank_Maze" }, {eDungeon.d3_Nightmare, "Rank_Damage" }, };

    public static Dictionary<eItem, EquipItemData> dic_EquipmentKey = new Dictionary<eItem, EquipItemData>
    {
        { eItem.Weapon, new EquipItemData{ id = 0, key = "Weapon" } },
        { eItem.Armor, new EquipItemData{ id = 1, key = "Armor" } },
        { eItem.Helmet, new EquipItemData{ id = 2, key = "Helmet" } },
        { eItem.Extra, new EquipItemData{ id = 3, key = "Extra" } },
        { eItem.Necklace, new EquipItemData{ id = 4, key = "Necklace" } },
        { eItem.Ring, new EquipItemData{ id = 5, key = "Ring" } },
    };
    public static List<eItem> list_Equipment = new List<eItem>
    { eItem.Weapon, eItem.Armor, eItem.Helmet, eItem.Extra, eItem.Necklace, eItem.Ring };

    public static Dictionary<eMainStatType, Dictionary<eStat, float>> dic_MainStatMultiplier = new Dictionary<eMainStatType, Dictionary<eStat, float>>
    {
        { eMainStatType.STR, new Dictionary<eStat, float> { { eStat.ATK, 1 }, { eStat.MaxHP, 22 }, { eStat.HP_REGEN, 0.1f }, { eStat.DEF_Multiplier, 0.001f }, } },
        { eMainStatType.DEX, new Dictionary<eStat, float> { { eStat.ATK, 1 }, { eStat.DEF, 0.167f }, { eStat.HERO_ATK_SPD, 0.01f }, { eStat.CRI_DMG_Multiplier, 0.001f }, } },
        { eMainStatType.INT, new Dictionary<eStat, float> { { eStat.ATK, 1 }, { eStat.MaxMP, 12 }, { eStat.MP_REGEN, 0.05f }, { eStat.M_DEF_Multiplier, 0.001f }, { eStat.M_CRI_DMG_Multiplier, 0.001f } } },
        { eMainStatType.LUCK, new Dictionary<eStat, float> { { eStat.CRI_DMG_Multiplier, 0.005f }, { eStat.M_CRI_DMG_Multiplier, 0.005f }, { eStat.GOLD_INCREASE, 1 }, { eStat.GOLD_Multiplier, 0.001f }, { eStat.ITEM_Multiplier, 0.001f }, { eStat.EXP_Multiplier, 0.001f } } },
    };

    public static Dictionary<int, List<eStat>> dic_StatUp = new Dictionary<int, List<eStat>>
    {
        { 0, new List<eStat>{ eStat.STR, eStat.DEX, eStat.INT, eStat.LUK } },
        { 1, new List<eStat>{ eStat.STR } }, { 2, new List<eStat>{ eStat.DEX } },
        { 3, new List<eStat>{ eStat.INT } }, { 4, new List<eStat>{ eStat.LUK } },
    };
    public static Dictionary<eStat, eCC> dic_StatUpCC_from_Stat = new Dictionary<eStat, eCC>
    { { eStat.STR, eCC.STR_Mul_Up }, { eStat.DEX, eCC.DEX_Mul_Up }, { eStat.INT, eCC.INT_Mul_Up }, { eStat.LUK, eCC.LUK_Mul_Up } };
    public static Dictionary<eStat, eStat> dic_StatUp_from_Stat = new Dictionary<eStat, eStat>
    { { eStat.STR, eStat.STR_Multiplier }, { eStat.DEX, eStat.DEX_Multiplier },{ eStat.INT, eStat.INT_Multiplier },{ eStat.LUK, eStat.LUK_Multiplier } };

    public static Dictionary<(eTargetCondition, int), int> dic_CollectionMul = new Dictionary<(eTargetCondition, int), int>
    {
        { (eTargetCondition.TakeEquip, 0), 1 }, { (eTargetCondition.TakeEquip, 1), 2 },
        { (eTargetCondition.TakeEquip, 5), 3 }, { (eTargetCondition.TakeEquip, 10), 5 },

        { (eTargetCondition.KillMonster, 0), 1 }, { (eTargetCondition.KillMonster, 1), 3 },
        { (eTargetCondition.KillMonster, 5), 5 }, { (eTargetCondition.KillMonster, 10), 10 },
    };

    public static string OptionKey_Sound = "Option_Sound";
    public static string OptionKey_UserType = "Option_UserType"; // 0 구글, 1 애플, 2 게스트
    public static string OptionKey_UserID = "Option_UserID";

    static Dictionary<eAnim, string> dic_animNames = new Dictionary<eAnim, string>
    {
        { eAnim.Idle, "idle" }, { eAnim.Run, "run" }, { eAnim.Die, "die" }, { eAnim.Hit, "hit" }, { eAnim.Dodge, "dodge" },
        { eAnim.Attack, "attack" }, { eAnim.Attack2, "attack2" }, { eAnim.Attack3, "attack3" }, { eAnim.Attack4, "attack4" },
        { eAnim.Skill, "casting" }
    };
    public static string Get_AnimName(eAnim _animtype) { return dic_animNames[_animtype]; }
    static PCActor _mypc;
    public static PCActor MyPC
    {
        get { return _mypc; }
        set
        {
            _mypc = value; 
            bMyPC = value;
        }
    }
    public static bool bMyPC;

    public static int ChatLimitLV = 1, PotionAddMin = 15;
    public static int[] arr_NeedMixCount = new int[] { 0, 10, 10, 10, 10, 10, 10, 0 }; // 등급에 따른 합성에 필요 갯수
    public static int[] arr_NeedTranscendCount = new int[] { 0, 12, 10, 8, 6, 4, 2, 1 }; // 등급에 따른 초월에 필요 갯수

    public static string OffButtonName = "button8";
    public static float Get_GameSpeed()
    {
        // TODO 정인호 : 게임 속도 제어
        //if (InGameInfo.Ins.Get_CurStageData().Chapter < 101 && LobbyChapterQuest.UseNote && ServerInfo.Ins.m_ServerData.Get_Common(eCommon.X2) > 0)
        //    return 1.25f;
        return 1f;
    }

    public static int Get_NextGradeID(eItemGrade CurGrade)
    {
        switch (CurGrade)
        {
            case eItemGrade.Common: return Random.Range(5, 9);
            case eItemGrade.Magic:  return Random.Range(9, 13);
            case eItemGrade.Rare:   return Random.Range(13, 17);
            case eItemGrade.Unique: return Random.Range(17, 21);
            case eItemGrade.Epic:   return Random.Range(21, 25);
            case eItemGrade.Legend: return Random.Range(25, 29);
        }
        return 0;
    }

    //                 역할   프리셋  아이디(펫, 요정은 id > 0, PC는 0)
    static Dictionary<(eRole, string, int), ActorStatInfo> dic_ActorStatInfo = new Dictionary<(eRole, string, int), ActorStatInfo>();

    public static ActorStatInfo Get_ActorStatInfoorNull(eRole role, bool showchange = true, string preset = "0", int id = 0, bool keephpmp = false)
    {
        var info = dic_ActorStatInfo.ContainsKey((role, preset, id)) ? dic_ActorStatInfo[(role, preset, id)] : null;
        if (!DSUtil.CheckNull(info)) info.Reset(keephpmp, showchange); // 존재할 때는 Reset을 안해서 여기서 해줌
        return info;
    }
    public static ActorStatInfo MakeorGet_ActorStatInfo(eRole role, ServerData sdata, PetListTableData petdata, string preset = "0", int id = 0, bool keephpmp = false)
    {
        var info = Get_ActorStatInfoorNull(role, true, preset, id, keephpmp);
        if (DSUtil.CheckNull(info))
        {
            var temp = new ActorStatInfo(role, sdata, petdata);
            dic_ActorStatInfo.Add((role, preset, id), temp);
            return temp;
        }

        info.Check_ServerData(sdata); // 서버 데이터 링크가 계속 유지되지 않으므로 한 번씩 갱신해야 함
        return info;
    }

    public static string Get_GradeColor(int _grade)
    {
        switch (_grade)
        {
            default: return "<color=#a6a6a7>";
            case 2: return  "<color=#cd835e>";
            case 3: return  "<color=#23e787>";
            case 4: return  "<color=#2ca1f4>";
            case 5: return  "<color=#fd4348>";
            case 6: return  "<color=#ffe613>";
            case 7: return  "<color=#dd61ef>";
            case 8: return "<color=#FF9413>";
            case 9: return "<color=#FF12A8>";
        }
    }
    public static Color Get_SliderGradeColor(eItemGrade _grade)
    {
        switch (_grade)
        {
            default: return new Color32(166, 166, 167, 255);
            case eItemGrade.Magic: return new Color32(205, 131, 94, 255);
            case eItemGrade.Rare: return new Color32(35, 231, 135, 255);
            case eItemGrade.Unique: return new Color32(44, 161, 244, 255);
            case eItemGrade.Epic: return new Color32(253, 67, 72, 255);
            case eItemGrade.Legend: return new Color32(255, 230, 19, 255);
            case eItemGrade.Myth: return new Color32(211, 97, 239, 255);
        }
    }
    public static eItemGrade Get_GradebyID(int id)
    {
        if (id < 5) return eItemGrade.Common;
        else if (id < 9) return eItemGrade.Magic;
        else if (id < 13) return eItemGrade.Rare;
        else if (id < 17) return eItemGrade.Unique;
        else if (id < 21) return eItemGrade.Epic;
        else if (id < 25) return eItemGrade.Legend;
        else return eItemGrade.Myth;
    }

    #region 컨텐츠 오픈 체크
    public static bool CanEnter_Content(eContentOpen content, bool _showToast = true)
    {
        if (ServerInfo.Ins.m_SC_ServerStatus.ContentsLock == 0) return true;

        int someVal = 0;
        switch (content)
        {
            //case eContentOpen.Witch: someVal = 10; break;
            //case eContentOpen.Equipment: someVal = 13; break;
            //case eContentOpen.Pet: someVal = 11; break;
            //case eContentOpen.Book: someVal = 27; break;
            //case eContentOpen.Kettle: someVal = 25; break;
            case eContentOpen.Shop: someVal = 26; break;
            case eContentOpen.Gamble: someVal = 11; break;
            //case eContentOpen.Inven: someVal = 28; break;
            //case eContentOpen.Title: someVal = 29; break;
            case eContentOpen.Mission: someVal = 32; break;
            case eContentOpen.Pass: someVal = 33; break;

            case eContentOpen.MyFarm:
                //if (ServerInfo.Ins.m_ServerData.Get_Common(eCommon.MaxMapID) >= 15) return true;
                //if (_showToast) ToastUI.Ins.Set("14챕터 강제 수용소 클리어 후 입장 가능");
                return false;
            case eContentOpen.Memory_Filed:
                //if (ServerInfo.Ins.m_ServerData.Get_Common(eCommon.MaxMapID) >= 4) return true;
                return false;
            case eContentOpen.Memory_Forest:
                //if (ServerInfo.Ins.m_ServerData.Get_Common(eCommon.MaxMapID) >= 5) return true;
                return false;
            case eContentOpen.Memory_Dungeon:
                //if (ServerInfo.Ins.m_ServerData.Get_Common(eCommon.MaxMapID) >= 6) return true;
                return false;
            case eContentOpen.Memory_Witch:
            case eContentOpen.Memory_PetBattle:
                //if (ServerInfo.Ins.m_ServerData.Get_Common(eCommon.MaxMapID) >= 10) return true;
                return false;
        }
        if (ServerInfo.Ins.m_ServerData.Get_Common(eCommon.GuideStep) >= someVal) return true;
        if (_showToast) ToastUI.Ins.Set(175, someVal);

        return false;
    }
    #endregion
    #region 노티 체크
    public static bool CanGetMemoryForestReward()
    {
        var sdata = ServerInfo.Ins.m_ServerData;
        return false;
    }
    public static bool CanDrinkPotion()
    {
        var sdata = ServerInfo.Ins.m_ServerData;
        var pTdata = table_kettle.Ins.Get_DataList(eItem.Potion);
        for (int i = 0; i < pTdata.Count; i++)
        {
            if (sdata.Check_ItemAmount(eItem.Potion, 1, pTdata[i].ID, false))
                return true;
        }
        return false;
    }
    public static bool CanCombineKettle(eItem potion_or_relic)
    {
        var sdata = ServerInfo.Ins.m_ServerData;
        var pTdata = table_kettle.Ins.Get_DataList(potion_or_relic);
        for (int i = 0; i < pTdata.Count; i++)
        {
            var temp = pTdata[i] as KettleTableData;
            bool existfood = false;
            for (int j = 0; j < temp.list_CombineData.Count; j++)
            {
                var temp2 = temp.list_CombineData[j];
                existfood = sdata.Check_ItemAmount(eItem.Food, temp2.FoodNeedAmount, temp2.FoodID, false);
                if (!existfood)
                    break;
            }
            if (existfood) return true;
        }
        return false;
    }
    #endregion
}

public enum eContentOpen
{
    Witch, Equipment, Pet, Book, Kettle, Shop, Gamble, MyFarm, Inven, Title, Mission, Pass, Memory_Filed, Memory_Forest, Memory_Dungeon, Memory_Witch, Memory_PetBattle,
}

public class ActorStatInfo
{
    eRole m_Role;
    eMainStatType e_MainStatType;
    ServerData m_sdata;
    PetListTableData m_petdata;
    MonsterTableData m_mobdata;
    MonsterAppearData m_moblvdata;

    Dictionary<eStat, ObscuredDouble> dic_StatValue = new Dictionary<eStat, ObscuredDouble>();
    Dictionary<eStat, ObscuredDouble> dic_StatValue_Buff = new Dictionary<eStat, ObscuredDouble>();
    Dictionary<eStat, ObscuredDouble> dic_StatValue_Debuff = new Dictionary<eStat, ObscuredDouble>();
    bool bInit = false;

    void Init()
    {
        if (!bInit)
        {
            bInit = true;
            for (eStat i = 0; i < eStat.None; i++)
                dic_StatValue.Add(i, 0d);
        }
    }
    void Clear()
    {
        var keys = new List<eStat>(dic_StatValue.Keys);
        foreach (var key in keys) dic_StatValue[key] = 0d;
    }
    public void Clear_BuffDebuff()
    {
        dic_StatValue_Buff.Clear();
        dic_StatValue_Debuff.Clear();
    }

    public ActorStatInfo(eRole role)
    {
        Init();
        m_Role = role;
    }
    public ActorStatInfo(eRole role, ServerData sdata, PetListTableData petdata)
    { // pc or pet 세팅
        Init();
        m_Role = role;
        m_sdata = sdata;
        m_petdata = petdata;
        Reset();
    }
    public ActorStatInfo(eRole role, MonsterTableData mobdata, MonsterAppearData moblvdata)
    { // 몬스터 세팅
        Init();
        m_Role = role;
        m_mobdata = mobdata;
        m_moblvdata = moblvdata;
        Reset();
    }

    public void Check_ServerData(ServerData sdata) { if (m_sdata != sdata) m_sdata = sdata; }
    public void Reset(bool keephpmp = false, bool showchange = true)
    {
        bool isPet = !DSUtil.CheckNull(m_petdata);
        if (showchange && m_Role == eRole.PC && !DSUtil.CheckNull(StatChangeUI.Ins)) StatChangeUI.Ins.Set(true, dic_StatValue);
        double hp = 0d, mp = 0d;
        if (keephpmp) { hp = Get_Stat(eStat.HP); mp = Get_Stat(eStat.MP); }
        Clear();
        if (!DSUtil.CheckNull(m_sdata))
        { // 아군
            var classData = table_classconfig.Ins.Get_Data_orNull(m_sdata.Get_EqiupmentEquip(eItem.PC));
            e_MainStatType = classData.e_MainStatType;
            var curMapData = MyValue.MyChoiceMapData;
            dic_StatValue[eStat.STR] = table_classconfig.Ins.Get_PureStat(eStat.STR, m_sdata) + m_sdata.MapData_Get_StatLv(curMapData.n_MapID, curMapData.n_Difficult, eMainStatType.STR);
            dic_StatValue[eStat.DEX] = table_classconfig.Ins.Get_PureStat(eStat.DEX, m_sdata) + m_sdata.MapData_Get_StatLv(curMapData.n_MapID, curMapData.n_Difficult, eMainStatType.DEX);
            dic_StatValue[eStat.INT] = table_classconfig.Ins.Get_PureStat(eStat.INT, m_sdata) + m_sdata.MapData_Get_StatLv(curMapData.n_MapID, curMapData.n_Difficult, eMainStatType.INT);
            dic_StatValue[eStat.LUK] = table_classconfig.Ins.Get_PureStat(eStat.LUK, m_sdata);
            Set_Stat(true, eStat.MaxHP, classData.n_DefaultHP);
            Set_Stat(true, eStat.MaxMP, classData.n_DefaultMP);

            Set_GlobalValue(); // GlobalValue 값 적용
            Set_JobPassive(classData); // 직업 전용 패시브 값 적용
            Set_SkillPassive(); // 스킬 패시브 값 적용
            Set_EquipItem(); // 착용 아이템 값 적용
            Set_EquipSlotEnchant(classData); // 착용 슬롯 인챈트 값 적용
            Set_PCAbility(classData.e_BattleType); // 캐릭터 특성 값 적용
            Set_PCAwaken(); // 캐릭터 각성 값 적용
            Set_PCLimit(); // 캐릭터 초월(한계돌파) 값 적용
            Set_Relic(); // 컬렉션 - 유물 값 적용
            Set_Collection(); // 컬렉션 - 장비, 몬스터 도감, 코스튬 값 적용
            Set_Fruit(); // 열매 값 적용
            Set_Farmer(); // 농부 값 적용(전투x)

            // 펫
            var Pet_All_Stat_Multiplier = isPet ? Get_Stat(eStat.Pet_Stat_Multiplier) : 0d;
            Set_Stat(true, eStat.STR, Get_Stat(eStat.STR) * (Get_Stat(eStat.STR_Multiplier) + Get_Stat(eStat.ALL_STAT_Multiplier) + Get_BuffStat(eStat.STR_Multiplier) + Pet_All_Stat_Multiplier));
            Set_Stat(true, eStat.DEX, Get_Stat(eStat.DEX) * (Get_Stat(eStat.DEX_Multiplier) + Get_Stat(eStat.ALL_STAT_Multiplier) + Get_BuffStat(eStat.DEX_Multiplier) + Pet_All_Stat_Multiplier));
            Set_Stat(true, eStat.INT, Get_Stat(eStat.INT) * (Get_Stat(eStat.INT_Multiplier) + Get_Stat(eStat.ALL_STAT_Multiplier) + Get_BuffStat(eStat.INT_Multiplier) + Pet_All_Stat_Multiplier));
            Set_Stat(true, eStat.LUK, Get_Stat(eStat.LUK) * (Get_Stat(eStat.LUK_Multiplier) + Get_Stat(eStat.ALL_STAT_Multiplier) + Get_BuffStat(eStat.LUK_Multiplier) + Pet_All_Stat_Multiplier));

            // 몬스터 웨이브
            Set_Stat(true, eStat.STR, DungeonInfo.Ins.dic_WaveStat[eMainStatType.STR]);
            Set_Stat(true, eStat.DEX, DungeonInfo.Ins.dic_WaveStat[eMainStatType.DEX]);
            Set_Stat(true, eStat.INT, DungeonInfo.Ins.dic_WaveStat[eMainStatType.INT]);

            // 힘
            var multi = MyValue.dic_MainStatMultiplier[eMainStatType.STR];
            if (classData.Get_MainStat() == eMainStatType.STR)
                Set_Stat(true, eStat.ATK, Get_Stat(eStat.STR) * multi[eStat.ATK]); // 힘캐 or 하이브리드캐
            Set_Stat(true, eStat.MaxHP, Get_Stat(eStat.STR) * multi[eStat.MaxHP]);
            Set_Stat(true, eStat.HP_REGEN, Get_Stat(eStat.STR) * multi[eStat.HP_REGEN]);
            Set_Stat(true, eStat.DEF_Multiplier, Get_Stat(eStat.STR) * multi[eStat.DEF_Multiplier]);

            // 민첩
            multi = MyValue.dic_MainStatMultiplier[eMainStatType.DEX];
            if (classData.Get_MainStat() == eMainStatType.DEX)
                Set_Stat(true, eStat.ATK, Get_Stat(eStat.DEX) * multi[eStat.ATK]); // 민첩캐 or 하이브리드캐
            Set_Stat(true, eStat.DEF, Get_Stat(eStat.DEX) * multi[eStat.DEF]);
            Set_Stat(true, eStat.HERO_ATK_SPD, Get_Stat(eStat.DEX) * multi[eStat.HERO_ATK_SPD]);
            Set_Stat(true, eStat.CRI_DMG_Multiplier, Get_Stat(eStat.DEX) * multi[eStat.CRI_DMG_Multiplier]);

            // 지능
            multi = MyValue.dic_MainStatMultiplier[eMainStatType.INT];
            if (classData.Get_MainStat() == eMainStatType.INT)
                Set_Stat(true, eStat.ATK, Get_Stat(eStat.INT) * multi[eStat.ATK]); // 지능캐 or 하이브리드캐
            Set_Stat(true, eStat.MaxMP, Get_Stat(eStat.INT) * multi[eStat.MaxMP]);
            Set_Stat(true, eStat.MP_REGEN, Get_Stat(eStat.INT) * multi[eStat.MP_REGEN]);
            Set_Stat(true, eStat.M_DEF_Multiplier, Get_Stat(eStat.INT) * multi[eStat.M_DEF_Multiplier]);
            Set_Stat(true, eStat.M_CRI_DMG_Multiplier, Get_Stat(eStat.INT) * multi[eStat.M_CRI_DMG_Multiplier]);

            // 행운
            multi = MyValue.dic_MainStatMultiplier[eMainStatType.LUCK];
            Set_Stat(true, eStat.CRI_DMG_Multiplier, Get_Stat(eStat.LUK) * multi[eStat.CRI_DMG_Multiplier]);
            Set_Stat(true, eStat.M_CRI_DMG_Multiplier, Get_Stat(eStat.LUK) * multi[eStat.M_CRI_DMG_Multiplier]);
            Set_Stat(true, eStat.GOLD_INCREASE, Get_Stat(eStat.LUK) * multi[eStat.GOLD_INCREASE]);
            Set_Stat(true, eStat.GOLD_Multiplier, Get_Stat(eStat.LUK) * multi[eStat.GOLD_Multiplier]);
            Set_Stat(true, eStat.ITEM_Multiplier, Get_Stat(eStat.LUK) * multi[eStat.ITEM_Multiplier]);
            Set_Stat(true, eStat.EXP_Multiplier, Get_Stat(eStat.LUK) * multi[eStat.EXP_Multiplier]);
        }
        else
        { // 몬스터
            Clear();

            Set_Stat(true, eStat.BaseDmg, m_mobdata.f_BaseATKRate * m_moblvdata.n_MonsterATK);
            Set_Stat(true, eStat.MaxHP, m_mobdata.f_BaseHPRate * m_moblvdata.n_MonsterHP);
            Set_Stat(true, eStat.HERO_ATK_SPD, m_mobdata.f_BaseATKSpeed);
            Set_Stat(true, eStat.HERO_MOVE_SPD, m_mobdata.f_BaseMOVSpeed);
            Set_Stat(true, eStat.DEF, m_mobdata.f_BaseDEFRate * m_moblvdata.n_MonsterDEF);
            Set_Stat(true, eStat.M_DEF, m_mobdata.f_BaseMDEFRate * m_moblvdata.n_MonsterMDEF);
            Set_Stat(true, eStat.ATK_SPD_Multiplier, 1);
            Set_Stat(true, eStat.MOVE_SPD_Multiplier, 1);

            Set_MonsterSkillPassive();
        }

        // 세팅된 값으로 최종 데이터 설정
        // 최종 공격력 설정
        Set_Stat(true, eStat.BaseDmg, Get_Stat(eStat.ATK));
        Set_Stat(true, eStat.BaseDmg, Get_Stat(eStat.BaseDmg) * Get_Stat(eStat.ATK_Multiplier));
        Set_Stat(true, eStat.BaseDmg, Get_Stat(eStat.BaseDmg) * Get_Stat(eStat.DMG_Multiplier)); // 연산 순서2 완료
        Set_Stat(true, eStat.BaseDmg, Get_BuffStat(eStat.BaseDmg) + Get_DebuffStat(eStat.BaseDmg));

        Set_Stat(true, eStat.MaxHP, Get_Stat(eStat.MaxHP) * Get_Stat(eStat.HP_Multiplier));
        Set_Stat(true, eStat.MaxMP, Get_Stat(eStat.MaxMP) * Get_Stat(eStat.MP_Multiplier));

        // 최종 방어력 설정
        Set_Stat(true, eStat.FinalDef, Get_Stat(eStat.DEF));
        Set_Stat(true, eStat.FinalDef, Get_Stat(eStat.DEF) * Get_Stat(eStat.DEF_Multiplier));
        Set_Stat(true, eStat.FinalDef, Get_BuffStat(eStat.FinalDef) + Get_DebuffStat(eStat.FinalDef));

        // 최종 마법 저항력 설정
        Set_Stat(true, eStat.FinalMDef, Get_Stat(eStat.M_DEF));
        Set_Stat(true, eStat.FinalMDef, Get_Stat(eStat.M_DEF) * Get_Stat(eStat.M_DEF_Multiplier));
        Set_Stat(true, eStat.FinalMDef, Get_BuffStat(eStat.FinalMDef) + Get_DebuffStat(eStat.FinalMDef));

        Set_Stat(true, eStat.FinalHPRegen, Get_Stat(eStat.HP_REGEN));
        Set_Stat(true, eStat.FinalHPRegen, Get_Stat(eStat.HP_REGEN) * Get_Stat(eStat.HP_REGEN_Multiplier));
        Set_Stat(true, eStat.FinalMPRegen, Get_Stat(eStat.MP_REGEN));
        Set_Stat(true, eStat.FinalMPRegen, Get_Stat(eStat.MP_REGEN) * Get_Stat(eStat.MP_REGEN_Multiplier));

        // 최종 공격속도 설정
        Set_Stat(true, eStat.FinalAttackSpeed, Get_Stat(eStat.HERO_ATK_SPD));
        Set_Stat(true, eStat.FinalAttackSpeed, Get_Stat(eStat.HERO_ATK_SPD) * (Get_Stat(eStat.ATK_SPD_Multiplier) - 1));
        Set_Stat(true, eStat.FinalAttackSpeed, Get_BuffStat(eStat.FinalAttackSpeed) + Get_DebuffStat(eStat.FinalAttackSpeed));

        // 최종 이동속도 설정
        Set_Stat(true, eStat.FinalMoveSpeed, Get_Stat(eStat.HERO_MOVE_SPD));
        Set_Stat(true, eStat.FinalMoveSpeed, Get_Stat(eStat.HERO_MOVE_SPD) * (Get_Stat(eStat.MOVE_SPD_Multiplier) - 1));
        Set_Stat(true, eStat.FinalMoveSpeed, Get_BuffStat(eStat.FinalMoveSpeed) + Get_DebuffStat(eStat.FinalMoveSpeed));

        // 최종 골드
        if (!DSUtil.CheckNull(m_sdata)) Set_Stat(true, eStat.GOLD_Multiplier, m_sdata.Buff.Get_RemainTime(0) > 0 ? 0.5 : 0);

        // 최종 경험치
        if (!DSUtil.CheckNull(m_sdata)) Set_Stat(true, eStat.EXP_Multiplier, m_sdata.Buff.Get_RemainTime(1) > 0 ? 0.5 : 0);

        // 최종 아이템
        if (!DSUtil.CheckNull(m_sdata)) Set_Stat(true, eStat.ITEM_Multiplier, m_sdata.Buff.Get_RemainTime(2) > 0 ? 0.5 : 0);

        if (isPet)
        { // 펫의 경우
            var keys = new List<eStat>(dic_StatValue.Keys);
            foreach (var key in keys)
                Set_Stat(key, dic_StatValue[key] * m_petdata.f_PetStatRate);

            Set_Stat(true, eStat.BaseDmg, m_petdata.Get_PureStat(eStat.ATK, m_sdata.Get_PetLv(m_petdata.n_PetID)));
            Set_Stat(true, eStat.BaseDmg, Get_Stat(eStat.BaseDmg) * Get_Stat(eStat.Pet_ATK_Multiplier));
            Set_Stat(true, eStat.MaxHP, m_petdata.Get_PureStat(eStat.HP, m_sdata.Get_PetLv(m_petdata.n_PetID)));
            Set_Stat(true, eStat.MaxHP, Get_Stat(eStat.MaxHP) * Get_Stat(eStat.Pet_HP_Multiplier));
            Set_Stat(true, eStat.FinalDef, m_petdata.Get_PureStat(eStat.DEF, m_sdata.Get_PetLv(m_petdata.n_PetID)));
            Set_Stat(true, eStat.FinalDef, Get_Stat(eStat.FinalDef) * Get_Stat(eStat.Pet_DEF_Multiplier));
            Set_Stat(true, eStat.FinalMDef, m_petdata.Get_PureStat(eStat.M_DEF, m_sdata.Get_PetLv(m_petdata.n_PetID)));
            Set_Stat(true, eStat.FinalMDef, Get_Stat(eStat.FinalMDef) * Get_Stat(eStat.Pet_M_DEF_Multiplier));

            Set_Stat(eStat.PetGradeRate, m_petdata.f_PetStatRate);
            Set_Stat(eStat.AttackRange, m_petdata.f_AttackRange);
            Set_Stat(eStat.AttackType, (int)m_petdata.e_AttackType);
            Set_Stat(eStat.FinalMoveSpeed, m_petdata.f_PetMoveSPD);
            Set_Stat(eStat.FinalAttackSpeed, m_petdata.f_PetAttackSPD);
        }

        Set_Stat(eStat.HP, keephpmp ? hp : Get_Stat(eStat.MaxHP));
        Set_Stat(eStat.MP, keephpmp ? mp : Get_Stat(eStat.MaxMP));

        // UI 표시
        if (showchange && m_Role == eRole.PC && !DSUtil.CheckNull(StatChangeUI.Ins)) StatChangeUI.Ins.Set(false, dic_StatValue);
    }
    public void Reset_byStatInfo(ActorStatInfo stat, float rate)
    {
        var keys = new List<eStat>(dic_StatValue.Keys);
        foreach (var key in keys)
            Set_Stat(key, stat.Get_Stat(key) * rate);
    }
    void Set_GlobalValue()
    {
        Set_Stat(true, eStat.ATK, table_GlobalValue.Ins.Get_Float("ATK"));
        Set_Stat(true, eStat.MaxHP, table_GlobalValue.Ins.Get_Float("HP"));
        Set_Stat(true, eStat.DEF, table_GlobalValue.Ins.Get_Float("DEF"));
        Set_Stat(true, eStat.M_DEF, table_GlobalValue.Ins.Get_Float("M_DEF"));
        Set_Stat(true, eStat.ATK_Multiplier, table_GlobalValue.Ins.Get_Float("ATK_Multiplier"));
        Set_Stat(true, eStat.HP_Multiplier, table_GlobalValue.Ins.Get_Float("HP_Multiplier"));
        Set_Stat(true, eStat.DEF_Multiplier, table_GlobalValue.Ins.Get_Float("DEF_Multiplier"));
        Set_Stat(true, eStat.M_DEF_Multiplier, table_GlobalValue.Ins.Get_Float("M_DEF_Multiplier"));
        Set_Stat(true, eStat.MaxMP, table_GlobalValue.Ins.Get_Float("MP"));
        Set_Stat(true, eStat.MP_Multiplier, table_GlobalValue.Ins.Get_Float("MP_Multiplier"));
        Set_Stat(true, eStat.ATK_FIXED, table_GlobalValue.Ins.Get_Float("ATK_FIXED"));
        Set_Stat(true, eStat.ATK_FIXED_DECREASE, table_GlobalValue.Ins.Get_Float("ATK_FIXED_DECREASE"));
        Set_Stat(true, eStat.CRI, table_GlobalValue.Ins.Get_Float("CRI"));
        Set_Stat(true, eStat.CRI_DMG_Multiplier, table_GlobalValue.Ins.Get_Float("CRI_DMG_Multiplier"));
        Set_Stat(true, eStat.M_CRI, table_GlobalValue.Ins.Get_Float("M_CRI"));
        Set_Stat(true, eStat.M_CRI_DMG_Multiplier, table_GlobalValue.Ins.Get_Float("M_CRI_DMG_Multiplier"));
        Set_Stat(true, eStat.SKILL_Multiplier, table_GlobalValue.Ins.Get_Float("SKILL_Multiplier"));
        Set_Stat(true, eStat.COOLTIME_Multiplier, table_GlobalValue.Ins.Get_Float("COOLTIME_Multiplier"));
        Set_Stat(true, eStat.HERO_ATK_SPD, table_GlobalValue.Ins.Get_Float("HERO_ATK_SPD"));
        Set_Stat(true, eStat.ATK_SPD_Multiplier, table_GlobalValue.Ins.Get_Float("ATK_SPD_Multiplier"));
        Set_Stat(true, eStat.HERO_MOVE_SPD, table_GlobalValue.Ins.Get_Float("HERO_MOVE_SPD"));
        Set_Stat(true, eStat.MOVE_SPD_Multiplier, table_GlobalValue.Ins.Get_Float("MOVE_SPD_Multiplier"));
        Set_Stat(true, eStat.HP_REGEN, table_GlobalValue.Ins.Get_Float("HP_REGEN"));
        Set_Stat(true, eStat.MP_REGEN, table_GlobalValue.Ins.Get_Float("MP_REGEN"));
        Set_Stat(true, eStat.HP_REGEN_Multiplier, table_GlobalValue.Ins.Get_Float("HP_REGEN_Multiplier"));
        Set_Stat(true, eStat.MP_REGEN_Multiplier, table_GlobalValue.Ins.Get_Float("MP_REGEN_Multiplier"));
        Set_Stat(true, eStat.PIERCING_Multiplier, table_GlobalValue.Ins.Get_Float("PIERCING_Multiplier"));
        Set_Stat(true, eStat.DMG_Multiplier, table_GlobalValue.Ins.Get_Float("DMG_Multiplier"));
        Set_Stat(true, eStat.GOLD_INCREASE, table_GlobalValue.Ins.Get_Float("GOLD_INCREASE"));
        Set_Stat(true, eStat.GOLD_Multiplier, table_GlobalValue.Ins.Get_Float("GOLD_Multiplier"));
        Set_Stat(true, eStat.EXP_Multiplier, table_GlobalValue.Ins.Get_Float("EXP_Multiplier"));
        Set_Stat(true, eStat.ITEM_Multiplier, table_GlobalValue.Ins.Get_Float("ITEM_Multiplier"));
    }
    void Set_JobPassive(ClassConfigTableData job)
    {
        var skilldata = table_skilllist.Ins.Get_Data_orNull(job.n_ExtraSkill);
        switch (skilldata.e_SkillEnhance)
        {
            case eSkillEnhance.Newbie:
                Set_Stat(true, eStat.Battle_GOLD_Multiplier, skilldata.f_ExtraValue1);
                Set_Stat(true, eStat.Battle_EXP_Multiplier, skilldata.f_ExtraValue2);
                break;
            case eSkillEnhance.Monster_Dmg:
                Set_Stat(true, eStat.Monster_DMG_Multiplier, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.MOV_SPD_Up:
                Set_Stat(true, eStat.MOVE_SPD_Multiplier, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.MP_Down:
                Set_Stat(true, eStat.SKILL_COST, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.Dmg_Decrease:
                Set_Stat(true, eStat.DMG_DECREASE, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.Dmg_Up:
                Set_Stat(true, eStat.DMG_Multiplier, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.ATK_SPD_Up:
                Set_Stat(true, eStat.ATK_SPD_Multiplier, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.CRI_Up:
                Set_Stat(true, eStat.CRI, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.Boss_Dmg:
                Set_Stat(true, eStat.CRI, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.PIERCING:
                Set_Stat(true, eStat.PIERCING_Multiplier, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.SkillCoolTime:
                Set_Stat(true, eStat.COOLTIME_Multiplier, skilldata.f_ExtraValue1);
                break;
            case eSkillEnhance.PetStat_Up:
                Set_Stat(true, eStat.Pet_Stat_Multiplier, skilldata.f_ExtraValue1);
                break;
        }
    }
    void Set_SkillPassive()
    {
        if (!DSUtil.CheckNull(m_sdata))
        {
            var skills = table_skilllist.Ins.Get_DataList();
            for (int i = 0; i < skills.Count; i++)
            {
                var skillData = skills[i];
                if (skillData.e_SkillType == eSkillType.Passive && m_sdata.IsEquipSkill(skillData.n_SkillID))
                    Set_SkillPassive(true, skillData);
            }

            // 펫 스킬 적용
            var petid = m_sdata.Get_EqiupmentEquip(eItem.Pet);
            if (petid > 0)
            {
                var petData = table_petlist.Ins.Get_Data_orNull(petid);
                var petpassive = table_skilllist.Ins.Get_Data_orNull(petData.n_PetPassiveSkill);
                if (petpassive.e_SkillType == eSkillType.Passive)
                    Set_SkillPassive(false, petpassive, petid);
            }
        }
    }
    void Set_SkillPassive(bool ispc, SkillListTableData skillData, int petid = 0)
    {
        var awakenlv = ispc ? m_sdata.Get_SkillAwakenLv(skillData.n_SkillID) : m_sdata.Get_PetSkillAwakenLv(petid);
        var tsac = table_skillawakenconfig.Ins;
        switch (skillData.e_SkillEnhance)
        {
            case eSkillEnhance.CRI_Dmg: // 1
                Set_Stat(true, eStat.CRI_DMG_Multiplier, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.CRI, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.CRI_DMG_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.CRI_Piercing_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3)); // 치명타 발생 시 스탯 관통력에 추가되는 관통력 적용
                break;
            case eSkillEnhance.BuffTime_Up: // 2
                Set_Stat(true, eStat.HeroBuffHP, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.HeroBuff_HP_REGEN_Multiplier, skillData.f_ExtraValue2);
                Set_Stat(true, eStat.HeroBuff_DEF, skillData.f_ExtraValue3);
                if (awakenlv >= 1) Set_Stat(true, eStat.HeroBuffHP, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.ATK_FIXED_DECREASE, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.DMG_DECREASE, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.Blooding: // 3
                Set_Stat(true, eStat.Blooding, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.BloodingTime, skillData.f_ExtraValue2);
                Set_Stat(true, eStat.BloodingDelay, skillData.f_ExtraValue3);
                Set_Stat(true, eStat.BloodingDmg, skillData.f_ExtraValue4);
                if (awakenlv >= 1) Set_Stat(true, eStat.BloodingDmg, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.BloodingTime, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.Blooding, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.HP_Drain: // 4
                Set_Stat(true, eStat.KillToHP_Rate, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.KillToHP, skillData.f_ExtraValue2);
                if (awakenlv >= 1) Set_Stat(true, eStat.KillToHP_Rate, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.KillToHP, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.KillToMP, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.ATK_Up: // 5
                Set_Stat(true, eStat.ATK, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.ATK_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.ATK_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.ATK_Multiplier, Get_MainStatValue() * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.HP_Up: // 6
                Set_Stat(true, eStat.MaxHP, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.HP_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.HP_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.HP_Multiplier, Get_MainStatValue() * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.MP_Up: // 7
                Set_Stat(true, eStat.MaxMP, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.MP_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.MP_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.MP_Multiplier, Get_MainStatValue() * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.Skill_Dmg: // 8
                Set_Stat(true, eStat.SKILL_Multiplier, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.M_CRI, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.M_CRI_DMG_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.SKILL_Multiplier, Get_MainStatValue() * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.Stun: // 9
                Set_Stat(true, eStat.Stun, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.StunTime, skillData.f_ExtraValue2);
                if (awakenlv >= 1) Set_Stat(true, eStat.StunDmg, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.StunTime, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.StunAdd, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.MP_Drain: // 10
                Set_Stat(true, eStat.KillToMP_Rate, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.KillToMP, skillData.f_ExtraValue2);
                if (awakenlv >= 1) Set_Stat(true, eStat.KillToMP_Rate, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.KillToMP, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.KillToHP, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.DEF_Down: // 11
                Set_Stat(true, eStat.DEF_Down, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.DEF_Down_Limit, skillData.f_ExtraValue2);
                if (awakenlv >= 1) Set_Stat(true, eStat.DEF_Down_Limit, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.PIERCING_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(eStat.DEF_Down_Step3, 1);
                break;
            case eSkillEnhance.M_DEF_Down: // 12
                Set_Stat(true, eStat.M_DEF_Down, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.M_DEF_Down_Limit, skillData.f_ExtraValue2);
                if (awakenlv >= 1) Set_Stat(true, eStat.M_DEF_Down_Limit, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.PIERCING_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(eStat.M_DEF_Down_Step3, 1);
                break;
            case eSkillEnhance.STR_Up: // 13
                Set_Stat(true, eStat.STR, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.STR_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.SKILL_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3)
                {
                    Set_Stat(true, eStat.STR, Get_Stat(eStat.DEX) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.STR, Get_Stat(eStat.INT) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.STR, Get_Stat(eStat.LUK) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                }
                break;
            case eSkillEnhance.DEX_Up: // 14
                Set_Stat(true, eStat.DEX, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.DEX_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.SKILL_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3)
                {
                    Set_Stat(true, eStat.DEX, Get_Stat(eStat.STR) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.DEX, Get_Stat(eStat.INT) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.DEX, Get_Stat(eStat.LUK) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                }
                break;
            case eSkillEnhance.INT_Up: // 15
                Set_Stat(true, eStat.INT, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.INT_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.SKILL_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3)
                {
                    Set_Stat(true, eStat.INT, Get_Stat(eStat.STR) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.INT, Get_Stat(eStat.DEX) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.INT, Get_Stat(eStat.LUK) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                }
                break;
            case eSkillEnhance.LUCK_Up: // 16
                Set_Stat(true, eStat.LUK, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.LUK_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.SKILL_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3)
                {
                    Set_Stat(true, eStat.LUK, Get_Stat(eStat.STR) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.LUK, Get_Stat(eStat.DEX) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                    Set_Stat(true, eStat.LUK, Get_Stat(eStat.INT) * tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                }
                break;
            case eSkillEnhance.ATK_SPD_Up: // 17
                Set_Stat(true, eStat.AttackSpeedRate_byAttack, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.AttackSpeedBuff_byAttack, skillData.f_ExtraValue2);
                Set_Stat(true, eStat.AttackSpeedTime_byAttack, skillData.f_ExtraValue3);
                if (awakenlv >= 1) Set_Stat(true, eStat.AttackSpeedTime_byAttack, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.AttackSpeedRate_byAttack, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.ATK_SPD_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.MOV_SPD_Up: // 18
                Set_Stat(true, eStat.MoveSpeedRate_byAttack, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.MoveSpeedBuff_byAttack, skillData.f_ExtraValue2);
                Set_Stat(true, eStat.MoveSpeedTime_byAttack, skillData.f_ExtraValue3);
                if (awakenlv >= 1) Set_Stat(true, eStat.MoveSpeedTime_byAttack, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.MoveSpeedRate_byAttack, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.MOVE_SPD_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.PIERCING: // 19
                Set_Stat(true, eStat.PiercingRate_byAttack, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.PiercingBuff_byAttack, skillData.f_ExtraValue2);
                Set_Stat(true, eStat.PiercingTime_byAttack, skillData.f_ExtraValue3);
                if (awakenlv >= 1) Set_Stat(true, eStat.PiercingRate_byAttack, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.PiercingTime_byAttack, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.PIERCING_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.Boss_Dmg: // 20
                Set_Stat(true, eStat.BOSS_DMG_Multiplier, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.BossDamage_Limit, skillData.f_ExtraValue2);
                if (awakenlv >= 1) Set_Stat(true, eStat.BossDamage_Limit, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.BOSS_Piercing_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.BOSS_DMG_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.Monster_Dmg: // 21
                Set_Stat(true, eStat.Monster_DMG_Multiplier, skillData.f_ExtraValue1);
                Set_Stat(true, eStat.MobDamage_Limit, skillData.f_ExtraValue2);
                if (awakenlv >= 1) Set_Stat(true, eStat.MobDamage_Limit, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.MOB_Piercing_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.Monster_DMG_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.GoldHunter: // 22
                Set_Stat(true, eStat.GOLD_INCREASE, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.GOLD_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.EXP_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.ITEM_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.MP_Down: // 23
                Set_Stat(true, eStat.SKILL_COST, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.MP_REGEN, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.MP_REGEN_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.COOLTIME_Multiplier, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
            case eSkillEnhance.AttackRange_Up: // 24
                Set_Stat(true, eStat.AttackRange_Up, skillData.f_ExtraValue1);
                if (awakenlv >= 1) Set_Stat(true, eStat.AttackKnockBack, tsac.Get_AwakenValue(skillData.n_SkillID, 1));
                if (awakenlv >= 2) Set_Stat(true, eStat.ProjectileSpeed_Up, tsac.Get_AwakenValue(skillData.n_SkillID, 2));
                if (awakenlv >= 3) Set_Stat(true, eStat.ProjectileSize_Up, tsac.Get_AwakenValue(skillData.n_SkillID, 3));
                break;
        }
    }
    void Set_MonsterSkillPassive()
    {
        if (m_mobdata.n_PassiveSkillID > 0)
        {
            var skilldata = table_skilllist.Ins.Get_Data_orNull(m_mobdata.n_PassiveSkillID);
            switch (skilldata.e_SkillEnhance)
            {
                case eSkillEnhance.ATK_SPD_Up: Set_Stat(true, eStat.ATK_SPD_Multiplier, skilldata.f_ExtraValue1); break;
                case eSkillEnhance.MOV_SPD_Up: Set_Stat(true, eStat.MOVE_SPD_Multiplier, skilldata.f_ExtraValue1); break;
                case eSkillEnhance.CRI_Up:     Set_Stat(true, eStat.CRI, skilldata.f_ExtraValue1);          break;
                case eSkillEnhance.DMG_TO_HP:  Set_Stat(true, eStat.DMG_TO_HP, skilldata.f_ExtraValue1);    break;
                case eSkillEnhance.SkillDmg_DECREASE: Set_Stat(true, eStat.SkillDmg_DECREASE, skilldata.f_ExtraValue1); break;
                case eSkillEnhance.BaseDmg_DECREASE:  Set_Stat(true, eStat.BaseDmg_DECREASE, skilldata.f_ExtraValue1);  break;
                case eSkillEnhance.HP_REGEN_Per1Sec:  Set_Stat(true, eStat.HP_REGEN_Per1Sec, skilldata.f_ExtraValue1);  break;
                case eSkillEnhance.HP_Up: Set_Stat(true, eStat.HP_Multiplier, skilldata.f_ExtraValue1); break;
                case eSkillEnhance.ATK_FIXED: Set_Stat(true, eStat.ADD_ATK_FIXED, skilldata.f_ExtraValue1); break;
                case eSkillEnhance.DMG_DECREASE: Set_Stat(true, eStat.DMG_DECREASE, skilldata.f_ExtraValue1); break;
                case eSkillEnhance.StartleBehind: Set_Stat(true, eStat.StartleBehind, 1); break;
                case eSkillEnhance.DeadSkin:
                    Set_Stat(true, eStat.SkillDmg_DECREASE, skilldata.f_ExtraValue1);
                    Set_Stat(true, eStat.CC_Immunity, 1d);
                    break;
                case eSkillEnhance.RageOfFairy:
                    Set_Stat(true, eStat.ProjectileSpeed_Up, skilldata.f_ExtraValue3);
                    break;
            }
        }
    }
    void Set_EquipItem()
    {
        if (!DSUtil.CheckNull(m_sdata))
        {
            foreach (var item in m_sdata.Equip.Equip)
            {
                var itemid = item.Value;
                if (itemid > 0)
                {
                    var equipData = table_equipitemlist.Ins.Get_Data_orNull(itemid);
                    if (!DSUtil.CheckNull(equipData))
                    {
                        // 제련 값 적용
                        var smeltlv = m_sdata.Get_SmeltingLv(itemid);
                        var smeltData = table_equipsmelting.Ins.Get_Data(smeltlv);
                        Set_Stat(true, equipData.e_AbilityType1, equipData.n_AbilityValue1 + equipData.n_AbilityValue1 * smeltData.f_IncreaseValueRate);
                        Set_Stat(true, equipData.e_AbilityType2, equipData.n_AbilityValue2 + equipData.n_AbilityValue2 * smeltData.f_IncreaseValueRate);
                        Set_Stat(true, equipData.e_AbilityType3, equipData.n_AbilityValue3 + equipData.n_AbilityValue3 * smeltData.f_IncreaseValueRate);

                        // 슬롯 값 적용
                        var slotdata = m_sdata.Get_SlotData(equipData.e_EquipParts);
                        EquipmentSlotUpgradeTableData ESUTD = table_equipslotupgrade.Ins.Get_Data(equipData.e_EquipParts, equipData.e_EquipAttribute);
                        Set_Stat(true, ESUTD.e_OptionType, ESUTD.Get_MainStatValue(slotdata.Lv));
                    }
                }
            }
        }
    }
    void Set_EquipSlotEnchant(ClassConfigTableData job)
    {
        for (int i = 0; i < m_sdata.Slot.Count; i++)
        {
            var slotdata = m_sdata.Slot[i];
            for (int j = 0; j < slotdata.Enchant.Count; j++)
            {
                var temp = slotdata.Enchant[j];
                if (temp.ID > 0)
                {
                    var Tdata = table_optionconfig.Ins.Get_Data(temp.ID);
                    if (!DSUtil.CheckNull(Tdata))
                    {
                        var val = Tdata.Get_Value(temp.Lv);
                        switch (Tdata.e_OptionType)
                        {
                            default:
                                Set_Stat(true, Tdata.e_OptionType, val);
                                break;
                            case eStat.Berserker:
                                Set_Stat(true, eStat.DMG_Multiplier, val);
                                Set_Stat(true, eStat.DMG_DECREASE, Tdata.f_ExtraValue1);
                                break;
                            case eStat.Stat_EXTRA:
                                Set_Stat(true, eStat.ATK, job.Get_DefaultMainStatValue() * val);
                                break;
                            case eStat.LUK_EXTRA_CURSE:
                                Set_Stat(true, eStat.GOLD_INCREASE, Tdata.f_ExtraValue1);
                                break;

                            case eStat.RND_SKILL:
                                break;

                            case eStat.STR_EXTRA_STUN:
                            case eStat.DEX_EXTRA_BLEED:
                            case eStat.INT_EXTRA_SLOW:
                            case eStat.STR_EXTRA_SPLASH:
                            case eStat.DEX_EXTRA_DART:
                            case eStat.INT_EXTRA_FREEZING:
                            case eStat.LUK_EXTRA_CRITICAL:
                                break;
                        }
                    }
                }
            }
        }
    }
    void Set_PCAbility(eBattleType battleType)
    {
        var data = table_abilityconfig.Ins.Get_DataList_Stat(battleType);
        for (int i = 0; i < data.Count; i++)
        {
            var lv = m_sdata.Get_AbilityLv(data[i].n_AbilityID);
            if (lv > 0)
                Set_Stat(true, data[i].e_OptionType, data[i].Get_Value(lv));
        }
    }
    void Set_PCAwaken()
    {
        var lst = table_awakenconfig.Ins.Get_DataList();
        for (int i = 0; i < lst.Count; i++)
        {
            var slotlv = m_sdata.Get_AwakenSlotLv(lst[i].e_UpgradeStatType, lst[i].n_UpgradeOrder);
            Set_Stat(true, lst[i].Get_SlotStat(), lst[i].Get_Value(slotlv));
        }
    }
    void Set_PCLimit()
    {
        var lv = m_sdata.Get_LimitLv();
        if (lv > 0)
        {
            var Tdata = table_breakinglimit.Ins.Get_Data_orNull(lv);
            Set_Stat(true, eStat.Monster_DMG_Multiplier, Tdata.f_Monster_DMG_Multiplier);
            Set_Stat(true, eStat.BOSS_DMG_Multiplier, Tdata.f_Boss_DMG_Multiplier);
            Set_Stat(true, eStat.ALL_STAT_Multiplier, Tdata.f_ALL_STAT_Multiplier);
        }

        var lst = m_sdata.Get_LimitSlot(m_sdata.Equip.LimitPreset.ToString());
        for (int i = 0; i < lst.Count; i++)
        {
            if (lst[i].ID > 0)
            {
                var Tdata = table_optionconfig.Ins.Get_Data(lst[i].ID);
                Set_Stat(true, Tdata.e_OptionType, Tdata.Get_Value(lst[i].Lv));
            }
        }
    }
    void Set_Relic()
    {
        var lst = table_reliclist.Ins.Get_DataList();
        for (int i = 0; i < lst.Count; i++)
        {
            var star = m_sdata.Get_RelicStar(lst[i].n_RelicID);
            if (star > 0)
            {
                var starData = table_optionconfig.Ins.Get_Data(lst[i].n_StarOptionID);
                var lvData = table_optionconfig.Ins.Get_Data(lst[i].n_DefaultOptionID);
                Set_Stat(true, starData.e_OptionType, starData.Get_Value(star));
                Set_Stat(true, lvData.e_OptionType, lvData.Get_Value(m_sdata.Get_RelicLv(lst[i].n_RelicID)));
            }
        }
    }
    void Set_Collection()
    {
        {
            var lst = table_collectionlist.Ins.Get_DataList();
            for (int i = 0; i < lst.Count; i++)
            {
                var lv = m_sdata.Get_CollectionLv(lst[i].n_TargetValue);
                if (lv > 0)
                {
                    Set_Stat(true, lst[i].Get_FirstStat(), lv > 0 ? lst[i].n_FirstRewardCount : 0);
                    var repeatStat = lst[i].Get_RepeatStat();
                    if (repeatStat != eStat.None)
                        Set_Stat(true, repeatStat, Mathf.Max(0, lv - 1) * lst[i].n_RepeatRewardCount);
                }
            }
        }

        {
            var lst = table_pccostumecollectionlist.Ins.Get_DataList();
            for (int i = 0; i < lst.Count; i++)
            {
                if (lst[i].IsCollection(m_sdata))
                    Set_Stat(true, lst[i].e_Stat, lst[i].n_StatValue);
            }
        }
    }
    void Set_Fruit()
    {
        var lst = table_fruit.Ins.Get_DataList();
        for (int i = 0; i < lst.Count; i++)
        {
            var eatCount = m_sdata.Get_EatFruitCount(lst[i].n_FruitID);
            Set_Stat(true, eStat.STR, lst[i].n_STR * eatCount);
            Set_Stat(true, eStat.DEX, lst[i].n_DEX * eatCount);
            Set_Stat(true, eStat.INT, lst[i].n_INT * eatCount);
            Set_Stat(true, eStat.LUK, lst[i].n_LUK * eatCount);
        }
    }
    void Set_Farmer()
    {
        var lst = table_farmerlist.Ins.Get_DataList();
        for (int i = 0; i < lst.Count; i++)
            if (m_sdata.Check_ItemAmount(lst[i].n_FarmerID, 1, false))
                Set_Stat(true, lst[i].e_FarmerStat, lst[i].f_StatValue);
    }

    public void Set_Maze()
    {
        if (MyValue.MyChoiceMapData.Get_MapData().e_Dungeon == eDungeon.d2_Maze)
        {
            var lv = MyValue.MyChoiceMapData.n_DungeonLv - 1;
            var keys = dic_StatValue.Keys.ToList();
            foreach (var key in keys)
            {
                dic_StatValue[key] += dic_StatValue[key] * (lv * MyValue.MyChoiceMapData.Get_DungeonMapData_orNull().f_Increase);
                dic_StatValue[key].RandomizeCryptoKey();
            }
        }
    }
    public void Set_Wave(int iteration)
    {
        if (MyValue.MyChoiceMapData.Get_MapData().e_Dungeon == eDungeon.d4_Wave)
        {
            var keys = dic_StatValue.Keys.ToList();
            foreach (var key in keys)
            {
                //if (key == eStat.BaseDmg && iteration > 0)
                //    Debug.Log($"전 {iteration} : {dic_StatValue[key]}");
                dic_StatValue[key] += dic_StatValue[key] * (iteration * MyValue.MyChoiceMapData.Get_DungeonMapData_orNull().f_Increase);
                dic_StatValue[key].RandomizeCryptoKey();
                //if (key == eStat.BaseDmg && iteration > 0)
                //    Debug.Log($"후 {iteration} : {dic_StatValue[key]}");
            }
        }
    }

    public double Get_Stat(eStat key, int idkey = 0)
    {
        if (dic_StatValue.ContainsKey(key))
            return dic_StatValue[key].GetDecrypted();
        return 0d;
    }
    public void Set_Stat(bool _add, eStat key, double _val)
    {
        if (_add) dic_StatValue[key] += _val;
        else      dic_StatValue[key] -= _val;

        if (key == eStat.HP)
        {
            var maxhp = Get_Stat(eStat.MaxHP);
            if (dic_StatValue[key] > maxhp)
                dic_StatValue[key] = maxhp;
            if (m_Role == eRole.PC && MyInfoUI.isIns)
                MyInfoUI.Ins.Set_HP(dic_StatValue[key], maxhp);
        }
        else if (key == eStat.MP)
        {
            var maxmp = Get_Stat(eStat.MaxMP);
            if (dic_StatValue[key] > maxmp)
                dic_StatValue[key] = maxmp;
            if (m_Role == eRole.PC && MyInfoUI.isIns)
                MyInfoUI.Ins.Set_MP((int)dic_StatValue[key], (int)maxmp);
        }

        dic_StatValue[key].RandomizeCryptoKey();
    }
    public void Set_Stat(eStat key, double _val)
    {
        dic_StatValue[key] = _val;
        dic_StatValue[key].RandomizeCryptoKey();

        if (m_Role == eRole.PC)
        {
            if (key == eStat.HP)
            {
                if (MyInfoUI.isIns)
                    MyInfoUI.Ins.Set_HP(dic_StatValue[key], Get_Stat(eStat.MaxHP));
            }
            else if (key == eStat.MP)
            {
                if (MyInfoUI.isIns)
                    MyInfoUI.Ins.Set_MP((int)dic_StatValue[key], (int)Get_Stat(eStat.MaxMP));
            }
        }
    }
    public double Get_MainStatValue()
    {
        switch (e_MainStatType)
        {
            case eMainStatType.STR:
            case eMainStatType.STR_DEX:
            case eMainStatType.STR_INT:
                return Get_Stat(eStat.STR);
            case eMainStatType.DEX:
            case eMainStatType.DEX_STR:
            case eMainStatType.DEX_INT:
                return Get_Stat(eStat.DEX);
            case eMainStatType.INT:
            case eMainStatType.INT_STR:
            case eMainStatType.INT_DEX:
                return Get_Stat(eStat.INT);
        }
        return 0;
    }

    public double Get_BuffStat(eStat stat) { return dic_StatValue_Buff.ContainsKey(stat) ? dic_StatValue_Buff[stat] : 0d; }
    public void Set_Buff(eStat stat, double v)
    {
        if (!dic_StatValue_Buff.ContainsKey(stat))
            dic_StatValue_Buff.Add(stat, v);
        else
            dic_StatValue_Buff[stat] = v;
        dic_StatValue_Buff[stat].RandomizeCryptoKey();
    }
    public void Set_Buff(bool add, eStat stat, double v)
    {
        if (!dic_StatValue_Buff.ContainsKey(stat))
        {
            if (add) dic_StatValue_Buff.Add(stat, v);
        }
        else
        {
            if (add) dic_StatValue_Buff[stat] += v;
            else dic_StatValue_Buff[stat] -= v;
        }
        dic_StatValue_Buff[stat].RandomizeCryptoKey();
    }
    public double Get_DebuffStat(eStat stat) { return dic_StatValue_Debuff.ContainsKey(stat) ? dic_StatValue_Debuff[stat] : 0d; }
    public void Set_Debuff(eStat stat, double v)
    {
        if (!dic_StatValue_Debuff.ContainsKey(stat))
            dic_StatValue_Debuff.Add(stat, v);
        else
            dic_StatValue_Debuff[stat] = v;
        dic_StatValue_Debuff[stat].RandomizeCryptoKey();
    }
    public void Set_Debuff(bool add, eStat stat, double v)
    {
        if (!dic_StatValue_Debuff.ContainsKey(stat))
        {
            if (add) dic_StatValue_Debuff.Add(stat, v);
        }
        else
        {
            if (add) dic_StatValue_Debuff[stat] += v;
            else dic_StatValue_Debuff[stat] -= v;
        }
        dic_StatValue_Debuff[stat].RandomizeCryptoKey();
    }
}