Пример #1
0
    private bool IsPurchased(WarehouseManager.MetaData.LevelMetaData metaData)
    {
        var fileName = metaData?.FileName;

        if (this.iapManager == null || fileName.IsInvalid())
        {
            return(false);
        }
        var iapKey = IAPLevelPak.GetIAPRequirement(metaData.FileName);

        return(iapKey.IsInvalid() || iapManager.HasGrant(iapKey));
    }
Пример #2
0
        public bool MoveNext(GameContext context, CategoryType?categoryOverride = null, IAPManager iapManager = null)
        {
            var levelPath       = String.Empty;
            var currentPath     = this._activeWarehouseLevelMeta?.relativePath;
            var currentCategory = categoryOverride ?? this._activeWarehouseData?.runtimeCategory ?? CategoryType.Easy;

            // get level list
            var levels = context.file.GetDirectoryFilePaths <WarehouseManager.Data>(appendedDirectory: currentCategory.ToString(), allowCache: true);

            Array.Sort(levels);

            var runtimeIndex = 0;

            if (!currentPath.IsValid() || Array.IndexOf(levels, currentPath) < 0)
            {
                levelPath = levels.First();
            }
            else
            {
                var currentIndex = Array.IndexOf(levels, currentPath);
                runtimeIndex = currentIndex + 1;
                var iapKey = runtimeIndex >= levels.Length ? "" : IAPLevelPak.GetIAPRequirement(levels[runtimeIndex]);
                if (runtimeIndex >= levels.Length || iapKey.IsValid() && !iapManager.HasGrant(iapKey))
                {
                    var nextCategory = currentCategory.GetNext();
                    if (nextCategory.Equals(currentCategory))
                    {
                        runtimeIndex = currentIndex; // we're on the last available level already
                    }
                    else
                    {
                        return(this.MoveNext(context, nextCategory)); // recursive into next category
                    }
                }
                levelPath = levels[runtimeIndex];
            }

            // move to elected level
            var levelData = context.file.LoadJson <WarehouseManager.Data>(levelPath);

            levelData.runtimeIndex    = runtimeIndex;
            levelData.runtimeCategory = currentCategory;
            this.SetActiveData(context, levelData, levelPath);

            // true if we were able to progress
            return(levelPath.Equals(currentPath));
        }
Пример #3
0
    private void ListPage(int pageNumber)
    {
        var previousIndex = this.currentIndex;
        var pageIndex     = pageNumber - 1;

        this.currentIndex = pageIndex;

        foreach (var prefab in this.levelPrefabs)
        {
            prefab.transform.SetParent(null, false);
        }

        var activeButtons = new List <GameObject>();

        for (var i = 0; i < this.LevelsPerPage && i < this.activePagedLevelData[pageIndex].Count; ++i)
        {
            var prefab = i < this.levelPrefabs.Count ? this.levelPrefabs[i] : null;
            if (prefab == null)
            {
                prefab = Instantiate(this.listLevelPrefab, Vector3.zero, Quaternion.identity);
                this.levelPrefabs.Add(prefab);
            }
            activeButtons.Add(prefab);
            prefab.transform.SetParent(this.levelHolder.transform, false);
            prefab.name = $"levelButton{i + 1}";

            var text         = prefab.GetComponentInChildren <Text>();
            var runtimeIndex = pageIndex * this.LevelsPerPage + i;
            text.text = $"#{runtimeIndex + 1}";

            var levelData   = this.activePagedLevelData[pageIndex][i];
            var button      = prefab.GetComponent <CustomButton>();
            var isPurchased = this.IsPurchased(levelData);

            var isPlayable = false;
            if (IsAllAvailable)
            {
                isPlayable = true;// && isPurchased; // test all purchased levels
            }
            else
            {
                isPlayable = this.IsPlayableLevel(levelData) && isPurchased;
            }

            button.Toggle(isPlayable);
            button.interactable = true;//isPlayable || !isPurchased;

            var levelButton = prefab.GetComponent <LevelButton>();
            levelButton.SetIcon(
                this.activeCategory,
                isPlayable,
                isPurchased,
                levelData.IsCompleted,
                levelData.IsCompleted ? this.completedLevelColor : this.activeLevelColor);

            button.onClick.RemoveAllListeners();
            button.onClick.AddListener(() =>
            {
                if (isPlayable)
                {
                    var data             = this.File.LoadJson <WarehouseManager.Data>(levelData.relativePath);
                    data.runtimeIndex    = runtimeIndex;
                    data.runtimeCategory = this.activeCategory;
                    this.PlaySfx();
                    this.OnLevelSelectedEvent.Invoke(data, levelData);
                }
                else if (!isPurchased && iapAlert != null)
                {
                    this.PlaySfx();
                    iapAlert.PromptIap(IAPLevelPak.GetIAPRequirement(levelData.FileName));
                }
                else if (!GameContext.IsNavigationEnabled)
                {
                    this.EventSystem.SetSelectedGameObject(null);
                }
            });

            var row  = i / this.levelsPerRow;
            var col  = i - row * this.levelsPerRow;
            var rect = prefab.GetComponent <RectTransform>();
            rect.localPosition = rect.localPosition
                                 .WithX(this.startListingPosition.x + col * this.levelWidth)
                                 .WithY(this.startListingPosition.y - row * this.levelHeight);
        }

        if (GameContext.IsNavigationEnabled)
        {
            if (!this.isInitialized)
            {
                this.SelectDefault();
            }
            else if (this.EventSystem.currentSelectedGameObject?.activeInHierarchy != true)
            {
                if (activeButtons.HasItems())
                {
                    var selectTarget = previousIndex > this.currentIndex ? activeButtons.First() : activeButtons.Last();
                    this.EventSystem.SetSelectedGameObject(selectTarget);
                }
                else
                {
                    this.SelectDefault();
                }
            }
        }

        this.isInitialized = true;
    }