Example #1
0
    //캐릭터 전체 장비(무기,갑옷,악세사리)에 존재하는 Stats의 총합을 리턴
    //해당 능력치 가져올때(리턴된 Array변수명[EQUIPMENT_OPTION_TYPE.해당능력치])
    //EX) equipmentValue[EQUIPMENT_OPTION_TYPE.STR] ->> 장비로 증가하는 STR 값
    public static int[] GetStatsOnlyAllEquipment(UserServantData servant)
    {
        int type_max = (int)EQUIPMENT_OPTION_TYPE.MAX;

        int[] statsValue = new int[type_max];
        for (int i = 0; i < type_max; i++)
        {
            statsValue[i] = 0;
        }

        int equip_type_max = (int)EQUIPMENT_TYPE.MAX;

        for (int equip_type = 0; equip_type < equip_type_max; equip_type++)
        {
            if (servant.equipmentDic[(EQUIPMENT_TYPE)equip_type] > 0)
            {
                UserEquipmentData equipData = UserDataManager.Inst.GetEquipmentInfo(servant.equipmentDic[(EQUIPMENT_TYPE)equip_type]);
                if (equipData == null)
                {
                    DebugLog.Log(false, "Invalid EquipData Info " + servant.equipmentDic[(EQUIPMENT_TYPE)equip_type]);
                }
                statsValue[(int)equipData.optionType] += equipData.value;
            }
            else
            {
                DebugLog.Log(false, "Select servant not equip " + (EQUIPMENT_TYPE)equip_type);
            }
        }

        return(statsValue);
    }
    // 이름 겹치는 버그에 대한 널처리 필요
    public bool AddServantData(UserServantData servantData)
    {
        if (servantDic.ContainsKey(servantData.index) == true)
        {
            return(false);
        }

        servantDic.Add(servantData.index, servantData);
        return(true);
    }
 public void SetServant(UserServantData servantData)
 {
     if (servantDic.ContainsKey(servantData.index) == true)
     {
         servantDic[servantData.index] = servantData;
     }
     else
     {
         servantDic.Add(servantData.index, servantData);
     }
 }
    void setData()
    {
        EquipmentList.Clear();

        if (partyInfo.getSelectedEquipType() == EQUIPMENT_TYPE.MAX)
        {
            DebugLog.Log(false, "Invalid Equipment type 'MAX'");
            return;
        }
        selectedEquipType = partyInfo.getSelectedEquipType();


        UserServantData servantData   = partyInfo.ServantList[partyInfo.selected_unit_idx];
        DBServantData   dbServantData = CSVData.Inst.GetServantData(servantData.id);

        for (int i = 0; i < UserDataManager.Inst.GetEquipmentList().Count; i++)
        {
            UserEquipmentData equipmentData   = UserDataManager.Inst.GetEquipmentList()[i];
            DBEquipmentData   dbEquipmentData = CSVData.Inst.GetEquipmentData(equipmentData.id);

            // 장착 가능 레벨 검사
            bool enable_equip_level = true;
            if (dbEquipmentData.tier == 2)
            {
                if (servantData.level <= 10)
                {
                    enable_equip_level = false;
                }
            }
            else if (dbEquipmentData.tier == 3)
            {
                if (servantData.level <= 20)
                {
                    enable_equip_level = false;
                }
            }
            else if (dbEquipmentData.tier == 4)
            {
                if (servantData.level <= 30)
                {
                    enable_equip_level = false;
                }
            }

            //선택된 파츠, 선택중인 서번트 직업, 장착가능한 레벨, 다른 서번트가 장착한 장비 , 장착할수 있는 상태인 장비
            if (equipmentData.equipmentType == selectedEquipType && equipmentData.isEquiped == false &&
                dbEquipmentData.isEquipAble(dbServantData.GetJobFlag) && enable_equip_level &&
                equipmentData.equipServantIndex == 0 && equipmentData.state == 1)
            {
                EquipmentList.Add(equipmentData);
            }
        }
    }
Example #5
0
    public void Popup(UserServantData result)
    {
        SetActiveButtons(true);

        DBServantData servantData = CSVData.Inst.GetServantData(result.id);

        if (servantData == null)
        {
            DebugLog.Log(false, "Invalid Servant ID : " + result.id);
            return;
        }

        resultName.text     = servantData.name;
        resultImage.texture = servantData.servantIcon.texture;
        gradeImage.texture  = CSVData.Inst.GetSpriteGachaGrade(servantData.grade).texture;

        resultStrStat.text = result.status.basicStr.ToString();
        resultIntStat.text = result.status.basicInt.ToString();
        resultDexStat.text = result.status.basicDex.ToString();
    }
    public void SetChangeAllValue()
    {
        UserServantData servantData = partyInfo.ServantList[partyInfo.selected_unit_idx];

        if (servantData == null)
        {
            DebugLog.Log(false, "Invalid Select Index : " + partyInfo.ServantList[partyInfo.selected_unit_idx]);
            return;
        }

        DBServantData dBServantData = CSVData.Inst.GetServantData(servantData.id);

        if (dBServantData == null)
        {
            DebugLog.Log(false, "Invalid Servant ID : " + servantData.id);
            return;
        }

        servant_stat_equip_current_item = Calculator.GetServantStatsEquipAllItem(servantData);

        textStr.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.STR] + SetChangeValue(textStrChange, EQUIPMENT_OPTION_TYPE.STR));
        textDex.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.DEX] + SetChangeValue(textDexChange, EQUIPMENT_OPTION_TYPE.DEX));
        textInt.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.INT] + SetChangeValue(textIntChange, EQUIPMENT_OPTION_TYPE.INT));

        textHp.text    = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.HP] + SetChangeValue(textHpChange, EQUIPMENT_OPTION_TYPE.HP));
        textAvoid.text = string.Format("{0}", dBServantData.avoid);

        textPAtk.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.ATK] + SetChangeValue(textPAtkChange, EQUIPMENT_OPTION_TYPE.ATK));
        textPDef.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.DEF] + SetChangeValue(textPDefChange, EQUIPMENT_OPTION_TYPE.DEF));
        textMAtk.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.MATK] + SetChangeValue(textMAtkChange, EQUIPMENT_OPTION_TYPE.MATK));
        textMDef.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.MDEF] + SetChangeValue(textMDefChange, EQUIPMENT_OPTION_TYPE.MDEF));

        textPCri.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.CriDmg]);
        //textPCriChange.text = string.Format("{0}", Calculator.GetCriticalDamage(current_status_equip_item, 0));
        textPCriPer.text = string.Format("{0}", servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.CriPer]);
        //textPCriPerChange.text = string.Format("{0}", Calculator.GetCriticalPercent(current_status_equip_item, 0));
    }
Example #7
0
    //착용중인 장비를 포함한 Servant Stats를 리턴
    public static int[] GetServantStatsEquipAllItem(UserServantData servant)
    {
        int[] current_stats_equipment_item = Calculator.GetStatsOnlyAllEquipment(servant);    //장비에 부여된 Stats으로 올라가는 능력.

        //servant의 Status 추가
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.STR] += servant.status.basicStr;
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.DEX] += servant.status.basicDex;
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.INT] += servant.status.basicInt;

        Status total_status = new Status(current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.STR], current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.DEX], current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.INT]);

        //장비 Status가 반영된 Servant의 Status로 나머지 Stats 계산
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.HP] += Calculator.GetMaxHp(total_status, servant.level);

        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.ATK]  += Calculator.GetAttack(total_status, servant.level);
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.DEF]  += Calculator.GetDefence(total_status, servant.level);
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.MATK] += Calculator.GetMagicAttack(total_status, servant.level);
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.MDEF] += Calculator.GetMagicDefence(total_status, servant.level);

        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.CriDmg] += Calculator.GetCriticalDamage(total_status, servant.level);
        current_stats_equipment_item[(int)EQUIPMENT_OPTION_TYPE.CriPer] += Calculator.GetCriticalPercent(total_status, servant.level);

        return(current_stats_equipment_item);
    }
 public void updateServantInfo(UserServantData s_data)
 {
     FrameServantInfo.GetComponent <ServantInfoManager>().updateServantInfo(s_data);
     FrameServantInfo.SetActive(true);
     FrameMonsterInfo.SetActive(false);
 }
    public int SetChangeValue(Text textChangeValue, EQUIPMENT_OPTION_TYPE type)
    {
        int change_value = change_stat[(int)type] - current_stat[(int)type];    //장비의 스탯 차이

        if (type == EQUIPMENT_OPTION_TYPE.STR || type == EQUIPMENT_OPTION_TYPE.DEX || type == EQUIPMENT_OPTION_TYPE.INT)
        {
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.STR] = servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.STR] + (change_stat[(int)EQUIPMENT_OPTION_TYPE.STR] - current_stat[(int)EQUIPMENT_OPTION_TYPE.STR]);
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.DEX] = servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.DEX] + (change_stat[(int)EQUIPMENT_OPTION_TYPE.DEX] - current_stat[(int)EQUIPMENT_OPTION_TYPE.DEX]);
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.INT] = servant_stat_equip_current_item[(int)EQUIPMENT_OPTION_TYPE.INT] + (change_stat[(int)EQUIPMENT_OPTION_TYPE.INT] - current_stat[(int)EQUIPMENT_OPTION_TYPE.INT]);

            Status total_status = new Status(servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.STR], servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.DEX], servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.INT]);

            UserServantData servantData = partyInfo.ServantList[partyInfo.selected_unit_idx];
            if (servantData == null)
            {
                DebugLog.Log(false, "Invalid Select Index : " + partyInfo.ServantList[partyInfo.selected_unit_idx]);
                return(0);
            }

            //장비 Status가 반영된 Servant의 Status로 나머지 Stats 계산
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.HP] = Calculator.GetMaxHp(total_status, servantData.level);

            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.ATK]  = Calculator.GetAttack(total_status, servantData.level);
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.DEF]  = Calculator.GetDefence(total_status, servantData.level);
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.MATK] = Calculator.GetMagicAttack(total_status, servantData.level);
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.MDEF] = Calculator.GetMagicDefence(total_status, servantData.level);

            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.CriDmg] = Calculator.GetCriticalDamage(total_status, servantData.level);
            servant_stat_equip_change_item[(int)EQUIPMENT_OPTION_TYPE.CriPer] = Calculator.GetCriticalPercent(total_status, servantData.level);
        }

        if (change_value > 0)
        {
            if (type == EQUIPMENT_OPTION_TYPE.STR || type == EQUIPMENT_OPTION_TYPE.DEX || type == EQUIPMENT_OPTION_TYPE.INT)
            {
                textChangeValue.text = string.Format("(+{0})", change_value);
            }
            else
            {
                textChangeValue.text = string.Format("(+{0})", change_value);
            }

            textChangeValue.gameObject.SetActive(true);
            textChangeValue.color = Color.green;
        }
        else if (change_value < 0)
        {
            if (type == EQUIPMENT_OPTION_TYPE.STR || type == EQUIPMENT_OPTION_TYPE.DEX || type == EQUIPMENT_OPTION_TYPE.INT)
            {
                textChangeValue.text = string.Format("(-{0})", change_value);
            }
            else
            {
                textChangeValue.text = string.Format("(-{0})", change_value);
            }

            textChangeValue.gameObject.SetActive(true);
            textChangeValue.color = Color.red;
        }
        else
        {
            textChangeValue.gameObject.SetActive(false);
        }

        return(change_value);
    }
    public void OnEnable()
    {
        Sprite xSprite = Resources.Load <Sprite>("UI/Common/exit");

        UserPartyData partyData = UserDataManager.Inst.GetUserPartyInfo();

        if (partyData.partyIndex == 0)
        {
            DebugLog.Log(true, "Invalid User Data");
            return;
        }

        for (int i = 0; i < partyData.formationDataDic.Count; i++)
        {
            if (partyData.formationDataDic.ContainsKey(i) == false)
            {
                continue;
            }

            if (partyData.formationDataDic[i].index == 0)
            {
                GradeImage[i].sprite = CSVData.Inst.GetSpriteGrade(GRADE_TYPE.COMMON);
                IconImage[i].sprite  = xSprite;
                objectInfo[i].SetActive(false);
                continue;
            }

            if (i <= DEFINE.ServantMaxFormationNum)
            {
                UserServantData servantData = UserDataManager.Inst.GetServantInfo(partyData.formationDataDic[i].index);
                if (servantData == null)
                {
                    DebugLog.Log(true, "Invalid Servant Index : " + partyData.formationDataDic[i].index);
                }

                DBServantData dBServantData = CSVData.Inst.GetServantData(servantData.id);
                if (dBServantData == null)
                {
                    DebugLog.Log(true, "Invalid Servant ID : " + servantData.id);
                }

                GradeImage[i].sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)servantData.grade);
                IconImage[i].sprite  = dBServantData.servantIcon;

                imageClass[i].sprite = CSVData.Inst.GetSpriteServantJob(servantData.jobType);
                textLevel[i].text    = servantData.level.ToString();

                if (servantData.level >= DEFINE.MAX_LEVEL)
                {
                    textExpPer[i].text     = "MAX";
                    imageExp[i].fillAmount = 1f;
                }
                else
                {
                    DBExpData dbExpData = CSVData.Inst.GetExpData(servantData.level);
                    if (dbExpData == null)
                    {
                        DebugLog.Log(false, "Invalid Level Data");
                    }
                    else
                    {
                        int exExp = 0;
                        if (servantData.level - 1 > 0)
                        {
                            DBExpData exDBExpData = CSVData.Inst.GetExpData(servantData.level - 1);
                            if (exDBExpData == null)
                            {
                                DebugLog.Log(false, "Invalid Level Data");
                            }
                            else
                            {
                                exExp = exDBExpData.charExp;
                            }
                        }
                        float expPer = (exExp - servantData.exp) / (float)(exExp - dbExpData.charExp);
                        textExpPer[i].text     = (int)(expPer * 100) + "%";
                        imageExp[i].fillAmount = expPer;
                    }
                }

                objectInfo[i].SetActive(true);
            }
            else
            {
                UserMonsterData monsterData = UserDataManager.Inst.GetMonsterInfo(partyData.formationDataDic[i].index);
                if (monsterData == null)
                {
                    DebugLog.Log(true, "Invalid Monster Index : " + partyData.formationDataDic[i].index);
                }

                DBMonsterData dbMonsterData = CSVData.Inst.GetMonsterData(monsterData.id);
                if (dbMonsterData == null)
                {
                    DebugLog.Log(true, "Invalid Monster ID : " + monsterData.id);
                }

                GradeImage[i].sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)monsterData.grade);
                IconImage[i].sprite  = dbMonsterData.monsterIcon;

                imageClass[i].sprite    = CSVData.Inst.GetSmallSpriteTribeType(monsterData.tribeType);
                imageType[i - 5].sprite = CSVData.Inst.GetSpriteElementType(monsterData.elementType);
                textLevel[i].text       = monsterData.level.ToString();

                if (monsterData.level >= DEFINE.MAX_LEVEL)
                {
                    textExpPer[i].text     = "MAX";
                    imageExp[i].fillAmount = 1f;
                }
                else
                {
                    DBExpData dbExpData = CSVData.Inst.GetExpData(monsterData.level);
                    if (dbExpData == null)
                    {
                        DebugLog.Log(false, "Invalid Level Data");
                    }
                    else
                    {
                        int exExp = 0;
                        if (monsterData.level - 1 > 0)
                        {
                            DBExpData exDBExpData = CSVData.Inst.GetExpData(monsterData.level - 1);
                            if (exDBExpData == null)
                            {
                                DebugLog.Log(false, "Invalid Level Data");
                            }
                            else
                            {
                                exExp = exDBExpData.charExp;
                            }
                        }
                        float expPer = (exExp - monsterData.exp) / (float)(exExp - dbExpData.charExp);
                        textExpPer[i].text     = (int)(expPer * 100) + "%";
                        imageExp[i].fillAmount = expPer;
                    }
                }

                objectInfo[i].SetActive(true);
            }
        }
    }
    public BattleStatus(UserCharacterStateData data, bool isMyParty)
    {
        Status.Add(EFFECT_ID.HP, data.maxHP);
        Status.Add(EFFECT_ID.SPEED, data.speed);
        Status.Add(EFFECT_ID.AVOID, data.avoid);
        NowHp = data.nowHp;

        if (isMyParty)
        {
            if (data.charType == CHAR_TYPE.SERVANT)
            {
                UserStageStateData statgData = UserDataManager.Inst.GetStageState();
                UserServantData    servant   = UserDataManager.Inst.GetServantInfo(data.index);

                Status.Add(EFFECT_ID.STR, servant.status.basicStr);
                Status.Add(EFFECT_ID.DEX, servant.status.basicDex);
                Status.Add(EFFECT_ID.INT, servant.status.basicInt);

                Equipment(servant.equipmentDic, true);

                for (int i = 0; i < statgData.mySynergyList.Count; i++)
                {
                    Buff(statgData.mySynergyList[i].id, true, 0);
                }

                for (int i = 0; i < servant.passiveSkillList.Count; i++)
                {
                    Buff(servant.passiveSkillList[i].id, true);
                }

                StatusReCalculation(servant.level);

                Equipment(servant.equipmentDic, false);

                for (int i = 0; i < statgData.mySynergyList.Count; i++)
                {
                    Buff(statgData.mySynergyList[i].id, false, 0);
                }

                for (int i = 0; i < servant.passiveSkillList.Count; i++)
                {
                    Buff(servant.passiveSkillList[i].id, false);
                }
            }
            else if (data.charType == CHAR_TYPE.MONSTER)
            {
                if (data.position < 10)
                {
                    UserStageStateData statgData = UserDataManager.Inst.GetStageState();
                    UserMonsterData    monster   = UserDataManager.Inst.GetMonsterInfo(data.index);

                    Status.Add(EFFECT_ID.STR, monster.status.basicStr);
                    Status.Add(EFFECT_ID.DEX, monster.status.basicDex);
                    Status.Add(EFFECT_ID.INT, monster.status.basicInt);

                    StatusReCalculation(monster.level);

                    for (int i = 0; i < statgData.mySynergyList.Count; i++)
                    {
                        Buff(statgData.mySynergyList[i].id, true, (int)monster.tribeType);
                    }

                    for (int i = 0; i < monster.passiveSkillList.Count; i++)
                    {
                        Buff(monster.passiveSkillList[i].id, true);
                    }

                    StatusReCalculation(monster.level);

                    for (int i = 0; i < statgData.mySynergyList.Count; i++)
                    {
                        Buff(statgData.mySynergyList[i].id, false, (int)monster.tribeType);
                    }

                    for (int i = 0; i < monster.passiveSkillList.Count; i++)
                    {
                        Buff(monster.passiveSkillList[i].id, false);
                    }
                }
            }
        }
        else
        {
            Status.Add(EFFECT_ID.STR, data.status.basicStr);
            Status.Add(EFFECT_ID.DEX, data.status.basicDex);
            Status.Add(EFFECT_ID.INT, data.status.basicInt);
        }
    }
    public void updateServantInfo(UserServantData s_data)
    {
        //unit_idx = u_idx;
        for (int i = 0; i < buttonEquip.Length; i++)
        {
            buttonEquip[i].gameObject.SetActive(false);
        }
        for (int i = 0; i < 3; i++)
        {
            buttonEquip[i].gameObject.SetActive(true);
        }

        UserServantData unit_data = s_data;// UserDataManager.Inst.GetServantInfo(unit_idx);

        if (unit_data == null)
        {
            DebugLog.Log(false, "Invalid Servant data By ServantInfoManager");
        }
        DBServantData db_unit_data = CSVData.Inst.GetServantData(unit_data.id);

        if (db_unit_data == null)
        {
            DebugLog.Log(false, "Invalid DB_Servant data By ServantInfoManager");
        }

        textUnitName.text = db_unit_data.name;
        textLevel.text    = string.Format("{0}", unit_data.level);


        for (EQUIPMENT_TYPE type = EQUIPMENT_TYPE.WEAPON; type < EQUIPMENT_TYPE.MAX; type++)
        {
            if (unit_data.equipmentDic[type] != 0)
            {
                UserEquipmentData equip_info = UserDataManager.Inst.GetEquipmentInfo(unit_data.equipmentDic[type]);
                if (equip_info == null)
                {
                    DebugLog.Log(true, "Invalid Index : " + unit_data.equipmentDic[type]);
                    return;
                }

                buttonEquip[(int)type].image.sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)equip_info.grade);
                buttonEquip[(int)type].transform.GetChild(0).GetComponent <Image>().enabled = false;
                buttonEquip[(int)type].transform.GetChild(1).GetComponent <Image>().enabled = true;
                buttonEquip[(int)type].transform.GetChild(1).GetComponent <Image>().sprite  = CSVData.Inst.GetEquipmentData(equip_info.id).equipmentIcon;
            }
            else
            {
                buttonEquip[(int)type].image.sprite = spriteEmptySlot;
                buttonEquip[(int)type].transform.GetChild(0).GetComponent <Image>().enabled = true;
                buttonEquip[(int)type].transform.GetChild(1).GetComponent <Image>().enabled = false;
            }
        }

        if (unit_data.level >= DEFINE.MAX_LEVEL)
        {
            textExp.text        = "MAX";
            imageExp.fillAmount = 1f;
        }
        else
        {
            DBExpData dbExpData = CSVData.Inst.GetExpData(unit_data.level);
            if (dbExpData == null)
            {
                DebugLog.Log(false, "Invalid Level Data");
            }
            else
            {
                int exExp = 0;
                if (unit_data.level - 1 > 0)
                {
                    DBExpData exDBExpData = CSVData.Inst.GetExpData(unit_data.level - 1);
                    if (exDBExpData == null)
                    {
                        DebugLog.Log(false, "Invalid Level Data");
                    }
                    else
                    {
                        exExp = exDBExpData.charExp;
                    }
                }

                textExp.text        = unit_data.exp + " / " + dbExpData.charExp;
                imageExp.fillAmount = (exExp - unit_data.exp) / (float)(exExp - dbExpData.charExp);
            }
        }

        //textGradeText.text;
        textGrade.text  = string.Format("{0}", unit_data.gradeType);
        textGrade.color = DEFINE.GetGradeColor(unit_data.gradeType);
        //textJobText.text;
        imagejob.sprite = CSVData.Inst.GetSpriteServantJob(unit_data.jobType);
        //textStatsText.text;

        int[] stat_by_set_equipment = Calculator.GetServantStatsEquipAllItem(unit_data);

        textStr.text = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.STR]);
        textDex.text = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.DEX]);
        textInt.text = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.INT]);

        textHP.text      = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.HP]);
        textAvoid.text   = string.Format("{0}", db_unit_data.avoid);
        textPAtk.text    = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.ATK]);
        textPDef.text    = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.DEF]);
        textMAtk.text    = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.MATK]);
        textMDef.text    = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.MDEF]);
        textPCri.text    = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.CriDmg]);
        textPCriPer.text = string.Format("{0}", stat_by_set_equipment[(int)EQUIPMENT_OPTION_TYPE.CriPer]);

        /*
         * textStr.text = string.Format("{0}", unit_data.status.basicStr);
         * textDex.text = string.Format("{0}", unit_data.status.basicDex);
         * textInt.text = string.Format("{0}", unit_data.status.basicInt);
         *
         * textHP.text = string.Format("{0}", unit_data.maxHP);
         * textSpeed.text = string.Format("{0}", db_unit_data.speed);
         * textPAtk.text = string.Format("{0}", unit_data.atk);
         * textPDef.text = string.Format("{0}", unit_data.def);
         * textMAtk.text = string.Format("{0}", unit_data.mAtk);
         * textMDef.text = string.Format("{0}", unit_data.mDef);
         * textPCri.text = string.Format("{0}", unit_data.criDmg);
         * textPCriPer.text = string.Format("{0}", unit_data.criPer);
         */

        if (unit_data.activeSkillList.Count > 0)
        {
            imageActive.gameObject.SetActive(true);
            imageActive.sprite = CSVData.Inst.GetSkillActiveData(unit_data.activeSkillList[0].id).activeIcon;
        }
        else
        {
            imageActive.gameObject.SetActive(false);
        }

        if (unit_data.passiveSkillList.Count > 0)
        {
            imagePassive.gameObject.SetActive(true);
            imagePassive.sprite = CSVData.Inst.GetSkillPassiveData(unit_data.passiveSkillList[0].id).passiveIcon;
        }
        else
        {
            imagePassive.gameObject.SetActive(false);
        }
    }
    public void updateFormation()
    {
        for (int i = 0; i < 5; i++)
        {
            if (formationSlot[i] == 0)
            {
                buttonServantFormation[i].image.sprite = spriteSlot[1];
                imageServantFormation[i].enabled       = false;

                objectServantInfo[i].SetActive(false);
            }
            else
            {
                UserServantData servant = UserDataManager.Inst.GetServantInfo(formationSlot[i]);
                if (servant == null)
                {
                    DebugLog.Log(false, "Invalid Servant ID : " + formationSlot[i]);
                    return;
                }

                buttonServantFormation[i].image.sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)servant.grade);
                imageServantFormation[i].enabled       = true;
                imageServantFormation[i].sprite        = CSVData.Inst.GetServantData(servant.id).servantIcon;

                imageServantType[i].sprite = CSVData.Inst.GetSpriteServantJob(servant.jobType);
                textServantLevel[i].text   = servant.level.ToString();

                if (servant.level >= DEFINE.MAX_LEVEL)
                {
                    textServantExpPer[i].text     = "MAX";
                    imageServantExp[i].fillAmount = 1f;
                }
                else
                {
                    DBExpData dbExpData = CSVData.Inst.GetExpData(servant.level);
                    if (dbExpData == null)
                    {
                        DebugLog.Log(false, "Invalid Level Data");
                    }
                    else
                    {
                        int exExp = 0;
                        if (servant.level - 1 > 0)
                        {
                            DBExpData exDBExpData = CSVData.Inst.GetExpData(servant.level - 1);
                            if (exDBExpData == null)
                            {
                                DebugLog.Log(false, "Invalid Level Data");
                            }
                            else
                            {
                                exExp = exDBExpData.charExp;
                            }
                        }
                        float expPer = (exExp - servant.exp) / (float)(exExp - dbExpData.charExp);
                        textServantExpPer[i].text     = (int)(expPer * 100) + "%";
                        imageServantExp[i].fillAmount = expPer;
                    }
                }


                objectServantInfo[i].SetActive(true);
            }
        }

        int[] synergy = new int[8];

        for (int i = 0; i < 5; i++)
        {
            if (formationSlot[i + 5] == 0)
            {
                buttonMonsterFormation[i].image.sprite = spriteSlot[1];
                imageMonsterFormation[i].enabled       = false;

                objectMonsterInfo[i].SetActive(false);
            }
            else
            {
                UserMonsterData monster = UserDataManager.Inst.GetMonsterInfo(formationSlot[i + 5]);
                if (monster == null)
                {
                    DebugLog.Log(false, "Invalid Monster ID : " + formationSlot[i + 5]);
                    return;
                }

                buttonMonsterFormation[i].image.sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)monster.grade);
                imageMonsterFormation[i].enabled       = true;
                imageMonsterFormation[i].sprite        = CSVData.Inst.GetMonsterData(monster.id).monsterIcon;

                imageMonsterTribe[i].sprite          = CSVData.Inst.GetSmallSpriteTribeType(monster.tribeType);
                synergy[(int)monster.tribeType - 1] += 1;
                imageMonsterType[i].sprite           = CSVData.Inst.GetSpriteElementType(monster.elementType);
                textMonsterLevel[i].text             = monster.level.ToString();

                if (monster.level >= DEFINE.MAX_LEVEL)
                {
                    textMonsterExpPer[i].text     = "MAX";
                    imageMonsterExp[i].fillAmount = 1f;
                }
                else
                {
                    DBExpData dbExpData = CSVData.Inst.GetExpData(monster.level);
                    if (dbExpData == null)
                    {
                        DebugLog.Log(false, "Invalid Level Data");
                    }
                    else
                    {
                        int exExp = 0;
                        if (monster.level - 1 > 0)
                        {
                            DBExpData exDBExpData = CSVData.Inst.GetExpData(monster.level - 1);
                            if (exDBExpData == null)
                            {
                                DebugLog.Log(false, "Invalid Level Data");
                            }
                            else
                            {
                                exExp = exDBExpData.charExp;
                            }
                        }
                        float expPer = (exExp - monster.exp) / (float)(exExp - dbExpData.charExp);
                        textMonsterExpPer[i].text     = (int)(expPer * 100) + "%";
                        imageMonsterExp[i].fillAmount = expPer;
                    }
                }


                objectMonsterInfo[i].SetActive(true);
            }
        }

        int synergyCount = 0;

        for (int i = 0; i < 8; i++)
        {
            int idCount = 0;
            if (synergy[i] == 5)
            {
                idCount = 3;
            }
            else if (synergy[i] >= 3)
            {
                idCount = 2;
            }
            else if (synergy[i] >= 2)
            {
                idCount = 1;
            }

            if (idCount == 0)
            {
                continue;
            }

            DBSkillPassiveData synergyData = CSVData.Inst.GetSynergyData(i + 1, idCount);
            imageSynergyIcon[synergyCount].sprite = synergyData.passiveIcon;
            textSynergySubject[synergyCount].text = synergyData.name;
            textSynergyDetail[synergyCount].text  = synergyData.explain;
            PartySynergy[synergyCount].SetActive(true);
            synergyCount += 1;
        }

        for (int i = synergyCount; i < 3; i++)
        {
            PartySynergy[i].SetActive(false);
        }
    }
    void updateAllView()
    {
        //Current Item
        UserServantData servantData = partyInfo.ServantList[partyInfo.selected_unit_idx];

        if (servantData == null)
        {
            DebugLog.Log(false, "Invalid Servant Index : " + partyInfo.selected_unit_idx);
        }

        UserEquipmentData currentEquipmentData = null;

        if (partyInfo.getSelectedEquipType() == EQUIPMENT_TYPE.MAX)
        {
            DebugLog.Log(false, "Invalid Equipment type 'MAX'");
            return;
        }

        int current_item_idx = servantData.equipmentDic[partyInfo.getSelectedEquipType()];

        if (current_item_idx > 0)
        {
            FrameCurrentItemInfo.SetActive(true);
            FrameCurrentItemNone.SetActive(false);
            currentEquipmentData = UserDataManager.Inst.GetEquipmentInfo(current_item_idx);

            if (currentEquipmentData == null)
            {
                DebugLog.Log(false, "Invalid Equipment data");
            }


            DBEquipmentData dBEquipment = CSVData.Inst.GetEquipmentData(currentEquipmentData.id);
            if (dBEquipment == null)
            {
                DebugLog.Log(false, "Invalid equipmentData ID : " + currentEquipmentData.id);
            }

            imageCurrentItem.sprite  = dBEquipment.equipmentIcon;
            textCurrentItemName.text = dBEquipment.name;
            //textCurrentGradeText.text;
            textCurrentGrade.text  = string.Format("{0}", ((GRADE_TYPE)currentEquipmentData.grade));
            textCurrentGrade.color = DEFINE.GetGradeColor((GRADE_TYPE)currentEquipmentData.grade);
            //textCurrentUpgradeText.text;
            textCurrentUpgrade.text = string.Format("+{0}", (currentEquipmentData.upgrade));;
            //textCurrentTierText.text;
            textCurrentTier.text = string.Format("{0}T", dBEquipment.tier);
            //textCurrentJobText.text;

            Color temp_color = imageCurrentJob[0].color;
            for (int i = 0; i < 5; i++)
            {
                imageCurrentJob[i].color = new Color(temp_color.r, temp_color.g, temp_color.b, 0.2f);
            }

            if (dBEquipment.jobLimit == SERVANT_JOB_FLAG.All)
            {
                for (int i = 0; i < 5; i++)
                {
                    imageCurrentJob[i].color = new Color(temp_color.r, temp_color.g, temp_color.b, 1f);
                }
            }
            else
            {
                for (int i = 0; i < 5; i++)
                {
                    SERVANT_JOB_FLAG checkJob = (SERVANT_JOB_FLAG)Math.Pow(2, (double)(i + 1));
                    if (dBEquipment.isEquipAble(checkJob) == true)
                    {
                        imageCurrentJob[i].color = new Color(temp_color.r, temp_color.g, temp_color.b, 1f);
                    }
                }
            }

            //초기화
            for (int i = 0; i < 10; i++)
            {
                current_stat[i] = 0;
            }

            imageCurrentStat[0].sprite = CSVData.Inst.GetSpriteOptionType(currentEquipmentData.optionType);
            textCurrentStat[0].text    = string.Format("{0}", currentEquipmentData.value);
            current_stat[(int)currentEquipmentData.optionType] = currentEquipmentData.value;

            //장착된 아이템이 있을땐 Clear버튼 활성화
            buttonClear.interactable = true;
        }
        else
        {
            DebugLog.Log(false, "current item none");
            FrameCurrentItemInfo.SetActive(false);
            FrameCurrentItemNone.SetActive(true);

            //장착된 아이템이 없을땐 Clear버튼 비활성화
            buttonClear.interactable = false;
        }

        updateChangeItemInfo(selectedItemIdx);

        SetChangeAllValue();
    }
    public void updateSlot(int unit_idx)
    {
        if (unit_idx > 0)
        {
            if (SubViewDeconstruction.Inst.GetDeconstructionType() == DECONSTRUCTION_TYPE.SERVANT || SubViewDeconstruction.Inst.GetDeconstructionType() == DECONSTRUCTION_TYPE.MONSTER)
            {
                FrameUnitInfo.SetActive(true);
                FrameItemInfo.SetActive(false);
                imageEmptySlot.enabled = false;
                this.GetComponent <Button>().interactable = true;

                PartyInfoVC party_info = PartyInfoVC.Inst;

                if (party_info.selectedMenu == PartyInfoVC.menu_type.SERVANT)
                {
                    UserServantData s_info = UserDataManager.Inst.GetServantInfo(unit_idx);
                    if (s_info == null)
                    {
                        DebugLog.Log(false, "Invalid Servant ID : " + s_info.id);
                    }
                    imageUnitGrade.sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)s_info.grade);
                    imageUnit.sprite      = CSVData.Inst.GetServantData(s_info.id).servantIcon;

                    textUnitLevel.text = string.Format("{0}", s_info.level);

                    textStr.text = string.Format("{0}", s_info.status.basicStr);
                    textDex.text = string.Format("{0}", s_info.status.basicDex);
                    textInt.text = string.Format("{0}", s_info.status.basicInt);
                }
                else if (party_info.selectedMenu == PartyInfoVC.menu_type.MONSTER)
                {
                    UserMonsterData m_info = UserDataManager.Inst.GetMonsterInfo(unit_idx);
                    if (m_info == null)
                    {
                        DebugLog.Log(false, "Invalid Monster ID : " + m_info.id);
                    }
                    imageUnitGrade.sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)m_info.grade);
                    imageUnit.sprite      = CSVData.Inst.GetMonsterData(m_info.id).monsterIcon;

                    textUnitLevel.text = string.Format("{0}", m_info.level);

                    textStr.text = string.Format("{0}", m_info.status.basicStr);
                    textDex.text = string.Format("{0}", m_info.status.basicDex);
                    textInt.text = string.Format("{0}", m_info.status.basicInt);
                }
            }
            else//Equip
            {
                FrameUnitInfo.SetActive(false);
                FrameItemInfo.SetActive(true);
                imageEmptySlot.enabled = false;
                this.GetComponent <Button>().interactable = true;

                UserEquipmentData e_info = UserDataManager.Inst.GetEquipmentInfo(unit_idx);
                if (e_info == null)
                {
                    DebugLog.Log(false, "Invalid Equip ID : " + e_info.id);
                }
                imageItemGrade.sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)e_info.grade);
                imageItem.sprite      = CSVData.Inst.GetEquipmentData(e_info.id).equipmentIcon;

                textItemLevel.text = string.Format("{0}", e_info.upgrade);

                imageStat.sprite = CSVData.Inst.GetSpriteOptionType(e_info.optionType);
                textStat.text    = string.Format("{0}", e_info.value);
            }
        }
        else
        {
            this.GetComponent <Button>().interactable = false;
            imageEmptySlot.enabled = true;
        }
    }
    public void OnClickButtonGrind()
    {
        if (dType == DECONSTRUCTION_TYPE.SERVANT)  // Servant
        {
            List <int> servantIndexList = new List <int>();

            for (int i = 0; i < deconstructionUnitList.Length; i++)
            {
                if (deconstructionUnitList[i] == 0)
                {
                    continue;
                }

                UserServantData servantData = UserDataManager.Inst.GetServantInfo(deconstructionUnitList[i]);
                if (servantData == null)
                {
                    DebugLog.Log(false, "Invalid Request Servant ID : " + deconstructionUnitList[i]);
                    return;
                }

                if (servantData.state != 1)
                {
                    DebugLog.Log(false, "Invalid Servant State : " + servantData.state);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant State");
                    return;
                }

                if (servantData.partyIndex != 0)
                {
                    DebugLog.Log(false, "Invalid Servant Index : " + servantData.partyIndex);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Already In Party");
                    return;
                }

                servantIndexList.Add(deconstructionUnitList[i]);
            }
#if UNITY_EDITOR
            Cheat.Inst.RequestServantBurnCheat(servantIndexList);
#else
            PacketManager.Inst.RequestServantBurn(servantIndexList);
#endif
        }
        else if (dType == DECONSTRUCTION_TYPE.MONSTER)  // Monster
        {
            List <int> monsterIndexList = new List <int>();

            for (int i = 0; i < deconstructionUnitList.Length; i++)
            {
                if (deconstructionUnitList[i] == 0)
                {
                    continue;
                }

                UserMonsterData monsterData = UserDataManager.Inst.GetMonsterInfo(deconstructionUnitList[i]);
                if (monsterData == null)
                {
                    DebugLog.Log(false, "Invalid Request Monster ID : " + deconstructionUnitList[i]);
                    return;
                }

                if (monsterData.state != 1)
                {
                    DebugLog.Log(false, "Invalid Monster State : " + monsterData.state);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Monster State");
                    return;
                }

                if (monsterData.partyIndex != 0)
                {
                    DebugLog.Log(false, "Invalid Monster Index : " + monsterData.partyIndex);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Already In Party");
                    return;
                }

                monsterIndexList.Add(deconstructionUnitList[i]);
            }

#if UNITY_EDITOR
            Cheat.Inst.RequestMonsterBurnCheat(monsterIndexList);
#else
            PacketManager.Inst.RequestMonsterBurn(monsterIndexList);
#endif
        }
        else if (dType == DECONSTRUCTION_TYPE.EQUIPMENT) // Equip
        {
            List <int> equipmentIndexList = new List <int>();

            for (int i = 0; i < deconstructionUnitList.Length; i++)
            {
                if (deconstructionUnitList[i] == 0)
                {
                    continue;
                }

                UserEquipmentData equipmentData = UserDataManager.Inst.GetEquipmentInfo(deconstructionUnitList[i]);
                if (equipmentData == null)
                {
                    DebugLog.Log(false, "Invalid Request Equipment ID : " + deconstructionUnitList[i]);
                    return;
                }

                if (equipmentData.state != 1)
                {
                    DebugLog.Log(false, "Invalid Equipment State : " + equipmentData.state);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Equipment State");
                    return;
                }

                if (equipmentData.equipServantIndex != 0)
                {
                    DebugLog.Log(false, "Invalid Equipment Already Equip Servant Index : " + equipmentData.equipServantIndex);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Already Equiped Servant");
                    return;
                }

                equipmentIndexList.Add(deconstructionUnitList[i]);
            }
#if UNITY_EDITOR
            Cheat.Inst.RequestEquipmentBurnCheat(equipmentIndexList);
#else
            PacketManager.Inst.RequestEquipmentBurn(equipmentIndexList);
#endif
        }
    }
    public void InsertUnit(int scroll_unit_idx)
    {
        UserDataManager u_data = UserDataManager.Inst;

        if (dType == DECONSTRUCTION_TYPE.SERVANT || dType == DECONSTRUCTION_TYPE.MONSTER)
        {
            if (dType == DECONSTRUCTION_TYPE.SERVANT)  // Servant
            {
                UserServantData servantData = UserDataManager.Inst.GetServantInfo(scroll_unit_idx);
                if (servantData == null)
                {
                    DebugLog.Log(false, "Invalid Request Servant ID : " + scroll_unit_idx);
                    return;
                }

                if (servantData.state != 1)
                {
                    DebugLog.Log(false, "Invalid Servant State : " + servantData.state);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant State");
                    return;
                }

                if (servantData.partyIndex != 0)
                {
                    DebugLog.Log(false, "Invalid Servant Party Index : " + servantData.partyIndex);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Already In Party");
                    return;
                }
            }
            else//Monster
            {
                UserMonsterData monsterData = UserDataManager.Inst.GetMonsterInfo(scroll_unit_idx);
                if (monsterData == null)
                {
                    DebugLog.Log(false, "Invalid Request Monster ID : " + scroll_unit_idx);
                    return;
                }

                if (monsterData.state != 1)
                {
                    DebugLog.Log(false, "Invalid Monster State : " + monsterData.state);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Monster State");
                    return;
                }

                if (monsterData.partyIndex != 0)
                {
                    DebugLog.Log(false, "Invalid Monster Index : " + monsterData.partyIndex);
                    SimpleErrorPopupVC.Inst.UpdateErrorText("Already In Party");
                    return;
                }
            }
        }
        else//Equip
        {
            UserEquipmentData equipmentData = UserDataManager.Inst.GetEquipmentInfo(scroll_unit_idx);
            if (equipmentData == null)
            {
                DebugLog.Log(false, "Invalid Request Servant ID : " + scroll_unit_idx);
                return;
            }

            if (equipmentData.state != 1)
            {
                DebugLog.Log(false, "Invalid Equip State : " + equipmentData.state);
                SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Equipment State");
                return;
            }

            if (equipmentData.isEquiped)
            {
                DebugLog.Log(false, "Invalid Equip isEquiped : " + equipmentData.isEquiped);
                SimpleErrorPopupVC.Inst.UpdateErrorText("Already Equiped Servant");
                return;
            }
        }

        deconstructionUnitList[unit_count] = scroll_unit_idx;
        unit_count++;
        updateView();
    }
    public void OnClickChange()
    {
        // 선택 서번트 인덱스
        int servantIndex = partyInfo.ServantList[partyInfo.selected_unit_idx].index;

        int equipmentIndex = EquipmentList[selectedItemIdx].index;

        // 서번트 인덱스 검사
        UserServantData servantData = UserDataManager.Inst.GetServantInfo(servantIndex);

        if (servantData == null)
        {
            DebugLog.Log(true, "Invalid Servant Index : " + servantIndex);
            SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant Index");
            return;
        }

        // 장비 타입 검사
        if (servantData.equipmentDic.ContainsKey(selectedEquipType) == false)
        {
            DebugLog.Log(true, "Invalid Servant Data");
            SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant Data");
            return;
        }

        // 서번트 동일 장비 검사
        if (servantData.equipmentDic[selectedEquipType] == equipmentIndex)
        {
            DebugLog.Log(false, "Already Equiped");
            SimpleErrorPopupVC.Inst.UpdateErrorText("Already Equiped");
            return;
        }

        // 장비 인덱스 검사
        UserEquipmentData equipmentData = UserDataManager.Inst.GetEquipmentInfo(equipmentIndex);

        if (equipmentData == null)
        {
            DebugLog.Log(true, "Invalid Equipment Index : " + equipmentIndex);
            SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Equipment");
            return;
        }

        // 장비 인덱스에 대한 타입 검사
        if (equipmentData.equipmentType != selectedEquipType)
        {
            DebugLog.Log(false, "Invalid Equipment Type : " + selectedEquipType.ToString() + ", ");
            SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Equipment Type");
            return;
        }

        // 장착중인 장비인지 검사
        if (equipmentData.isEquiped == true)
        {
            DebugLog.Log(false, "Already ServantEquiped : " + equipmentData.equipServantIndex);
            SimpleErrorPopupVC.Inst.UpdateErrorText("Already Servant Equiped");
            return;
        }

        // DB 장비 ID 검사
        DBEquipmentData dbEquipmentData = CSVData.Inst.GetEquipmentData(equipmentData.id);

        if (dbEquipmentData == null)
        {
            DebugLog.Log(false, "Invalid Equipment Data ID : " + equipmentData.id);
            return;
        }

        // DB 서번트 ID 검사
        DBServantData dbServantData = CSVData.Inst.GetServantData(servantData.id);

        if (dbServantData == null)
        {
            DebugLog.Log(false, "Invalid Servant Data ID : " + servantData.id);
            return;
        }

        // 장착 가능 직업 검사
        if (dbEquipmentData.isEquipAble(dbServantData.GetJobFlag) == false)
        {
            DebugLog.Log(false, "Invalid Servant Equipable Job : " + dbServantData.GetJobFlag + ", Need Job : " + dbEquipmentData.jobLimit);
            SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant Equipable Job");
            return;
        }

        // 장착 가능 레벨 검사
        if (dbEquipmentData.tier == 2)
        {
            if (servantData.level <= 10)
            {
                DebugLog.Log(false, "Invalid Servant Equipable Level : " + servantData.level + ", Need Level : 11");
                SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant Equipable Level, Need Level : 11");
                return;
            }
        }
        else if (dbEquipmentData.tier == 3)
        {
            if (servantData.level <= 20)
            {
                DebugLog.Log(false, "Invalid Servant Equipable Level : " + servantData.level + ", Need Level : 21");
                SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant Equipable Level, Need Level : 21");
                return;
            }
        }
        else if (dbEquipmentData.tier == 4)
        {
            if (servantData.level <= 30)
            {
                DebugLog.Log(false, "Invalid Servant Equipable Level : " + servantData.level + ", Need Level : 31");
                SimpleErrorPopupVC.Inst.UpdateErrorText("Invalid Servant Equipable Level, Need Level : 31");
                return;
            }
        }

#if UNITY_EDITOR
        Cheat.Inst.RequestEquipServantCheat(servantIndex, selectedEquipType, equipmentIndex);
#else
        PacketManager.Inst.RequestEquipServant(servantIndex, selectedEquipType, equipmentIndex);
#endif
    }