设计模式 是指在软件开发中为解决常见问题而总结出的一套 可复用的解决方案。这些模式是经过长期实践证明有效的 编程经验总结，并可以在不同的项目中复用。设计模式并不是代码片段，而是对常见问题的 抽象解决方案，它提供了代码结构和模块间交互的一种设计思路，帮助开发者解决特定的设计问题。

设计模式的特点：

通用性：设计模式针对的是软件开发中常见的设计问题，适用于各种软件工程项目。
可复用性：设计模式可以在不同项目和环境下被重复使用，提高代码的可维护性和扩展性。
可扩展性：设计模式有助于让代码结构更加灵活，易于扩展和修改。
模块化：通过设计模式，可以减少代码的耦合性，增强模块间的独立性。
提高沟通效率：设计模式为开发者提供了一种通用的设计语言，使得团队成员能够快速理解并讨论设计方案。

二、状态模式（State Pattern）

状态模式（State Pattern） 是一种行为型设计模式，它允许一个对象在其内部状态发生改变时改变其行为。状态模式将与状态相关的行为封装在独立的状态类中，系统在运行时根据状态的变化来切换不同的行为。

通过状态模式，状态转换和行为执行得到了很好的分离，符合面向对象设计的单一职责原则，即每个类只负责一项具体的职责。

状态模式的结构

上下文类（Context Class）：维护当前状态的引用，负责在运行时根据状态的变化调用不同的状态类的行为。
状态接口（State Interface）：定义状态类的共同行为，这通常是一个抽象类或接口。
具体状态类（Concrete State Class）：实现状态接口，提供每个状态下具体的行为。

1、什么时候使用状态模式

对象的行为依赖于状态变化时，并且行为会随着状态的不同而发生变化。
对象的状态变化频繁，而且状态之间的切换逻辑复杂，状态模式可以很好地管理这些状态。
状态转换具有规律性，每个状态都有固定的行为模式或规则，状态模式可以简化这种逻辑。
需要避免使用大量条件判断来实现不同状态下的行为时，状态模式是一个更优雅的解决方案。

2、使用状态模式的好处

简化条件判断逻辑：通过将状态转换逻辑封装到各个具体状态类中，状态模式避免了大量的 if-else 或 switch 语句，代码更清晰。
增强系统的扩展性：状态模式将状态相关的行为封装到独立的类中，因此添加新的状态或修改现有状态的行为不会影响其他代码，符合开闭原则。
使状态行为与上下文解耦：上下文类仅负责状态的切换，而具体的行为由状态类来实现，保持了上下文类的简洁。
提高代码可维护性：状态类各自独立，便于测试、调试和维护。

3、使用状态模式时的注意事项

状态类的数量增加：状态模式的一个潜在问题是状态类的数量可能会随着状态的增多而增加，导致类过多。此时需要评估是否有必要使用状态模式，还是可以通过其他方式优化。
上下文和状态类的依赖：虽然状态模式将状态行为独立出来，但状态类与上下文之间的相互引用可能导致依赖复杂性，需要控制好状态类的职责。
状态转换规则复杂时：如果状态之间的转换规则非常复杂，可能需要将转换逻辑从具体状态类中抽离，避免具体状态类中的代码变得过于庞大。

三、在 Unity 中使用状态模式

在 Unity 中，状态模式可以很好地用于角色的状态管理，例如角色的运动状态、攻击状态、死亡状态等。我们可以通过状态模式将这些行为封装在不同的状态类中，使得角色能够根据当前状态动态切换行为。

下面我们使用状态模式，实现一个角色可以在站立、行走、奔跑和跳跃状态之间切换的示例，基于 Unity 的 3D 环境。

参考类图如下：

1、定义状态接口

我们首先定义一个接口 ICharacterState，每个具体的状态类都需要实现该接口。

public interface ICharacterState
{
    void HandleInput(Character character);
    void UpdateState(Character character);
}

2、具体状态类

根据不同的角色状态（站立、行走、奔跑、跳跃），我们为每个状态创建一个具体的类。每个状态类都实现了 ICharacterState 接口。

using UnityEngine;

// 站立状态类
public class StandState : ICharacterState
{
    public void HandleInput(Character character)
    {
        if (Input.GetKeyDown(KeyCode.W))
        {
            character.SetState(new WalkState());
        }
    }

    public void UpdateState(Character character)
    {
        Debug.Log("角色正在站立");
    }
}

// 行走状态类
public class WalkState : ICharacterState
{
    public void HandleInput(Character character)
    {
        if (Input.GetKeyDown(KeyCode.R))
        {
            character.SetState(new RunState());
        }
        else if (Input.GetKeyDown(KeyCode.Space))
        {
            character.SetState(new JumpState());
        }
    }

    public void UpdateState(Character character)
    {
        character.transform.Translate(Vector3.forward * 2f * Time.deltaTime);
        Debug.Log("角色正在行走");
    }
}

// 奔跑状态类
public class RunState : ICharacterState
{
    public void HandleInput(Character character)
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            character.SetState(new JumpState());
        }
    }

    public void UpdateState(Character character)
    {
        character.transform.Translate(Vector3.forward * 5f * Time.deltaTime);
        Debug.Log("角色正在奔跑");
    }
}

// 跳跃状态类
public class JumpState : ICharacterState
{
    public void HandleInput(Character character)
    {
        // 空中不允许其他输入
    }

    public void UpdateState(Character character)
    {
        character.transform.Translate(Vector3.up * 5f * Time.deltaTime);
        Debug.Log("角色正在跳跃");
        // 跳跃结束后返回站立状态
        character.SetState(new StandState());
    }
}

3、上下文类

接下来定义上下文类 Character，它维护当前的状态，并通过 SetState() 方法进行状态的切换。

using UnityEngine;

public class Character : MonoBehaviour
{
    private ICharacterState currentState;

    void Start()
    {
        // 初始化状态为站立
        currentState = new StandState();
    }

    void Update()
    {
        // 处理输入并更新状态
        currentState.HandleInput(this);
        currentState.UpdateState(this);
    }

    // 切换状态
    public void SetState(ICharacterState newState)
    {
        currentState = newState;
    }
}

4、使用场景中的角色

在 Unity 场景中，我们可以将此状态系统应用到一个角色对象上，比如一个 3D 模型。使用状态模式，角色将根据输入切换行为，比如从站立到行走，再到奔跑或跳跃。

创建一个新的脚本 GameController 来管理和初始化角色。

using UnityEngine;

public class GameController : MonoBehaviour
{
    public GameObject characterPrefab;
    private Character character;

    void Start()
    {
        // 初始化角色对象
        GameObject characterObject = Instantiate(characterPrefab);
        character = characterObject.AddComponent<Character>();
    }

    
}

5、在 Unity 中运行

创建一个空的 Unity 场景，放置一个 3D 角色（立方体、模型等）作为 characterPrefab。
添加 Character 和 GameController 脚本到 Unity 场景。
在游戏运行时，角色会根据键盘输入（W 切换到行走状态，R 切换到奔跑状态，空格键切换到跳跃状态）来切换不同的行为。

6、示例分析

初始状态为站立：当游戏开始时，角色默认处于站立状态。此时控制台输出“角色正在站立”，并且没有移动。
切换到行走状态：当玩家按下 W 键时，角色进入行走状态，角色开始向前移动，控制台输出“角色正在行走”。
切换到奔跑状态：按下 R 键，角色从行走状态切换到奔跑状态，移动速度加快，控制台输出“角色正在奔跑”。
切换到跳跃状态：按下空格键，角色进入跳跃状态，角色向上移动，跳跃结束后角色自动返回站立状态。

状态模式在 Unity 中非常适用于处理角色的状态转换。例如，角色的运动状态、游戏中的敌人 AI 状态等。通过将每个状态的行为封装成独立的类，我们可以灵活地进行状态切换并保持代码结构的清晰与可扩展性。

简化了复杂的状态管理：避免使用大量的 if-else 或 switch-case 语句，减少了冗余代码。
高可扩展性：当需要添加新的状态时，只需要新建一个状态类即可，不会影响现有的代码。
增强了代码的可维护性：各个状态之间相互独立，符合单一职责原则，每个状态类只负责处理特定状态下的行为。

四、观察者模式（Observer Pattern）

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象之间的一对多依赖关系。当一个对象的状态发生变化时，它的所有依赖者（观察者）都会收到通知并自动更新。这种模式用于事件处理系统，当某个对象发生改变时，依赖该对象的其他对象能够及时响应。

在观察者模式中，主要有两个角色：

被观察者（Subject）：状态发生变化的对象，它维护了一组观察者列表，并在状态发生变化时通知它们。
观察者（Observer）：依赖被观察者的对象，它注册到被观察者上，并在被观察者状态变化时得到通知。

1、什么时候使用观察者模式

事件系统：需要实现基于事件驱动的系统，许多 UI 系统使用观察者模式来处理按钮点击、值变化等事件。
数据同步：当某个对象的状态改变时，依赖它的其他对象需要同步更新。
系统中存在一对多的依赖关系：例如，一个对象的变化需要通知多个对象做出反应，典型的例子包括股票价格变化通知、新闻订阅系统等。
通知机制：在某些情况下，多个模块需要接收到某个变化的信息（如游戏事件、社交媒体通知等）。

2、使用观察者模式的好处

解耦合：观察者和被观察者之间的耦合度低。被观察者只知道观察者实现了某些接口，而无需了解它们的具体实现细节。
灵活性：可以动态添加或移除观察者，系统的扩展性好。
提高代码的可维护性：将状态的变化与相应的反应分开，使代码更易于维护和修改。
响应式更新：观察者模式允许系统中的多个对象自动响应某个对象的状态变化，无需显式调用每个依赖对象。

3、使用时的注意事项

性能问题：当观察者数量过多时，每次状态改变都需要通知所有观察者，这可能会引起性能问题。
避免循环依赖：如果观察者在更新过程中再次触发了被观察者的通知，可能会导致循环调用或死锁。
顺序问题：多个观察者对同一事件做出响应时，要注意观察者之间的顺序依赖，可能会导致某些观察者未按预期更新。
内存泄漏问题：要确保观察者可以正确地从被观察者中移除，以避免内存泄漏问题。

五、在 Unity 中使用观察者模式

为了演示如何在 Unity 中使用 观察者模式，我们将实现一个示例：当玩家接触到一个触发器（Trigger）时，游戏会通知观察者更新，例如改变颜色、显示文本等。这个示例将演示如何使用观察者模式管理多个对象对玩家触发事件做出反应。

参考类图如下：

1、定义观察者接口

首先，我们定义一个观察者接口，所有的观察者类都需要实现这个接口。

public interface IObserver
{
    void OnNotify();
}

2、定义被观察者类

然后我们定义一个被观察者类。在这个示例中，被观察者是一个触发器，当玩家接触触发器时，它会通知所有观察者。

using System.Collections.Generic;
using UnityEngine;

public class TriggerSubject : MonoBehaviour
{
    private List<IObserver> observers = new List<IObserver>();

    // 注册观察者
    public void RegisterObserver(IObserver observer)
    {
        observers.Add(observer);
    }

    // 移除观察者
    public void RemoveObserver(IObserver observer)
    {
        observers.Remove(observer);
    }

    // 通知所有观察者
    public void NotifyObservers()
    {
        foreach (IObserver observer in observers)
        {
            observer.OnNotify();
        }
    }

    // Unity 的触发器事件，当玩家接触触发器时调用
    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            NotifyObservers();
        }
    }
}

3、实现观察者类

接下来我们创建几个不同的观察者类，每个观察者类会响应触发器的通知。在这个例子中，我们将创建两个观察者：

一个会改变颜色
一个会显示文本

3.1 观察者 1：改变颜色的观察者

using UnityEngine;

public class ColorObserver : MonoBehaviour, IObserver
{
    public Renderer objectRenderer;

    public void OnNotify()
    {
        // 随机改变对象的颜色
        objectRenderer.material.color = new Color(Random.value, Random.value, Random.value);
        Debug.Log("ColorObserver: Color changed!");
    }
}

3.2 观察者 2：显示文本的观察者

using UnityEngine;
using UnityEngine.UI;

public class TextObserver : MonoBehaviour, IObserver
{
    public Text messageText;

    public void OnNotify()
    {
        // 显示通知文本
        messageText.text = "Player triggered the event!";
        Debug.Log("TextObserver: Text updated!");
    }
}

4、在场景中使用观察者模式

现在我们在 Unity 场景中设置以下内容：

创建一个空的 GameObject，命名为 Trigger，并将 TriggerSubject 脚本附加到该对象上。同时，在该对象上添加一个 BoxCollider，并勾选 Is Trigger。
创建两个 3D 物体（如立方体或球体），并附加 ColorObserver 脚本到其中一个物体，记得将 objectRenderer 变量拖入到 Inspector 中。
创建一个 UI 文本，附加 TextObserver 脚本，并将 messageText 变量拖入 Inspector。
在游戏的 Start() 函数中，注册观察者。

using UnityEngine;

public class GameManager : MonoBehaviour
{
    public TriggerSubject triggerSubject;
    public ColorObserver colorObserver;
    public TextObserver textObserver;

    void Start()
    {
        // 注册观察者
        triggerSubject.RegisterObserver(colorObserver);
        triggerSubject.RegisterObserver(textObserver);
    }

    void OnDestroy()
    {
        // 在销毁时移除观察者，避免内存泄漏
        triggerSubject.RemoveObserver(colorObserver);
        triggerSubject.RemoveObserver(textObserver);
    }
}

5、运行示例

将 GameManager 脚本挂载到 Unity 场景中的一个空对象上。
在 GameManager 中的 Inspector 窗口，将 triggerSubject、colorObserver 和 textObserver 分别拖入相应的字段。
运行游戏，当玩家接触 Trigger 对象时，注册的观察者将会被通知：
- 物体的颜色会发生变化。
- UI 文本会显示 "Player triggered the event!"。

6、示例分析

触发器 (TriggerSubject) 是被观察者，当玩家接触它时，它会调用 NotifyObservers() 方法通知所有的观察者。
观察者 (ColorObserver 和 TextObserver) 实现了 IObserver 接口，并在 OnNotify() 方法中定义了各自的行为。
通过这种设计，任何新增的观察者只需要实现 IObserver 接口，并注册到 TriggerSubject 中，而不需要修改已有的代码。

通过这个示例，我们可以看到如何在 Unity 中运用 观察者模式，处理多个对象对同一事件的响应。这种模式在处理游戏事件、状态变化等场景中十分有用，尤其是在复杂的游戏系统中。

松耦合：观察者和被观察者之间的关系松耦合，被观察者不需要关心观察者的具体实现。
扩展性：可以轻松添加新的观察者，而无需修改被观察者的代码。

六、备忘录模式（Memento Pattern）

备忘录模式（Memento Pattern）是一种行为型设计模式，它允许在不暴露对象内部状态的情况下保存和恢复对象的状态。备忘录模式通常用于需要撤销或恢复操作的场景。模式主要由三个角色组成：

发起人（Originator）：需要保存和恢复状态的对象。
备忘录（Memento）：保存发起人的内部状态的对象。
管理员（Caretaker）：负责管理备忘录的对象，它不对备忘录的内容进行操作，只负责保存和恢复。

1、什么时候使用备忘录模式

撤销操作：当用户需要撤销某个操作，例如文本编辑器中的撤销/重做功能。
游戏存档：在游戏中保存和恢复玩家的状态，例如关卡进度、角色状态等。
复杂状态管理：当对象的状态比较复杂，且需要频繁保存和恢复时。

2、使用备忘录模式的好处

封装性：备忘录模式允许保存对象的状态，而无需暴露其内部结构。
简化状态管理：可以轻松地实现状态的保存和恢复，尤其是在需要实现撤销/重做功能时。
易于实现：对于需要保留状态的对象，备忘录模式提供了一种简单、直观的方式来管理对象的状态。

3、使用时的注意事项

内存使用：备忘录模式可能会消耗大量内存，特别是在需要保存大量状态时。需要合理管理备忘录的数量。
性能问题：频繁的状态保存和恢复可能会影响系统性能。
设计复杂性：虽然备忘录模式提供了良好的封装性，但实现可能会增加系统的复杂性。

七、在 Unity 中使用备忘录模式

为了在 Unity 中演示 备忘录模式，我们将实现一个简单的示例：玩家可以在场景中移动，并能够保存和恢复其位置和生命值的状态。这个示例将展示如何使用备忘录模式管理游戏状态。

参考类图如下：

1、定义备忘录类

首先，我们定义一个备忘录类，用于保存玩家的状态信息（位置和生命值）。

[System.Serializable]
public class PlayerMemento
{
    public Vector3 position;
    public int health;

    public PlayerMemento(Vector3 position, int health)
    {
        this.position = position;
        this.health = health;
    }
}

2、定义发起人类

接下来，我们定义一个 Player 类，它代表玩家，并提供保存和恢复状态的方法。

using UnityEngine;

public class Player : MonoBehaviour
{
    public Vector3 position;
    public int health;

    void Start()
    {
        position = transform.position; // 初始化位置
        health = 100; // 初始化生命值
    }

    // 创建备忘录
    public PlayerMemento CreateMemento()
    {
        return new PlayerMemento(position, health);
    }

    // 从备忘录恢复状态
    public void RestoreMemento(PlayerMemento memento)
    {
        position = memento.position;
        health = memento.health;
        transform.position = position; // 更新实际位置
    }

    void Update()
    {
        // 移动玩家
        float moveSpeed = 5f;
        float moveHorizontal = Input.GetAxis("Horizontal");
        float moveVertical = Input.GetAxis("Vertical");
        Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical) * moveSpeed * Time.deltaTime;
        transform.Translate(movement);

        // 打印当前状态
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Debug.Log($"Current Position: {transform.position}, Health: {health}");
        }
    }

    // 示例：改变生命值
    public void TakeDamage(int damage)
    {
        health -= damage;
        Debug.Log($"Player took damage: {damage}. Current Health: {health}");
    }
}

3、定义管理员类

然后，我们定义一个 GameManager 类，用于管理备忘录的保存和恢复。

using System.Collections.Generic;
using UnityEngine;

public class GameManager : MonoBehaviour
{
    private Player player;
    private List<PlayerMemento> mementoList = new List<PlayerMemento>();
    private int currentStateIndex = -1;

    void Start()
    {
        player = FindObjectOfType<Player>();
    }

    // 保存当前状态
    public void SaveState()
    {
        PlayerMemento memento = player.CreateMemento();
        mementoList.Add(memento);
        currentStateIndex++;
        Debug.Log($"Game state saved! Total states: {mementoList.Count}");
    }

    // 恢复到上一个状态
    public void RestorePreviousState()
    {
        if (currentStateIndex > 0)
        {
            currentStateIndex--;
            player.RestoreMemento(mementoList[currentStateIndex]);
            Debug.Log($"Restored to state {currentStateIndex}!");
        }
        else
        {
            Debug.Log("No previous state to restore!");
        }
    }

    // 恢复到下一个状态
    public void RestoreNextState()
    {
        if (currentStateIndex < mementoList.Count - 1)
        {
            currentStateIndex++;
            player.RestoreMemento(mementoList[currentStateIndex]);
            Debug.Log($"Restored to state {currentStateIndex}!");
        }
        else
        {
            Debug.Log("No next state to restore!");
        }
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.S)) // 按下 S 保存状态
        {
            SaveState();
        }

        if (Input.GetKeyDown(KeyCode.R)) // 按下 R 恢复上一个状态
        {
            RestorePreviousState();
        }

        if (Input.GetKeyDown(KeyCode.N)) // 按下 N 恢复下一个状态
        {
            RestoreNextState();
        }

        if (Input.GetKeyDown(KeyCode.D)) // 按下 D 造成伤害
        {
            player.TakeDamage(10);
        }
    }
}

4、在 Unity 中测试

创建一个空的 GameObject，命名为 GameManager，并附加 GameManager 脚本。
创建一个球体作为玩家对象，附加 Player 脚本。
在 Unity 编辑器中，设置场景，确保玩家对象和游戏管理器在同一场景中。

5、运行示例

在游戏运行时，玩家可以使用以下键来测试备忘录模式：

S：保存当前状态。
R：恢复到上一个保存的状态。
N：恢复到下一个保存的状态。
D：造成 10 点伤害（测试生命值变化）。

6、示例分析

发起人（Player）：玩家的状态可以被保存和恢复。CreateMemento() 方法创建备忘录，RestoreMemento() 方法从备忘录恢复状态。
备忘录（PlayerMemento）：封装了玩家的位置和生命值。
管理员（GameManager）：管理备忘录，允许保存和恢复状态。

通过这个示例，我们展示了如何在 Unity 中实现 备忘录模式，用于管理对象的状态保存和恢复。这种模式在处理游戏中的撤销/重做功能、存档等场景中非常有用。

状态管理简单：通过备忘录模式，可以轻松保存和恢复玩家的状态。
封装性强：玩家的内部状态不暴露，保持了良好的封装性。
灵活性：可以方便地扩展状态保存的内容，例如增加更多的属性。

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » Unity 设计模式之行为型模式 -【状态模式】【观察者模式】【备忘录模式】

点赞(0) 打赏

本文分类：文章资讯
本文标签：Unity 设计模式之行为型模式 -【状态模式】【观察者模式】【备忘录模式】
浏览次数：27 次浏览
本文链接：https://freeymw.com/article/28967.html

评论列表共有 0 条评论

暂无评论

Unity 设计模式 之 行为型模式 -【状态模式】【观察者模式】【备忘录模式】