[同事A] ────> [中介者] <─── [同事B]
    ↑____________|____________↑

// 中介者接口
public interface IMediator
{
    void Notify(object sender, string ev);
}

// 基礎(chǔ)同事類
public abstract class Colleague
{
    protected IMediator _mediator;

    public Colleague(IMediator mediator)
    {
        _mediator = mediator;
    }
}

// 具體同事A
public class ConcreteColleagueA : Colleague
{
    public ConcreteColleagueA(IMediator mediator) : base(mediator) { }

    public void DoA()
    {
        Console.WriteLine("ColleagueA does A.");
        _mediator.Notify(this, "A");
    }

    public void DoB()
    {
        Console.WriteLine("ColleagueA does B.");
    }
}

// 具體同事B
public class ConcreteColleagueB : Colleague
{
    public ConcreteColleagueB(IMediator mediator) : base(mediator) { }

    public void DoC()
    {
        Console.WriteLine("ColleagueB does C.");
        _mediator.Notify(this, "C");
    }

    public void DoD()
    {
        Console.WriteLine("ColleagueB does D.");
    }
}

// 具體中介者
public class ConcreteMediator : IMediator
{
    private ConcreteColleagueA _colleagueA;
    private ConcreteColleagueB _colleagueB;

    public ConcreteColleagueA ColleagueA
    {
        set { _colleagueA = value; }
    }

    public ConcreteColleagueB ColleagueB
    {
        set { _colleagueB = value; }
    }

    public void Notify(object sender, string ev)
    {
        if (ev == "A")
        {
            Console.WriteLine("Mediator reacts on A and triggers:");
            _colleagueB.DoC();
        }
  
        if (ev == "C")
        {
            Console.WriteLine("Mediator reacts on C and triggers:");
            _colleagueA.DoB();
            _colleagueB.DoD();
        }
    }
}

// 客戶端代碼
var mediator = new ConcreteMediator();
var colleagueA = new ConcreteColleagueA(mediator);
var colleagueB = new ConcreteColleagueB(mediator);

mediator.ColleagueA = colleagueA;
mediator.ColleagueB = colleagueB;

Console.WriteLine("Client triggers operation A.");
colleagueA.DoA();

Console.WriteLine();

Console.WriteLine("Client triggers operation C.");
colleagueB.DoC();

// 中介者接口
public interface IChatRoom
{
    void Register(Participant participant);
    void Send(string from, string to, string message);
}

// 具體中介者 - 聊天室
public class ChatRoom : IChatRoom
{
    private Dictionary<string, Participant> _participants = new Dictionary<string, Participant>();

    public void Register(Participant participant)
    {
        if (!_participants.ContainsKey(participant.Name))
        {
            _participants.Add(participant.Name, participant);
        }
        participant.ChatRoom = this;
    }

    public void Send(string from, string to, string message)
    {
        if (_participants.TryGetValue(to, out var participant))
        {
            participant.Receive(from, message);
        }
    }
}

// 同事基類
public abstract class Participant
{
    public string Name { get; }
    public IChatRoom ChatRoom { get; set; }

    protected Participant(string name)
    {
        Name = name;
    }

    public void Send(string to, string message)
    {
        ChatRoom.Send(Name, to, message);
    }

    public abstract void Receive(string from, string message);
}

// 具體同事類
public class User : Participant
{
    public User(string name) : base(name) { }

    public override void Receive(string from, string message)
    {
        Console.WriteLine($"{from} to {Name}: '{message}'");
    }
}

// 使用
var chatRoom = new ChatRoom();

var john = new User("John");
var jane = new User("Jane");

chatRoom.Register(john);
chatRoom.Register(jane);

john.Send("Jane", "Hi Jane!");
jane.Send("John", "Hello John!");

// 航空交通管制中介者接口
public interface IAirTrafficControl
{
    // 注冊(cè)飛機(jī)到管制系統(tǒng)
    void RegisterAircraft(Aircraft aircraft);
  
    // 發(fā)送警告消息（發(fā)送者飛機(jī) + 消息內(nèi)容）
    void SendWarningMessage(Aircraft sender, string message);
}

// 飛機(jī)類（同事類）
public class Aircraft
{
    // 飛機(jī)呼號(hào)（唯一標(biāo)識(shí)）
    public string CallSign { get; }
  
    // 持有對(duì)航空管制中心（中介者）的引用
    private IAirTrafficControl _atc;
  
    // 構(gòu)造函數(shù)：初始化飛機(jī)并注冊(cè)到管制系統(tǒng)
    public Aircraft(string callSign, IAirTrafficControl atc)
    {
        CallSign = callSign;
        _atc = atc;
        _atc.RegisterAircraft(this); // 自動(dòng)注冊(cè)到管制系統(tǒng)
    }
  
    // 發(fā)送警告消息（通過(guò)管制中心轉(zhuǎn)發(fā)）
    public void SendWarning(string message)
    {
        // 不直接聯(lián)系其他飛機(jī)，而是通過(guò)管制中心發(fā)送
        _atc.SendWarningMessage(this, message);
    }
  
    // 接收來(lái)自其他飛機(jī)的警告
    public void ReceiveWarning(string from, string message)
    {
        // 打印接收到的警告信息
        Console.WriteLine($"{CallSign} received from {from}: {message}");
    }
}

// 塔臺(tái)管制中心（具體中介者實(shí)現(xiàn)）
public class Tower : IAirTrafficControl
{
    // 保存所有注冊(cè)的飛機(jī)列表
    private List<Aircraft> _aircrafts = new List<Aircraft>();
  
    // 注冊(cè)飛機(jī)到管制系統(tǒng)
    public void RegisterAircraft(Aircraft aircraft)
    {
        // 防止重復(fù)注冊(cè)
        if (!_aircrafts.Contains(aircraft))
        {
            _aircrafts.Add(aircraft);
        }
    }
  
    // 處理警告消息轉(zhuǎn)發(fā)
    public void SendWarningMessage(Aircraft sender, string message)
    {
        // 遍歷所有已注冊(cè)的飛機(jī)（排除發(fā)送者自己）
        foreach (var aircraft in _aircrafts.Where(a => a != sender))
        {
            // 將消息轉(zhuǎn)發(fā)給其他飛機(jī)
            aircraft.ReceiveWarning(sender.CallSign, message);
        }
    }
}

// 訂單中介者接口
public interface IOrderMediator
{
    // 通知方法：組件通過(guò)此方法與中介者通信
    // sender - 觸發(fā)事件的組件
    // eventType - 事件類型標(biāo)識(shí)
    void Notify(OrderComponent sender, string eventType);
}

// 訂單組件基類（抽象同事類）
public abstract class OrderComponent
{
    // 持有對(duì)中介者的引用
    protected IOrderMediator _mediator;
  
    // 構(gòu)造函數(shù)：注入中介者實(shí)例
    public OrderComponent(IOrderMediator mediator)
    {
        _mediator = mediator;
    }
}

// 庫(kù)存系統(tǒng)（具體同事類）
public class InventorySystem : OrderComponent
{
    // 構(gòu)造函數(shù)：調(diào)用基類構(gòu)造函數(shù)
    public InventorySystem(IOrderMediator mediator) : base(mediator) { }
  
    // 檢查庫(kù)存方法
    public void CheckStock()
    {
        Console.WriteLine("Checking stock...");
        // 通知中介者庫(kù)存已檢查
        _mediator.Notify(this, "StockChecked");
    }
  
    // 更新庫(kù)存方法
    public void UpdateStock()
    {
        Console.WriteLine("Updating stock...");
    }
}

// 支付系統(tǒng)（具體同事類）
public class PaymentSystem : OrderComponent
{
    // 構(gòu)造函數(shù)：調(diào)用基類構(gòu)造函數(shù)
    public PaymentSystem(IOrderMediator mediator) : base(mediator) { }
  
    // 處理支付方法
    public void ProcessPayment()
    {
        Console.WriteLine("Processing payment...");
        // 通知中介者支付已處理
        _mediator.Notify(this, "PaymentProcessed");
    }
}

// 訂單中介者實(shí)現(xiàn)（具體中介者）
public class OrderMediator : IOrderMediator
{
    // 持有庫(kù)存系統(tǒng)引用
    private InventorySystem _inventory;
    // 持有支付系統(tǒng)引用
    private PaymentSystem _payment;
  
    // 構(gòu)造函數(shù)：注入需要的組件
    public OrderMediator(InventorySystem inventory, PaymentSystem payment)
    {
        _inventory = inventory;
        _payment = payment;
    }
  
    // 實(shí)現(xiàn)通知處理方法
    public void Notify(OrderComponent sender, string eventType)
    {
        // 如果是庫(kù)存系統(tǒng)且事件類型為"StockChecked"
        if (sender is InventorySystem && eventType == "StockChecked")
        {
            // 觸發(fā)支付系統(tǒng)處理支付
            _payment.ProcessPayment();
        }
        // 如果是支付系統(tǒng)且事件類型為"PaymentProcessed"
        else if (sender is PaymentSystem && eventType == "PaymentProcessed")
        {
            // 更新庫(kù)存
            _inventory.UpdateStock();
            Console.WriteLine("Order completed!");
        }
    }
}

// 定義事件參數(shù)基類
public abstract class OrderEventArgs : EventArgs
{
    public string EventType { get; set; }
}

// 庫(kù)存系統(tǒng)事件參數(shù)
public class InventoryEventArgs : OrderEventArgs
{
    public int ProductId { get; set; }
    public int Quantity { get; set; }
}

// 支付系統(tǒng)事件參數(shù)
public class PaymentEventArgs : OrderEventArgs
{
    public decimal Amount { get; set; }
    public string PaymentMethod { get; set; }
}

// 訂單組件基類（使用事件）
public abstract class OrderComponent
{
    // 定義事件處理器委托
    public delegate void OrderEventHandler(object sender, OrderEventArgs e);
  
    // 組件事件
    public event OrderEventHandler OnOrderEvent;
  
    // 觸發(fā)事件的方法
    protected void RaiseEvent(OrderEventArgs e)
    {
        OnOrderEvent?.Invoke(this, e);
    }
}

// 庫(kù)存系統(tǒng)實(shí)現(xiàn)
public class InventorySystem : OrderComponent
{
    public void CheckStock(int productId)
    {
        Console.WriteLine($"Checking stock for product {productId}...");
        RaiseEvent(new InventoryEventArgs {
            EventType = "StockChecked",
            ProductId = productId,
            Quantity = 100 // 假設(shè)檢查到有100個(gè)庫(kù)存
        });
    }
  
    public void UpdateStock(int productId, int quantity)
    {
        Console.WriteLine($"Updating stock for product {productId}, quantity: {quantity}");
    }
}

// 支付系統(tǒng)實(shí)現(xiàn)
public class PaymentSystem : OrderComponent
{
    public void ProcessPayment(decimal amount, string method)
    {
        Console.WriteLine($"Processing payment of {amount} via {method}");
        RaiseEvent(new PaymentEventArgs {
            EventType = "PaymentProcessed",
            Amount = amount,
            PaymentMethod = method
        });
    }
}

public class OrderEventCoordinator
{
    private readonly InventorySystem _inventory;
    private readonly PaymentSystem _payment;
  
    public OrderEventCoordinator(InventorySystem inventory, PaymentSystem payment)
    {
        _inventory = inventory;
        _payment = payment;
  
        // 訂閱庫(kù)存系統(tǒng)事件
        _inventory.OnOrderEvent += HandleInventoryEvent;
  
        // 訂閱支付系統(tǒng)事件
        _payment.OnOrderEvent += HandlePaymentEvent;
    }
  
    private void HandleInventoryEvent(object sender, OrderEventArgs e)
    {
        if (e is InventoryEventArgs args && args.EventType == "StockChecked")
        {
            // 庫(kù)存檢查完成后處理支付
            _payment.ProcessPayment(99.99m, "CreditCard");
        }
    }
  
    private void HandlePaymentEvent(object sender, OrderEventArgs e)
    {
        if (e is PaymentEventArgs args && args.EventType == "PaymentProcessed")
        {
            // 支付完成后更新庫(kù)存
            _inventory.UpdateStock(1, -1); // 假設(shè)產(chǎn)品ID為1，減少1個(gè)庫(kù)存
            Console.WriteLine("Order completed!");
        }
    }
}

// 組件基類（使用Action委托）
public abstract class OrderComponent
{
    protected Action<string, object> MediatorCallback { get; }
  
    public OrderComponent(Action<string, object> mediatorCallback)
    {
        MediatorCallback = mediatorCallback;
    }
}

// 庫(kù)存系統(tǒng)
public class InventorySystem : OrderComponent
{
    public InventorySystem(Action<string, object> callback) : base(callback) {}
  
    public void CheckStock(int productId)
    {
        Console.WriteLine($"Checking stock for product {productId}...");
        MediatorCallback?.Invoke("StockChecked", new { ProductId = productId });
    }
  
    public void UpdateStock(int productId, int quantity)
    {
        Console.WriteLine($"Updating stock for product {productId}, quantity: {quantity}");
    }
}

// 支付系統(tǒng)
public class PaymentSystem : OrderComponent
{
    public PaymentSystem(Action<string, object> callback) : base(callback) {}
  
    public void ProcessPayment(decimal amount, string method)
    {
        Console.WriteLine($"Processing payment of {amount} via {method}");
        MediatorCallback?.Invoke("PaymentProcessed", new { Amount = amount, Method = method });
    }
}

// 使用Lambda表達(dá)式作為中介者
public class Program
{
    public static void Main()
    {
        // 創(chuàng)建支付系統(tǒng)并定義其回調(diào)
        var payment = new PaymentSystem((eventType, data) => 
        {
            if (eventType == "PaymentProcessed")
            {
                Console.WriteLine("Payment processed callback");
            }
        });
  
        // 創(chuàng)建庫(kù)存系統(tǒng)并定義完整流程
        var inventory = new InventorySystem((eventType, data) => 
        {
            dynamic eventData = data;
      
            if (eventType == "StockChecked")
            {
                Console.WriteLine($"Stock checked for product {eventData.ProductId}");
                payment.ProcessPayment(99.99m, "CreditCard");
            }
            else if (eventType == "PaymentProcessed")
            {
                inventory.UpdateStock(1, -1);
                Console.WriteLine("Order completed!");
            }
        });
  
        // 啟動(dòng)流程
        inventory.CheckStock(1);
    }
}

// 安裝MediatR NuGet包
// Install-Package MediatR

// 定義事件/通知
public class StockCheckedEvent : INotification
{
    public int ProductId { get; set; }
}

public class PaymentProcessedEvent : INotification
{
    public decimal Amount { get; set; }
}

// 定義處理器
public class StockCheckedHandler : INotificationHandler<StockCheckedEvent>
{
    private readonly IMediator _mediator;
  
    public StockCheckedHandler(IMediator mediator)
    {
        _mediator = mediator;
    }
  
    public async Task Handle(StockCheckedEvent notification, CancellationToken ct)
    {
        Console.WriteLine($"Stock checked for product {notification.ProductId}");
        await _mediator.Publish(new PaymentProcessedEvent { Amount = 99.99m }, ct);
    }
}

public class PaymentProcessedHandler : INotificationHandler<PaymentProcessedEvent>
{
    public Task Handle(PaymentProcessedEvent notification, CancellationToken ct)
    {
        Console.WriteLine($"Payment processed: {notification.Amount}");
        Console.WriteLine("Order completed!");
        return Task.CompletedTask;
    }
}

// 使用示例
var services = new ServiceCollection();
services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));
var provider = services.BuildServiceProvider();

var mediator = provider.GetRequiredService<IMediator>();
await mediator.Publish(new StockCheckedEvent { ProductId = 1 });

using UnityEngine;
using UnityEngine.UI;

// 中介者接口
public interface IUIMediator
{
    void Notify(UIComponent sender, string eventName);
}

// 具體中介者 - UI管理器
public class UIManager : MonoBehaviour, IUIMediator
{
    public Button startButton;
    public Button optionsButton;
    public Button quitButton;
    public GameObject mainMenuPanel;
    public GameObject optionsPanel;
  
    private void Start()
    {
        // 為每個(gè)UI組件設(shè)置中介者引用
        startButton.GetComponent<UIComponent>().SetMediator(this);
        optionsButton.GetComponent<UIComponent>().SetMediator(this);
        quitButton.GetComponent<UIComponent>().SetMediator(this);
  
        // 初始化UI狀態(tài)
        mainMenuPanel.SetActive(true);
        optionsPanel.SetActive(false);
    }
  
    // 處理UI組件通知
    public void Notify(UIComponent sender, string eventName)
    {
        switch (eventName)
        {
            case "StartButtonClicked":
                OnStartGame();
                break;
            case "OptionsButtonClicked":
                OnOpenOptions();
                break;
            case "QuitButtonClicked":
                OnQuitGame();
                break;
            case "BackButtonClicked":
                OnBackToMenu();
                break;
        }
    }
  
    private void OnStartGame()
    {
        Debug.Log("開(kāi)始游戲");
        mainMenuPanel.SetActive(false);
        // 這里可以添加游戲開(kāi)始的邏輯
    }
  
    private void OnOpenOptions()
    {
        Debug.Log("打開(kāi)選項(xiàng)菜單");
        mainMenuPanel.SetActive(false);
        optionsPanel.SetActive(true);
    }
  
    private void OnQuitGame()
    {
        Debug.Log("退出游戲");
        Application.Quit();
    }
  
    private void OnBackToMenu()
    {
        Debug.Log("返回主菜單");
        optionsPanel.SetActive(false);
        mainMenuPanel.SetActive(true);
    }
}

// 同事類 - UI組件基類
public class UIComponent : MonoBehaviour
{
    protected IUIMediator mediator;
  
    // 設(shè)置中介者
    public void SetMediator(IUIMediator mediator)
    {
        this.mediator = mediator;
    }
  
    // 通知中介者
    protected void NotifyMediator(string eventName)
    {
        mediator?.Notify(this, eventName);
    }
}

// 具體同事類 - 開(kāi)始按鈕
public class StartButton : UIComponent
{
    private Button button;
  
    private void Awake()
    {
        button = GetComponent<Button>();
        button.onClick.AddListener(OnClick);
    }
  
    private void OnClick()
    {
        NotifyMediator("StartButtonClicked");
    }
}

// 具體同事類 - 選項(xiàng)按鈕
public class OptionsButton : UIComponent
{
    private Button button;
  
    private void Awake()
    {
        button = GetComponent<Button>();
        button.onClick.AddListener(OnClick);
    }
  
    private void OnClick()
    {
        NotifyMediator("OptionsButtonClicked");
    }
}

// 具體同事類 - 退出按鈕
public class QuitButton : UIComponent
{
    private Button button;
  
    private void Awake()
    {
        button = GetComponent<Button>();
        button.onClick.AddListener(OnClick);
    }
  
    private void OnClick()
    {
        NotifyMediator("QuitButtonClicked");
    }
}

// 具體同事類 - 返回按鈕
public class BackButton : UIComponent
{
    private Button button;
  
    private void Awake()
    {
        button = GetComponent<Button>();
        button.onClick.AddListener(OnClick);
    }
  
    private void OnClick()
    {
        NotifyMediator("BackButtonClicked");
    }
}

using UnityEngine;
using System.Collections.Generic;

// 事件類型枚舉
public enum GameEventType
{
    PlayerDied,
    EnemyKilled,
    ItemCollected,
    LevelCompleted
}

// 中介者接口
public interface IGameEventMediator
{
    void Subscribe(GameEventType eventType, IGameEventSubscriber subscriber);
    void Unsubscribe(GameEventType eventType, IGameEventSubscriber subscriber);
    void Publish(GameEventType eventType, object sender, object eventData);
}

// 具體中介者 - 游戲事件管理器
public class GameEventManager : MonoBehaviour, IGameEventMediator
{
    private Dictionary<GameEventType, List<IGameEventSubscriber>> subscribers = 
        new Dictionary<GameEventType, List<IGameEventSubscriber>>();
  
    // 訂閱事件
    public void Subscribe(GameEventType eventType, IGameEventSubscriber subscriber)
    {
        if (!subscribers.ContainsKey(eventType))
        {
            subscribers[eventType] = new List<IGameEventSubscriber>();
        }
  
        if (!subscribers[eventType].Contains(subscriber))
        {
            subscribers[eventType].Add(subscriber);
        }
    }
  
    // 取消訂閱
    public void Unsubscribe(GameEventType eventType, IGameEventSubscriber subscriber)
    {
        if (subscribers.ContainsKey(eventType))
        {
            subscribers[eventType].Remove(subscriber);
        }
    }
  
    // 發(fā)布事件
    public void Publish(GameEventType eventType, object sender, object eventData)
    {
        if (subscribers.ContainsKey(eventType))
        {
            foreach (var subscriber in subscribers[eventType])
            {
                subscriber.OnEvent(eventType, sender, eventData);
            }
        }
    }
}

// 同事接口 - 事件訂閱者
public interface IGameEventSubscriber
{
    void OnEvent(GameEventType eventType, object sender, object eventData);
}

// 具體同事類 - 玩家控制器
public class PlayerController : MonoBehaviour, IGameEventSubscriber
{
    private IGameEventMediator eventMediator;
    public int health = 100;
  
    private void Start()
    {
        eventMediator = FindObjectOfType<GameEventManager>();
        eventMediator.Subscribe(GameEventType.PlayerDied, this);
    }
  
    private void OnDestroy()
    {
        eventMediator?.Unsubscribe(GameEventType.PlayerDied, this);
    }
  
    public void TakeDamage(int damage)
    {
        health -= damage;
  
        if (health <= 0)
        {
            eventMediator.Publish(GameEventType.PlayerDied, this, null);
        }
    }
  
    public void OnEvent(GameEventType eventType, object sender, object eventData)
    {
        if (eventType == GameEventType.PlayerDied && sender == this)
        {
            Debug.Log("玩家死亡事件處理");
            // 處理玩家死亡邏輯
        }
    }
}

// 具體同事類 - 成就系統(tǒng)
public class AchievementSystem : MonoBehaviour, IGameEventSubscriber
{
    private IGameEventMediator eventMediator;
  
    private void Start()
    {
        eventMediator = FindObjectOfType<GameEventManager>();
        eventMediator.Subscribe(GameEventType.EnemyKilled, this);
        eventMediator.Subscribe(GameEventType.ItemCollected, this);
    }
  
    private void OnDestroy()
    {
        eventMediator?.Unsubscribe(GameEventType.EnemyKilled, this);
        eventMediator?.Unsubscribe(GameEventType.ItemCollected, this);
    }
  
    public void OnEvent(GameEventType eventType, object sender, object eventData)
    {
        switch (eventType)
        {
            case GameEventType.EnemyKilled:
                Debug.Log("成就系統(tǒng): 敵人被擊殺");
                // 更新?lián)魵⒊删?
                break;
            case GameEventType.ItemCollected:
                Debug.Log("成就系統(tǒng): 物品被收集");
                // 更新收集成就
                break;
        }
    }
}

// 具體同事類 - 音頻管理器
public class AudioManager : MonoBehaviour, IGameEventSubscriber
{
    private IGameEventMediator eventMediator;
  
    private void Start()
    {
        eventMediator = FindObjectOfType<GameEventManager>();
        eventMediator.Subscribe(GameEventType.PlayerDied, this);
        eventMediator.Subscribe(GameEventType.LevelCompleted, this);
    }
  
    private void OnDestroy()
    {
        eventMediator?.Unsubscribe(GameEventType.PlayerDied, this);
        eventMediator?.Unsubscribe(GameEventType.LevelCompleted, this);
    }
  
    public void OnEvent(GameEventType eventType, object sender, object eventData)
    {
        switch (eventType)
        {
            case GameEventType.PlayerDied:
                Debug.Log("播放死亡音效");
                // 播放死亡音效
                break;
            case GameEventType.LevelCompleted:
                Debug.Log("播放關(guān)卡完成音效");
                // 播放勝利音效
                break;
        }
    }
}

using UnityEngine;
using System.Collections.Generic;

// 中介者接口
public interface IAIMediator
{
    void RegisterAI(AIEntity ai);
    void UnregisterAI(AIEntity ai);
    void SendMessage(AIEntity sender, string message);
}

// 具體中介者 - AI協(xié)調(diào)器
public class AICoordinator : MonoBehaviour, IAIMediator
{
    private List<AIEntity> aiEntities = new List<AIEntity>();
  
    // 注冊(cè)AI實(shí)體
    public void RegisterAI(AIEntity ai)
    {
        if (!aiEntities.Contains(ai))
        {
            aiEntities.Add(ai);
        }
    }
  
    // 注銷AI實(shí)體
    public void UnregisterAI(AIEntity ai)
    {
        aiEntities.Remove(ai);
    }
  
    // 廣播消息
    public void SendMessage(AIEntity sender, string message)
    {
        foreach (var ai in aiEntities)
        {
            if (ai != sender) // 不發(fā)送給自己
            {
                ai.ReceiveMessage(message);
            }
        }
    }
}

// 同事類 - AI實(shí)體基類
public abstract class AIEntity : MonoBehaviour
{
    protected IAIMediator mediator;
  
    // 設(shè)置中介者
    public void SetMediator(IAIMediator mediator)
    {
        this.mediator = mediator;
        mediator.RegisterAI(this);
    }
  
    // 發(fā)送消息
    protected void SendToOthers(string message)
    {
        mediator?.SendMessage(this, message);
    }
  
    // 接收消息
    public abstract void ReceiveMessage(string message);
  
    private void OnDestroy()
    {
        mediator?.UnregisterAI(this);
    }
}

// 具體同事類 - 守衛(wèi)AI
public class GuardAI : AIEntity
{
    private bool isAlerted = false;
  
    private void Start()
    {
        // 在中介者中注冊(cè)
        SetMediator(FindObjectOfType<AICoordinator>());
    }
  
    // 發(fā)現(xiàn)玩家
    public void SpotPlayer()
    {
        Debug.Log("守衛(wèi)發(fā)現(xiàn)玩家！");
        isAlerted = true;
        SendToOthers("PlayerSpotted");
    }
  
    // 接收消息
    public override void ReceiveMessage(string message)
    {
        if (message == "PlayerSpotted" && !isAlerted)
        {
            Debug.Log("守衛(wèi)收到警報(bào): 玩家被發(fā)現(xiàn)！");
            isAlerted = true;
            // 進(jìn)入警戒狀態(tài)
        }
    }
}

// 具體同事類 - 巡邏AI
public class PatrolAI : AIEntity
{
    private bool isAlerted = false;
  
    private void Start()
    {
        // 在中介者中注冊(cè)
        SetMediator(FindObjectOfType<AICoordinator>());
    }
  
    // 發(fā)現(xiàn)玩家
    public void SpotPlayer()
    {
        Debug.Log("巡邏AI發(fā)現(xiàn)玩家！");
        isAlerted = true;
        SendToOthers("PlayerSpotted");
    }
  
    // 接收消息
    public override void ReceiveMessage(string message)
    {
        if (message == "PlayerSpotted" && !isAlerted)
        {
            Debug.Log("巡邏AI收到警報(bào): 玩家被發(fā)現(xiàn)！");
            isAlerted = true;
            // 改變巡邏路線
        }
    }
}

// 具體同事類 - 狙擊手AI
public class SniperAI : AIEntity
{
    private bool isAlerted = false;
  
    private void Start()
    {
        // 在中介者中注冊(cè)
        SetMediator(FindObjectOfType<AICoordinator>());
    }
  
    // 接收消息
    public override void ReceiveMessage(string message)
    {
        if (message == "PlayerSpotted" && !isAlerted)
        {
            Debug.Log("狙擊手收到警報(bào): 玩家被發(fā)現(xiàn)！準(zhǔn)備狙擊...");
            isAlerted = true;
            // 進(jìn)入狙擊位置
        }
    }
}