Example #1
0
 public void Complete()
 {
     PlayData.StageData stageData = Game.Instance.playData.GetCurrentStageData();
     if (level <= stageData.clearLevel)
     {
         starImage.gameObject.SetActive(true);
     }
 }
Example #2
0
 public void Unlock()
 {
     PlayData.StageData stageData = Game.Instance.playData.GetCurrentStageData();
     if (level <= stageData.clearLevel + 1)
     {
         buttonImage.sprite       = unlockedLevelSprite;
         text.text                = level.ToString();
         startLevelButton.enabled = true;
         text.gameObject.SetActive(true);
     }
 }
Example #3
0
 public void Init(Config.StageInfo info)
 {
     this.info  = info;
     panelImage = GetComponent <Image>();
     button     = GetComponent <Button>();
     PlayData.StageData stageData = Game.Instance.playData.stageDatas[info.id - 1];
     clearLevel       = stageData.clearLevel;
     description.text = "clear previous stage";
     Config.WorldInfo worldInfo = Game.Instance.config.worldInfos [info.world - 1];
     if (info.id == worldInfo.stageInfos [0].id)
     {
         description.text = "collect " + worldInfo.openStar + " stars";
     }
     open = stageData.open;
 }
Example #4
0
    public void Init(int stage, int level)
    {
        this.stage = stage;
        this.level = level;
        startLevelButton.enabled = false;
        starImage.gameObject.SetActive(false);
        text.gameObject.SetActive(false);
        buttonImage.sprite = lockedLevelSprite;
        PlayData.StageData stageData = Game.Instance.playData.GetCurrentStageData();
        if (level <= stageData.clearLevel + 1)
        {
            Unlock();
        }

        if (level <= stageData.clearLevel)
        {
            Complete();
        }
    }
Example #5
0
    public void Load()
    {
        Debug.Log("loaded \'playdata.dat\' from " + Application.persistentDataPath + "/playdata.dat");
        openWorlds = new bool[Game.Instance.config.worldInfos.Count];
        stageDatas = new StageData[Game.Instance.config.stageInfos.Count];
        openBlocks = new Dictionary <string, string> ();
        adsFree    = false;
        Quest.Init();
        achievements = new Dictionary <string, Achievement> ();

        PlayData tmpPlayData = null;

        if (File.Exists(Application.persistentDataPath + "/playdata.dat"))
        {
            BinaryFormatter bf   = new BinaryFormatter();
            FileStream      file = File.Open(Application.persistentDataPath + "/playdata.dat", FileMode.Open);
            tmpPlayData = (PlayData)bf.Deserialize(file);
            file.Close();
        }

        if (null != tmpPlayData)
        {
            hint    = tmpPlayData.hint;
            star    = tmpPlayData.star;
            adsFree = tmpPlayData.adsFree;
            for (int i = 0; i < tmpPlayData.openWorlds.Length; i++)
            {
                openWorlds [i] = false;
                if (i < openWorlds.Length)
                {
                    openWorlds [i] = tmpPlayData.openWorlds [i];
                }
            }

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

            achievements = tmpPlayData.achievements;
            foreach (var itr in achievements)
            {
                Achievement achievement = itr.Value;
                achievement.Start();
                Quest.AddQuest(achievement);
            }
            openBlocks = tmpPlayData.openBlocks;
        }


        foreach (Config.AchievementInfo achievementInfo in Game.Instance.config.achievementInfos)
        {
            if (null == Quest.Find(achievementInfo.id))
            {
                Achievement achievement = new Achievement(
                    achievementInfo.id,
                    achievementInfo.name,
                    achievementInfo.description,
                    new Quest.Progress("", achievementInfo.type, achievementInfo.key, achievementInfo.goal)
                    );
                achievements.Add(achievement.id, achievement);
                Quest.AddQuest(achievement);
            }
        }

        for (int i = 0; i < stageDatas.Length; i++)
        {
            if (null == stageDatas[i])
            {
                PlayData.StageData stageData = new PlayData.StageData();
                stageData.id         = i + 1;
                stageData.clearLevel = 0;
                stageData.open       = false;
                stageDatas [i]       = stageData;
            }
        }

        foreach (Config.WorldInfo worldInfo in Game.Instance.config.worldInfos)
        {
            if (star >= worldInfo.openStar)
            {
                openWorlds[worldInfo.id - 1] = true;
                stageDatas[worldInfo.stageInfos[0].id - 1].open = true;
            }
        }
    }
Example #6
0
    public IEnumerator _CheckLevelComplete()
    {
        if (true == Map.Instance.CheckComplete())
        {
            AudioManager.Instance.Play("LevelClear");
            int rewardCount = 0;
            playTime = Time.realtimeSinceStartup - playTime;
            PlayData.StageData stageData = playData.GetCurrentStageData();

            if (playData.currentLevel > stageData.clearLevel)
            {
                playData.star       += 1;
                stageData.clearLevel = playData.currentLevel;

                stagePanel.totalStarCount = playData.star;
                stagePanel.GetStageInfo(stageData.id).clearLevel = stageData.clearLevel;
                levelPanel.GetLevelInfo(stageData.clearLevel).Complete();

                Quest.Update(Achievement.Type.StarCollectCount, "");

                Config.StageInfo stageInfo = config.FindStageInfo(stageData.id);
                if (playData.currentLevel < stageInfo.totalLevel)
                {
                    levelPanel.GetLevelInfo(stageData.clearLevel + 1).Unlock();
                }
                else if (playData.currentLevel == stageInfo.totalLevel)
                {
                    rewardCount = 1;
                    Quest.Update(Achievement.Type.StageCompleteCount, "");
                    if (stageInfo.id < config.stageInfos.Count)
                    {
                        playData.GetStageData(stageData.id + 1).open   = true;
                        stagePanel.GetStageInfo(stageData.id + 1).open = true;
                    }
                }

                Analytics.CustomEvent("LevelComplete", new Dictionary <string, object> {
                    { "stage", playData.currentStage },
                    { "level", playData.currentStage + "-" + playData.currentLevel },
                    { "star", playData.star }
                });
            }

            GetNewOpenWorld();
            playData.Save();

            yield return(new WaitForSeconds(1.0f));

            yield return(StartCoroutine(gamePanel.levelComplete.Open()));

            if (0 < rewardCount)
            {
                AddHint(rewardCount);
            }

            if (true == playData.adsFree)
            {
                yield break;
            }

            if (advertisement.requestCount++ < advertisement.interval_count)
            {
                yield break;
            }

            if (Time.realtimeSinceStartup - advertisement.lastAdsShowTime < advertisement.interval_time)
            {
                yield break;
            }
            advertisement.Show(Advertisement.PlacementType.Interstitial);
            advertisement.requestCount    = 0;
            advertisement.lastAdsShowTime = Time.realtimeSinceStartup;
        }
    }