# puremvc

**Repository Path**: CGzhao/puremvc

## Basic Information

- **Project Name**: puremvc
- **Description**: puremvc
- **Primary Language**: C#
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-09-29
- **Last Updated**: 2025-12-02

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Unity + PureMVC 小 Demo 说明

本项目展示了在 Unity 中使用 PureMVC 完成一次完整的 UI 交互流程：点击界面上的 `Random` 按钮后，通过 `Facade` 分发通知触发 `Command`，`Command` 调用 `Proxy` 更新数据，再由订阅通知的 `Mediator` 更新 UI 文本与滑条。

## 功能概述
- 点击 `hpButton` 后触发 `RandomBtnClick` 通知。
- `HpCommand` 响应通知，调用 `HpProxy.RandomHp()` 生成 0–100 的随机 HP。
- `HpCommand` 发送 `HpChanged` 通知并携带最新 HP。
- `HpMediator` 订阅 `HpChanged`，更新 `hpText` 文本与 `hpSlider` 数值。

## 核心角色
- `Facade`：应用总线，负责注册与分发通知、Command、Proxy、Mediator。
- `Command`：业务命令，收到通知时执行业务逻辑（本例中更新 HP 并转发通知）。
- `Proxy`：数据模型与数据访问层（本例中持有并生成随机 HP）。
- `Mediator`：界面层，订阅通知并更新 UI（本例中更新文本与滑条）。

## 启动与注册
应用启动入口在 `ApplicationMgr.Start`，它会调用 `ApplicationFacade.StartUp()` 完成注册。

```csharp
// Assets/Scripts/Core/ApplicationMgr.cs
public class ApplicationMgr : MonoBehaviour
{
    void Start()
    {
        ApplicationFacade.Instance.StartUp();
    }
}
```

`ApplicationFacade` 负责注册 Command、Proxy、Mediator：

```csharp
// Assets/Scripts/Core/ApplicationFacade.cs
using PureMVC.Patterns.Facade;
using UnityEngine;

public class ApplicationFacade : Facade
{
    public static readonly ApplicationFacade Instance = new ApplicationFacade();

    public void StartUp()
    {
        RegisterCommds();
        RegisterProxys();
        RegisterMediators();
    }

    private void RegisterCommds()
    {
        RegisterCommand("RandomBtnClick", () => new HpCommand());
    }
    
    private void RegisterProxys()
    {
        RegisterProxy(new HpProxy("HpProxy"));
    }
    
    private void RegisterMediators()
    {
        var uiRoot = GameObject.FindGameObjectWithTag("UIRoot");
        RegisterMediator(new HpBtnMediator("HpBtnMediator", uiRoot));
        RegisterMediator(new HpMediator("HpMediator", uiRoot));
    }
}
```

## 交互时序（点击按钮 → 更新数据 → 刷新 UI）
1. `HpBtnMediator` 在构造时找到 `hpButton` 并监听点击，点击后通过 `Facade` 发送 `RandomBtnClick` 通知。
2. `HpCommand` 被注册到 `RandomBtnClick`，执行时获取 `HpProxy` 并调用 `RandomHp()` 更新数据；随后再发送 `HpChanged` 通知并携带最新 HP。
3. `HpMediator` 订阅并处理 `HpChanged`，将文本更新为 `HP: <值>`，并将滑条设置为 `hp / 100f`。

### 按钮 → 通知（Mediator 发起）
```csharp
// Assets/Scripts/Core/HpBtnMediator.cs
using PureMVC.Patterns.Mediator;
using UnityEngine;
using UnityEngine.UI;

public class HpBtnMediator : Mediator
{
    private Button _randomBtn;

    public HpBtnMediator(string mediatorName, object viewComponent = null) : base(mediatorName, viewComponent)
    {
        _randomBtn = ((GameObject)viewComponent).transform.Find("hpButton").GetComponent<Button>();
        _randomBtn.onClick.AddListener(OnRandomBtnClick);
    }
    
    private void OnRandomBtnClick()
    {
        ApplicationFacade.Instance.SendNotification("RandomBtnClick");
    }
}
```

### 业务执行与转发（Command 调用 Proxy 并分发结果）
```csharp
// Assets/Scripts/Core/HpCommand.cs
using PureMVC.Interfaces;
using PureMVC.Patterns.Command;

public class HpCommand : SimpleCommand
{
    public override void Execute(INotification notification)
    {
        base.Execute(notification);
        switch (notification.Name)
        {
            case "RandomBtnClick":
                HpProxy hpProxy = ApplicationFacade.Instance.RetrieveProxy("HpProxy") as HpProxy;
                hpProxy.RandomHp();
                float hp = hpProxy.Hp;
                ApplicationFacade.Instance.SendNotification("HpChanged", hp);
                break;
        }
    }
}
```

### 数据层（Proxy 持有并生成随机 HP）
```csharp
// Assets/Scripts/Core/HpProxy.cs
using PureMVC.Patterns.Proxy;
using UnityEngine;

public class HpProxy : Proxy
{
    private float _hp = 99;
    public float Hp
    {
        get { return _hp; }
    }

    public HpProxy(string proxyName, object data = null) : base(proxyName, data) {}
    
    public void RandomHp()
    {
        _hp = Random.Range(0, 100);
    }
}
```

### UI 更新（Mediator 订阅通知并刷新 UI）
```csharp
// Assets/Scripts/Core/HpMediator.cs
using System.Collections.Generic;
using PureMVC.Patterns.Mediator;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

public class HpMediator : Mediator
{
    private TMP_Text _hpText;
    private Slider _hpSlider;

    public HpMediator(string mediatorName, object viewComponent = null) : base(mediatorName, viewComponent)
    {
        _hpText = ((GameObject)viewComponent).transform.Find("hpText").GetComponent<TMP_Text>();
        _hpSlider = ((GameObject)viewComponent).transform.Find("hpSlider").GetComponent<Slider>();
    }
    
    public override string[] ListNotificationInterests()
    {
        IList<string> interests = new List<string>();
        interests.Add("HpChanged");
        return interests.ToArray();
    }
    
    public override void HandleNotification(PureMVC.Interfaces.INotification notification)
    {
        switch (notification.Name)
        {
            case "HpChanged":
                float hp = (float)notification.Body;
                _hpText.text = "HP: " + hp.ToString("F0");
                _hpSlider.value = hp / 100f;
                break;
        }
    }
}
```

## 场景与 UI 要求
- `UIRoot`：场景中需有一个打上 `UIRoot` 标签的根对象，`Facade` 会用它作为视图挂载点。
- 子节点命名：在 `UIRoot` 下需存在以下节点并挂有对应组件：
  - `hpButton`（`Button`）
  - `hpText`（`TMP_Text`）
  - `hpSlider`（`Slider`）
  - （扩展）`hpResetButton`（`Button`）

## 如何运行
- 在任意场景对象上挂载 `ApplicationMgr` 组件。
- 确保 `UIRoot` 以及其子节点 `hpButton`、`hpText`、`hpSlider` 命名与组件正确。
- 运行场景，点击 `hpButton` 即可看到 HP 文本与滑条变化。

（扩展）如果你添加了 `hpResetButton`，点击它将重置 HP 为 100 并刷新 UI。

## 扩展建议
- 新增按钮与数据：为新的按钮定义通知，新增 `Command` 与 `Proxy` 方法，`Mediator` 订阅并更新 UI。
- 解耦与常量化：将通知名（如 `RandomBtnClick`、`HpChanged`）集中到常量类，降低硬编码风险。

---

## 扩展实现：通知常量与重置按钮

为降低字符串硬编码风险，新增通知常量类，并实现重置按钮流程（将 HP 重置为 100）：

### 通知常量集中化
```csharp
// Assets/Scripts/Core/Notifications.cs
public static class Notifications
{
    public const string RandomBtnClick = "RandomBtnClick";
    public const string ResetBtnClick = "ResetBtnClick";
    public const string HpChanged = "HpChanged";
}
```

### Facade 注册新增通知
```csharp
// Assets/Scripts/Core/ApplicationFacade.cs（片段）
private void RegisterCommds()
{
    RegisterCommand(Notifications.RandomBtnClick, () => new HpCommand());
    RegisterCommand(Notifications.ResetBtnClick, () => new HpCommand());
}
```

### Command 扩展处理逻辑
```csharp
// Assets/Scripts/Core/HpCommand.cs（片段）
public override void Execute(INotification notification)
{
    base.Execute(notification);
    switch (notification.Name)
    {
        case Notifications.RandomBtnClick:
            var hpProxy = ApplicationFacade.Instance.RetrieveProxy("HpProxy") as HpProxy;
            hpProxy.RandomHp();
            ApplicationFacade.Instance.SendNotification(Notifications.HpChanged, hpProxy.Hp);
            break;
        case Notifications.ResetBtnClick:
            var hpProxy2 = ApplicationFacade.Instance.RetrieveProxy("HpProxy") as HpProxy;
            hpProxy2.ResetHp();
            ApplicationFacade.Instance.SendNotification(Notifications.HpChanged, hpProxy2.Hp);
            break;
    }
}
```

### Proxy 新增方法
```csharp
// Assets/Scripts/Core/HpProxy.cs（片段）
public void ResetHp()
{
    _hp = 100f;
}
```

### Mediator 支持两个按钮（安全查找）
```csharp
// Assets/Scripts/Core/HpBtnMediator.cs（片段）
private Button _randomBtn;
private Button _resetBtn;

public HpBtnMediator(string mediatorName, object viewComponent = null) : base(mediatorName, viewComponent)
{
    var root = ((GameObject)viewComponent).transform;
    var randomBtnTf = root.Find("hpButton");
    if (randomBtnTf != null)
    {
        _randomBtn = randomBtnTf.GetComponent<Button>();
        _randomBtn.onClick.AddListener(OnRandomBtnClick);
    }
    var resetBtnTf = root.Find("hpResetButton");
    if (resetBtnTf != null)
    {
        _resetBtn = resetBtnTf.GetComponent<Button>();
        _resetBtn.onClick.AddListener(OnResetBtnClick);
    }
}

private void OnRandomBtnClick()
{
    ApplicationFacade.Instance.SendNotification(Notifications.RandomBtnClick);
}

private void OnResetBtnClick()
{
    ApplicationFacade.Instance.SendNotification(Notifications.ResetBtnClick);
}
```

### Mediator 订阅通知（保持不变，改用常量）
```csharp
// Assets/Scripts/Core/HpMediator.cs（片段）
public override string[] ListNotificationInterests()
{
    return new[]{ Notifications.HpChanged };
}

public override void HandleNotification(PureMVC.Interfaces.INotification notification)
{
    switch (notification.Name)
    {
        case Notifications.HpChanged:
            float hp = (float)notification.Body;
            _hpText.text = "HP: " + hp.ToString("F0");
            _hpSlider.value = hp / 100f;
            break;
    }
}
```

## 流程图（Mermaid）
```mermaid
flowchart TD
    subgraph Random Flow
        A[hpButton 点击] --> B[HpBtnMediator\nSendNotification(RandomBtnClick)]
        B --> C[Facade 分发到 HpCommand]
        C --> D[HpProxy.RandomHp()]
        D --> E[Facade.SendNotification(HpChanged, hp)]
        E --> F[HpMediator.HandleNotification(HpChanged)]
        F --> G[更新 hpText 与 hpSlider]
    end

    subgraph Reset Flow
        A2[hpResetButton 点击] --> B2[HpBtnMediator\nSendNotification(ResetBtnClick)]
        B2 --> C
        C --> D2[HpProxy.ResetHp()]
        D2 --> E
    end
```