Game中的状态机

最新推荐文章于 2020-12-24 17:50:49 发布
最新推荐文章于 2020-12-24 17:50:49 发布
阅读量253 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq313796269/article/details/76374099
版权
我相信大多数博友都会玩游戏。

玩游戏，牵涉到状态包含 登陆，正常，死亡，复活，下线，

在上面状态的基础上。同时包含 站立，走动，跑动，不可移动施法状态，

　　　　　　　　　　　　　　战斗状态，

通常这是三个不同的分组。也就说可以同时存在的状态和不可同时存在的状态。

通常情况下也许你会这么定义，

//分组1
public bool 登陆 = false;
public bool 死亡 = false;
public bool 复活 = false;
public bool 下线 = false;
public bool 正常 = false;
public bool 打坐 = false;
//分组2
public bool 站立 = false;
public bool 走动 = false;
public bool 跑动 = false;
public bool 施法 = false;
//分组3
public bool 战斗 = false;

这种情况下，判断就变得很复杂，因为存在，同时成立和非同时成立的状态，

例如，战斗的同时可以走动，也可以跑动，或者技能施法

但是在打坐，下线，死亡等状态的时候既不能走动，也不能战斗也不能施法。

这样一来一去，判断的if else 会多的，让你头痛欲裂的吧。

或许你会想到，是要枚举，因为枚举提供位运算，提供Enum.HasFlag()方法来判断是否存在值

public enum Stauts
{
    //分组1
    空值,
    登陆,
    死亡,
    复活,
    下线,
    正常,
    打坐,
    //分组2
    站立,
    走动,
    跑动,
    施法,
    //分组3
    战斗,
}

查看一下使用方式

Stauts sValue = Stauts.登陆;

sValue = sValue | Stauts.站立;

if (sValue.HasFlag(Stauts.站立))
{
    Console.WriteLine("存在站立状态");
}

输出：

 

但是，继续测试一下

 

这样看出来了，我并没有设置复活状态，但是却存在复活状态~！

探究得明原因，是因为 位或（｜） 运算，  按位或（｜）表示相对应的每位至少有一个为1，则结果为1，只有两个都为0，结果才为0.

所以，我们应该设置枚举值的不同值；

为了更直观的查看运算方式，我们输出枚举值的二进制值，

public static void Show(Stauts value)
{
    string log = ("结果：" + ((long)value).ToString().PadLeft(10, ' ') + " -> " + Convert.ToString(((long)value), 2).PadLeft(64, '0'));
    Console.WriteLine(log);

}

 

查看一下

我们看到

Stauts.登陆 | Stauts.死亡 位或计算方式，结果值。

这些明白了，那就是枚举的值，定义不合法，

public enum Stauts
{
    //分组1
    空值 = 0,
    登陆 = 1,
    死亡 = 2,
    复活 = 4,
    下线 = 8,
    正常 = 10,
    打坐 = 20,
    //分组2
    站立 = 40,
    走动 = 80,
    跑动 = 100,
    施法 = 200,
    //分组3
    战斗 = 400,
}

 

 

输出结果

这下，没有了复活状态。这样判断，会减少一半，

可还是出现一个问题。那就是分组问题，也就说，死亡状态和复活状态不能同时存在，

死亡状态和跑动状态也不可能同时存在

那么我们在想，枚举值的能不能分组呢？

可惜C#下面枚举值，只能使用整型的基础类型。

没办法只能另辟蹊径：

    public class EnumStatus
    {

        public long Value { get; private set; }

        public long GroupValue { private set; get; }

        public EnumStatus(long value, long group)
        {
            this.Value = value;
        }
    }

接下来我们设置一组常量

        // 0x000000一旦竟然这组状态忽略一切状态
        public static EnumStatus Status0_空值 = new EnumStatus(0, 0x000000);
        public static EnumStatus Status0_登陆 = new EnumStatus(1 << 0, 0x000000);
        public static EnumStatus Status0_死亡 = new EnumStatus(1 << 1, 0x000000);
        public static EnumStatus Status0_复活 = new EnumStatus(1 << 2, 0x000000);
        public static EnumStatus Status0_下线 = new EnumStatus(1 << 3, 0x000000);
        public static EnumStatus Status0_正常 = new EnumStatus(1 << 4, 0x000000);
        public static EnumStatus Status1_打坐 = new EnumStatus(1 << 5, 0x000000);

        //移动组状态 4个状态值
        public static EnumStatus Status1_站立 = new EnumStatus(1 << 6, 0x00000f);//4位一组
        public static EnumStatus Status1_走动 = new EnumStatus(1 << 7, 0x00000f);//
        public static EnumStatus Status1_跑动 = new EnumStatus(1 << 8, 0x00000f);//
        public static EnumStatus Status1_施法 = new EnumStatus(1 << 9, 0x00000f);// 无法移动的施法

        //战斗状态 这组只有一个状态值
        public static EnumStatus Status2_战斗 = new EnumStatus(1 << 10, 0x000010);//

后面的分组值，的由来是

0x00000f  二进制 0000,1111,

0x000010 二进制 0001,0000,
这样就成功分组了

 

上面分组代码代码有错误：

        // 0x000000一旦竟然这组状态忽略一切状态
        public static EnumStatus Status0_空值 = new EnumStatus(0, 0x000000);
        public static EnumStatus Status0_登陆 = new EnumStatus(1 << 0, 0x000000);
        public static EnumStatus Status0_死亡 = new EnumStatus(1 << 1, 0x000000);
        public static EnumStatus Status0_复活 = new EnumStatus(1 << 2, 0x000000);
        public static EnumStatus Status0_下线 = new EnumStatus(1 << 3, 0x000000);
        public static EnumStatus Status0_正常 = new EnumStatus(1 << 4, 0x000000);
        public static EnumStatus Status1_打坐 = new EnumStatus(1 << 5, 0x000000);

        //移动组状态 4个状态值
        public static EnumStatus Status1_站立 = new EnumStatus(1 << 6, 0x0003c0);//4位一组
        public static EnumStatus Status1_走动 = new EnumStatus(1 << 7, 0x0003c0);//
        public static EnumStatus Status1_跑动 = new EnumStatus(1 << 8, 0x0003c0);//
        public static EnumStatus Status1_施法 = new EnumStatus(1 << 9, 0x0003c0);// 无法移动的施法

        //战斗状态 这组只有一个状态值
        public static EnumStatus Status2_战斗 = new EnumStatus(1 << 10, 0x000400);//

由于前面的分组0占用了6位，

所以分组应该改为，

 

也许看到这里你需要一定的位运算知识了；

接下来我在介绍一下

位运算的操作符

//// 按位异或（^）比较特殊，它比较的是如果两个不同则值为1（如：（1、0）（0、1）），相同则为0（如：（1、1）（0、0））。
//// 按位与(&)表示相对应的两位必须都为1，结果才为1，否则为0
//// 按位或（｜）表示相对应的每位至少有一个为1，则结果为1，只有两个都为0，结果才为0.
//// 按位取反~ 运算符对操作数执行按位求补运算，其效果相当于反转每一位。

修改一下计算值

    public class EnumStatus
    {

        public long Value { get; private set; }

        public long GroupValue { private set; get; }

        public EnumStatus(long value, long group)
        {
            this.Value = value;
        }

        public bool HasFlag(EnumStatus status)
        {
            return (this.Value & status.Value) != 0;
        }

        public void Show()
        {
            string log = ("结果：" + this.Value.ToString().PadLeft(10, ' ') + " -> " + Convert.ToString(this.Value, 2).PadLeft(64, '0'));
            Console.WriteLine(log);

        }

        public static EnumStatus operator |(EnumStatus statusLeft, EnumStatus statusRight)
        {
            statusLeft.Value = statusLeft.Value & statusRight.GroupValue | statusRight.Value;
            return statusLeft;
        }

        public static EnumStatus operator &(EnumStatus statusLeft, EnumStatus statusRight)
        {
            statusLeft.Value = statusLeft.Value & (~statusRight.Value);
            return statusLeft;
        }

    }

 

 

上面重载的 位域算法也是有问题的。

public static EnumStatus operator |(EnumStatus statusLeft, EnumStatus statusRight)
        {
            if (statusRight.GroupValue==0)//当分组为0的时候清除所有状态
            {
                statusLeft.Value = statusLeft.Value & (statusRight.GroupValue) | statusRight.Value;
            }
            else
            {//当分组不为零
                statusLeft.Value = statusLeft.Value & (~statusRight.GroupValue) | statusRight.Value;
            }
            return statusLeft;
        }

这下才是正确的结果

 

这下是不是很轻松的解决了这一系列的状态问题呢？包括各种同时存在和不同时的存在的状态~！

但是这也有一个弊端，那就是值只有64个，也就是64个状态，，虽然存在分组。但是每一个分组的值都必须不同才行。

不知道，各位看官还有么没有更好的办法？？？？

==============================================================================================

java版本的

 

java的枚举是可以自定义的这方面比较方便

但是java没有运算符重载，

 

enum EnumStatus {

    //0x000000一旦竟然这组状态忽略一切状态
    Status0_空值(0, 0x000000),
    Status0_登陆(1 << 0, 0x000000),
    Status0_下线(1 << 1, 0x000000),
    Status0_正常(1 << 2, 0x000000),
    //移动组状态
    Status1_走动(1 << 3, 0x00000f),
    Status1_跑动(1 << 4, 0x00000f);

    Long value = 0L;
    Long group = 0L;

    private EnumStatus(long value, long group) {
        this.value = value;
        this.group = group;
    }

    public boolean hasFlag(EnumStatus status) {
        return (value & (~status.value)) != 0;
    }

    public void addStatus(EnumStatus status) {
        value = value & status.group | status.value;
    }

    public void removeStatus(EnumStatus status) {
        value = value & (~status.value);
    }

    public void show() {

        String log = "结果：" + padLeft(this.value + "", 10, " ") + " -> " + padLeft(Long.toBinaryString(this.value), 64, "0");
        System.out.println(log);
    }

    String padLeft(String source, int length, String paddingChar) {
        String strB = Long.toBinaryString(this.value);
        int forCount = length - strB.length();
        for (int i = 0; i < forCount; i++) {
            strB = paddingChar + strB;
        }
        return strB;
    }
}

上面代码分组计算错误。修改为

public void addStatus(EnumStatus status) {
        if (status.group == 0) {//分组为零
            value = value & status.group | status.value;
        } else {//分组不为零
            value = value & (~status.group) | status.value;
        }
    }

 

 

测试代码

        EnumStatus status = EnumStatus.Status0_空值;
        System.out.println("===============Status.Status0_空值================");
        status.show();
        System.out.println("===============Status.Status0_登陆================");
        status.addStatus(EnumStatus.Status0_登陆);
        status.show();
        if (status.hasFlag(EnumStatus.Status0_登陆)) {
            System.out.println("存在状态 Status.Status0_登陆");
        } else {
            System.out.println("不存在状态 Status.Status0_登陆");
        }
        System.out.println("===============Status.Status0_正常================");
        status.addStatus(EnumStatus.Status0_正常);
        status.show();
        if (status.hasFlag(EnumStatus.Status0_登陆)) {
            System.out.println("存在状态 Status.Status0_登陆");
        } else {
            System.out.println("不存在状态 Status.Status0_登陆");
        }
        System.out.println("===============Status.Status1_跑动================");
        status.addStatus(EnumStatus.Status1_跑动);
        status.show();
        if (status.hasFlag(EnumStatus.Status0_正常)) {
            System.out.println("存在状态 Status.Status0_正常");
        } else {
            System.out.println("不存在状态 Status.Status0_正常");
        }
        System.out.println("===============Status.Status0_下线================");
        status.addStatus(EnumStatus.Status0_下线);
        status.show();
        if (status.hasFlag(EnumStatus.Status1_跑动)) {
            System.out.println("存在状态 Status.Status1_跑动");
        } else {
            System.out.println("不存在状态 Status.Status1_跑动");
        }

输出结果为

===============Status.Status0_空值================
结果：         0 -> 0000000000000000000000000000000000000000000000000000000000000000
===============Status.Status0_登陆================
结果：         1 -> 0000000000000000000000000000000000000000000000000000000000000001
不存在状态 Status.Status0_登陆
===============Status.Status0_正常================
结果：       100 -> 0000000000000000000000000000000000000000000000000000000000000100
存在状态 Status.Status0_登陆
===============Status.Status1_跑动================
结果：     10100 -> 0000000000000000000000000000000000000000000000000000000000010100
存在状态 Status.Status0_正常
===============Status.Status0_下线================
结果：        10 -> 0000000000000000000000000000000000000000000000000000000000000010
存在状态 Status.Status1_跑动

到此为止。。ok，，，，

状态机，整理完成。。

 

無心道（失足程序猿）
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MMOARPG地下守护神_单机版实战视频课程(中部)
06-04
      《地下守护神》是暗黑魔幻风格的ARPG手游，是真正按照商业级技术水准研发的Unity大型教学案例。这是“刘老师讲Unity”课程体系中到目前为止最重量级教学课程，本课程将带领大家从手游前端各重要功能开发(基于MVC框架搭建、)到网络端的方方面面知识点，一一进行详细还原讲解，使得学员在短期内游戏研发能力有个质的突破，“主程”虚位以待，等待您的加入。 单机版主要技术点：    1: 前端分层的MVC架构设计，开发自定义的资源动态加载插件、音频插件、对话系统插件、事件监听插件、自定义强大的对象缓冲池脚本插件进行项目性能大幅提升等。    2: UI粒子特效、场景淡入淡出控制。    3: 单机与移动端的双输入控制系统开发。    4: 数值平衡处理与开发。    5: 多种设计模式在游戏研发过程中的灵活运用。    6: XML技术的灵活运用，在系统解耦与资源国际化方面的技术突破。    7: 开发强大灵活的日志系统插件，应对服务器与移动端的各种复杂系统调试需求。温馨提示：        本课程使用Virtual Studio2012，以及Unity5.2 进行开发与讲解。（推荐学员使用Unity5.2 版本减少开发过程中不必要的麻烦，VS使用更高版本则没有任何影响。） A：《MMOARPG地下守护神_单机版实战视频课程(上部)》https://edu.csdn.net/course/detail/24965B：《MMOARPG地下守护神_单机版实战视频课程(下部)》https://edu.csdn.net/course/detail/24979  
状态机--状态机4，关于战斗中负责兵种状态切换的状态机
zlQQhs（莫落）的专栏
04-02 2940
前面花了4篇文章废话了那么多却没有提到传说中的状态机，那么这一篇就来讲讲那个 传说中的状态机到底是个长什么样的东东，前面几篇主要是做铺垫用，下面总结下： 1.状态切换由事件驱动，如调用onIdle()进入待机状态，调用onWalk()进入行走状态 2.状态有进入，也有退出，如调用onFrozen()进入冰冻状态，调用onFrozenEnd()退出冰冻状态 3.状态之间的切换是有限制
2017-12-10战斗有限状态机FSM
liuchichi的博客
12-10 826
1.https://www.processon.com/ 在线做流程图 2.FSM：状态变化导致行为变化 有限的行为 有外部、内部的触发，造成转变 转变告诉给AI，AI去执行 AI执行后，反作用回状态，同步 3.可扩展性的代码 先罗列行为：巡逻Patrol、追逐Chasel、攻击Attack、死亡Dead 抽离共性：FSMState父类，上面4个继承父类
游戏中的状态机
托尼的博客
08-28 7001
游戏中的状态机基本上所有的软件都是有限状态机（finite-state machine，FSM）。什么是FSM呢？它是一个有向图，由一组节点和一组相应的转移函数组成。这句话是在写作这篇文章前刚从书上抄来的。通俗一点讲，它是一个事件驱动系统的模型，这个模型由有限数目的状态，若干输入和状态与状态之间转换的规则组成。在某一时刻，有一个或一组状态是FSM的当前状态，FSM接收输入事件并根据转换规则，将当前状态转为新的状态。正是由于这三个元素的组合，使得FSM具备了自己的行为特点。在游戏开发中，FSM被用来实现人工智
有限状态机的c语言实现
10-26
printf("this is a game.\n"); printf ("if you want to OPEN THE DOOR ,input 1\n"); printf ("if you want to CLOSE THE DOOR ,input 2\n"); printf ("if you want to LOCK THE DOOR ,input 3\n"); printf (...
FSM_有限状态机
06-12
相关链接 https://blog.csdn.net/qq_35433081/article/details/80664096 https://indienova.com/indie-game-development/game-programming-patterns-3/
Demo10-有限状态机的使用1
08-03
1.FsmState（有限状态机基类） 2.站立状态类（HeroIdleState） 3.行走状态类（HeroWalkState） 5.让状态机启动 6.运行
HFSM2：高性能分层有限状态机框架
01-30
高性能分层有限状态机 C ++ 11中的仅标头的分层FSM框架，具有完全静态定义的结构（无动态分配），并使用可变参数模板构建。 编译器支持 Visual Studio 14、15、16 GCC 5、6、7、8、9 lang 3.7、3.8、3.9、4、5、6...
AIStateMachines:用于C的状态机框架，专为超快速实体组件系统而设计
03-06
C的状态机用于构建状态机结构和处理程序功能的框架和符号，主要用于实体组件系统中。 当在对象的连续数组中的每个对象上运行相同的代码时，实体组件系统将以最快的速度（最少的高速缓存未命中次数，最大的编译时优化...
一个多态性的游戏状态机系统
热门推荐
Popy007(Twinsen)的专栏
12-13 1万+
-潘宏-2012年12月-本人水平有限，疏忽错误在所难免，还请各位高手不吝赐教-email: [email protected]/panhong101任何一款游戏产品，都需要在几种界面之间进行转换：logo、trailer、main menu、in-game、settings menu等等，并且会在这些转换之间处理资源问题。对于实现这样的转换，不同的游戏做法有所差异，但基本上会
【翻译】游戏设计模式之状态机
SpkingR的博客
07-24 681
一、前言 本文是一篇关于游戏设计模式之状态模式的文章内容翻译，我在上一篇文章 Godot3游戏引擎入门之十四：刚体RidigBody2D节点的使用以及简单的FSM状态机介绍中简单地介绍了 FSM 有限状态机的含义以及游戏中的简单实现，讲述的很浅显，如果你对游戏设计模式感兴趣，我相信本篇文章会适合你，如有翻译不当之处请谅解，哈哈。
游戏中分层状态机的实现
xtxy的专栏
07-31 1万+
状态机的实现方式有很多种，一般都使用比较简单的switch case方式来实现对事件的处理和状态的转移，如下所示： void ProcessEvent(Event event) { switch(state) { case StateA: StateAProcess(event); break; case StateB: StateBProcess(event);
状态机--状态机1，关于战斗中兵种状态的初步设计
zlQQhs（莫落）的专栏
04-02 1601
战斗中的主要对象是兵种，最前期只有待机，行走，攻击三种状态，而这些都由兵种AI去调用切换 简单的AI如：向前行走，如果攻击范围内出现敌人，则切换为待机状态，攻击间隔一到就开始攻击 工程是用quick-cocos2dx创建的，用的是lua脚本语言，代码如： local Soldier = class("Soldier") function Soldier:ctor() end -
有限状态机在游戏中应用
dayday_up2的专栏
02-02 1077
游戏在进行过程中，会涉及各种状态的切换，比如一个人有攻击，移动，站立三种状态，攻击可以和移动互相转换状态，移动和站立也可以互相转动状态，攻击和站立也可以互相转换动态，这就符合有限状态机的时候，当情况简单的时候，可以在一个类中进行这三种状态的转换，但是当情况复杂，那么可以每种状态一个类，再把拥有各种状态的类，也就是人这个对象，传到状态里，再进行操作。请看以下代码。var Player = cc.Sp
MMORPG学习笔记——简单战斗系统（一）有限状态机控制
qq_27535197的博客
10-31 1794
战斗框架主要由有限状态机（FSM），AI，角色信息（RoleInfo），以及控制他们的角色控制器四个部分组成。 整个加载过程为：角色控制器绑定在角色或者角色模型的父物体上，然后每次登录场景之后，创建角色或者怪物，然后通过角色或者怪物身上的初始化函数，初始化FSM，AI，RoleInfo，即通过实例化脚本，通过构造函数将角色控制器传递给脚本，达到降低耦合的作用 首先是动画状态机的控制，如果选择新动...
战斗框架设计
weixin_30693183的博客
06-01 391
游戏内的战斗框架涉及多个模块，包括技能，施法单元等。 大芒果对wow的实现 可施法单元Unit将会执行castspell，对某个目标使用某个法术进行施法。看起来所有的AI功能都是由CreatureAI来做的，每个精灵都会有一个CreatureAI指针，用来管理自己的行为逻辑，包括移动，施法等。例如施法的时候，会取出与自己关联的实体对象Unit* pCaster，然后调用Unit的CastSpe...
0x000000f怎么修复 win10_win10重新安装后进入出现状态显示0xc000000f错误代码怎么解决...
weixin_32312081的博客
12-24 6036
最近有用户想要重新安装win10系统，可是在重新安装后进入电脑，却出现状态显示0xc000000f错误代码，导致无法进入系统，这该怎么办呢，我们可以制作pe然后进入pe修复引导即可，这就给大家带来win10重新安装后进入出现状态显示0xc000000f错误代码的解决方法吧。具体步骤如下：1、首先准备一个制作好的U盘装机大师U盘启动盘，然后连接好电脑与U盘启动盘。重启电脑，在开机画面出现时按下启动快...
状态机--状态机5，关于战斗兵种的多状态
zlQQhs（莫落）的专栏
04-03 3209
在前面一篇《状态机4，关于战斗中负责兵种状态切换的状态机》中实现了一个简单的状态机 在最后抛出了为什么说简单的问题，因为在一个复杂的战斗中，一个角色很少说只有一个状态， 或者说根本不可能，多状态是合理的需求，在之前实现的状态机中，角色同时只能有一个状态， 要么行走状态，要么冰冻状态，从代码逻辑上看，一个新的状态进来当前的状态会被顶替掉， 来看需求：一个角色的攻击的过程中中了一个中毒
gameframework 创建有限状态机
最新发布
07-27
要创建一个有限状态机（Finite State Machine）的游戏框架，可以按照以下步骤进行： 1. 定义状态（States）：首先，确定游戏中的各个状态。例如，你的游戏可能有开始状态、进行中状态、暂停状态和结束状态等。 2. 定义状态转换（State Transitions：确定状态之间的转换条件。例如，当游戏从开始状态转换到进行中状态时，可能需要玩家点击开始按钮。 3. 实现状态类：为每个状态创建一个类，该类负责处理该状态下的逻辑和行为。每个状态类应该有进入状态、更新状态和退出状态的方法。 4. 创建状态管理器（State Manager）：实现一个状态管理器来管理各个状态之间的转换。状态管理器应该能够根据当前状态和转换条件，切换到下一个合适的状态。 5. 在游戏主循环中使用状态管理器：在游戏的主循环中，使用状态管理器来更新当前状态，并执行该状态下的逻辑和行为。 下面是一个简单的示例代码，展示了如何使用 C# 创建一个简单的有限状态机游戏框架： ```csharp // 定义游戏状态枚举 enum GameState { Start, Playing, Paused, End } // 状态基类 abstract class State { public abstract void Enter(); public abstract void Update(); public abstract void Exit(); } // 开始状态 class StartState : State { public override void Enter() { Console.WriteLine("Game started"); } public override void Update() { // 处理状态转换条件 if (Keyboard.IsKeyDown(Keys.Space)) { GameStateManager.ChangeState(GameState.Playing); } } public override void Exit() { Console.WriteLine("Leaving start state"); } } // 进行中状态 class PlayingState : State { public override void Enter() { Console.WriteLine("Game playing"); } public override void Update() { // 处理状态转换条件 if (Keyboard.IsKeyDown(Keys.P)) { GameStateManager.ChangeState(GameState.Paused); } else if (GameOverCondition) { GameStateManager.ChangeState(GameState.End); } } public override void Exit() { Console.WriteLine("Leaving playing state"); } } // 暂停状态 class PausedState : State { public override void Enter() { Console.WriteLine("Game paused"); } public override void Update() { // 处理状态转换条件 if (Keyboard.IsKeyDown(Keys.R)) { GameStateManager.ChangeState(GameState.Playing); } } public override void Exit() { Console.WriteLine("Leaving paused state"); } } // 结束状态 class EndState : State { public override void Enter() { Console.WriteLine("Game ended"); } public override void Update() { // 处理状态转换条件 if (Keyboard.IsKeyDown(Keys.Space)) { GameStateManager.ChangeState(GameState.Start); } } public override void Exit() { Console.WriteLine("Leaving end state"); } } // 状态管理器 class GameStateManager { private static State currentState; public static void ChangeState(GameState newState) { // 退出当前状态 currentState?.Exit(); // 创建新状态实例 switch (newState) { case GameState.Start: currentState = new StartState(); break; case GameState.Playing: currentState = new PlayingState(); break; case GameState.Paused: currentState = new PausedState(); break; case GameState.End: currentState = new EndState(); break; } // 进入新状态 currentState?.Enter(); } public static void UpdateCurrentState() { currentState?.Update(); } } // 游戏主循环 class GameLoop { static void Main(string[] args) { // 初始化游戏状态 GameStateManager.ChangeState(GameState.Start); // 游戏主循环 while (true) { // 更新当前状态 GameStateManager.UpdateCurrentState(); // 其他游戏逻辑 Thread.Sleep(16); // 控制帧率 } } } ``` 这只是一个简单的示例，你可以根据你的具体需求进行扩展和修改。希望这可以帮助到你！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值