MVP

using UnityEngine;

namespace Patterns.Architectural.MVP
{
    /// <summary>
    /// Builds the triad for the shop screen: creates the Model, finds the
    /// View in the scene and hands both to a new Presenter.
    /// </summary>
    public class InventoryBootstrap : MonoBehaviour
    {
        [SerializeField] private InventoryView view;
        [SerializeField] private int startingGold = 50;

        private InventoryPresenter presenter;

        private void Start()
        {
            var model = new InventoryModel(startingGold);
            presenter = new InventoryPresenter(model, view);
        }

        private void OnDestroy()
        {
            presenter?.Dispose();
            presenter = null;
        }
    }
}

using System;
using System.Collections.Generic;

namespace Patterns.Architectural.MVP
{
    /// <summary>
    /// The Model: pure C#, no UnityEngine dependency. Owns state and rules
    /// and announces every change through an event.
    /// </summary>
    public class InventoryModel
    {
        private readonly List<string> items = new();

        public int Gold { get; private set; }
        public IReadOnlyList<string> Items => items;
        public int Capacity { get; } = 6;

        public event Action Changed;

        public InventoryModel(int startingGold) => Gold = startingGold;

        public void AddGold(int amount)
        {
            if (amount <= 0) return;
            Gold += amount;
            Changed?.Invoke();
        }

        public bool TryBuy(string itemId, int price)
        {
            if (Gold < price || items.Count >= Capacity)
                return false;

            Gold -= price;
            items.Add(itemId);
            Changed?.Invoke();
            return true;
        }
    }
}

using System;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

namespace Patterns.Architectural.MVP
{
    /// <summary>
    /// The View: owns UI references, forwards clicks as events and draws
    /// whatever it is told to. It never sees the Model.
    /// </summary>
    public class InventoryView : MonoBehaviour
    {
        [SerializeField] private Button buyButton;
        [SerializeField] private Button addGoldButton;
        [SerializeField] private TMP_Text goldLabel;
        [SerializeField] private TMP_Text itemsLabel;
        [SerializeField] private TMP_Text feedbackLabel;

        public event Action BuyClicked;
        public event Action AddGoldClicked;

        private void OnEnable()
        {
            buyButton.onClick.AddListener(OnBuy);
            addGoldButton.onClick.AddListener(OnAddGold);
        }

        private void OnDisable()
        {
            buyButton.onClick.RemoveListener(OnBuy);
            addGoldButton.onClick.RemoveListener(OnAddGold);
        }

        private void OnBuy() => BuyClicked?.Invoke();
        private void OnAddGold() => AddGoldClicked?.Invoke();

        public void Render(int gold, IReadOnlyList<string> items, bool canBuy)
        {
            goldLabel.text = $"{gold} g";
            itemsLabel.text = items.Count == 0 ? "(empty)" : string.Join(", ", items);
            buyButton.interactable = canBuy;
        }

        public void ShowFeedback(string message) => feedbackLabel.text = message;
    }
}

using System;

namespace Patterns.Architectural.MVP
{
    /// <summary>
    /// The Presenter: translates View events into Model calls and Model
    /// changes into View renders. The only class that knows both sides.
    /// </summary>
    public class InventoryPresenter : IDisposable
    {
        private const string PotionId = "Potion";
        private const int PotionPrice = 30;
        private const int GoldPerClick = 25;

        private readonly InventoryModel model;
        private readonly InventoryView view;

        public InventoryPresenter(InventoryModel model, InventoryView view)
        {
            this.model = model;
            this.view = view;

            view.BuyClicked += HandleBuy;
            view.AddGoldClicked += HandleAddGold;
            model.Changed += Refresh;

            Refresh();
        }

        private void HandleBuy()
        {
            if (!model.TryBuy(PotionId, PotionPrice))
                view.ShowFeedback("Not enough gold or bag is full.");
        }

        private void HandleAddGold() => model.AddGold(GoldPerClick);

        private void Refresh()
        {
            bool canBuy = model.Gold >= PotionPrice && model.Items.Count < model.Capacity;
            view.Render(model.Gold, model.Items, canBuy);
        }

        public void Dispose()
        {
            view.BuyClicked -= HandleBuy;
            view.AddGoldClicked -= HandleAddGold;
            model.Changed -= Refresh;
        }
    }
}