12.解释器模式

设计模式 > 行为型模式 设计模式 行为型模式
发布时间 :
字数:3.6k 阅读 : 评论:
  1. 12.行为型模式-解释器模式
    1. 12.1 基础知识
      1. 学习难度：5
      2. 使用频率：1
      3. 总分：2
      4. 定义
      5. 说人话
      6. 结构图
      7. 实现步骤
      8. 说明
    2. 12.2 模版代码
      1. 上下文类
      2. 表达式接口和终结非总结表达式类
      3. 客户端
    3. 12.3 CSharp实践
      1. 实践需求
      2. 解释器接口和具体解释器类
      3. 客户端
    4. 12.4 Unity实践
      1. 实践需求
      2. 输入信息相关类
      3. 解释器相关类
      4. 易大师技能系统上下文类
      5. 易大师输入管理器类
      6. 客户端
      7. 运行结果

12.行为型模式-解释器模式

12.1 基础知识

学习难度：5

使用频率：1

总分：2

定义

解释器模式（Interpreter Pattern）给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

说人话

解释器模式用于定义一种语言的文法，并提供解释器来解释语言中的句子。在解释器模式中，非终结表达式的解释方法调用其他表达式的解释方法进行操作。

结构图

实现步骤

  • 上下文类：包含需要解释的信息或一些解释信息相关的集合，并提供操作方法以供解释器使用。
  • 表达式接口：定义解释方法。
  • 终结符表达式类：实现抽象表达式接口，表示文法中的终结符。实现解释方法时会返回不可再操作的表达式。
  • 非终结符表达式类：实现抽象表达式接口，表示文法中的非终结符。通常会在类中定义其他表达式变量。实现解释方法时会对其他表达式调用解释方法并进行操作。
  • 客户端：创建上下文类，定义表达式树得到表达式对象并解释。

说明

解释器模式在实际应用中使用频率较低，通常用于特定领域的语言解析和处理，例如编译器、正则表达式解析等。

12.2 模版代码

上下文类

// 上下文类 包含要被解释的信息
class Context
{
    public string Input { get; set; }
    public string Output { get; set; }

    public Context(string input)
    {
        Input = input;
    }
}

表达式接口和终结非总结表达式类

// 表达式接口 定义了解释方法
interface IExpression
{
    void Interpret(Context context);
}

// 终结符表达式
class TerminalExpression : IExpression
{
    public void Interpret(Context context)
    {
        // 实现终结符表达式的解释逻辑
        context.Output = "终结符表达式";
    }
}

// 非终结符表达式类
class NonTerminalExpression : IExpression
{
    private IExpression leftExpression;
    private IExpression rightExpression;

    public NonTerminalExpression(IExpression left, IExpression right)
    {
        leftExpression = left;
        rightExpression = right;
    }

    public void Interpret(Context context)
    {
        // 实现非终结符表达式的解释逻辑，通常基于左右表达式的组合
        leftExpression.Interpret(context);
        rightExpression.Interpret(context);
        context.Output = $"非终结符表达式 [{leftExpression.GetType().Name} {rightExpression.GetType().Name}]";
    }
}

客户端

class Program
{
    static void Main(string[] args)
    {
        Context context = new Context("示例输入");

        // 创建两个终结符表达式和一个非终结符表达式
        IExpression terminalExpression1 = new TerminalExpression();
        IExpression terminalExpression2 = new TerminalExpression();
        IExpression nonTerminalExpression = new NonTerminalExpression(terminalExpression1, terminalExpression2);

        // 解释表达式
        nonTerminalExpression.Interpret(context);
        
        Console.WriteLine(context.Output);//非终结符表达式 [TerminalExpression TerminalExpression]
    }
}

12.3 CSharp实践

实践需求

使用解释器模式，模拟加减运算。

解释器接口和具体解释器类

// 抽象表达式接口
public interface IExpression
{
    int Interpret(Dictionary<string, int> variables);
}

// 终结符表达式类 - 变量表达式
public class VariableExpression : IExpression
{
    private string variableName;

    public VariableExpression(string name)
    {
        variableName = name;
    }

    public int Interpret(Dictionary<string, int> variables)
    {
        if (variables.ContainsKey(variableName))
        {
            return variables[variableName];
        }
        else
        {
            throw new InvalidOperationException($"变量 '{variableName}' 未找到。"); // 抛出未找到变量的异常
        }
    }
}

// 终结符表达式类 - 常量表达式
public class ConstantExpression : IExpression
{
    private int value;

    public ConstantExpression(int value)
    {
        this.value = value;
    }

    public int Interpret(Dictionary<string, int> variables)
    {
        return value;
    }
}

// 非终结符表达式类 - 加法表达式
public class AddExpression : IExpression
{
    private IExpression left;
    private IExpression right;

    public AddExpression(IExpression left, IExpression right)
    {
        this.left = left;
        this.right = right;
    }

    public int Interpret(Dictionary<string, int> variables)
    {
        return left.Interpret(variables) + right.Interpret(variables);
    }
}

// 非终结符表达式类 - 减法表达式
public class SubtractExpression : IExpression
{
    private IExpression left;
    private IExpression right;

    public SubtractExpression(IExpression left, IExpression right)
    {
        this.left = left;
        this.right = right;
    }

    public int Interpret(Dictionary<string, int> variables)
    {
        return left.Interpret(variables) - right.Interpret(variables);
    }
}

客户端

class Program
{
    static void Main(string[] args)
    {
        // 创建变量字典并赋值
        Dictionary<string, int> variables = new Dictionary<string, int>();
        variables["x"] = 10;
        variables["y"] = 5;

        // 创建表达式 x+20
        IExpression expression = new AddExpression(new VariableExpression("x"), new ConstantExpression(20));

        // 解释并计算表达式的值
        int result = expression.Interpret(variables);
        Console.WriteLine("结果: " + result); // 30

        // 创建另一个表达式 x+20的结果-5
        expression = new SubtractExpression(expression, new VariableExpression("y"));

        // 再次解释并计算表达式的值
        result = expression.Interpret(variables);
        Console.WriteLine("结果: " + result); // 25
    }
}

12.4 Unity实践

实践需求

使用解释器模式，模拟剑圣可以单个使用技能和使用连招组合。

输入信息相关类

//易大师输入信息抽象类
public abstract class YiInputInfo
{

}

// 表示易大师的单按键输入信息类
public class YiSingleInputInfo : YiInputInfo
{
    public KeyCode keyCode; // 存储单按键的 KeyCode

    // 构造函数，用于初始化单按键输入信息
    public YiSingleInputInfo(KeyCode keyCode)
    {
        this.keyCode = keyCode; // 通过构造函数接收按键信息并存储在类的成员变量中
    }
}

// 表示易大师的连招输入信息类
public class YiComboInputInfo : YiInputInfo
{
    public List<KeyCode> keyCodeList; // 存储连招输入的按键列表

    // 构造函数，用于初始化连招输入信息
    public YiComboInputInfo(List<KeyCode> keyCodeList)
    {
        this.keyCodeList = keyCodeList; // 通过构造函数接收按键列表信息并存储在类的成员变量中
    }
}

解释器相关类

// 表示易大师技能表达式的通用接口
public interface ISkillExpression
{
    // 执行技能表达式，接受一个 YiContext 参数，以便在执行中访问游戏对象和数据
    void Execute(YiContext yiContext);
}

// 表示易大师的技能表达式类，用于执行“阿尔法突袭”技能
public class AlphaStrikeExpression : ISkillExpression
{
    // 执行“阿尔法突袭”技能
    public void Execute(YiContext yiContext)
    {
        Debug.Log("无极剑圣使用了阿尔法突袭，造成大量伤害！");
        // 在此处可以添加执行 Alpha Strike 技能的伤害逻辑

        // 使用动画触发器来播放技能动画
        yiContext.yiAnimator.SetTrigger(yiContext.GetSkillExpressionKeyCode(this.GetType()).ToString());
    }
}

// 表示易大师的技能表达式类，用于执行“冥想”技能
public class MeditationExpression : ISkillExpression
{
    // 执行“冥想”技能
    public void Execute(YiContext yiContext)
    {
        Debug.Log("无极剑圣开始冥想，恢复生命值！");
        // 在此处可以添加执行 Meditation 技能的生命值恢复逻辑

        // 使用动画触发器来播放技能动画
        yiContext.yiAnimator.SetTrigger(yiContext.GetSkillExpressionKeyCode(this.GetType()).ToString());
    }
}

// 表示易大师的技能表达式类，用于执行“无极剑道”技能
public class WujuStyleExpression : ISkillExpression
{
    // 执行“无极剑道”技能
    public void Execute(YiContext yiContext)
    {
        Debug.Log("无极剑圣启动了无极剑道，攻击变成真实伤害！");
        // 在此处可以添加执行 Wuju Style 技能的效果逻辑，例如将攻击变成真实伤害

        // 使用动画触发器来播放技能动画
        yiContext.yiAnimator.SetTrigger(yiContext.GetSkillExpressionKeyCode(this.GetType()).ToString());
    }
}

// 表示易大师的连招技能表达式类，实现了 ISkillExpression 接口
public class ComboExpression : ISkillExpression
{
    public List<ISkillExpression> comboSkillExpressionList = new List<ISkillExpression>();

    // 构造函数，用于初始化连招技能表达式
    public ComboExpression(List<ISkillExpression> comboSkillExpressionList)
    {
        this.comboSkillExpressionList = comboSkillExpressionList; // 通过构造函数接收连招技能表达式列表并存储在类的成员变量中
    }

    // 执行连招技能
    public void Execute(YiContext yiContext)
    {
        Debug.Log("进入连招");
        string comboKeyCodeStr = null;

        // 遍历连招技能表达式列表
        foreach (var comboSkillExpressionItem in comboSkillExpressionList)
        {
            comboKeyCodeStr += yiContext.GetSkillExpressionKeyCode(comboSkillExpressionItem.GetType()) + " ";
            // comboSkillExpressionItem.Execute(yiContext);
        }

        // 使用协程执行连招技能
        MyTimer.GetInstance().StartCoroutine(ExecuteComboSkills(comboSkillExpressionList, yiContext));
        Debug.Log("连招是" + comboKeyCodeStr);
        // Debug.Log("退出连招");
    }

    // 协程，用于逐个执行连招技能
    IEnumerator ExecuteComboSkills(List<ISkillExpression> comboSkillExpressionList, YiContext yiContext)
    {
        // 遍历连招技能表达式列表
        foreach (var comboSkillExpressionItem in comboSkillExpressionList)
        {
            // 执行当前连招技能表达式
            comboSkillExpressionItem.Execute(yiContext);

            // 等待一定数量的帧
            for (int i = 0; i < 100; i++)
            {
                yield return null; // 等待一帧
            }
        }
    }
}

易大师技能系统上下文类

// 易大师技能系统上下文类
public class YiContext
{
    // 易大师游戏对象的预制体
    private GameObject yiPrefab = Resources.Load<GameObject>("Lesson30_行为型模式_解释器模式/Yi");

    // 易大师游戏对象
    private GameObject yiGameObject;

    // 易大师技能表达式与按键之间的映射字典
    private Dictionary<KeyCode, Type> yiSkillMappingDictionary;

    // 获取技能映射字典的访问器
    public Dictionary<KeyCode, Type> YiSkillMappingDictionary => yiSkillMappingDictionary;

    // 易大师的动画控制器
    public Animator yiAnimator;

    // 易大师技能系统上下文的构造函数
    public YiContext()
    {
        // 实例化易大师游戏对象
        yiGameObject = GameObject.Instantiate(yiPrefab);

        // 获取易大师的动画控制器
        yiAnimator = yiGameObject.GetComponent<Animator>();

        // 初始化技能映射字典，并将按键与对应的技能表达式类型关联
        yiSkillMappingDictionary = new Dictionary<KeyCode, Type>();
        yiSkillMappingDictionary.Add(KeyCode.Q, typeof(AlphaStrikeExpression));
        yiSkillMappingDictionary.Add(KeyCode.W, typeof(MeditationExpression));
        yiSkillMappingDictionary.Add(KeyCode.E, typeof(WujuStyleExpression));
    }

    // 执行给定的技能表达式
    public void ExecuteSkill(ISkillExpression skillExpression)
    {
        skillExpression.Execute(this);
    }

    // 检查易大师是否处于空闲状态
    public bool IsYiIdle()
    {
        foreach (var yiSkillMappingItem in yiSkillMappingDictionary)
        {
            // 如果有技能在执行中，则易大师不是空闲的
            if (yiAnimator.GetBool(yiSkillMappingItem.Key.ToString()))
            {
                return false;
            }
        }

        // 所有技能都未在执行中，易大师被认为是空闲的
        return true;
    }

    // 获取与给定技能表达式类型关联的按键
    public KeyCode GetSkillExpressionKeyCode(Type skillExpressionType)
    {
        foreach (var yiSkillMappingItem in yiSkillMappingDictionary)
        {
            // 如果找到与给定技能表达式类型匹配的项，返回关联的按键
            if (skillExpressionType == yiSkillMappingItem.Value)
                return yiSkillMappingItem.Key;
        }

        // 如果没有找到匹配的项，记录错误并返回默认按键
        Debug.Log("该技能没有在技能映射字典");
        return KeyCode.Space;
    }
}

易大师输入管理器类

// 易大师输入管理器类，用于处理技能输入和解析
public class YiInputManager : MonoBehaviorSingleton<YiInputManager>
{
    // 存储易大师的输入信息列表
    private List<YiInputInfo> yiInputInfoList = new List<YiInputInfo>();

    // 用于临时存储连招输入信息的按键列表
    private List<KeyCode> comboInputInfoKeyCodeList = new List<KeyCode>();

    // 输入管理器的活动状态标志
    private bool isActive;

    // 易大师上下文，用于技能解析和执行
    private YiContext yiContext;

    // 连续输入的时间阈值
    private float CONTINUOUS_INPUT_THRESHOLD = 0.2f;

    // 上次输入时间
    private float lastInputTime;

    // 标志是否正在连续输入
    private bool isInputContinuous;

    // 向输入列表添加输入信息
    public void AddYiInputInfo(YiInputInfo yiInputInfo)
    {
        yiInputInfoList.Add(yiInputInfo);
    }

    // 设置输入管理器的活动状态和相关上下文
    public void SetActive(bool active, YiContext context)
    {
        this.isActive = active;
        this.yiContext = context;
    }

    // 解析输入信息为技能表达式
    public ISkillExpression ParseYiInputInfoToSkillExpression(YiInputInfo yiInputInfo)
    {
        // 检查输入信息的类型是否为单个按键输入
        if (yiInputInfo is YiSingleInputInfo)
        {
            // 将输入信息转换为单个按键输入对象
            YiSingleInputInfo yiSingleInputInfo = yiInputInfo as YiSingleInputInfo;

            // 检查按键是否在技能映射字典中
            if (yiContext.YiSkillMappingDictionary.ContainsKey(yiSingleInputInfo.keyCode))
            {
                // 根据按键查找对应的技能表达式类型，并创建技能表达式实例
                return (ISkillExpression)Activator.CreateInstance(
                    yiContext.YiSkillMappingDictionary[yiSingleInputInfo.keyCode]);
            }
        }
        // 如果输入信息的类型为连招输入
        else if (yiInputInfo is YiComboInputInfo)
        {
            // 将输入信息转换为连招输入对象
            YiComboInputInfo yiComboInputInfo = yiInputInfo as YiComboInputInfo;

            List<ISkillExpression> comboSkillExpressionList = new List<ISkillExpression>();

            // 遍历连招输入中的按键列表
            foreach (var keyCode in yiComboInputInfo.keyCodeList)
            {
                // 检查按键是否在技能映射字典中
                if (yiContext.YiSkillMappingDictionary.ContainsKey(keyCode))
                {
                    // 根据按键查找对应的技能表达式类型，并创建技能表达式实例，添加到连招技能表达式列表
                    ISkillExpression skillExpression =
                        (ISkillExpression)Activator.CreateInstance(yiContext.YiSkillMappingDictionary[keyCode]);
                    comboSkillExpressionList.Add(skillExpression);
                }
            }

            // 创建并返回一个连招技能表达式
            return new ComboExpression(comboSkillExpressionList);
        }

        // 如果无法识别输入信息的类型或按键无法匹配到技能表达式，记录错误并返回空
        Debug.Log("无法转换为技能表达式");
        return null;
    }


    // 检查输入信息
    public void CheckInputInfo()
    {
        float currentTime = Time.time;

        // 如果距离上次输入时间超过连续输入的时间阈值
        if (currentTime - lastInputTime > CONTINUOUS_INPUT_THRESHOLD)
        {
            // 如果连招输入列表不为空
            if (comboInputInfoKeyCodeList.Count != 0)
            {
                // 如果连招输入列表只包含一个按键
                if (comboInputInfoKeyCodeList.Count == 1)
                {
                    // 创建一个单按键输入信息并添加到输入信息列表中
                    List<KeyCode> inputInfoKeyCodeList = comboInputInfoKeyCodeList.ToList();
                    AddYiInputInfo(new YiSingleInputInfo(inputInfoKeyCodeList[0]));
                    comboInputInfoKeyCodeList.Clear();
                    Debug.Log("非连续输入");
                }
                // 如果连招输入列表包含多个按键
                else if (comboInputInfoKeyCodeList.Count > 1)
                {
                    // 创建一个连招输入信息并添加到输入信息列表中
                    List<KeyCode> inputInfoKeyCodeList = comboInputInfoKeyCodeList.ToList();
                    AddYiInputInfo(new YiComboInputInfo(inputInfoKeyCodeList));
                    comboInputInfoKeyCodeList.Clear();
                    Debug.Log("连续输入");
                }
            }
        }

        // 如果有任何按键被按下
        if (UnityEngine.Input.anyKeyDown)
        {
            // 遍历易大师技能映射字典中的每个键值对
            foreach (var yiSKillMappingItem in yiContext.YiSkillMappingDictionary)
            {
                // 检查当前帧是否按下了映射字典中的某个技能按键
                if (UnityEngine.Input.GetKeyDown(yiSKillMappingItem.Key))
                {
                    currentTime = Time.time;

                    // 判断当前时间与上次输入时间的差值是否小于连续输入的阈值
                    if (currentTime - lastInputTime <= CONTINUOUS_INPUT_THRESHOLD)
                    {
                        // 表示此次输入为连续输入
                        isInputContinuous = true;
                    }
                    else
                    {
                        // 重置连续输入标志，表示此次输入为非连续输入
                        isInputContinuous = false;
                    }

                    // 处理连续输入
                    if (isInputContinuous)
                    {
                        Debug.Log("连续输入");
                        comboInputInfoKeyCodeList.Add(yiSKillMappingItem.Key);
                    }
                    // 处理非连续输入
                    else
                    {
                        if (comboInputInfoKeyCodeList.Count != 0)
                        {
                            // 如果连招输入列表只包含一个按键
                            if (comboInputInfoKeyCodeList.Count == 1)
                            {
                                Debug.Log("非连续输入");

                                // 创建单按键输入信息并添加到输入信息列表中
                                List<KeyCode> inputInfoKeyCodeList = comboInputInfoKeyCodeList.ToList();
                                AddYiInputInfo(new YiSingleInputInfo(inputInfoKeyCodeList[0]));
                                comboInputInfoKeyCodeList.Clear();
                                comboInputInfoKeyCodeList.Add(yiSKillMappingItem.Key);
                            }
                            // 如果连招输入列表包含多个按键
                            else if (comboInputInfoKeyCodeList.Count > 1)
                            {
                                Debug.Log("连续输入");

                                // 创建连招输入信息并添加到输入信息列表中
                                List<KeyCode> inputInfoKeyCodeList = comboInputInfoKeyCodeList.ToList();
                                AddYiInputInfo(new YiComboInputInfo(inputInfoKeyCodeList));
                                comboInputInfoKeyCodeList.Clear();
                                comboInputInfoKeyCodeList.Add(yiSKillMappingItem.Key);
                            }
                        }
                        else
                        {
                            // 如果连招输入列表为空，直接添加当前按键
                            comboInputInfoKeyCodeList.Add(yiSKillMappingItem.Key);
                        }
                    }

                    // 更新上次输入时间
                    lastInputTime = currentTime;
                }
            }
        }
    }


    private void Update()
    {
        if (!isActive) return;

        CheckInputInfo();

        if (yiInputInfoList.Count > 0 && yiContext.IsYiIdle())
        {
            // 执行下一个技能表达式并从输入列表中移除
            yiContext.ExecuteSkill(ParseYiInputInfoToSkillExpression(yiInputInfoList[0]));
            yiInputInfoList.Remove(yiInputInfoList[0]);
        }
    }
}

客户端

public class TestInterpreterPattern:MonoBehaviour
{
    void Start()
    {
        // 创建无极剑圣易大师
        YiContext yiContext = new YiContext();

        YiInputManager.GetInstance().SetActive(true,yiContext);
        
    }
}

运行结果

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏