コード例 #1
0
    public void setData(string id, GameIDData.Type type, bool include512Bg = false)
    {
        if (data == null)
        {
            data = new GameIDData();
        }
        data.parse(id, type);

        switch (data.type)
        {
        case GameIDData.Type.Equip:
            lbName.text = data.partsData.name;
            break;

        case GameIDData.Type.Skill:
            lbName.text = data.skillData.name;
            break;

        case GameIDData.Type.Unit:
            lbName.text = data.unitData.name;
            break;
        }

        setLevel(data.level);

        lbMaxLevel.text = data.maxLevel.ToString();

        showFrame(data.rare, include512Bg);
    }
コード例 #2
0
 public void init(GameIDData.Type invenType)
 {
     tabType = invenType;
     setSelect();
     changeTab(GameDataManager.instance.selectHeroId);
     refreshUnlock();
 }
コード例 #3
0
    public void playComposeResult(string newId, string[] sourceIds, GameIDData.Type cType)
    {
        GameManager.me.uiManager.uiMenu.uiHero.selectedSlot = null;
        GameManager.me.uiManager.uiMenu.uiSkill.selectSlot  = null;
        GameManager.me.uiManager.uiMenu.uiSummon.selectSlot = null;

        StartCoroutine(playComposeResultCT(newId, sourceIds, cType));
    }
コード例 #4
0
    public void playMakeResult(string[] results, bool isShopMode = true)
    {
        if (results == null || results.Length == 0)
        {
            return;
        }

        bool canStartMake = false;

        for (int i = 0; i < results.Length; ++i)
        {
            if (UIRewardNoticePanel.checkReward(results[i], false))
            {
            }
            else if (canStartMake == false)
            {
                GameIDData.Type t = GameIDData.getItemTypeById(results[i]);
                switch (t)
                {
                case GameIDData.Type.Equip:
                case GameIDData.Type.Skill:
                case GameIDData.Type.Unit:
                    canStartMake = true;
                    break;
                }
            }
        }

        if (canStartMake)
        {
            _makingModeIsShop = isShopMode;

            isPlayingMaking = true;

            step = Step.Start;

            if (_makingModeIsShop)
            {
                GameManager.me.uiManager.popupShop.goShopBlocker.gameObject.SetActive(true);
            }

            StartCoroutine(playMakeCt(results));
        }
        else
        {
            if (GameManager.me.uiManager.rewardNotice.isPlaying == false)
            {
                GameManager.me.uiManager.rewardNotice.next();
            }
        }
    }
コード例 #5
0
    void settingNewInvenItem(List <GameIDData> targetList, GameIDData.Type invenType)
    {
        bool hasNewItem = false;

        foreach (GameIDData gd in targetList)
        {
            // 이전 목록에 있고 그 녀석이 new 였다면.
            if (_invenPrevItemChecker.ContainsKey(gd.serverId) && _invenPrevItemChecker[gd.serverId] > 0)
            {
                if (_invenNewItemChecker[gd.serverId] > 0)
                {
                    gd.isNew   = true;
                    hasNewItem = true;
                }

                --_invenPrevItemChecker[gd.serverId];
                --_invenNewItemChecker[gd.serverId];
            }
            // 이전 목록에 없으면 무조건 new.
            else
            {
                gd.isNew   = true;
                hasNewItem = true;
            }
        }

        _invenPrevItemChecker.Clear();
        _invenNewItemChecker.Clear();

        switch (invenType)
        {
        case GameIDData.Type.Equip:
            UILobby.setHasNewEquipRune(hasNewItem);
            break;

        case GameIDData.Type.Skill:
            UILobby.setHasNewSkillRune(hasNewItem);
            break;

        case GameIDData.Type.Unit:
            UILobby.setHasNewUnitRune(hasNewItem);
            break;
        }
    }
コード例 #6
0
    public void refreshInventory(GameIDData.Type refreshType)
    {
        switch (refreshType)
        {
        case GameIDData.Type.Equip:
            GameManager.me.uiManager.uiMenu.uiHero.refreshList();
            break;

        case GameIDData.Type.Skill:
            GameManager.me.uiManager.uiMenu.uiSkill.refreshMySkills();
            GameManager.me.uiManager.uiMenu.uiSkill.refreshSkillInven();
            break;

        case GameIDData.Type.Unit:
            GameManager.me.uiManager.uiMenu.uiSummon.refreshMyUnits();
            GameManager.me.uiManager.uiMenu.uiSummon.refreshUnitInven();
            break;
        }
    }
コード例 #7
0
    public string getCharacterSelectedRune(string runeId, GameIDData.Type runeType, int didLoad)
    {
        if (didLoad == WSDefine.NO)
        {
            return(string.Empty);
        }

        switch (runeType)
        {
        case GameIDData.Type.Equip:
            return(getCharacterSelectedEquip(runeId));

        case GameIDData.Type.Skill:
            return(getCharacterSelectedSkill(runeId));

        case GameIDData.Type.Unit:
            return(getCharacterSelectedUnit(runeId));
        }

        return(string.Empty);
    }
コード例 #8
0
    IEnumerator playMakeCt(string[] results)
    {
        _leftDisplayItems.Clear();

        card10Container.gameObject.SetActive(false);
        reinforceSlotContainer.SetActive(false);

        type = Type.UnitMake;

        GameIDData.Type itemType = GameIDData.Type.Equip;

        while (GameDataManager.instance.isCompleteLoadModel == false)
        {
            yield return(null);
        }
        ;

        bool hasLoadingModel = false;

        for (int i = 0; i < results.Length; ++i)
        {
            itemType = GameIDData.getItemTypeById(results[i]);
            if (itemType == GameIDData.Type.None)
            {
                continue;
            }

            GameIDData d = new GameIDData();
            d.parse(results[i], itemType);
            _leftDisplayItems.Add(d);

            switch (itemType)
            {
            case GameIDData.Type.Unit:
                GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[d.unitData.resource]);
                hasLoadingModel = true;
                break;
            }
        }


        _nowDisplayIndex = 0;
        isFirstCard      = true;

        if (hasLoadingModel)
        {
            GameDataManager.instance.startModelLoad();
            while (GameDataManager.instance.isCompleteLoadModel == false)
            {
                yield return(null);
            }
            ;
        }

        sendEvent(makeStarter);

        yield return(new WaitForSeconds(0.4f));

        if ((_leftDisplayItems.Count == 5 || _leftDisplayItems.Count == 10) && TutorialManager.instance.isTutorialMode == false)
        {
            GameManager.me.uiManager.activeRuneStudioSkipButton();
            step = Step.Start;
        }
        else
        {
            GameManager.me.uiManager.goBtnRuneStudioSkip.SetActive(false);
        }
    }
コード例 #9
0
    public void playReinforceResult(string newId, string[] sourceIds, GameIDData.Type rType)
    {
        reinforceMoveablePanelParent.transform.localScale = new Vector3(1, 1, 1);

        reinforceResultId = newId;
        type          = Type.Reinforce;
        reinforceType = rType;

        GameManager.me.uiManager.uiMenu.uiHero.selectedSlot = null;
        GameManager.me.uiManager.uiMenu.uiSkill.selectSlot  = null;
        GameManager.me.uiManager.uiMenu.uiSummon.selectSlot = null;

        reinforceSlotContainer.SetActive(true);

        for (int i = 0; i < 5; ++i)
        {
            Renderer ren;

            if (i < sourceIds.Length)
            {
                GameIDData temp = new GameIDData();
                temp.parse(sourceIds[i], reinforceType);

                switch (temp.type)
                {
                case GameIDData.Type.Equip:
                    reinforceSlots[i].setData(UIChallengeItemSlot.Type.Equip, temp);
                    break;

                case GameIDData.Type.Unit:
                    reinforceSlots[i].setData(UIChallengeItemSlot.Type.Unit, temp);
                    break;

                case GameIDData.Type.Skill:
                    reinforceSlots[i].setData(UIChallengeItemSlot.Type.Skill, temp);
                    break;
                }

                reinforceRenderingSlot[i].enabled = true;
            }
            else
            {
                ren = reinforceRenderingSlot[i].GetComponent <Renderer>();
                reinforceRenderingSlot[i].enabled = false;
            }
        }

        reinforceResultData.parse(newId, reinforceType);


        // 강화되기 전 데이터를 먼저 보여준다.
        switch (reinforceResultData.type)
        {
        case GameIDData.Type.Equip:

            GameManager.me.uiManager.uiMenu.uiHero.itemDetailPopup.show(reinforceOriginalData, RuneInfoPopup.Type.Reinforce, UIReinforceBarPanel.isTabSlot == false);
            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
            break;

        case GameIDData.Type.Skill:

            GameManager.me.uiManager.popupSkillPreview.show(reinforceOriginalData, RuneInfoPopup.Type.Reinforce, UIReinforceBarPanel.isTabSlot == false, true);

            break;

        case GameIDData.Type.Unit:

            GameManager.me.uiManager.popupSummonDetail.show(reinforceOriginalData, RuneInfoPopup.Type.Reinforce, UIReinforceBarPanel.isTabSlot == false);
            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
            break;
        }

        cam256.gameObject.SetActive(true);

        sendEvent(reinforceStarter);

        if (TutorialManager.instance.isTutorialMode == false)
        {
            GameManager.me.uiManager.activeRuneStudioSkipButton();
            step = Step.Start;
        }
    }
コード例 #10
0
    IEnumerator playComposeResultCT(string newId, string[] sourceIds, GameIDData.Type cType)
    {
        reinforceSlotContainer.SetActive(false);
        RuneStudioMain.instance.rootCompose.gameObject.SetActive(true);

        composeMovablePanelParent.transform.localScale = new Vector3(1, 1, 1);

        type = Type.Compose;

        composeType = cType;



        composeResultId = newId;
        composeResultData.parse(newId, cType);

        composeCardFrame1.setData(sourceIds[0], cType);
        composeCardFrame2.setData(sourceIds[1], cType);

        showCard512Studio(100);

        if (cType == GameIDData.Type.Unit)
        {
            while (GameDataManager.instance.isCompleteLoadModel == false)
            {
                yield return(null);
            }
            ;

            GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[composeCardFrame1.data.unitData.resource]);
            GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[composeCardFrame2.data.unitData.resource]);
            GameDataManager.instance.startModelLoad();
            while (GameDataManager.instance.isCompleteLoadModel == false)
            {
                yield return(null);
            }
            ;

            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
        }
        else if (cType == GameIDData.Type.Equip)
        {
            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
        }

        card2Container.gameObject.SetActive(true);

        card2BgSlot[0].customSizeRatio = 1.85f;
        card2BgSlot[1].customSizeRatio = 1.85f;

        card2BgSlot[0].setData(composeCardFrame1.data);
        card2BgSlot[1].setData(composeCardFrame2.data);

        composeResultData.parse(newId, cType);


        cam512.gameObject.SetActive(true);

        sendEvent(composeController[composeCardFrame1.data.rare]);

        if (TutorialManager.instance.isTutorialMode == false)
        {
            yield return(new WaitForSeconds(0.4f));

            step = Step.Start;
            GameManager.me.uiManager.activeRuneStudioSkipButton();
        }
    }
コード例 #11
0
    IEnumerator playTranscendResultCT(string newId, string sourceId, GameIDData.Type cType)
    {
        reinforceSlotContainer.SetActive(false);
        RuneStudioMain.instance.rootTranscend.gameObject.SetActive(true);

        transcendMovablePanelParent.parent.transform.localScale = new Vector3(1, 1, 1);
        transcendMovablePanelParent.transform.localScale        = new Vector3(1, 1, 1);

        type = Type.Transcend;

        transcendType = cType;

        transcendResultId = newId;
        transcendResultData.parse(newId, cType);

        transcendOriginalData.parse(sourceId);


        reinforceSlotContainer.SetActive(true);

        for (int i = 0; i < 5; ++i)
        {
            Renderer ren;

            if (i < 2)
            {
                GameIDData temp = new GameIDData();

                if (i == 0)
                {
                    temp.parse(sourceId, cType);
                }
                else if (i == 1)
                {
                    if (string.IsNullOrEmpty(UIRuneReforegePopup.currentIngredientId) == false)
                    {
                        temp.parse(UIRuneReforegePopup.currentIngredientId, cType);
                    }
                    else
                    {
                        temp.parse(sourceId, cType);
                    }
                }

                //if(i == 0)
                {
                    switch (temp.type)
                    {
                    case GameIDData.Type.Equip:
                        reinforceSlots[i].setData(UIChallengeItemSlot.Type.Equip, temp);
                        break;

                    case GameIDData.Type.Unit:
                        reinforceSlots[i].setData(UIChallengeItemSlot.Type.Unit, temp);
                        break;

                    case GameIDData.Type.Skill:
                        reinforceSlots[i].setData(UIChallengeItemSlot.Type.Skill, temp);
                        break;
                    }
                }



//				else if(i == 1)
//				{
//					reinforceSlots[i].setData(WSDefine.RUNESTONE+"_1");
//					reinforceSlots[i].showLevelBar = false;
//				}

                reinforceRenderingSlot[i].enabled = true;
            }
            else
            {
                ren = reinforceRenderingSlot[i].GetComponent <Renderer>();
                reinforceRenderingSlot[i].enabled = false;
            }
        }

        if (cType == GameIDData.Type.Unit)
        {
            while (GameDataManager.instance.isCompleteLoadModel == false)
            {
                yield return(null);
            }
            ;

            GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[transcendResultData.unitData.resource]);
            GameDataManager.instance.startModelLoad();
            while (GameDataManager.instance.isCompleteLoadModel == false)
            {
                yield return(null);
            }
            ;

            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
        }
        else if (cType == GameIDData.Type.Equip)
        {
            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
        }

        cam256.gameObject.SetActive(true);

        sendEvent(transcendStarter);

        if (TutorialManager.instance.isTutorialMode == false)
        {
            GameManager.me.uiManager.activeRuneStudioSkipButton();
            step = Step.Start;
        }
    }
コード例 #12
0
    IEnumerator playEvolveResultCT(string newId, string sourceId, GameIDData.Type cType)
    {
        evolutionRuneRenderer.sharedMaterial.color = new Color(0.5f, 0.5f, 0.5f);

        reinforceSlotContainer.SetActive(false);

        type = Type.Evolve;

        evolveType = cType;

        evolveResultId = newId;
        evolveResultData.parse(newId, cType);

        switch (evolveResultData.rare)
        {
        case RareType.SS:
            rootEvolve[4].gameObject.SetActive(true);
            evolutionCardFrame[4].setData(sourceId, cType);
            evolveMovablePanelParent[4].transform.localScale = new Vector3(1, 1, 1);
            showCard512Studio(RareType.S);
            break;

        case RareType.S:
            rootEvolve[3].gameObject.SetActive(true);
            evolutionCardFrame[3].setData(sourceId, cType);
            evolveMovablePanelParent[3].transform.localScale = new Vector3(1, 1, 1);
            showCard512Studio(RareType.A);
            break;

        case RareType.A:
            rootEvolve[2].gameObject.SetActive(true);
            evolutionCardFrame[2].setData(sourceId, cType);
            evolveMovablePanelParent[2].transform.localScale = new Vector3(1, 1, 1);
            showCard512Studio(RareType.B);
            break;

        case RareType.B:
            rootEvolve[1].gameObject.SetActive(true);
            evolutionCardFrame[1].setData(sourceId, cType);
            evolveMovablePanelParent[1].transform.localScale = new Vector3(1, 1, 1);
            showCard512Studio(RareType.C);
            break;

        default:
            rootEvolve[0].gameObject.SetActive(true);
            evolutionCardFrame[0].setData(sourceId, cType);
            evolveMovablePanelParent[0].transform.localScale = new Vector3(1, 1, 1);
            showCard512Studio(RareType.D);
            break;
        }

        if (cType == GameIDData.Type.Unit)
        {
            while (GameDataManager.instance.isCompleteLoadModel == false)
            {
                yield return(null);
            }
            ;

            switch (evolveResultData.rare)
            {
            case RareType.SS:
                GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[evolutionCardFrame[4].data.unitData.resource]);
                break;

            case RareType.S:
                GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[evolutionCardFrame[3].data.unitData.resource]);
                break;

            case RareType.A:
                GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[evolutionCardFrame[2].data.unitData.resource]);
                break;

            case RareType.B:
                GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[evolutionCardFrame[1].data.unitData.resource]);
                break;

            default:
                GameDataManager.instance.addLoadModelData(GameManager.info.monsterData[evolutionCardFrame[0].data.unitData.resource]);
                break;
            }



            GameDataManager.instance.startModelLoad();
            while (GameDataManager.instance.isCompleteLoadModel == false)
            {
                yield return(null);
            }
            ;

            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
        }
        else if (cType == GameIDData.Type.Equip)
        {
            spSkillIcon.cachedTransform.parent.gameObject.SetActive(false);
        }

        evolveSourceBgSlot.gameObject.SetActive(true);
        evolveSourceBgSlot.customSizeRatio = 3.2f;



        cam512.gameObject.SetActive(true);

        switch (evolveResultData.rare)
        {
        case RareType.SS:
            evolveSourceBgSlot.setData(evolutionCardFrame[4].data);
            sendEvent(evolveController[4]);
            break;

        case RareType.S:
            evolveSourceBgSlot.setData(evolutionCardFrame[3].data);
            sendEvent(evolveController[3]);
            break;

        case RareType.A:
            evolveSourceBgSlot.setData(evolutionCardFrame[2].data);
            sendEvent(evolveController[2]);
            break;

        case RareType.B:
            evolveSourceBgSlot.setData(evolutionCardFrame[1].data);
            sendEvent(evolveController[1]);
            break;

        default:
            evolveSourceBgSlot.setData(evolutionCardFrame[0].data);
            sendEvent(evolveController[0]);
            break;
        }



        if (TutorialManager.instance.isTutorialMode == false)
        {
            yield return(new WaitForSeconds(0.4f));

            step = Step.Start;
            GameManager.me.uiManager.activeRuneStudioSkipButton();
        }
    }