Esempio n. 1
0
    private void UpdateUI()
    {
        bool adOpen = MapModel.Instance.IsPassed((int)GameModel.Instance.GetGameConfig(1010));

        if (adOpen && ADModel.Instance.ADIsReady())
        {
            adBtn.gameObject.SetActive(true);
        }
        else
        {
            adBtn.gameObject.SetActive(false);
        }

        UpdateWealths();

        ShowStar();

        comingTrans.GetComponentInChildren <Text>().text = LanguageUtil.GetTxt(11105);

        skillBtn.gameObject.SetActive(SkillTempletModel.Instance.SkillModuleIsUnlock());
        SkillTempletModel.Instance.selectGroupIndex = 0;
        skillTipAnim.Stop();
        for (int i = 0; i < SkillTempletModel.Instance.skillGroups.Count; i++)
        {
            SkillGroupInfo skillTempletGroupInfo = SkillTempletModel.Instance.skillGroups[i];
            skillTempletGroupInfo.index = i;
            int bottleId = skillTempletGroupInfo.GetGroupId();
            for (int j = 0; j < skillTempletGroupInfo.skillTemplets.Count; j++)
            {
                SkillTempletInfo skillTempletInfo = skillTempletGroupInfo.skillTemplets[j];

                if (skillTempletInfo.IsUnlock() && skillTempletInfo.config.type == 1)
                {
                    if (skillTempletInfo.lv < SkillTempletModel.MAX_LEVEL)
                    {
                        int leftStar = MapModel.Instance.starInfo.GetSkillCanUseStar();
                        if (leftStar >= skillTempletInfo.LevelUpCostStar())
                        {
                            int        levelUpNeedBottle = skillTempletInfo.LevelUpCostBottle();
                            WealthInfo bottleInfo        = PlayerModel.Instance.GetWealth(bottleId);
                            if (bottleInfo.count >= levelUpNeedBottle)
                            {
                                SkillTempletModel.Instance.selectGroupIndex = i;
                                Image skillIcon = skillBtn.FindChild("icon").GetComponent <Image>();

                                skillIcon.overrideSprite = ResModel.Instance.GetSprite("icon/cell/cell_" + bottleId);
                                skillTipAnim.Play();
                                return;
                            }
                        }
                    }
                }
            }
        }
    }
Esempio n. 2
0
    public bool SkillModuleIsUnlockLevelUp()
    {
        SkillTempletInfo skillTempletInfo = skillGroups[0].skillTemplets[1];

        if (skillTempletInfo.IsUnlock())
        {
            return(true);
        }

        return(false);
    }
Esempio n. 3
0
    private void ShowSmallItemTip()
    {
        int animCount = 0;

        for (int i = 0; i < SkillTempletModel.Instance.skillGroups.Count; i++)
        {
            SkillGroupInfo skillTempletGroupInfo = SkillTempletModel.Instance.skillGroups[i];
            skillTempletGroupInfo.index = i;
            int bottleId = skillTempletGroupInfo.GetGroupId();
            SkillTempletInfo skillTempletInfo = skillTempletGroupInfo.skillTemplets[1];

            GameObject    item         = smallList.GetItemByName("skill_" + bottleId);
            RectTransform iconTrans    = (RectTransform)item.transform.FindChild("icon");
            Animation     skillTipAnim = iconTrans.GetComponent <Animation>();

            if (skillTempletInfo.IsUnlock() && skillTempletInfo.config.type == 1)
            {
                if (skillTempletInfo.lv < SkillTempletModel.MAX_LEVEL)
                {
                    int leftStar = MapModel.Instance.starInfo.GetSkillCanUseStar();
                    if (leftStar >= skillTempletInfo.LevelUpCostStar())
                    {
                        int        levelUpNeedBottle = skillTempletInfo.LevelUpCostBottle();
                        WealthInfo bottleInfo        = PlayerModel.Instance.GetWealth(bottleId);
                        if (bottleInfo.count >= levelUpNeedBottle)
                        {
                            if (!skillTipAnim.isPlaying)
                            {
                                LeanTween.delayedCall(0.2f * animCount, delegate()
                                {
                                    skillTipAnim.Play();
                                });
                            }

                            animCount++;
                            continue;
                        }
                    }
                }
            }

            LeanTween.delayedCall(0.2f, delegate()
            {
                skillTipAnim.Stop();
                iconTrans.anchoredPosition = new Vector2(0, -70);
                iconTrans.localScale       = new Vector3(1, 1, 1);
            });
        }
    }
Esempio n. 4
0
    private void OnUpLvClick(GameObject go)
    {
        if (skillTempletInfo == null)
        {
            return;
        }

        if (!skillTempletInfo.IsUnlock())
        {
            config_map_item map_item = (config_map_item)ResModel.Instance.config_map.GetItem(skillTempletInfo.config.unlockId);

            PromptModel.Instance.Pop(LanguageUtil.GetTxt(11303) + ":" + map_item.name);
            return;
        }
        int leftStar = MapModel.Instance.starInfo.GetSkillCanUseStar();

        if (leftStar >= skillTempletInfo.LevelUpCostStar())
        {
            WealthInfo bottleInfo = PlayerModel.Instance.GetWealth(skillGroupInfo.GetGroupId());
            if (bottleInfo.count < skillTempletInfo.LevelUpCostBottle())
            {
                PromptModel.Instance.Pop(LanguageUtil.GetTxt(11901), false, bottleInfo.type);
            }
            else
            {
                bottleInfo.count -= skillTempletInfo.LevelUpCostBottle();
                PlayerModel.Instance.SaveWealths();
                SkillTempletModel.Instance.UpLevel(skillTempletInfo, 1);
                //PromptModel.Instance.Pop(LanguageUtil.GetTxt(11305));
            }
        }
        else
        {
            PromptModel.Instance.Pop(LanguageUtil.GetTxt(11901), false, (int)WealthTypeEnum.Star);
        }
    }
Esempio n. 5
0
    public bool SkillModuleIsUnlock()
    {
        for (int i = 0; i < skillGroups.Count; i++)
        {
            SkillGroupInfo skillGroupInfo = skillGroups[i];

            for (int j = 0; j < skillGroupInfo.skillTemplets.Count; j++)
            {
                SkillTempletInfo skillTempletInfo = skillGroupInfo.skillTemplets[j];
                if (skillTempletInfo.IsUnlock())
                {
                    return(true);
                }
            }
        }
        return(false);
    }
Esempio n. 6
0
    override protected void UpdateView()
    {
        base.UpdateView();

        skillLabel.text = LanguageUtil.GetTxt(11806);

        EventTriggerListener.Get(skillButton.gameObject).onClick = reportModule.OnSkillClick;
        BattleModel.Instance.lose_map = BattleModel.Instance.crtConfig.id;

        for (int i = 0; i < SkillTempletModel.Instance.skillGroups.Count; i++)
        {
            SkillGroupInfo skillTempletGroupInfo = SkillTempletModel.Instance.skillGroups[i];
            skillTempletGroupInfo.index = i;
            int bottleId = skillTempletGroupInfo.GetGroupId();
            for (int j = 0; j < skillTempletGroupInfo.skillTemplets.Count; j++)
            {
                SkillTempletInfo skillTempletInfo = skillTempletGroupInfo.skillTemplets[j];

                if (skillTempletInfo.IsUnlock() && skillTempletInfo.config.type == 1)
                {
                    if (skillTempletInfo.lv < SkillTempletModel.MAX_LEVEL)
                    {
                        int leftStar = MapModel.Instance.starInfo.GetSkillCanUseStar();
                        if (leftStar >= skillTempletInfo.LevelUpCostStar())
                        {
                            int        levelUpNeedBottle = skillTempletInfo.LevelUpCostBottle();
                            WealthInfo bottleInfo        = PlayerModel.Instance.GetWealth(bottleId);
                            if (bottleInfo.count >= levelUpNeedBottle)
                            {
                                SkillTempletModel.Instance.selectGroupIndex = i;
                                Image skillIcon = skillButton.transform.FindChild("icon").GetComponent <Image>();
                                skillIcon.overrideSprite = ResModel.Instance.GetSprite("icon/cell/cell_" + bottleId);
                                return;
                            }
                        }
                    }
                }
            }
        }

        LeanTween.delayedCall(0.1f, GuideModel.Instance.CheckGuide);
    }
Esempio n. 7
0
    private void FindSwicthNext()
    {
        nextTempletInfo = null;

        config_cell_item cell = (config_cell_item)GameMgr.resourceMgr.config_cell.GetItem(skillTempletInfo.config.cellId);

        List <SkillTempletInfo> skillTemplets = SkillTempletModel.Instance.GetGroup(cell.hide_id).skillTemplets;

        int i;

        for (i = 0; i < skillTemplets.Count; i++)
        {
            SkillTempletInfo skillTemplet = skillTemplets[i];

            if (skillTemplet.config.cellId == skillTempletInfo.config.cellId)
            {
                break;
            }
        }

        if (i == (skillTemplets.Count - 1))
        {
            nextTempletInfo = skillTemplets[0];
        }
        else
        {
            nextTempletInfo = skillTemplets[i + 1];
        }

        if (nextTempletInfo.IsUnlock() == false)
        {
            nextTempletInfo = null;
            switchTip.gameObject.SetActive(false);
        }
        else
        {
            switchTip.gameObject.SetActive(true);
        }
    }
Esempio n. 8
0
    protected virtual void UpdateView()
    {
        nameText.text   = LanguageUtil.GetTxt(11106) + ": " + BattleModel.Instance.crtConfig.name;
        resultText.text = LanguageUtil.GetTxt(11807);
        closeButton.GetComponentInChildren <Text>().text = LanguageUtil.GetTxt(11804);
        againButton.GetComponentInChildren <Text>().text = LanguageUtil.GetTxt(11803);
        nextButton.GetComponentInChildren <Text>().text  = LanguageUtil.GetTxt(11802);
        scoreLabel.text = LanguageUtil.GetTxt(11801);

        EventTriggerListener.Get(closeButton.gameObject).onClick = reportModule.OnCloseClick;
        EventTriggerListener.Get(againButton.gameObject).onClick = reportModule.OnAgainClick;
        EventTriggerListener.Get(nextButton.gameObject).onClick  = reportModule.OnNextClick;
        EventTriggerListener.Get(shareButton.gameObject).onClick = reportModule.OnShareClick;

        float rollOffTime = 0;

        scoreText.RollNumber(FightModel.Instance.fightInfo.score, "", rollOffTime);
        rollOffTime += scoreText.maxRollTime;

        List <config_sort_item> scoreItems = GameMgr.resourceMgr.config_sort.GetItemsByType(3);

        for (int c = 0; c < scoreItems.Count; c++)
        {
            config_sort_item scoreItem = scoreItems[c];
            if (scoreItem.refer <= FightModel.Instance.fightInfo.score)
            {
                SocialModel.Instance.ReportProgress(scoreItem.gid, 1);
            }
        }

        int star = FightModel.Instance.fightInfo.GetStarCount();

        star1Image.gameObject.SetActive(false);
        star2Image.gameObject.SetActive(false);
        star3Image.gameObject.SetActive(false);
        if (star >= 1)
        {
            star1BGImage.color = ColorMgr.GetColor(ColorMgr.COLOR_WIGHT, 0.01f);
            star1Image.gameObject.SetActive(true);
            GameObject effectPrefab = GameMgr.resourceMgr.GetGameObject("effect.ab", "effect_fireworks_n");
            GameObject itemEffect   = GameObject.Instantiate(effectPrefab);
            itemEffect.transform.SetParent(star1Image.transform, false);
            itemEffect.transform.SetParent(transform, true);
        }

        if (star >= 2)
        {
            star2BGImage.color = ColorMgr.GetColor(ColorMgr.COLOR_WIGHT, 0.01f);
            star2Image.gameObject.SetActive(true);
            GameObject effectPrefab = GameMgr.resourceMgr.GetGameObject("effect.ab", "effect_fireworks_n");
            GameObject itemEffect   = GameObject.Instantiate(effectPrefab);
            itemEffect.transform.SetParent(star2Image.transform, false);
            itemEffect.transform.SetParent(transform, true);
        }

        if (star >= 3)
        {
            star3BGImage.color = ColorMgr.GetColor(ColorMgr.COLOR_WIGHT, 0.01f);
            star3Image.gameObject.SetActive(true);
            GameObject effectPrefab = GameMgr.resourceMgr.GetGameObject("effect.ab", "effect_fireworks_n");
            GameObject itemEffect   = GameObject.Instantiate(effectPrefab);
            itemEffect.transform.SetParent(star3Image.transform, false);
            itemEffect.transform.SetParent(transform, true);
        }

        int        winCoin  = (int)FightModel.Instance.fightInfo.score / (int)GameModel.Instance.GetGameConfig(1009);
        WealthInfo coinInfo = PlayerModel.Instance.GetWealth((int)WealthTypeEnum.Coin);
        int        winGem   = 0;
        WealthInfo gemInfo  = PlayerModel.Instance.GetWealth((int)WealthTypeEnum.Gem);

        bool isPassed = MapModel.Instance.IsPassed(BattleModel.Instance.crtConfig.id);

        if (isPassed)
        {
            int coinAdd = (int)GameModel.Instance.GetGameConfig(1008);
            winCoin        += coinAdd;
            coinInfo.count += winCoin;
            coinText.RollNumber(winCoin, "+", rollOffTime);
            rollOffTime += coinText.maxRollTime;
            gemText.RollNumber(winGem, "+", rollOffTime);
            rollOffTime += gemText.maxRollTime;
        }
        else
        {
            int coinAdd = (int)GameModel.Instance.GetGameConfig(1005);;
            winCoin        += coinAdd;
            coinInfo.count += winCoin;
            coinText.RollNumber(winCoin, "+", rollOffTime);
            rollOffTime += coinText.maxRollTime;
            int gemAdd = (int)GameModel.Instance.GetGameConfig(1006);;
            winGem        += gemAdd;
            gemInfo.count += winGem;
            gemText.RollNumber(winGem, "+", rollOffTime);
            rollOffTime += gemText.maxRollTime;
        }

        GameObject bottlePrefab = GameMgr.resourceMgr.GetGameObject("prefab/reportmodule.ab", "ReportBottle");

        bottleList.itemPrefab = bottlePrefab;

        bool findSkillLv = false;

        for (int i = 0; i < SkillTempletModel.Instance.skillGroups.Count; i++)
        {
            SkillGroupInfo skillTempletGroupInfo = SkillTempletModel.Instance.skillGroups[i];

            int groupId = skillTempletGroupInfo.GetGroupId();

            int groupCount = CollectModel.Instance.profileCollect.GetCount(groupId);

            if (groupCount > 0)
            {
                Transform bottleTrans = bottleList.NewItem().GetComponent <Transform>();
                bottleTrans.name = "" + i;

                Image mask = bottleTrans.FindChild("mask").GetComponent <Image>();
                mask.color = ColorMgr.GetColor(ColorMgr.GetCellColorValue(groupId));
                Image icon = bottleTrans.FindChild("icon").GetComponent <Image>();
                icon.overrideSprite = GameMgr.resourceMgr.GetSprite("icon/cell.ab", "cell_" + groupId);
                NumberText numText = bottleTrans.FindChild("Text").GetComponent <NumberText>();
                numText.RollNumber(groupCount, "+", rollOffTime);
                rollOffTime += numText.maxRollTime;
                WealthInfo bottleInfo = PlayerModel.Instance.GetWealth(groupId);
                bottleInfo.count += groupCount;

                EventTriggerListener.Get(bottleTrans.gameObject).onClick = OnOpenSkill;

                string prefStr = PlayerPrefsUtil.BOTTLE_COLLECT + groupId;
                PlayerPrefsUtil.SetInt(prefStr, PlayerPrefsUtil.GetInt(prefStr) + groupCount);

                config_sort_item config_sort_item = GameMgr.resourceMgr.config_sort.GetItemByTypeAndSpecial(2, "" + groupId);

                float bottleProgress = PlayerPrefsUtil.GetInt(prefStr) / (config_sort_item.refer + 0.00f);

                SocialModel.Instance.ReportProgress(config_sort_item.gid, bottleProgress);
            }

            SkillTempletInfo skillTempletInfo = skillTempletGroupInfo.skillTemplets[1];

            if (skillTempletInfo.IsUnlock() && skillTempletInfo.config.type == 1 && findSkillLv == false && skillButton != null)
            {
                if (skillTempletInfo.lv < SkillTempletModel.MAX_LEVEL)
                {
                    int leftStar = MapModel.Instance.starInfo.GetSkillCanUseStar();
                    if (leftStar >= skillTempletInfo.LevelUpCostStar())
                    {
                        int        levelUpNeedBottle = skillTempletInfo.LevelUpCostBottle();
                        WealthInfo bottleInfo        = PlayerModel.Instance.GetWealth(groupId);
                        if (bottleInfo.count >= levelUpNeedBottle)
                        {
                            findSkillLv = true;
                            skillButton.gameObject.SetActive(true);
                            SkillTempletModel.Instance.selectGroupIndex = i;
                            Image skillIcon = skillButton.transform.FindChild("icon").GetComponent <Image>();
                            skillIcon.overrideSprite = GameMgr.resourceMgr.GetSprite("icon/cell.ab", "cell_" + groupId);
                            EventTriggerListener.Get(skillButton.gameObject).onClick = OnClickSkill;
                        }
                    }
                }
            }
        }

        if (findSkillLv == false && skillButton != null)
        {
            skillButton.gameObject.SetActive(false);
        }

        PlayerModel.Instance.SaveWealths();

        MapInfo mapInfo = new MapInfo();

        mapInfo.configId = BattleModel.Instance.crtConfig.id;
        mapInfo.score    = FightModel.Instance.fightInfo.score;
        mapInfo.star     = star;

        MapModel.Instance.PassLevel(mapInfo);
        nextButton.gameObject.SetActive(FightModel.Instance.fightInfo.isWin);

        config_sort_item star_item = GameMgr.resourceMgr.config_sort.GetItemByTypeAndSpecial(1, "11104");

        SocialModel.Instance.ReportScore(star_item.gid, MapModel.Instance.starInfo.crtStar);

        config_sort_item level_item = GameMgr.resourceMgr.config_sort.GetItemByTypeAndSpecial(1, "1");

        SocialModel.Instance.ReportScore(level_item.gid, MapModel.Instance.starInfo.openMapFullStar / 3);

        config_sort_item diamond_item = GameMgr.resourceMgr.config_sort.GetItemByTypeAndSpecial(1, "11101");

        SocialModel.Instance.ReportScore(diamond_item.gid, gemInfo.count);
    }