示例#1
0
    public void SetUpgradeType(UPGRADE_TYPE type)
    {
        upgradeType = type;

        if (upgradeType == UPGRADE_TYPE.MONSTER)
        {
            partyInfo             = PartyInfoVC.Inst;
            scrollList.prefabUnit = prefabPartyUnit;
            FrameScroll.SetActive(true);

            //선택된 몬스터 Data
            monsterData = partyInfo.MonsterList[partyInfo.selected_unit_idx];
        }
        else//upgradeType == UPGRADE_TYPE.EQUIPMENT
        {
            equipmentInfo         = EquipmentInfoManager.Inst;
            scrollList.prefabUnit = prefabItemUnit;
            FrameScroll.SetActive(false);

            //선택된 장비 Data
            equipmentData = equipmentInfo.EquipmentList[(int)equipmentInfo.GetSelectedMenu()][equipmentInfo.GetUnitIdx()];

            InsertEquipmentUpgradeScroll();
        }

        initScrollList();
        updateView();
    }
示例#2
0
    public void UpgradeMonster()
    {
        UserMonsterData subMonsterData = UserDataManager.Inst.GetMonsterInfo(inserted_object_idx);

        if (subMonsterData == null)
        {
            DebugLog.Log(false, "Invalid Request Monster ID : " + inserted_object_idx);
            return;
        }

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

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

#if UNITY_EDITOR
        Cheat.Inst.RequestMonsterUpgradeCheat(monsterData.index, subMonsterData.index);
#else
        PacketManager.Inst.RequestMonsterUpgrade(monsterData.index, subMonsterData.index);
#endif
    }
示例#3
0
 public void updateView(UserMonsterData monsterData)
 {
     imageMonster.sprite = CSVData.Inst.GetMonsterIcon(monsterData.id);
     imageGrade.sprite   = CSVData.Inst.GetSpriteGrade(monsterData.gradeType);
     imageTribe.sprite   = CSVData.Inst.GetSmallSpriteTribeType(monsterData.tribeType);
     imageType.sprite    = CSVData.Inst.GetSpriteElementType(monsterData.elementType);
     textUpgrade.text    = string.Format("+{0}", monsterData.upgrade);
 }
    public void ShowUpgradeMonsterResult(bool is_success, UserMonsterData monsterData)
    {
        GameObject objSubView = Instantiate(Resources.Load("UI/Misc/UpgradeResultVC")) as GameObject;

        objSubView.transform.SetParent(this.transform);
        objSubView.GetComponent <RectTransform>().anchoredPosition = Vector2.zero;
        objSubView.GetComponent <UpgradeResultVC>().updateView(is_success, monsterData);

        LobbyTopInfo.Inst.UpdateTopInfo();
    }
    public bool AddMonsterData(UserMonsterData monsterData)
    {
        if (monsterDic.ContainsKey(monsterData.index) == true)
        {
            return(false);
        }

        monsterDic.Add(monsterData.index, monsterData);
        return(true);
    }
 public void SetMonster(UserMonsterData monsterData)
 {
     if (monsterDic.ContainsKey(monsterData.index) == true)
     {
         monsterDic[monsterData.index] = monsterData;
     }
     else
     {
         monsterDic.Add(monsterData.index, monsterData);
     }
 }
    public void updateMonsterInfo(UserMonsterData m_data)
    {
        FrameServantInfo.SetActive(false);
        FrameMonsterInfo.SetActive(true);
        MonsterInfoManager m_info_manager = FrameMonsterInfo.GetComponent <MonsterInfoManager>();

        if (m_data != null)
        {
            m_info_manager.updateMonsterInfo(m_data);
            m_info_manager.FrameMonsterInfo.SetActive(true);
            m_info_manager.FrameNoneMonster.SetActive(false);
        }
        else
        {
            frameScroll.SetActive(false);
            m_info_manager.FrameMonsterInfo.SetActive(false);
            m_info_manager.FrameNoneMonster.SetActive(true);
        }
    }
示例#8
0
    public void Popup(UserMonsterData result)
    {
        SetActiveButtons(true);

        DBMonsterData monsterData = CSVData.Inst.GetMonsterData(result.id);

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

        resultName.text     = monsterData.name;
        resultImage.texture = monsterData.monsterIcon.texture;
        gradeImage.texture  = CSVData.Inst.GetSpriteGachaGrade((GRADE_TYPE)result.grade).texture;

        resultStrStat.text = result.status.basicStr.ToString();
        resultIntStat.text = result.status.basicInt.ToString();
        resultDexStat.text = result.status.basicDex.ToString();
    }
    public void updateView(bool is_success, UserMonsterData monsterData)
    {
        objBreak.SetActive(false);
        if (is_success)
        {
            textResult.text = "Upgrade Success!!!";
            textResult.GetComponent <UITextGradient>().m_color1 = new Color(1, 245 / 255f, 138 / 255f);
            textResult.GetComponent <UITextGradient>().m_color2 = new Color(1, 176 / 255f, 45 / 255f);
            imageResultEffect.sprite = spriteSuccess;
        }
        else
        {
            textResult.text = "Upgrade Fail...";
            textResult.GetComponent <UITextGradient>().m_color1 = new Color(150 / 255f, 150 / 255f, 150 / 255f);
            textResult.GetComponent <UITextGradient>().m_color2 = new Color(50 / 255f, 50 / 255f, 50 / 255f);
            imageResultEffect.sprite = spriteFail;
        }

        GameObject resultMonster = Instantiate(resultMonsterPrefab);

        resultMonster.transform.SetParent(FrameResultImage);
        resultMonster.GetComponent <RectTransform>().anchoredPosition = Vector2.zero;
        resultMonster.GetComponent <UpgradeResultMonster>().updateView(monsterData);
    }
示例#10
0
    void updateView()
    {
        //선택중인 오브젝트 정보
        if (upgradeType == UPGRADE_TYPE.MONSTER)
        {
            FrameSelectedObject.sprite     = CSVData.Inst.GetSpriteGrade(monsterData.gradeType);
            ImageSelectedObject.sprite     = CSVData.Inst.GetMonsterData(monsterData.id).monsterIcon;
            textSelectedObjectUpgrade.text = string.Format("+{0}", monsterData.upgrade);
        }
        else
        {
            FrameSelectedObject.sprite     = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)equipmentData.grade);
            ImageSelectedObject.sprite     = CSVData.Inst.GetEquipmentData(equipmentData.id).equipmentIcon;
            textSelectedObjectUpgrade.text = string.Format("+{0}", equipmentData.upgrade);
        }

        if (upgradeType == UPGRADE_TYPE.MONSTER)//강화에 사용될 오브젝트를 선택했을때
        {
            if (inserted_object_idx > 0)
            {
                FrameInsertObject.gameObject.SetActive(true);
                FrameResultSlot.gameObject.SetActive(true);
                textUgt.gameObject.SetActive(true);

                //강화에 사용될 오브젝트 정보
                UserMonsterData inserted_monster_data = UserDataManager.Inst.GetMonsterInfo(inserted_object_idx);
                if (inserted_monster_data == null)
                {
                    DebugLog.Log(false, "Invalid Insert monster data by SubViewUpgrade");
                    return;
                }

                FrameInsertObject.sprite     = CSVData.Inst.GetSpriteGrade(inserted_monster_data.gradeType);
                ImageInsertObject.sprite     = CSVData.Inst.GetMonsterData(inserted_monster_data.id).monsterIcon;
                textInsertObjectUpgrade.text = string.Format("+{0}", inserted_monster_data.upgrade);
                textNeedPerCount.text        = "";

                DBMonsterUpgradeData upgradeData = CSVData.Inst.GetMonsterUpgradeData(monsterData.grade, monsterData.upgrade, inserted_monster_data.upgrade);
                if (upgradeData == null)
                {
                    DebugLog.Log(false, "Invalid Upgrade Data : " + monsterData.grade + ", " + monsterData.upgrade + ", " + inserted_monster_data.upgrade);
                    return;
                }

                //강화 비용, 성공률
                textUgt.text        = string.Format("{0}", (upgradeData.needUTGCount / 10000));
                textSuccessPer.text = string.Format("{0}%", upgradeData.successPer);

                //강화 성공시 오브젝트 정보
                FrameResultSlot.sprite = CSVData.Inst.GetSpriteGrade(monsterData.gradeType);
                imageResultSlot.sprite = CSVData.Inst.GetMonsterData(monsterData.id).monsterIcon;
                textResultUpgrade.text = string.Format("+{0}", monsterData.upgrade + 1);

                buttonUpgrade.interactable = true;
            }
            else
            {
                FrameInsertObject.gameObject.SetActive(false);
                textUgt.gameObject.SetActive(false);
                textSuccessPer.text = "";
                FrameResultSlot.gameObject.SetActive(false);

                buttonUpgrade.interactable = false;
            }
        }
        else if (upgradeType == UPGRADE_TYPE.EQUIPMENT)
        {
            FrameInsertObject.gameObject.SetActive(true);
            FrameResultSlot.gameObject.SetActive(true);
            textUgt.gameObject.SetActive(true);

            DBEquipmentUpgradeData upgradeData = CSVData.Inst.GetEquipmentUpgradeData(equipmentData.grade, (int)equipmentData.equipmentType, equipmentData.upgrade);
            if (upgradeData == null)
            {
                DebugLog.Log(false, "Invalid Upgrade Data : " + equipmentData.grade + ", " + equipmentData.equipmentType + ", " + equipmentData.upgrade);
                return;
            }

            DBItemData scrollData = CSVData.Inst.GetItemData(upgradeData.needItemID);
            if (scrollData == null)
            {
                DebugLog.Log(false, "Invalid Scroll Data : " + upgradeData.needItemID);
                return;
            }

            FrameInsertObject.sprite = CSVData.Inst.GetSpriteGrade(GRADE_TYPE.COMMON);
            ImageInsertObject.sprite = scrollData.ItemIcon;
            //주문서는 업그레이드 표시 X
            textInsertObjectUpgrade.text = "";
            int itemCount = UserDataManager.Inst.GetItemCount(scrollData.id);
            textNeedPerCount.text = upgradeData.needItemCount + "/" + itemCount;
            if (itemCount < upgradeData.needItemCount)
            {
                textNeedPerCount.color = Color.red;
            }
            else
            {
                textNeedPerCount.color = Color.white;
            }

            //강화 비용, 성공률
            textUgt.text        = string.Format("{0}", upgradeData.needUTGCount);
            textSuccessPer.text = string.Format("{0}%", upgradeData.successPer);

            //강화 성공시 오브젝트 정보
            FrameResultSlot.sprite = CSVData.Inst.GetSpriteGrade((GRADE_TYPE)equipmentData.grade);
            imageResultSlot.sprite = CSVData.Inst.GetEquipmentData(equipmentData.id).equipmentIcon;
            textResultUpgrade.text = string.Format("+{0}", equipmentData.upgrade + 1);

            buttonUpgrade.interactable = true;
        }
        else
        {
            FrameInsertObject.gameObject.SetActive(false);
            textUgt.gameObject.SetActive(false);
            textSuccessPer.text = "";
            FrameResultSlot.gameObject.SetActive(false);

            buttonUpgrade.interactable = false;
        }
    }
    public void updateMonsterInfo(UserMonsterData m_data)
    {
        //unit_idx = u_idx;

        UserMonsterData unit_data = m_data;// UserDataManager.Inst.GetMonsterInfo(unit_idx);

        if (unit_data == null)
        {
            DebugLog.Log(false, "Invalid Monster data By MonsterInfoManager");
        }
        DBMonsterData db_unit_data = CSVData.Inst.GetMonsterData(unit_data.id);

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

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

        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);
        //textUpgradeText.text;
        textUpgrade.text = string.Format("+{0}", unit_data.upgrade);
        //textClassText.text;
        imageTribe.sprite = CSVData.Inst.GetSmallSpriteTribeType(db_unit_data.tribeType);
        //textTypeText.text;
        imageType.sprite = CSVData.Inst.GetSpriteElementType(db_unit_data.elementType);

        //textStatsText.text;

        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);
        textAvoid.text   = string.Format("{0}", db_unit_data.avoid);
        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.passiveSkillList.Count > 0)
        {
            imagePassive.gameObject.SetActive(true);
            imagePassive.sprite = CSVData.Inst.GetSkillPassiveData(unit_data.passiveSkillList[0].id).passiveIcon;
        }
        else
        {
            imagePassive.gameObject.SetActive(false);
        }

        //파티에 등록된 상태인지
        if (unit_data.upgrade >= DEFINE.MAX_MONSTER_UPGRADE_COUNT)
        {
            buttonUpgrade.interactable = false;
            textSetParty.fontSize      = 40;
            textSetParty.text          = "MAX";
        }
        else if (unit_data.partyIndex > 0)
        {
            buttonUpgrade.interactable = false;
            textSetParty.fontSize      = 60;
            textSetParty.text          = "P";
        }
        else
        {
            buttonUpgrade.interactable = true;
            textSetParty.text          = "";
        }
    }
    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 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 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
        }
    }
示例#16
0
    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);
        }
    }
示例#17
0
    public void InsertUnit(int scroll_unit_idx)
    {
        //재료를 다른 몬스터(또는 다른 주문서)로 바꿀 수 있기 때문에 필요 없을듯.
        //if (inserted_object_idx > 0)
        //{
        //    DebugLog.Log(false, "Warning : 이미 필요한 아이템 삽입됨!");
        //}

        UserDataManager u_data   = UserDataManager.Inst;
        int             unit_idx = 0;

        if (checkInsertedObject(scroll_unit_idx))
        {
            DebugLog.Log(false, "Warning : 이미 분해 슬롯에 등록된 유닛 입니다.");
        }
        else
        {
            if (upgradeType == UPGRADE_TYPE.MONSTER)
            {
                UserMonsterData insertMonsterData = UserDataManager.Inst.GetMonsterInfo(scroll_unit_idx);
                if (insertMonsterData == null)
                {
                    DebugLog.Log(false, "Invalid Request Monster ID : " + scroll_unit_idx);
                    return;
                }

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

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

                //같은 종류의 몬스터, 같은 등급, 선택된 몬스터보다 등급이 낮거나 같은 것들만,
                //if (insertMonsterData.id == partyInfo.MonsterList[i].id && insertMonsterData.grade == partyInfo.MonsterList[i].grade && insertMonsterData.upgrade >= partyInfo.MonsterList[i].upgrade)

                //현재 선택된 몬스터 제외 : insertMonsterData.index >= partyInfo.MonsterList[i].index
            }
            else//Equip
            {
                UserEquipmentData insertEquipmentData = UserDataManager.Inst.GetEquipmentInfo(scroll_unit_idx);
                if (insertEquipmentData == null)
                {
                    DebugLog.Log(false, "Invalid Request Servant ID : " + scroll_unit_idx);
                    return;
                }

                if (insertEquipmentData.state != 1)
                {
                    DebugLog.Log(false, "Invalid Equip State : " + insertEquipmentData.state);
                    return;
                }

                if (insertEquipmentData.isEquiped)
                {
                    DebugLog.Log(false, "Invalid Equip isEquiped : " + insertEquipmentData.isEquiped);
                    return;
                }

                //같은 종류의 장비, 같은 등급, 선택된 장비보다 등급이 낮거나 같은 것들만
            }

            unit_idx            = scroll_unit_idx;
            inserted_object_idx = unit_idx;
            updateView();
        }
    }
    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;
        }
    }