Mediator

using UnityEngine;

namespace Patterns.Behavioral.Mediator
{
    /// <summary>
    /// Client: asks individual aircraft to land. All coordination
    /// happens inside the ControlTower.
    /// </summary>
    public class AirportDemo : MonoBehaviour
    {
        [SerializeField] private Aircraft[] aircraft;

        private void Update()
        {
            for (int i = 0; i < aircraft.Length && i < 9; i++)
            {
                // Keys 1..9 request landing for each plane.
                if (Input.GetKeyDown(KeyCode.Alpha1 + i))
                    aircraft[i].TryLand();
            }
        }
    }
}

namespace Patterns.Behavioral.Mediator
{
    /// <summary>
    /// The mediator contract. Aircraft only ever see this interface,
    /// never each other.
    /// </summary>
    public interface IAirTrafficMediator
    {
        void Register(Aircraft aircraft);
        void Unregister(Aircraft aircraft);

        /// <summary>Asks for the runway. Returns true if landing is cleared.</summary>
        bool RequestLanding(Aircraft aircraft);

        /// <summary>Called by the aircraft once it has vacated the runway.</summary>
        void ReportRunwayClear(Aircraft aircraft);
    }
}

using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Behavioral.Mediator
{
    /// <summary>
    /// Concrete mediator. Owns the shared runway rule and relays
    /// status messages to every other registered aircraft.
    /// </summary>
    public class ControlTower : MonoBehaviour, IAirTrafficMediator
    {
        private readonly List<Aircraft> fleet = new();
        private Aircraft onRunway;

        public void Register(Aircraft aircraft)
        {
            if (!fleet.Contains(aircraft))
                fleet.Add(aircraft);
        }

        public void Unregister(Aircraft aircraft)
        {
            fleet.Remove(aircraft);
            if (onRunway == aircraft)
                onRunway = null;
        }

        public bool RequestLanding(Aircraft aircraft)
        {
            if (onRunway != null)
            {
                Debug.Log($"Tower: {aircraft.CallSign}, hold. Runway occupied by {onRunway.CallSign}.");
                return false;
            }

            onRunway = aircraft;
            Broadcast(aircraft, $"{aircraft.CallSign} is landing. Hold your position.");
            return true;
        }

        public void ReportRunwayClear(Aircraft aircraft)
        {
            if (onRunway != aircraft) return;

            onRunway = null;
            Broadcast(aircraft, "Runway is clear.");
        }

        private void Broadcast(Aircraft sender, string message)
        {
            foreach (Aircraft other in fleet)
            {
                if (other != sender)
                    other.Receive(message);
            }
        }
    }
}

using System.Collections;
using UnityEngine;

namespace Patterns.Behavioral.Mediator
{
    /// <summary>
    /// Colleague. Knows the tower, never another aircraft.
    /// </summary>
    public class Aircraft : MonoBehaviour
    {
        [SerializeField] private string callSign = "UA-101";
        [SerializeField] private ControlTower tower;
        [SerializeField] private float landingDuration = 3f;

        public string CallSign => callSign;
        public bool IsLanding { get; private set; }

        private IAirTrafficMediator Mediator => tower;

        private void OnEnable() => Mediator.Register(this);
        private void OnDisable() => Mediator.Unregister(this);

        public void TryLand()
        {
            if (IsLanding) return;

            if (Mediator.RequestLanding(this))
                StartCoroutine(LandRoutine());
        }

        public void Receive(string message)
        {
            Debug.Log($"{callSign} hears tower: {message}");
        }

        private IEnumerator LandRoutine()
        {
            IsLanding = true;
            yield return new WaitForSeconds(landingDuration);
            IsLanding = false;
            Mediator.ReportRunwayClear(this);
        }
    }
}