游戏开发中有限状态机

最新推荐文章于 2023-03-03 11:59:10 发布
最新推荐文章于 2023-03-03 11:59:10 发布
阅读量2.5k 收藏 4
点赞数 1
分类专栏： 设计模式 文章标签： C++ 游戏开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nin_cool/article/details/52595060
版权
有限状态机在游戏开发中是经常用到的数学模型，虽然我做的是"万年捕鱼"，但是有幸在2014年用Unity开发《怒海潜江》(已经成为线上尸体)中研究学习了有限状态机并且在项目中成功使用，对BOSS状态的控制让我惊艳到了(虽然是自己开发的，哈哈)。时至今日很多时候都在做重复的工作，最近的招聘好多应聘者都谈到了有限状态机这个东西，那么就重新来学习一次吧。
有限状态机，（ 英语 ：Finite-state machine, FSM），又称 有限状态自动机 ，简称状态机，是表示有限个 状态 以及在这些状态之间的转移和动作等行为的 数学模型 。-------《百度百科》
首先我们谈谈对"有限状态自动机"这个名词的理解。首先"状态"，就是指某个对象有多种状态，我们举个游戏中的例子，怪物有待机，行走，攻击，死亡等等这几个状态；“有限状态”就是指状态是有限个的，这个也很好理解；"自动机"的意思是说具有一定的AI能力。很多人都写过FSM,但是大多数人都是自己来控制状态的切换，并没有真正做到自动(AI)的程度。在有限个状态中自动切换，实现一个状态转换的死循环。
状态机由下列几部分组成:
状态集(States) ,事件(Event), 动作(Action), 转换(Transition)。
我们用实例一步一步来看FSM。如果让我们来实现一个游戏中的怪物，需求中怪物有饥饿，觅食，战斗，逃跑，玩耍这些状态 :

如果用(if else)或者(switch case)来实现的话，那么在Update中就充斥着大量的逻辑判断和跳转，如果增加一个状态或者减少一个状态，那么就要对应修改大量的逻辑判断，很容易造成bug，违反了高内聚低耦合的设计思维。
首先我们引入状态模式，把我们要实现的怪物状态进行封装: 
#pragma once

#include "../HrState/State.h"

class HrFSMState : State
{
public:
	HrFSMState();
	~HrFSMState();

	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;
};

#pragma once

#include <memory>
#include "HrFSMState.h"

class HrMonsterEntity;

class HrMonsterState : public HrFSMState
{
public:
	HrMonsterState(std::shared_ptr<HrMonsterEntity> pEntity);
	~HrMonsterState();


	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;

protected:
	std::shared_ptr<HrMonsterEntity> m_pStateOwnerEntity;

};

class HrMonsterHungryState : public HrMonsterState
{
public:
	HrMonsterHungryState(std::shared_ptr<HrMonsterEntity> pEntity);
	~HrMonsterHungryState();

	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;

};

class HrMonsterPlayState : public HrMonsterState
{
public:
	HrMonsterPlayState(std::shared_ptr<HrMonsterEntity> pEntity);
	~HrMonsterPlayState();

	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;
};

class HrMonsterFightState : public HrMonsterState
{
public:
	HrMonsterFightState(std::shared_ptr<HrMonsterEntity> pEntity);
	~HrMonsterFightState();

	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;
};

class HrMonsterEatState : public HrMonsterState
{
public:
	HrMonsterEatState(std::shared_ptr<HrMonsterEntity> pEntity);
	~HrMonsterEatState();

	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;
};

class HrMonsterEscapeState : public HrMonsterState
{
public:
	HrMonsterEscapeState(std::shared_ptr<HrMonsterEntity> pEntity);
	~HrMonsterEscapeState();

	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;
};

class HrMonsterForagingState : public HrMonsterState
{
public:
	HrMonsterForagingState(std::shared_ptr<HrMonsterEntity> pEntity);
	~HrMonsterForagingState();

	virtual void Enter() override;

	virtual void Execute() override;

	virtual void Exit() override;
};
#include "stdafx.h"
#include "HrMonsterState.h"
#include "HrMonsterEntity.h"
#include "HrRandomUtil.h"
#include <iostream>

HrMonsterState::HrMonsterState(std::shared_ptr<HrMonsterEntity> pEntity)
{
	m_pStateOwnerEntity = pEntity;
}

HrMonsterState::~HrMonsterState()
{
}

void HrMonsterState::Enter()
{

}

void HrMonsterState::Execute()
{

}

void HrMonsterState::Exit()
{

}

// HungryState /

HrMonsterHungryState::HrMonsterHungryState(std::shared_ptr<HrMonsterEntity> pEntity) : HrMonsterState(pEntity)
{

}

HrMonsterHungryState::~HrMonsterHungryState()
{

}

void HrMonsterHungryState::Enter()
{
	std::cout << " HungryState: Enter" << std::endl;
}

void HrMonsterHungryState::Execute()
{
	std::cout << " HungryState: 饿了" << std::endl;
	m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_FORAGING);
}

void HrMonsterHungryState::Exit()
{
	std::cout << " HungryState: Exit" << std::endl;
}

 PlaySate ///

HrMonsterPlayState::HrMonsterPlayState(std::shared_ptr<HrMonsterEntity> pEntity) : HrMonsterState(pEntity)
{

}

HrMonsterPlayState::~HrMonsterPlayState()
{

}

void HrMonsterPlayState::Enter()
{
	std::cout << " PlayState: Enter" << std::endl;
}

void HrMonsterPlayState::Execute()
{
	std::cout << " PlayState: Playing 妈妈睡了起来嗨" << std::endl;
	if (m_pStateOwnerEntity->IsHungry())
	{
		m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_HUNGRY);
	}
	else if (HrRandomUtil::GetRandNum(1, 10000) <= 1000)
	{
		std::cout << " PlayState: 遭遇敌人。。。。" << std::endl;
		m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_FIGHT);
	}
}

void HrMonsterPlayState::Exit()
{
	std::cout << " PlayState: Exit" << std::endl;
}

// FightState /

HrMonsterFightState::HrMonsterFightState(std::shared_ptr<HrMonsterEntity> pEntity) : HrMonsterState(pEntity)
{

}

HrMonsterFightState::~HrMonsterFightState()
{

}

void HrMonsterFightState::Enter()
{
	std::cout << " FightState: Enter" << std::endl;
}

void HrMonsterFightState::Execute()
{
	std::cout << " FightState: Execute" << std::endl;
	int nRandNum = HrRandomUtil::GetRandNum(1, 10000);
	if (nRandNum < 1000)
	{
		std::cout << " FightState: 战胜了！" << std::endl;
		if (m_pStateOwnerEntity->IsHungry())
			m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_EAT);
		else
			m_pStateOwnerEntity->ChangeToPreviousState();
	}
	else if (nRandNum < 2000)
	{
		std::cout << " FightState: 战败了！" << std::endl;
		m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_ESCAPE);
	}
	else
	{
		std::cout << " FightState: 战斗中。。。。" << std::endl;
	}
}

void HrMonsterFightState::Exit()
{
	std::cout << " FightState: Exit" << std::endl;
}

/ FightState 

HrMonsterEatState::HrMonsterEatState(std::shared_ptr<HrMonsterEntity> pEntity) : HrMonsterState(pEntity)
{

}

HrMonsterEatState::~HrMonsterEatState()
{

}

void HrMonsterEatState::Enter()
{
	std::cout << " EatState: Enter" << std::endl;
}

void HrMonsterEatState::Execute()
{
	std::cout << " EatState: Execute 吃" << std::endl;
	if (m_pStateOwnerEntity->Eat())
	{
		m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_PLAY);
	}
}

void HrMonsterEatState::Exit()
{
	std::cout << " EatState: Exit" << std::endl;
}

// EscapeState //
HrMonsterEscapeState::HrMonsterEscapeState(std::shared_ptr<HrMonsterEntity> pEntity) : HrMonsterState(pEntity)
{
}

HrMonsterEscapeState::~HrMonsterEscapeState()
{

}

void HrMonsterEscapeState::Enter()
{
	std::cout << " EscapeState: Enter" << std::endl;
}

void HrMonsterEscapeState::Execute()
{
	std::cout << " EscapeState: Execute 逃跑中..." << std::endl;
	if (HrRandomUtil::GetRandNum(1, 10000) <= 1000)
	{
		if (m_pStateOwnerEntity->IsHungry())
		{
			m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_HUNGRY);
		}
		else
		{
			m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_PLAY);
		}
	}
}

void HrMonsterEscapeState::Exit()
{
	std::cout << " EscapeState: Exit" << std::endl;
}

// ForagingState //

HrMonsterForagingState::HrMonsterForagingState(std::shared_ptr<HrMonsterEntity> pEntity) : HrMonsterState(pEntity)
{
}

HrMonsterForagingState::~HrMonsterForagingState()
{

}

void HrMonsterForagingState::Enter()
{
	std::cout << " ForagingState: Enter" << std::endl;
}

void HrMonsterForagingState::Execute()
{
	std::cout << " ForagingState: Execute 寻找食物中。。。。" << std::endl;
	if (HrRandomUtil::GetRandNum(1, 10000) <= 1000)
	{
		std::cout << " ForagingState: 找到一个小羊羔~ " << std::endl;
		m_pStateOwnerEntity->ChangeState(HrMonsterEntity::ENUM_STATE_FIGHT);
	}
}

void HrMonsterForagingState::Exit()
{
	std::cout << " ForagingState: Exit" << std::endl;
}


对怪物状态的分析，我们针对每个状态进行封装，而具体的状态逻辑也封装在了每一个状态里，状态互不干扰，把耦合降到最低。而控制当前状态的是StateMachine来控制： 
#pragma once
#include <memory>

class HrFSMEntity;
class HrFSMState;

class HrFSMStateMachine
{
public:
	HrFSMStateMachine();
	virtual ~HrFSMStateMachine();

	virtual void SetOwnerEntiry(std::shared_ptr<HrFSMEntity> pEntity);
	virtual void SetCurrentState(std::shared_ptr<HrFSMState> pState);
	virtual void SetPreviousState(std::shared_ptr<HrFSMState> pState);

	virtual void ChangeState(std::shared_ptr<HrFSMState> pState);
	virtual void ChangeToPreviousState();

	virtual void Update();

	virtual std::shared_ptr<HrFSMState> GetCurretnState(std::shared_ptr<HrFSMState> pState);
	virtual std::shared_ptr<HrFSMState> GetPreviousState(std::shared_ptr<HrFSMState> pState);
protected:
	std::shared_ptr<HrFSMEntity> m_pEntityOwer;

	std::shared_ptr<HrFSMState> m_pPreviousState;
	std::shared_ptr<HrFSMState> m_pCurrentState;
};

具体的实体，即怪物继承状态模式的Context，并且持有FSMStateMachine。在状态转换的实现时，我用ID来控制具体状态，并通过状态ID来实现状态的转化，这里和之前的状态模式稍有区别：

#pragma once

#include "../HrState/Context.h"

class HrFSMEntity : public Context
{
public:
	HrFSMEntity();
	~HrFSMEntity();

	virtual void ChangeState(std::shared_ptr<State> pState) override;
	virtual void ChangeState(int nStateID) override;
	virtual void ChangeToPreviousState() override;

	virtual void Execute() override;
};

#pragma once

#include "HrFSMEntity.h"
#include <iostream>

class HrFSMStateMachine;

class HrMonsterHungryState;
class HrMonsterEatState;
class HrMonsterEscapeState;
class HrMonsterFightState;
class HrMonsterForagingState;
class HrMonsterPlayState;

class HrMonsterEntity : public HrFSMEntity
{
public:
	HrMonsterEntity();
	~HrMonsterEntity();

	enum ENUM_MONSTER_STATE
	{
		ENUM_STATE_HUNGRY,
		ENUM_STATE_EAT,
		ENUM_STATE_ESCAPE,
		ENUM_STATE_FIGHT,
		ENUM_STATE_FORAGING,
		ENUM_STATE_PLAY,
	};

	void InitMonsterEntityState();

	virtual void ChangeState(int nStateID) override;
	virtual void ChangeToPreviousState() override;
	virtual void Execute() override;

	bool IsHungry();
	bool Eat();
protected:
	std::shared_ptr<HrFSMStateMachine> m_pStateMachine;

	std::shared_ptr<HrMonsterHungryState> m_pStateHungry;
	std::shared_ptr<HrMonsterEatState> m_pStateEat;
	std::shared_ptr<HrMonsterEscapeState> m_pStateEscape;
	std::shared_ptr<HrMonsterFightState> m_pStateFight;
	std::shared_ptr<HrMonsterForagingState> m_pStateForaging;
	std::shared_ptr<HrMonsterPlayState> m_pStatePlay;

	//最大值100 低于10饥饿
	int m_nDegreeOfStarvation;
};

#include "stdafx.h"
#include "HrMonsterEntity.h"
#include "HrFSMStateMachine.h"
#include "HrMonsterState.h" 

HrMonsterEntity::HrMonsterEntity()
{

	m_nDegreeOfStarvation = 10;
}

HrMonsterEntity::~HrMonsterEntity()
{
}

void HrMonsterEntity::InitMonsterEntityState()
{
	m_pStateMachine = std::make_shared<HrFSMStateMachine>();

	m_pStateHungry = std::make_shared<HrMonsterHungryState>(std::dynamic_pointer_cast<HrMonsterEntity>(shared_from_this()));
	m_pStateEat = std::make_shared<HrMonsterEatState>(std::dynamic_pointer_cast<HrMonsterEntity>(shared_from_this()));
	m_pStateEscape = std::make_shared<HrMonsterEscapeState>(std::dynamic_pointer_cast<HrMonsterEntity>(shared_from_this()));
	m_pStateFight = std::make_shared<HrMonsterFightState>(std::dynamic_pointer_cast<HrMonsterEntity>(shared_from_this()));
	m_pStateForaging = std::make_shared<HrMonsterForagingState>(std::dynamic_pointer_cast<HrMonsterEntity>(shared_from_this()));
	m_pStatePlay = std::make_shared<HrMonsterPlayState>(std::dynamic_pointer_cast<HrMonsterEntity>(shared_from_this()));

	m_pStateMachine->SetOwnerEntiry(std::dynamic_pointer_cast<HrFSMEntity>(shared_from_this()));
	m_pStateMachine->SetCurrentState(m_pStatePlay);
	m_pStateMachine->SetPreviousState(m_pStatePlay);

}

void HrMonsterEntity::ChangeState(int nStateID)
{
	switch (nStateID)
	{
	case ENUM_STATE_HUNGRY:
		m_pStateMachine->ChangeState(m_pStateHungry);
		break;
	case ENUM_STATE_EAT:
		m_pStateMachine->ChangeState(m_pStateEat);
		break;
	case ENUM_STATE_ESCAPE:
		m_pStateMachine->ChangeState(m_pStateEscape);
		break;
	case ENUM_STATE_FIGHT:
		m_pStateMachine->ChangeState(m_pStateFight);
		break;
	case ENUM_STATE_FORAGING:
		m_pStateMachine->ChangeState(m_pStateForaging);
		break;
	case ENUM_STATE_PLAY:
		m_pStateMachine->ChangeState(m_pStatePlay);
		break;
	default:
		std::cout << " Error State " << std::endl;
		break;
	}
}

void HrMonsterEntity::ChangeToPreviousState()
{
	m_pStateMachine->ChangeToPreviousState();
}

void HrMonsterEntity::Execute()
{
	--m_nDegreeOfStarvation;
	if (m_nDegreeOfStarvation < 0)
	{
		m_nDegreeOfStarvation = 0;
	}

	m_pStateMachine->Update();
}

bool HrMonsterEntity::IsHungry()
{
	return m_nDegreeOfStarvation <= 5;
}

bool HrMonsterEntity::Eat()
{
	return (m_nDegreeOfStarvation += 2 ) >= 10;
}


这样就实现了一个非常简单的状态机，各个状态之间的转换逻辑还非常简单，具体的转换要根据具体的需求来实现。具体的实现我觉得不必死板，只要保持着设计模式的思维，结构的改动要根据具体的需求。在之前的怒海项目中，我另外加入了一个全局状态来控制一个更大范围的状态，比如无敌状态，在无敌的时候各个状态会有另外的一系列行为。加入把无敌状态也对等封装的话需要封装更多的状态，增加了逻辑复杂度。

Nin_Cool
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity有限状态机Demo下载
07-28
https://blog.csdn.net/q764424567/article/details/119182977 下载前，请先看一下这篇文章
游戏开发中的有限状态机（FMS）
qq_39361474的博客
03-04 795
游戏开发中的有限状态机（FMS） 这个可以看成是一个AI模板，无论大小游戏中敌人以及一些NPC都是是游戏中不可或缺的一些元素，他们AI的好坏会严重影响我们的游戏体验，而有限状态机可以制作一些简单的AI，并且可以保持逻辑的有序性以及代码的可阅读性。 创建一个最基本的接口，所有状态都基于这个接口 public interface IState { void OnEnter();//进入状态 void OnUpdate();//状态进行中 void OnExit();//离开状态 }
使用有限状态自动机实现C语言的声明解析器
河西无名式
10-12 2828
摘要：在很多的游戏编程中，我们使用了有限状态自动机作为模型。有限状态自动机作为变成模型，具有通用性好，方便理解的特点。本文主要结合前一个系列的两篇文章（1）C语言声明解析器的实现和（2）用C语言实现有限状态自动机 来说明如何用有限状态自动机模型实现一个C语言的声明解析器。
[游戏架构] 有限状态机的实际应用
hhh314159的博客
03-03 929
有限状态机（Finite State Machine，简称FSM）是一种常用的计算机科学中的建模工具，用于描述由离散状态和状态之间的转换组成的系统。它主要由一个有限的状态集合、一个初始状态、一个输入事件集合、状态之间的转换以及与每个状态相关联的输出动作组成。
FSM:网络游戏开发中的有限状态机（实践篇）
peter_teng的专栏
06-22 8481
上一篇文章《FSM:网络游戏开发中的有限状态机（理论篇）》中，讲解了FSM的基础知识。这里，我结合图形及具体例子，讲解下FSM在实际开发中的运用。 首先，图解下上篇文章中提到的各种action。 1.InputAction：某状态下收到某事件，输出相应动作。这里不发生状态变更，只是对输入事件的一个响应。属于瞬时动作。 2.LeaveAction：离开某一状态时的相应动作。这个
MekaStasis-1.0-Unity有限状态机编辑器工具
最新发布
04-26
MekaStasis，Unity有限状态机编辑器 这是一个小型Unity工具，用于帮助创建有限状态机。主要是为快速原型设计和帮助调试而开发的。截至版本1.0，其功能包括： - 状态States！ - 可重用操作Reusable Actions。您可以...
[世嘉MD开发]C语言有限状态机.zip
01-16
C语言实现的FSM有限状态机，环境是vscode+SGDK，SGDK是开发世嘉MD游戏用的开发工具，不懂的可以看我博客学习。
unity有限状态机02
02-20
视频通过一个简单的坦克射击游戏，介绍了unity游戏开发时用到的有限状态机
unity3D有限状态机
02-17
有限状态机，附带工程及源码，清晰注释
一个有趣的有限状态机的JAVA实现
07-10
知道如何用java+有限状态机把大象塞进冰箱吗？
有限状态机游戏编程
05-07
1.人物类的实现（以Mao类为例） 2.状态类的实现（以MaoOwnedStates为例） 3.消息系统的添加（以CommandorOwnedStates为例）
Cocos2d-x游戏开发之有限状态机(FSM)
翻肚鱼儿的博客
09-17 454
首先来看基本上所有的软件都是有限状态机（finite-state machine，FSM）。它是一个有向图，由一组节点和一组相应的转移函数组成。通俗点讲，它是一个事件驱动系统的模型，这个模型由有限数目的状态，若干输入和状态与状态之间转换的规则组成。在某一时刻，有一个或一组状态是FSM的当前状态，FSM接收输入事件并根据转换规则，将当前状态转为新的状态。正是由于这三个元素的组合，使得FSM具备了自己的行为特点。在游戏开发中，FSM被用来实现人工智能的决策过程，控制游戏对象的行为。 1、最简单的状态机 可能
Lemmings_HDLbits(旅鼠游戏——基于Verilog描述的有限状态机简单小游戏)
NJUzzf98的博客
04-09 3913
旅鼠游戏中的动物行为很简单 ，我们将使用有限状态机FSM对其进行建模。
【游戏设计模式】之三 状态模式、有限状态机 & Unity版本实现
热门推荐
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
10-16 6万+
游戏开发过程中，各种游戏状态的切换无处不在。但很多时候，简单粗暴的if else加标志位的方式并不能很地道地解决问题，这时，就可以运用到状态模式以及状态机来高效地完成任务。状态模式与状态机，因为他们关联紧密，常常放在一起讨论和运用。而本文将对他们在游戏开发中的使用，进行一些探讨。 PS:这篇文章起源于《Game Programming Patterns》第二章第六节。这是一篇略长的文章，约5200
游戏开发之状态机的实现与优化
Zzz的专栏
05-21 2940
转自：http://bbs.gameres.com/thread_479479_1_1.html注：单线程思考引言　　你是否还在面对乱作一团的代码束手无策？你是否仍然觉得复杂的逻辑无从下手？你是否觉得游戏AI高端得毫无头绪？本文将以一个复杂的弹窗逻辑和RPG游戏挂机AI的实现为案例，讲述状态机的概念及其写法。　　本文分为以下部分：　　有限状态机（finite-state machine）：对状态机...
游戏服务器之AI设计——有限状态机
littleschemer的博客
01-06 4115
游戏世界里有各种各样的AI行为，例如怪物砍人，玩家自动挂机等等。一个游戏好不好玩，很重要一点就是游戏的A质量，毕竟PVE占玩家游戏时间很大比重。当然，游戏AI设计难度非常大。本文介绍如何使用有限状态机实现简单的游戏AI逻辑。
游戏 AI 设计之 FSM 有限状态机
zhanxi1992的专栏
03-07 8682
有限状态机（finite-state machine，缩写：FSM）又称有限状态自动机（finite-state automaton，缩写：FSA），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学计算模型。 　　从历史上来说，有限状态机是一个被数学家用来解决问题的严格形式化的设备。在人工智能变成中，我们可以建 FSM 理解为： 　　一个有限状态机是一个设备，或是一个设备模型，具有有限数量的状态，它可以在任何给定的时间根据输入进行操作，使得从一个状态变换到另一个状态，或者是促使一个输出
游戏开发中的状态机实现
weixin_30568591的博客
07-06 194
一、最简单的有限状态机包括一个FiniteStateMachine类和一个FsmState类。FsmState类只有了Enter/Update/Exit三个函数。FiniteStateMachine提供ChangeState。 if (currentState != null) currentState.Exit(); currentState = newState; if (...
unity 中有限状态机
03-28
Unity中的有限状态机（FSM）是一种流程控制方法，它将一个对象或一个系统划分为多个状态，并且根据一定的条件和规则来决定何时转换到另一个状态。FSM在游戏开发中非常常见，因为游戏中有许多对象都需要根据不同的条件和规则进行状态转换，例如玩家角色、敌人AI、动画控制等。 在Unity中，可以通过编写脚本来实现有限状态机。常见的实现方式是使用枚举类型来定义不同的状态，并在脚本中编写转换条件和规则。例如，以下是一个简单的有限状态机脚本示例： ``` public enum PlayerState { Idle, Walk, Run, Jump, Attack } public class Player : MonoBehaviour { private PlayerState currentState; void Start() { currentState = PlayerState.Idle; } void Update() { switch(currentState) { case PlayerState.Idle: if(Input.GetKeyDown(KeyCode.Space)) { currentState = PlayerState.Jump; } else if(Input.GetAxis("Horizontal") != 0) { currentState = PlayerState.Walk; } break; case PlayerState.Walk: if(Input.GetKeyDown(KeyCode.Space)) { currentState = PlayerState.Jump; } else if(Input.GetAxis("Horizontal") == 0) { currentState = PlayerState.Idle; } else if(Input.GetKey(KeyCode.LeftShift)) { currentState = PlayerState.Run; } break; case PlayerState.Run: if(Input.GetKeyDown(KeyCode.Space)) { currentState = PlayerState.Jump; } else if(Input.GetAxis("Horizontal") == 0) { currentState = PlayerState.Idle; } else if(!Input.GetKey(KeyCode.LeftShift)) { currentState = PlayerState.Walk; } break; case PlayerState.Jump: if(transform.position.y < 0) { currentState = PlayerState.Idle; } break; } } } ``` 在这个例子中，定义了五种不同的玩家状态：Idle、Walk、Run、Jump和Attack。在Start方法中，将当前状态设置为Idle。在Update方法中，根据当前状态不同的转换条件和规则，决定何时转换到另一个状态。例如，如果当前状态为Idle，并且玩家按下了空格键，就会转换到Jump状态。如果当前状态为Walk，并且玩家没有按下左Shift键，就会转换到Idle状态。 通过这种方式，可以轻松实现复杂的状态转换逻辑，从而使游戏对象在不同的状态下具有不同的行为和动画效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值