플레이어 스탯 시스템

using UnityEngine;

[CreateAssetMenu(fileName = "PlayerStatus", menuName = "Player/Status")]
public class PlayerStatus : ScriptableObject
{
    public const int maxPoint = 5;

    [SerializeField] float initHp;      // 초기 체력
    [SerializeField] float initBt;     // 초기 배터리
    [SerializeField] float initSp;        // 초기 이동속도
    [SerializeField] float initAtk;     // 초기 힘
    [SerializeField] float initGsp;      // 초기 채집속도

    [SerializeField] int hpPoint;
    [SerializeField] int btPoint;
    [SerializeField] int spPoint;
    [SerializeField] int atkPoint;
    [SerializeField] int gspPoint;

    [SerializeField] float hpIncrease;
    [SerializeField] float btIncrease;
    [SerializeField] float spIncrease;
    [SerializeField] float atkIncrease;
    [SerializeField] float gspIncrease;

    [SerializeField] bool isForestUnLock;
    [SerializeField] bool isDesertUnLock;
    [SerializeField] bool isCaveUnLock;

    public int MAXPOINT
    {
        get { return maxPoint; }
    }

    #region 스탯 프로퍼티
    public float HP
    {
        get
        {
            return initHp + hpPoint * hpIncrease;
        }
    }

    public float BT
    {
        get
        {
            return initBt + btPoint * btIncrease;
        }
    }

    public float SP
    {
        get
        {
            return initSp + spPoint * spIncrease;
        }
    }

    public float ATK
    {
        get
        {
            return initAtk + atkPoint * atkIncrease;
        }
    }

    public float GSP
    {
        get
        {
            return initGsp - gspPoint * gspIncrease;
        }
    }
    #endregion

    #region 스탯 레벨 포인트 프로퍼티
    public int HpPoint { get; set; }
    public int BtPoint { get; set; }
    public int SpPoint { get; set; }
    public int AtkPoint { get; set; }
    public int GspPoint { get; set; }
    #endregion

    #region 스킬 포인트당 증가량 프로퍼티
    public float HpIncrease { get; }
    public float BtIncrease { get; }
    public float SpIncrease { get; }
    public float AtkIncrease { get; set; }
    public float GspIncrease { get; }
    #endregion

    #region 맵 해금 상태
    // 숲 해금 상태
    public bool IsForestUnLock { get; set; }

    // 사막 해금 상태
    public bool IsDesertUnLock { get; set; }

    // 동굴 해금 상태
    public bool IsCaveUnLock { get; set; }
    #endregion
}

using System.Collections;
using UnityEngine;

public class StatusManager : MonoBehaviour
{
    public static StatusManager instance;   

    [SerializeField] PlayerStatus playerStatus;  
    [SerializeField] float currentHp;    // 현재 체력
    [SerializeField] float currentBt;    // 현재 배터리

    // 체력 감소, 배터리 증가&감소 관련 로직 => 무한 반복되지 않도록
    bool plusBattery = false;
    bool minusBattery = false;
    bool minusHp = false;
    bool minusHpMap = false;

    // 플레이어가 죽은 상태인지 확인
    public bool die = false;

    // 치트키 관련 변수
    bool isCheatHp;
    bool isCheatBt;
    bool isCheatAtk;
    float befAtk;

    #region Property
    public PlayerStatus PlayerStatus
    {
        get { return playerStatus; }
        set { playerStatus = value; }
    }

    // 최대 체력
    public float MaxHp
    {
        get { return playerStatus.HP; }
    }

    // 현재 체력
    public float CurrentHp
    {
        get { return currentHp; }
        set
        {
            currentHp = value;
            if(currentHp > MaxHp) currentHp = MaxHp;
            if(currentHp < 0 ) currentHp = 0;
        }
    }

    // 최대 배터리
    public float MaxBt
    {
        get { return playerStatus.BT; }
    }

    // 현재 배터리
    public float CurrentBt
    {
        get { return currentBt; }
        set
        {
            currentBt = value;
            if(currentBt >= MaxBt) currentBt = MaxBt;
            if(currentBt < 0) currentBt = 0;
        }
    }
    #endregion

    private void Awake()
    {
        if (instance == null)
        {
            instance = this;
            DontDestroyOnLoad(this.gameObject);
        }
        else Destroy(this.gameObject);
    
        playerStatus = ScriptableObject.Instantiate(Resources.Load<PlayerStatus>("Prefabs/PlayerData/PlayerStatus"));

        // 치트키 변수 => 현재 공격력 저장
        befAtk = playerStatus.AtkIncrease;
    }

    private void Start()
    {
        Initialize();
    }

    // 초기화 함수
    void Initialize()
    {
        // 현재 체력과 배터리를 최대 체력과 배터리로 설정
        currentHp = MaxHp;
        currentBt = MaxBt;

        // 치트키 관련 변수
        isCheatHp = false;
        isCheatBt = false;
        isCheatAtk = false;
    }

    #region 치트키 함수
    // 치트키 중 무적을 클릭했을 때
    public void CheatHp()
    {
        isCheatHp = !isCheatHp;
    }

    // 치트키 중 배터리를 클릭했을 때
    public void CheatBt()
    {
        isCheatBt = !isCheatBt;
    }

    // 치트키 중 공격력을 클릭했을 때
    public void CheatAtk()
    {
        isCheatAtk = !isCheatAtk;

        // 치트 중이라면
        if (isCheatAtk)
        {   
            // 공격력 증가량을 100으로 설정하고, 공격력 포인트 1 증가
            playerStatus.AtkIncrease = 100;
            playerStatus.AtkPoint++;
        }
        // 치트를 비활성화하면
        else
        {
            // 공격력 증가량을 원상복귀 후, 공격력 포인트 원상복귀
            playerStatus.AtkIncrease = befAtk;
            playerStatus.AtkPoint--;
        }
    }
    #endregion

    private void FixedUpdate()
    {
        #region 치트
        // 체력이 치트 상태일 때,
        if (isCheatHp)
        {
            // 현재 체력을 최대 체력으로
            CurrentHp = MaxHp;
        }

        // 배터리가 치트 상태일 때, 
        if (isCheatBt)
        {
            // 현재 배터리를 최대 배터리로 
            currentBt = MaxBt;
        }
        #endregion

        // 플레이어가 해금되지 않은 장소를 갈 때, 체력 감소
        MapLockMinusHP();

        // 현재 체력이 0보다 클 때,
        if (currentHp > 0)
        {
            // 플레이어가 지금 집이 아니라면,
            if (!PlayerController.instance.isHouse)
            {
                // 배터리 감소 코루틴 호출
                if (currentBt > 0) StartCoroutine("MinusCurrentBt");
                else
                {
                    // 배터리가 0이되면 배터리 감소 코루틴 중지 및 체력 감소 코루틴 호출
                    StopCoroutine("MinusCurrentBt");
                    StartCoroutine("MinusCurrentHp");
                }
            }
            // 플레이어가 지금 집이라면,
            else
            {  
                // 현재 배터리가 최대 배터리보다 적다면, 배터리 증가 코루틴 호출
                if (currentBt < MaxBt) StartCoroutine("PlusCurrentBt");

                // 만약 현재 배터리가 최대 배터리만큼 찼다면, 배터리 증가 코루틴 중지
                else StopCoroutine("PlusCurrentBt");
            }
        }

        // 플레이어 죽음 처리
        else
        {
            if (!die)
            {
                // 죽었다고 표시
                die = true;

                // 체력 감소 코루틴이 실행 중이라면, 체력 감소 코루틴 중지
                StopCoroutine("MinusCurrentHp");
                
                // 인벤에 있던 모든 아이템을 삭제
                Inven.instance.RemoveAll();

                // 죽었을 때 UI를 활성화
                UiManager_.instance.Die();
            }
        }
    }

    // 배터리 증가 함수 => 플레이어가 기지 내부에 있을 때, 빠르게 배터리가 증가하도록 설정한다.
    IEnumerator PlusCurrentBt()
    {
        // plusBattery가 false일 때만 실행
        if (!plusBattery)
        {
            // plusBattery를 true로 설정하여 무한 반복을 방지
            plusBattery = true;

            // 1초 후
            yield return new WaitForSecondsRealtime(1.0f);
            
            // 현재 배터리 10 증가
            currentBt+= 10;

            // 만약, 현재 배터리가 최대 배터리보다 많다면, 현재 배터리를 최대 배터리로 설정
            if(currentBt > MaxBt) currentBt = MaxBt;
            
            // plusBattery를 false로 설정하여 다시 이 코루틴이 실행될 수 있도록 설정
            plusBattery = false;
        }
    }

    // 배터리 감소 함수 => 기본 1분에 1씩 감소하여 플레이어가 기지 외부에서 최대 10분동안 돌아다닐 수 있도록 설정한다.
    IEnumerator MinusCurrentBt()
    {
        // minusBattery가 false일 때만 실행
        if(!minusBattery)
        {
            // minusBattery를 true로 설정하여 무한 반복 방지
            minusBattery = true;

            // 60초 후
            yield return new WaitForSecondsRealtime(1f);

            // 만약 플레이어가 지금 하늘을 날고 있지 않으면, 배터리를 1만 감소시키고, 플레이어가 하늘을 날고 있다면 20을 감소시킴
            if (!PlayerController.instance.isFlying) currentBt--;
            else currentBt -= 20;

            // 현재 배터리가 0 미만이라면, 현재 배터리를 0으로 설정
            if(currentBt < 0) currentBt = 0;

            // minusBattery를 false로 설정하여, 다시 이 코루틴이 실행될 수 있도록 설정
            minusBattery = false;
        }
    }

    // 배터리가 없을 때 체력 감소
    IEnumerator MinusCurrentHp()
    {
        // minusHp가 false일 때만 실행
        if (!minusHp)
        {
            // minusHp를 true로 설정하여 무한 반복 방지
            minusHp = true;

            // 1초 후 
            yield return new WaitForSecondsRealtime(1.0f);

            // 현재 체력 5 감소
            currentHp -= 5;

            // 현재 체력이 0 미만이라면, 현재 체력을 0으로 설정
            if(currentHp < 0) currentHp = 0;

            // minusHp를 false로 설정하여 다시 이 코루틴에 실행될 수 있도록 설정
            minusHp = false;
        }
    }
    
    // 체력 감소 코루틴 => 해금되지 않은 맵을 갔을 때 호출
    IEnumerator MapLockMinusCurrentHP()
    {
        // minusHpMap이 false일 때만 실행
        if (!minusHpMap)
        {
            //minusHpMap을 true로 설정하여 무한 반복 방지
            minusHpMap = true;

            // 체력 10 감소 => 바로 바로 감소되어야 하기 때문에 WaitFor....전에 실행함
            currentHp -= 10;

            // 만약 현재 체력이 0 미만이라면, 현재 체력을 0으로 설정
            if (currentHp < 0) currentHp = 0;

            // 1초 후
            yield return new WaitForSecondsRealtime(1.0f);

            // minusHpMap을 false로 설정하여 다시 이 코루틴에 실행될 수 있도록 설정
            minusHpMap = false;
        }
    }

    // 체력 감소 코루틴 시작 및 중지
    void MapLockMinusHP()
    {
        // 플레이어가 현재 해금되지 않은 맵에 있다면
        if ((PlayerController.instance.isForest && !playerStatus.IsForestUnLock)
             || (PlayerController.instance.isDesert && !playerStatus.IsDesertUnLock)
             || (PlayerController.instance.isCave && !playerStatus.IsCaveUnLock))
            StartCoroutine(MapLockMinusCurrentHP());    // 체력 감소 시작
        else StopCoroutine(MapLockMinusCurrentHP());    // 아니라면, 체력 감소 중지
    }

    // 초기화 함수
    public void Reset()
    {
        currentHp = MaxHp;
        CurrentBt = MaxBt;        
    }
}

using UnityEngine;

public class StatusUi_ : MonoBehaviour
{
    // 스탯매니저를 가져올 변수
    StatusManager statusManager;

    // 현재 각 스탯값
    private UILabel hpLabel;
    private UILabel btLabel;
    private UILabel spLabel;
    private UILabel atkLabel;
    private UILabel gspLabel;

    // 현재 각 스탯들의 강화 상태 값(퍼센트)
    private UILabel hpPercent;
    private UILabel btPercent;
    private UILabel spPercent;
    private UILabel atkPercent;
    private UILabel gspPercent;

    // 현재 각 스탯들의 강화 상태 슬라이더
    private UISprite hpBar;
    private UISprite btBar;
    private UISprite spBar;
    private UISprite atkBar;
    private UISprite gspBar;

    // 현재 총 강화 상태를 숫자로 표시
    private UISprite circle;
    private UILabel upgradeLevel;

    float Hp;
    float Bt;
    float Sp;
    float Atk;
    float Gsp;

    int HpPoint;
    int BtPoint;
    int SpPoint;
    int AtkPoint;
    int GspPoint;

    private void Awake()
    {
        Initialize();
    }

    void Start()
    {
        VariableSetting();
        TextUpdate();
        PercentageUpdate();
        StatLevelGraph();
        CircleValueUpdate();
    }

    void Update()
    {
        VariableSetting();
        TextUpdate();
        PercentageUpdate();
        StatLevelGraph();
        CircleValueUpdate();
    }

    void Initialize()
    {
        statusManager = StatusManager.instance;

        hpLabel = GameObject.Find("NowHpLabel").GetComponent<UILabel>();
        btLabel = GameObject.Find("NowBtLabel").GetComponent<UILabel>();
        spLabel = GameObject.Find("NowSpLabel").GetComponent<UILabel>();
        atkLabel = GameObject.Find("NowAtkLabel").GetComponent<UILabel>();
        gspLabel = GameObject.Find("NowGspLabel").GetComponent<UILabel>();

        hpPercent = GameObject.Find("HpPercentage").GetComponent<UILabel>();
        btPercent = GameObject.Find("BtPercentage").GetComponent<UILabel>();
        spPercent = GameObject.Find("SpPercentage").GetComponent<UILabel>();
        atkPercent = GameObject.Find("AtkPercentage").GetComponent<UILabel>();
        gspPercent = GameObject.Find("GspPercentage").GetComponent<UILabel>();

        hpBar = GameObject.Find("HPFilled").GetComponent<UISprite>();
        btBar = GameObject.Find("BTFilled").GetComponent<UISprite>();
        spBar = GameObject.Find("SPFilled").GetComponent<UISprite>();
        atkBar = GameObject.Find("ATKFilled").GetComponent<UISprite>();
        gspBar = GameObject.Find("GSPFilled").GetComponent<UISprite>();

        circle = GameObject.Find("CircleValue").GetComponent<UISprite>();
        upgradeLevel = GameObject.Find("UpgradeLabel").GetComponent<UILabel>();

    }

    void VariableSetting()
    {
        Hp = statusManager.PlayerStatus.HP;
        Bt = statusManager.PlayerStatus.BT;
        Sp = statusManager.PlayerStatus.SP;
        Atk = statusManager.PlayerStatus.ATK;
        Gsp = statusManager.PlayerStatus.GSP;

        HpPoint = statusManager.PlayerStatus.HpPoint;
        BtPoint = statusManager.PlayerStatus.BtPoint;
        SpPoint = statusManager.PlayerStatus.SpPoint;
        AtkPoint = statusManager.PlayerStatus.AtkPoint;
        GspPoint = statusManager.PlayerStatus.GspPoint;
    }

    void TextUpdate()
    {
        hpLabel.text =  "HP : " + Hp.ToString();
        btLabel.text =  "BT : " + Bt.ToString();
        spLabel.text =  "SP : " + Sp.ToString();
        atkLabel.text = "ATK : " + Atk.ToString();
        gspLabel.text = "GSP : " + Gsp.ToString();
    }

    void PercentageUpdate()
    {
        hpPercent.text = (HpPoint * 20).ToString() + "%";
        btPercent.text = (BtPoint * 20).ToString() + "%";
        spPercent.text = (SpPoint * 20).ToString() + "%";
        atkPercent.text = (AtkPoint * 20).ToString() + "%";
        gspPercent.text = (GspPoint * 20).ToString() + "%";
    }

    void StatLevelGraph()
    {
        hpBar.fillAmount = (float)HpPoint / 5.0f;
        btBar.fillAmount = (float)BtPoint / 5.0f;
        spBar.fillAmount = (float)SpPoint / 5.0f;
        atkBar.fillAmount = (float)AtkPoint / 5.0f;
        gspBar.fillAmount = (float)GspPoint / 5.0f;
    }

    void CircleValueUpdate()
    {
        circle.fillAmount = (float)(HpPoint + BtPoint + SpPoint + AtkPoint + GspPoint)/ 25.0f;
        upgradeLevel.text = (circle.fillAmount * 100).ToString();
    }
}