ShowMessages.cs

namespace Utils
{
  public class ShowMessages : MonoBehaviour
  {
    [SerializeField]
    private Text _message;

    private TimedQueue<string> queue;

    void Start()
    {
        queue = new TimedQueue<string>(ShowMessage, ShowDefaultMessage);
        queue.Enqueue("one");
        queue.Enqueue("Ha Ha");
        queue.Enqueue("two");
        queue.Enqueue("Ha Ha");
    }

    void Update() 
    {
        queue.Update(Time.deltaTime);
    }
    
    public void ShowMessage(string t)
    {
        _message.text = t;
    }

    public void ShowDefaultMessage()
    {
        _message.text = "default message";
    }
  }
}

TimedQueue.cs

namespace Utils
{
    public class TimedQueue<T>
    {
        private float _dequeueTimer;
        private readonly float _dequeueDelay;

        private float _emptyTimer;
        private readonly float _emptyDelay;

        private readonly Queue<T> _messageQueue = new Queue<T>();

        public delegate void OnMessage(T t);
        private OnMessage _callbackMessage;

        public delegate void OnEmpty();
        private OnEmpty _callbackEmpty;

        public TimedQueue(OnMessage callbackMessage, OnEmpty callbackEmpty, float dequeueDelay = 0.5f, float emptyDelay = 2.0f)
        {
            _callbackMessage = callbackMessage;
            _callbackEmpty = callbackEmpty;

            _dequeueDelay = dequeueDelay;
            _dequeueTimer = dequeueDelay + 0.1f;

            _emptyDelay = emptyDelay;
            _emptyTimer = _emptyDelay + 0.1f;
        }

        public void Update(float deltaTime)
        {
            if (_messageQueue.Count > 0)
            {
                _emptyTimer = 0;
                if (_dequeueTimer > _dequeueDelay)
                {
                    _callbackMessage(_messageQueue.Dequeue());
                    _dequeueTimer = 0;
                }
                _dequeueTimer += deltaTime;
            }
            else
            {
                if (_emptyTimer < _emptyDelay)
                {
                    _emptyTimer += deltaTime;
                    if (_emptyTimer > _emptyDelay)
                    {
                       _callbackEmpty();
                    }
                }
            }
        }

        public void Enqueue(T t)
        {
            _messageQueue.Enqueue(t);
            _emptyTimer = 0.0f;
        }
    }
}