Game中的状态机

我相信大多数博友都会玩游戏。

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

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

              战斗状态,

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

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

//分组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("存在站立状态");
}

输出:Game中的状态机

但是,继续测试一下

Game中的状态机

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

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

所以,我们应该设置枚举值的不同值;

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

public static void Show(Stauts value)
{
    , ).PadLeft(, '));
    Console.WriteLine(log);

}

查看一下Game中的状态机

我们看到

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

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

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

输出结果

Game中的状态机

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

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

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

那么我们在想,枚举值的能不能分组呢?

Game中的状态机

可惜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一旦竟然这组状态忽略一切状态
        , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);

        //移动组状态 4个状态值
         << , 0x00000f);//4位一组
         << , 0x00000f);//
         << , 0x00000f);//
         << , 0x00000f);// 无法移动的施法

        //战斗状态 这组只有一个状态值
         << , 0x000010);//

后面的分组值,的由来是

Game中的状态机Game中的状态机

0x00000f  二进制 0000,1111,

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

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

        // 0x000000一旦竟然这组状态忽略一切状态
        , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);
         << , 0x000000);

        //移动组状态 4个状态值
         << , 0x0003c0);//4位一组
         << , 0x0003c0);//
         << , 0x0003c0);//
         << , 0x0003c0);// 无法移动的施法

        //战斗状态 这组只有一个状态值
         << , 0x000400);//

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

所以分组应该改为,

Game中的状态机Game中的状态机

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

接下来我在介绍一下

位运算的操作符

//// 按位异或(^)比较特殊,它比较的是如果两个不同则值为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)
        {
            ;
        }

        public void Show()
        {
            , ).PadLeft(, '));
            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;
        }

    }

Game中的状态机

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

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

这下才是正确的结果

Game中的状态机

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

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

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

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

java版本的

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

但是java没有运算符重载,

enum EnumStatus {

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

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

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

    public boolean hasFlag(EnumStatus status) {
        ;
    }

    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 = , , ");
        System.out.println(log);
    }

    String padLeft(String source, int length, String paddingChar) {
        String strB = Long.toBinaryString(this.value);
        int forCount = length - strB.length();
        ; 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_空值================
结果:          ->
===============Status.Status0_登陆================
结果:          ->
不存在状态 Status.Status0_登陆
===============Status.Status0_正常================
结果:        ->
存在状态 Status.Status0_登陆
===============Status.Status1_跑动================
结果:      ->
存在状态 Status.Status0_正常
===============Status.Status0_下线================
结果:         ->
存在状态 Status.Status1_跑动

到此为止。。ok,,,,

状态机,整理完成。。

上一篇:COJN 0575 800601滑雪


下一篇:控件之combox