Assets/Scripts/ShopController.cs - master - dedikins/Clicker

Assets/Scripts/ShopController.cs
983 строки24 KB
dedikins
Завершение разработки магазина
31 май 2026, 23:26
31 май 2026, 23:26fd3cf45
using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class ShopController : MonoBehaviour
{
    public static ShopController Instance;

    [Header("Panel")]
    [SerializeField] private GameObject shopPanel;

    [Header("Upgrade Data")]
    [SerializeField]
    private UpgradeData[] upgrades;

    [Header("UI")]
    [SerializeField]
    private UpgradeCardUI clickCard;

    [SerializeField]
    private UpgradeCardUI autoCard;

    [SerializeField]
    private UpgradeCardUI critCard;

    [SerializeField]
    private UpgradeCardUI critPowerCard;

    [SerializeField]
    private UpgradeCardUI doubleCoinsCard;

    [SerializeField]
    private UpgradeCardUI coinsMultiplierCard;

    [SerializeField]
    private UpgradeCardUI autoSpeedCard;

    [SerializeField]
    private UpgradeCardUI autoClickCard;

    [SerializeField]
    private UpgradeCardUI discountCard;

    private void Awake()
    {
        Instance = this;
    }

    private void Start()
    {
        Refresh();
    }

    public void Open()
    {
        shopPanel.SetActive(true);
        Refresh();
    }

    public void Close()
    {
        shopPanel.SetActive(false);
    }

    public void BuyUpgrade(string id)
    {
        UpgradeData data =
            GetUpgradeData(id);

        if (data == null)
        {
            Debug.LogError($"Upgrade {id} not found");
            return;
        }

        UpgradeState state =
            GameManager.Instance.GetUpgrade(id);

        // ===== �������� MAX LEVEL =====

        if (state.Level >= data.MaxLevel)
        {
            Debug.Log("Max level reached");
            return;
        }

        // ===== ���� =====

        int cost =
            GetUpgradeCost(data, state.Level);

        // ===== ������� �� ����� =====

        if (!GameManager.Instance.SpendCoins(cost))
        {
            Debug.Log("Not enough coins");
            return;
        }

        // ===== �������� ������� =====

        state.Level++;

        // ===== ��������� ������ =====

        ApplyUpgrade(id);

        UpgradeCardUI card = GetCardById(id);

        if (card != null &&
            card.purchaseAnimation != null)
        {
            card.purchaseAnimation.Play();
        }

        AudioManager.Instance?.PlayUpgrade();

        GameManager.Instance.Save();

        Refresh();
    }

    private UpgradeData GetUpgradeData(string id)
    {
        foreach (UpgradeData data in upgrades)
        {
            if (data.Id == id)
                return data;
        }

        return null;
    }

    private int GetUpgradeCost(
    UpgradeData data,
    int level)
    {
        float cost =
            data.BaseCost *
            Mathf.Pow(
                data.CostMultiplier,
                level);

        // ===== ������ =====

        cost *=
            1f -
            GameManager.Instance.Progress.ShopDiscount;

        return Mathf.RoundToInt(cost);
    }

    private void ApplyUpgrade(string id)
    {
        PlayerProgress p =
            GameManager.Instance.Progress;

        switch (id)
        {
            case "click":
                p.ClickPower += 1;
                break;

            case "auto":
                p.AutoIncome += 1;
                break;

            case "critChance":
                p.CritChance += 0.02f;
                break;

            case "critPower":
                p.CritMultiplier += 0.25f;
                break;

            case "doubleCoins":
                p.DoubleCoinsChance += 0.01f;
                break;

            case "coinsMultiplier":
                p.CoinsMultiplier += 0.1f;
                break;

            case "autoSpeed":
                p.AutoIncomeSpeed += 0.1f;
                break;

            case "autoClick":
                p.AutoClickPower += 1;
                break;

            case "discount":

                p.ShopDiscount += 0.02f;

                p.ShopDiscount =
                    Mathf.Clamp(
                        p.ShopDiscount,
                        0f,
                        0.8f);

                break;
        }
    }

    private void Buy(
        string id,
        int baseCost,
        float multiplier,
        bool click)
    {
        var state =
            GameManager.Instance.GetUpgrade(id);

        int cost =
            Mathf.RoundToInt(
                baseCost * Mathf.Pow(multiplier, state.Level));

        if (!GameManager.Instance.SpendCoins(cost))
            return;

        state.Level++;

        AudioManager.Instance?.PlayUpgrade();

        if (click)
            GameManager.Instance.AddClickPower(1);
        else
            GameManager.Instance.AddAutoIncome(1);

        GameManager.Instance.Save();

        Refresh();
    }

    public void Refresh()
    {
        RefreshClick();

        RefreshAuto();

        RefreshCrit();

        RefreshCritPower();

        RefreshDoubleCoins();

        RefreshCoinsMultiplier();

        RefreshAutoSpeed();

        RefreshAutoClick();

        RefreshDiscount();
    }

    private void RefreshClick()
    {
        UpgradeData data =
            GetUpgradeData("click");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("click");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        if (clickCard != null)
        {
            clickCard.titleText.text =
                data.Title;

            clickCard.descriptionText.text =
                data.Description;

            clickCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            clickCard.costText.text =
                maxed
                ? "MAX"
                : $"{cost} �����";

            float progress =
                (float)state.Level /
                data.MaxLevel;

            clickCard.progressFill.fillAmount =
                progress;

            bool canBuy =
                GameManager.Instance.Progress.Coins >= cost;

            if (clickCard.lockIcon != null)
            {
                clickCard.lockIcon.SetActive(
                    !canBuy && !maxed);
            }

            if (maxed)
            {
                clickCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                clickCard.costText.text = "MAX";
            }
            else if (!canBuy)
            {
                clickCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                clickCard.costText.color =
                    Color.red;
            }
            else
            {
                clickCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                clickCard.costText.color =
                    Color.white;
            }

            switch (data.Rarity)
            {
                case UpgradeRarity.Common:
                    clickCard.rarityBar.color =
                        Color.gray;
                    break;

                case UpgradeRarity.Rare:
                    clickCard.rarityBar.color =
                        Color.blue;
                    break;

                case UpgradeRarity.Epic:
                    clickCard.rarityBar.color =
                        new Color(0.7f, 0f, 1f);
                    break;

                case UpgradeRarity.Legendary:
                    clickCard.rarityBar.color =
                        new Color(1f, 0.7f, 0f);
                    break;
            }
        }
    }

    private void RefreshAuto()
    {
        UpgradeData data =
            GetUpgradeData("auto");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("auto");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (autoCard != null)
        {
            autoCard.titleText.text =
                data.Title;

            autoCard.descriptionText.text =
                data.Description;

            autoCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            autoCard.costText.text =
                maxed
                ? "MAX"
                : $"{cost} �����";

            float progress =
                (float)state.Level /
                data.MaxLevel;

            autoCard.progressFill.fillAmount =
                progress;

            autoCard.lockIcon.SetActive(
                !canBuy && !maxed);

            if (maxed)
            {
                autoCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                autoCard.costText.color =
                    Color.white;
            }
            else if (!canBuy)
            {
                autoCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                autoCard.costText.color =
                    Color.red;
            }
            else
            {
                autoCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                autoCard.costText.color =
                    Color.white;
            }

            switch (data.Rarity)
            {
                case UpgradeRarity.Common:
                    autoCard.rarityBar.color =
                        Color.gray;
                    break;

                case UpgradeRarity.Rare:
                    autoCard.rarityBar.color =
                        Color.blue;
                    break;

                case UpgradeRarity.Epic:
                    autoCard.rarityBar.color =
                        new Color(0.7f, 0f, 1f);
                    break;

                case UpgradeRarity.Legendary:
                    autoCard.rarityBar.color =
                        new Color(1f, 0.7f, 0f);
                    break;
            }
        }
    }

    private void RefreshCrit()
    {
        UpgradeData data =
            GetUpgradeData("critChance");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("critChance");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (critCard != null)
        {
            float critChance =
                GameManager.Instance.Progress.CritChance * 100f;

            critCard.titleText.text =
                data.Title;

            critCard.descriptionText.text =
                $"+{critChance:0}% ���� �����";

            critCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            critCard.costText.text =
                maxed
                ? "MAX"
                : $"{cost} �����";

            critCard.progressFill.fillAmount =
                (float)state.Level /
                data.MaxLevel;

            critCard.lockIcon.SetActive(
                !canBuy && !maxed);

            critCard.rarityBar.color =
                GetRarityColor(data.Rarity);

            if (maxed)
            {
                critCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);
            }
            else if (!canBuy)
            {
                critCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                critCard.costText.color =
                    Color.red;
            }
            else
            {
                critCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                critCard.costText.color =
                    Color.white;
            }
        }
    }

    private void RefreshCritPower()
    {
        UpgradeData data =
            GetUpgradeData("critPower");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("critPower");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (critPowerCard != null)
        {
            critPowerCard.titleText.text =
                data.Title;

            critPowerCard.descriptionText.text =
                $"+{state.Level * 0.1f:0.0} � ���� �����";

            critPowerCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            critPowerCard.costText.text =
                maxed
                ? "MAX"
                : $"{cost} �����";

            critPowerCard.progressFill.fillAmount =
                (float)state.Level /
                data.MaxLevel;

            critPowerCard.lockIcon.SetActive(
                !canBuy && !maxed);


            if (maxed)
            {
                critPowerCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                critPowerCard.costText.color =
                    Color.white;
            }
            else if (!canBuy)
            {
                critPowerCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                critPowerCard.costText.color =
                    Color.red;
            }
            else
            {
                critPowerCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                critPowerCard.costText.color =
                    Color.white;
            }

            critPowerCard.rarityBar.color =
                new Color(0.7f, 0f, 1f);
        }
    }

    private void RefreshDoubleCoins()
    {
        UpgradeData data =
            GetUpgradeData("doubleCoins");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("doubleCoins");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (doubleCoinsCard != null)
        {
            doubleCoinsCard.titleText.text =
                data.Title;

            doubleCoinsCard.descriptionText.text =
                $"+{state.Level}% ���� x2";

            doubleCoinsCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            doubleCoinsCard.costText.text =
                maxed ? "MAX" : $"{cost} �����";

            doubleCoinsCard.progressFill.fillAmount =
                (float)state.Level /
                data.MaxLevel;

            doubleCoinsCard.lockIcon.SetActive(
                !canBuy && !maxed);

            doubleCoinsCard.rarityBar.color =
                GetRarityColor(data.Rarity);

            if (maxed)
            {
                doubleCoinsCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                doubleCoinsCard.costText.color =
                    Color.white;
            }
            else if (!canBuy)
            {
                doubleCoinsCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                doubleCoinsCard.costText.color =
                    Color.red;
            }
            else
            {
                doubleCoinsCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                doubleCoinsCard.costText.color =
                    Color.white;
            }

        }
    }

    private void RefreshCoinsMultiplier()
    {
        UpgradeData data =
            GetUpgradeData("coinsMultiplier");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("coinsMultiplier");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (coinsMultiplierCard != null)
        {
            coinsMultiplierCard.titleText.text =
                data.Title;

            coinsMultiplierCard.descriptionText.text =
                $"x{1f + state.Level * 0.1f:0.0} �����";

            coinsMultiplierCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            coinsMultiplierCard.costText.text =
                maxed ? "MAX" : $"{cost} �����";

            coinsMultiplierCard.progressFill.fillAmount =
                (float)state.Level /
                data.MaxLevel;

            coinsMultiplierCard.lockIcon.SetActive(
                !canBuy && !maxed);

            coinsMultiplierCard.rarityBar.color =
                GetRarityColor(data.Rarity);

            if (maxed)
            {
                coinsMultiplierCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                coinsMultiplierCard.costText.color =
                    Color.white;
            }
            else if (!canBuy)
            {
                coinsMultiplierCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                coinsMultiplierCard.costText.color =
                    Color.red;
            }
            else
            {
                coinsMultiplierCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                coinsMultiplierCard.costText.color =
                    Color.white;
            }
        }
    }

    private void RefreshAutoSpeed()
    {
        UpgradeData data =
            GetUpgradeData("autoSpeed");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("autoSpeed");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (autoSpeedCard != null)
        {
            autoSpeedCard.titleText.text =
                data.Title;

            autoSpeedCard.descriptionText.text =
                $"+{state.Level}% ��������";

            autoSpeedCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            autoSpeedCard.costText.text =
                maxed ? "MAX" : $"{cost} �����";

            autoSpeedCard.progressFill.fillAmount =
                (float)state.Level /
                data.MaxLevel;

            autoSpeedCard.lockIcon.SetActive(
                !canBuy && !maxed);

            autoSpeedCard.rarityBar.color =
                GetRarityColor(data.Rarity);

            if (maxed)
            {
                autoSpeedCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                autoSpeedCard.costText.color =
                    Color.white;
            }
            else if (!canBuy)
            {
                autoSpeedCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                autoSpeedCard.costText.color =
                    Color.red;
            }
            else
            {
                autoSpeedCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                autoSpeedCard.costText.color =
                    Color.white;
            }
        }
    }

    private void RefreshAutoClick()
    {
        UpgradeData data =
            GetUpgradeData("autoClick");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("autoClick");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (autoClickCard != null)
        {
            autoClickCard.titleText.text =
                data.Title;

            autoClickCard.descriptionText.text =
                $"+{state.Level} ����������";

            autoClickCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            autoClickCard.costText.text =
                maxed ? "MAX" : $"{cost} �����";

            autoClickCard.progressFill.fillAmount =
                (float)state.Level /
                data.MaxLevel;

            autoClickCard.lockIcon.SetActive(
                !canBuy && !maxed);

            autoClickCard.rarityBar.color =
                GetRarityColor(data.Rarity);

            if (maxed)
            {
                autoClickCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                autoClickCard.costText.color =
                    Color.white;
            }
            else if (!canBuy)
            {
                autoClickCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                autoClickCard.costText.color =
                    Color.red;
            }
            else
            {
                autoClickCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                autoClickCard.costText.color =
                    Color.white;
            }
        }
    }

    private void RefreshDiscount()
    {
        UpgradeData data =
            GetUpgradeData("discount");

        UpgradeState state =
            GameManager.Instance.GetUpgrade("discount");

        int cost =
            GetUpgradeCost(data, state.Level);

        bool maxed =
            state.Level >= data.MaxLevel;

        bool canBuy =
            GameManager.Instance.Progress.Coins >= cost;

        if (discountCard != null)
        {
            discountCard.titleText.text =
                data.Title;

            discountCard.descriptionText.text =
                $"-{state.Level}% ����";

            discountCard.levelText.text =
                $"LVL {state.Level}/{data.MaxLevel}";

            discountCard.costText.text =
                maxed ? "MAX" : $"{cost} �����";

            discountCard.progressFill.fillAmount =
                (float)state.Level /
                data.MaxLevel;

            discountCard.lockIcon.SetActive(
                !canBuy && !maxed);

            discountCard.rarityBar.color =
                GetRarityColor(data.Rarity);

            if (maxed)
            {
                discountCard.background.color =
                    new Color(0.2f, 0.2f, 0.2f);

                discountCard.costText.color =
                    Color.white;
            }
            else if (!canBuy)
            {
                discountCard.background.color =
                    new Color(0.35f, 0.35f, 0.35f);

                discountCard.costText.color =
                    Color.red;
            }
            else
            {
                discountCard.background.color =
                    new Color(0.22f, 0.22f, 0.22f);

                discountCard.costText.color =
                    Color.white;
            }
        }
    }

    private Color GetRarityColor(
    UpgradeRarity rarity)
    {
        switch (rarity)
        {
            case UpgradeRarity.Common:
                return Color.gray;

            case UpgradeRarity.Rare:
                return Color.blue;

            case UpgradeRarity.Epic:
                return new Color(0.7f, 0f, 1f);

            case UpgradeRarity.Legendary:
                return new Color(1f, 0.7f, 0f);

            default:
                return Color.white;
        }
    }

    private UpgradeCardUI GetCardById(string id)
    {
        switch (id)
        {
            case "click":
                return clickCard;

            case "auto":
                return autoCard;

            case "critChance":
                return critCard;

            case "critPower":
                return critPowerCard;

            case "doubleCoins":
                return doubleCoinsCard;

            case "coinsMultiplier":
                return coinsMultiplierCard;

            case "autoSpeed":
                return autoSpeedCard;

            case "autoClick":
                return autoClickCard;

            case "discount":
                return discountCard;
        }

        return null;
    }
}