StatsManager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public enum UpgradeTypes
{
    ENEMY_HEALTH,
    ENEMY_DAMAGE,
    ENEMY_ARMOR,
    MANA_COST,
}

public struct EnemyStats
{
    public float healthMultiplier;
    public float damageMultiplier;
    public float armorMultiplier;
}

public struct PlayerStats
{
    public float healthMultiplier;
    public float damageMultiplier;
    public float armorMultiplier;
}

public class UpgradeData
{
    public Upgrade upgrade;
    public int count;

    // How much it costs to purchase another one of this upgrade
    public int GetNextUpgradeCost()
    {
        return StatsManager.instance.AdjustManaCost(GetUnadjustedNextUpgradeCost());
    }

    public float GetTotalEffectMultiplier()
    {
        return 1 + count * upgrade.effectMultiplier;
    }

    // You probably shouldn't call this outside this file.
    public int GetUnadjustedNextUpgradeCost()
    {
        return (int)(upgrade.baseCost * (1 + count * upgrade.costMultiplier));
    }
}

public class StatsManager : MonoBehaviour
{

    public static StatsManager instance { get; private set; }

    EnemyStats currentEnemyStats;
    PlayerStats currentPlayerStats;
    [SerializeField] int currentMana;

    [SerializeField] List<Upgrade> availableUpgrades;

    // Information about currently available and purchased upgrades. Should only be read, not modified.
    public Dictionary<UpgradeTypes, UpgradeData> upgrades = new Dictionary<UpgradeTypes, UpgradeData>();

    public EnemyStats GetEnemyStats()
    {
        return currentEnemyStats;
    }

    public PlayerStats GetPlayerStats(int stage)
    {
        // TODO use `stage`
        return currentPlayerStats;
    }

    public int GetMana()
    {
        return currentMana;
    }

    // Adjusts the given Mana cost based on the amount of Mana cost upgrades currently bought.
    public int AdjustManaCost(int cost)
    {
        return (int)(cost * upgrades[UpgradeTypes.MANA_COST].GetTotalEffectMultiplier());
    }

    public int GetNextUpgradeCost(UpgradeTypes type)
    {
        return upgrades[type].GetNextUpgradeCost();
    }

    // Buys an upgrade, spending the required amount of Mana in the process. Returns false if not enough Mana is available.
    public bool BuyUpgrade(UpgradeTypes type)
    {
        if (!ModifyMana(-GetNextUpgradeCost(type)))
        {
            return false;
        }
        upgrades[type].count++;
        RecalculateStatMultipliers();
        return true;
    }

    // Add (positive value) or spend (negative value) Mana. Returns false if not enough Mana is available to spend.
    public bool ModifyMana(int delta)
    {
        if (!CanModifyMana(delta))
        {
            return false;
        }
        currentMana += delta;
        return true;
    }

    // If `delta` is negative, returns this amount of Mana can be spent. If `delta` is positive, this will always return `true`.
    public bool CanModifyMana(int delta)
    {
        return currentMana + delta >= 0;
    }

    void RecalculateStatMultipliers()
    {
        currentEnemyStats.healthMultiplier = upgrades[UpgradeTypes.ENEMY_HEALTH].GetTotalEffectMultiplier();
        currentEnemyStats.damageMultiplier = upgrades[UpgradeTypes.ENEMY_DAMAGE].GetTotalEffectMultiplier();
        currentEnemyStats.armorMultiplier = upgrades[UpgradeTypes.ENEMY_ARMOR].GetTotalEffectMultiplier();
    }

    void Awake()
    {
        if (instance == null)
        {
            instance = this;
        }
        else if (instance != this)
        {
            Destroy(gameObject);
        }
        DontDestroyOnLoad(gameObject);

        foreach (Upgrade upgrade in availableUpgrades)
        {
            UpgradeData upgradeData = new UpgradeData();
            upgrades.Add(upgrade.type, upgradeData);
        }

        currentEnemyStats.healthMultiplier = 1f;
        currentEnemyStats.damageMultiplier = 1f;
        currentEnemyStats.armorMultiplier = 1f;
        currentPlayerStats.healthMultiplier = 1f;
        currentPlayerStats.damageMultiplier = 1f;
        currentPlayerStats.armorMultiplier = 1f;
    }
}