游戏AI的创造思路-技术基础-行为树

最新推荐文章于 2024-11-10 11:30:20 发布
最新推荐文章于 2024-11-10 11:30:20 发布
阅读量1.5k 收藏 15
点赞数 43
分类专栏： AI 游戏 文章标签： 游戏 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37694276/article/details/140379822
版权
AI 同时被 2 个专栏收录
32 篇文章 1 订阅
订阅专栏
游戏
32 篇文章 0 订阅
订阅专栏

行为树源自于游戏，但又不单单局限在游戏中，现代的行为树为游戏提供了一套快速简洁的控制NPC/AI的方法。所以本篇来讲讲行为树这个老祖宗~~~~

目录

1. 行为树的定义

2. 发展历史

2.1. 起源与早期发展

2.2. 关键节点与重要进展

2.3. 当前现状与未来

3. 行为树用到的“公式”和函数

3.1. 节点类型与逻辑判断

3.2. 概率选择（Random Selector）

3.3. 权重计算（在某些扩展应用中）

3.4. 状态管理与转换

3.5. 性能优化与算法选择

3.6. 行为树的表示

4. 行为树的运行原理

4.1. 行为树的运行原理

4.2. Python代码实现

5. 行为树的优缺点和解决方法

5.1. 行为树的优点

5.2. 行为树的主要缺点和解决方法

5.2.1. 性能消耗

5.2.2. 灵活性不足

5.2.3. 调试困难

5.2.4. 设计复杂度高

6. 行为树的运用实例

6.1. 行为树在《光环》中的应用

6.1.1. 结构设计

6.1.2. NPC行为定义

6.1.3. 条件与决策

6.1.4. 灵活性与可扩展性

6.2. 《光环》中行为树的一种可能的实现方法

1. 行为树的定义

行为树（Behavior Tree, BT）是一种用于表示和执行智能体（如游戏中的角色）行为的图形化建模语言。

它由节点组成，这些节点按照树状结构排列，每个节点代表一个行为或决策。

行为树通过遍历树结构，根据节点的类型和状态来执行相应的行为或决策逻辑。

2. 发展历史

行为树（Behavior Tree，简称BT）的发展历程可以追溯到其在计算机科学、机器人学、控制系统和电子游戏等领域的应用与发展。以下是对行为树发展历程的详细介绍，包括关键节点：

2.1. 起源与早期发展

起源：
行为树最初起源于电脑游戏产业，作为一种模拟非玩家角色（NPC）行为的强大工具。它们被设计用于以模块化的方式描述有限任务集之间的切换，从而创建复杂的AI行为。

早期发展：

  • 概念提出：行为树的概念最初由某些研究者提出，用于解决状态机（FSM）在复杂系统中维护困难的问题。行为树通过树状结构表示AI的行为决策，使得系统更加模块化和易于管理。
  • 关键思想：行为树采用节点描述行为逻辑，节点之间通过父子关系连接，形成一棵树状结构。不同类型的节点（如组合节点、装饰器节点、条件节点、行为节点）在执行过程中返回不同的状态（成功、失败、运行中），从而控制整个行为树的执行流程。

2.2. 关键节点与重要进展

行为树理论的完善：

  • 随着研究的深入，行为树的理论逐渐完善。研究者们提出了多种类型的节点和组合方式，如选择节点、顺序节点、并行节点等，以应对不同的行为决策需求。
  • 行为树的执行逻辑和状态管理机制也得到了进一步的优化和改进。

在游戏产业的应用与推广：

  • 行为树因其直观、易于设计和调试的特点，在游戏产业中得到了广泛的应用。许多备受瞩目的电子游戏，如《光晕》、《生化奇兵》和《孢子》等，都采用了行为树来模拟NPC的行为。
  • 游戏开发者社区对行为树的支持和推广，进一步加速了其行为树技术的发展和普及。

在机器人学和控制系统中的应用：

  • 近年来，行为树逐渐扩展到机器人学和控制系统领域。研究者们发现，行为树在描述复杂机器人的行为决策方面具有显著优势。
  • 行为树被用于控制无人机、复杂机器人以及多机器人系统的多任务执行，展现出强大的灵活性和可扩展性。

事件驱动行为树的提出：

  • 为了解决经典行为树在可伸缩性方面的一些问题，研究者们提出了事件驱动行为树的概念。事件驱动行为树通过引入事件处理机制，使得行为树能够更灵活地响应外部事件和中断。
  • 事件驱动行为树的提出标志着行为树技术进入了一个新的发展阶段，其在复杂系统和实时控制系统中的应用前景更加广阔。

2.3. 当前现状与未来

当前现状：

  • 行为树已经成为一种成熟且广泛应用的AI行为决策工具。在游戏开发、机器人学、控制系统等多个领域都能看到其行为树的身影。
  • 随着技术的不断发展，行为树的性能和效率也在不断提高，以满足更复杂和实时性要求更高的应用场景。

未来：

  • 行为树技术将继续在各个领域得到深入应用和发展。随着人工智能和机器人技术的不断进步，行为树作为一种重要的行为决策工具，其重要性将日益凸显。
  • 未来，我们可以期待看到更多创新性的行为树变体和应用案例的出现，以应对更加复杂和多样化的AI行为决策需求。

3. 行为树用到的“公式”和函数

行为树算法（Behavior Tree, BT）是一种用于控制任务执行流程的分层节点树模型，它广泛应用于计算机科学、机器人、控制系统和视频游戏等领域。行为树通过模块化的方式描述任务集之间的切换，使得复杂任务的实现变得简单且易于管理。然而，行为树算法本身并不直接依赖于复杂的数学公式或函数，而是更多地依赖于逻辑判断和状态管理。以下是对行为树算法中可能涉及的一些数学元素和函数概念的详细介绍：

3.1. 节点类型与逻辑判断

行为树由不同类型的节点组成，包括根节点、复合节点（如Selector、Sequence、Parallel等）和叶子节点（条件节点和动作节点）。这些节点在执行过程中，会根据内部逻辑或外部条件进行判断，从而决定下一步的执行路径。

  • 条件节点：通常用于判断某个条件是否满足，返回布尔值（true或false）。条件节点的内部实现可能涉及简单的比较运算（如==、!=、<、>等），但这些并不构成复杂的数学公式。
  • 动作节点：执行具体的行为或操作，并返回执行结果（通常是成功或失败）。动作节点的执行可能依赖于一些参数或变量，但这些参数的处理通常也是基于简单的赋值或条件判断。

3.2. 概率选择（Random Selector）

在Random Selector节点中，子节点的选择是随机的。这通常通过生成随机数并与子节点关联的权重进行比较来实现。这里涉及的数学函数主要是随机数生成函数（如C++中的rand()函数或特定库中的随机数生成器）。虽然随机数生成背后可能有复杂的算法支持，但在行为树的上下文中，这些算法被抽象为简单的函数调用。

3.3. 权重计算（在某些扩展应用中）

在一些高级应用中，行为树节点可能会被赋予权重，以表示其优先级或重要性。权重的计算可能涉及简单的算术运算（如加法、乘法），但这些运算并不构成复杂的数学公式。权重的使用通常是在选择节点时进行的，通过比较权重来决定哪个节点应该被执行。

3.4. 状态管理与转换

行为树通过节点的状态（如成功、失败、运行中）来管理任务的执行流程。状态之间的转换通常基于节点的执行结果和逻辑判断。虽然状态管理本身不涉及复杂的数学公式，但它要求开发者对任务执行流程有清晰的理解，并能够正确地设计节点之间的逻辑关系。

3.5. 性能优化与算法选择

在行为树的实现过程中，可能会考虑性能优化的问题。例如，通过减少不必要的节点遍历、优化条件判断的逻辑等方式来提高执行效率。这些优化措施可能涉及到算法的选择和应用，但通常不会涉及复杂的数学公式或函数。

3.6. 行为树的表示

行为树算法本身并不直接依赖于复杂的数学公式或函数。它更多地是通过逻辑判断和状态管理来实现任务的控制和执行。

然而，在行为树的实现和优化过程中，可能会涉及一些简单的数学运算和算法选择。

对于想要深入了解行为树算法的开发者来说，掌握基本的编程逻辑和算法知识是非常重要的。

虽然行为树的核心并不在于数学公式，但节点中确实会用到一些条件函数或行为函数来决定节点的执行。

这些函数通常是根据智能体的状态或环境参数来定义的，例如：

def is_enemy_in_range(entity, enemy):  
    # 检查敌人是否在实体的攻击范围内  
    return distance(entity.position, enemy.position) < entity.attack_range  
  
def attack(entity, enemy):  
    # 实体攻击敌人的行为  
    print(f"{entity.name} is attacking {enemy.name}!")

在行为树中，这些函数会被用作装饰器节点或任务节点的条件或行为。

4. 行为树的运行原理

行为树（Behavior Tree, BT）的运行原理基于树状结构的遍历和执行。

行为树由不同类型的节点组成，包括任务节点（Task Nodes）、装饰器节点（Decorator Nodes）和组合节点（Composite Nodes）。

每种节点类型在执行时都有其特定的行为或决策逻辑。

4.1. 行为树的运行原理

  1. 根节点开始：行为树的执行从根节点开始。

  2. 节点遍历：根据节点的类型，行为树遍历器（或称为“执行器”）决定如何遍历子节点。

    • 对于组合节点，遍历器会根据其特定的逻辑（如顺序执行、选择执行等）遍历其子节点。
    • 对于装饰器节点，遍历器会先执行装饰器节点的逻辑，然后根据结果决定是否遍历其子节点。
    • 对于任务节点，遍历器会直接执行任务节点的行为，并返回执行结果。

  3. 状态返回：每个节点在执行完毕后都会返回一个状态，通常包括成功（SUCCESS）、失败（FAILURE）和运行中（RUNNING）。这些状态会被传递给父节点，并最终影响整个行为树的执行结果。

  4. 递归执行：行为树的执行是一个递归过程。遍历器会递归地遍历和执行每个节点，直到达到叶子节点或满足特定的终止条件。

4.2. Python代码实现

下面是一个简单的Python代码示例，实现了一个完整的行为树构建并进行简单行为决策的过程。

# 定义行为树节点的基类  
class BTNode:  
    def tick(self, context):  
        raise NotImplementedError  
  
# 定义任务节点  
class ActionNode(BTNode):  
    def __init__(self, name, action):  
        self.name = name  
        self.action = action  
  
    def tick(self, context):  
        print(f"Executing action: {self.name}")  
        self.action(context)  
        return "SUCCESS"  
  
# 定义装饰器节点  
class ConditionNode(BTNode):  
    def __init__(self, name, condition):  
        self.name = name  
        self.condition = condition  
        self.child = None  
  
    def tick(self, context):  
        print(f"Checking condition: {self.name}")  
        if self.condition(context):  
            if self.child:  
                return self.child.tick(context)  
            return "SUCCESS"  
        else:  
            return "FAILURE"  
  
# 定义组合节点（选择器）  
class SelectorNode(BTNode):  
    def __init__(self, name):  
        self.name = name  
        self.children = []  
  
    def tick(self, context):  
        print(f"Executing selector: {self.name}")  
        for child in self.children:  
            result = child.tick(context)  
            if result == "SUCCESS":  
                return "SUCCESS"  
        return "FAILURE"  
  
# 定义上下文环境  
class Context:  
    def __init__(self):  
        self.has_enemy = True  
        self.is_hungry = False  
  
# 定义具体的行为和条件函数  
def attack_enemy(context):  
    print("Attacking enemy!")  
  
def is_enemy_present(context):  
    return context.has_enemy  
  
def eat_food(context):  
    print("Eating food!")  
  
def is_hungry(context):  
    return context.is_hungry  
  
# 构建行为树  
root = SelectorNode("Root")  
  
attack_sequence = SelectorNode("AttackSequence")  
attack_sequence.children.append(ConditionNode("IsEnemyPresent", is_enemy_present).set_child(ActionNode("AttackEnemy", attack_enemy)))  
  
eat_sequence = SelectorNode("EatSequence")  
eat_sequence.children.append(ConditionNode("IsHungry", is_hungry).set_child(ActionNode("EatFood", eat_food)))  
  
root.children.append(attack_sequence)  
root.children.append(eat_sequence)  
  
# 执行行为树  
context = Context()  
result = root.tick(context)  
print(f"Behavior tree execution result: {result}")

这个例子中我们定义了一个简单的行为树，它包括两个选择器节点（AttackSequence 和 EatSequence），每个选择器节点下都有一个条件节点和一个动作节点。

行为树从根节点开始执行，并根据条件节点的结果选择执行相应的动作节点。

最后，打印出行为树的执行结果。

5. 行为树的优缺点和解决方法

5.1. 行为树的优点

优点：

  1. 模块化：行为树的结构使得行为可以很容易地被添加、修改和重用。
  2. 可扩展性：通过添加新的节点类型或组合现有节点，可以处理复杂的决策逻辑。
  3. 可视化：行为树的可视化表示使得开发者能够更容易地理解和调试AI行为。

5.2. 行为树的主要缺点和解决方法

5.2.1. 性能消耗

问题描述：行为树在每一帧都会从根节点开始执行，这可能导致相对于状态机（FSM）消耗更多的CPU资源。特别是当行为树结构复杂、节点众多时，性能问题尤为突出。

解决方法：

  • 优化树结构：通过简化行为树结构，减少不必要的节点和层次，可以降低性能消耗。
  • 使用记忆节点：对于某些控制流节点（如Sequence和Fallback节点），可以实现记忆功能，即缓存子节点的执行结果，避免重复执行相同的子节点。
  • 并行处理：利用并行计算技术，同时处理多个子节点的执行，提高整体执行效率。

5.2.2. 灵活性不足

问题描述：行为树的设计依赖于固定的架构，不够灵活。在设计时做出的选择可能不是最优的，且每次执行都需要经过大量的逻辑判断。

解决方法：

  • 动态调整：设计允许在运行时动态调整行为树结构的机制，以应对不同的情况和需求。
  • 引入其他算法：结合其他算法（如GOAP，目标导向型行动计划）来弥补行为树在灵活性方面的不足。
  • 模块化设计：将行为树拆分为多个模块，每个模块负责特定的功能，通过模块的组合和替换来实现不同的行为逻辑。

5.2.3. 调试困难

问题描述：行为树的调试相对于状态机来说可能更为复杂，因为行为树的执行流程更加动态和复杂。

解决方法：

  • 可视化工具：使用行为树的可视化工具来构建和调试行为树，可以直观地看到节点的执行状态和流程变化。
  • 日志记录：在行为树的执行过程中记录详细的日志信息，包括节点的执行结果、状态变化等，以便于调试和问题分析。
  • 单元测试：对行为树中的关键节点和逻辑进行单元测试，确保它们的正确性和稳定性。

5.2.4. 设计复杂度高

问题描述：设计一个高效且合理的行为树需要较高的设计复杂度和对任务逻辑的深入理解。

解决方法：

  • 文档和设计规范：制定详细的设计文档和规范，明确行为树的设计目标和原则，降低设计复杂度。
  • 经验分享：借鉴其他成功项目中的行为树设计经验，通过交流和分享来提高设计水平。
  • 迭代优化：在项目开发过程中不断迭代和优化行为树的设计，根据实际情况进行调整和改进。

6. 行为树的运用实例

6.1. 行为树在《光环》中的应用

《光环》系列游戏是一款知名的科幻第一人称射击游戏，由微软旗下的343 Industries开发。

6.1.1. 结构设计

在《光环》中，行为树的结构被精心设计以应对复杂的游戏场景。行为树可能包含多个层级，每个层级处理不同级别的决策。例如，顶层节点可能负责选择当前的主要行为（如进攻、防御、撤退等），而子节点则负责执行具体的动作（如移动、射击、使用道具等）。

6.1.2. NPC行为定义

通过行为树，开发者可以为NPC定义一系列行为，这些行为可以根据游戏状态和NPC状态动态调整。例如：

  • 进攻行为：当NPC检测到敌人时，可能会触发进攻行为。进攻行为可能包括移动到攻击位置、瞄准敌人、射击等动作。
  • 防御行为：当NPC受到威胁或生命值较低时，可能会采取防御行为，如寻找掩体、躲避攻击等。
  • 协助玩家行为：在某些情况下，NPC可能会协助玩家完成任务，如跟随玩家、提供火力支援等。
  • 撤退行为：当NPC无法有效对抗敌人或生命值极低时，可能会选择撤退以保存实力。

6.1.3. 条件与决策

行为树中的条件节点用于评估当前游戏状态和NPC状态，以决定是否执行某个动作。

例如，一个条件节点可能检查NPC是否能看到敌人，如果能看到，则继续执行进攻行为；

如果看不到，则可能执行搜索或巡逻行为。

6.1.4. 灵活性与可扩展性

行为树的设计使得NPC行为具有高度的灵活性和可扩展性。开发者可以轻松添加、删除或修改节点，以适应游戏需求的变化。

此外，行为树还支持模块化设计，不同的行为可以封装成独立的子树，便于复用和维护。

6.2. 《光环》中行为树的一种可能的实现方法

《光环》游戏中使用行为树算法控制NPC行为是一种高效且灵活的方法。通过行为树，开发者可以定义复杂的NPC行为逻辑，并根据游戏状态动态调整NPC的行为。尽管存在性能开销和设计复杂度的挑战，但行为树的优点使得它在游戏AI领域得到了广泛应用。

需要注意的是，由于《光环》游戏的具体实现细节并未完全公开，以上信息主要基于行为树算法的一般原理和游戏AI领域的通用知识进行推断和总结。

尽管《光环》游戏本身并没有公开其具体的AI实现细节，可以肯定的是至少使用了行为树算法来控制NPC（非玩家角色）的行为。

我们可以根据行为树算法的一般原理来构想一个在《光环》游戏中可能的应用实例。

在《光环》游戏中，NPC的行为可能非常复杂，包括策略制定、进攻、防御、协助玩家、指挥撤退以及使用各种道具。行为树算法可以很好地组织和管理这些行为，使得NPC能够根据当前的游戏环境和玩家的行为做出合理的反应。

《光环》游戏中使用行为树算法控制NPC（非玩家角色）行为是一个复杂的系统，它允许游戏开发者以灵活且可维护的方式定义NPC在各种游戏情境下的反应和行为。以下是对《光环》游戏中使用行为树算法控制NPC行为的详细介绍：

以下是一个简化的行为树结构，用于控制《光环》游戏中的NPC行为：

Root  
├── Selector (Priority Selector)  
│   ├── Strategy (制定策略)  
│   ├── Attack (进攻)  
│   ├── Defend (防御)  
│   ├── AssistPlayer (协助玩家)  
│   └── Retreat (指挥撤退)  
└── Sequence (执行一系列动作)  
    ├── UseItem (使用道具)  
    │   ├── UseGrenade (使用手雷)  
    │   ├── UseMedikit (使用医疗包)  
    │   └── UseStimpack (注射兴奋剂)  
    └── ... (其他可能的行为)

Python代码实现

完整的Python实现代码，它模拟了《光环》游戏中NPC使用行为树算法来控制其行为。这个实现包含了进攻、防御、协助玩家和撤退等行为的简单逻辑。

import random  
  
# 行为节点类
class BehaviorNode:  
    def execute(self, context):  
        pass  

#  选择器节点
class SelectorNode(BehaviorNode):  
    def __init__(self, children):  
        self.children = children  
  
    def execute(self, context):  
        for child in self.children:  
            if child.execute(context):  
                return True  
        return False  

# 序列节点类  
class SequenceNode(BehaviorNode):  
    def __init__(self, children):  
        self.children = children  
  
    def execute(self, context):  
        for child in self.children:  
            if not child.execute(context):  
                return False  
        return True  

# 行为节点类  
class ActionNode(BehaviorNode):  
    def __init__(self, action):  
        self.action = action  
  
    def execute(self, context):  
        return self.action(context)  

# 条件节点类  
class ConditionNode(BehaviorNode):  
    def __init__(self, condition):  
        self.condition = condition  
  
    def execute(self, context):  
        return self.condition(context)  
  
# 定义特别条件
# 看到敌人 
def can_see_enemy(context):  
    return context.get('enemy_visible', False)  

# 健康低  
def is_health_low(context):  
    return context.get('health', 100) < 30  

# 玩家靠近  
def player_nearby(context):  
    return context.get('player_distance', float('inf')) < 10  
  
# 攻击行为  
def attack_action(context):  
    print("NPC is attacking.")  
    return True  

# 防御行为  
def defend_action(context):  
    print("NPC is defending.")  
    return True  

# 协助玩家行为  
def assist_player_action(context):  
    print("NPC is assisting the player.")  
    return True  

# 撤退行为  
def retreat_action(context):  
    print("NPC is retreating.")  
    return True  

# 策略动作行为 
def strategy_action(context):  
    # Implement strategy logic  
    print("NPC is formulating a strategy.")  
    return True  
  
# 构建行为树
root = SelectorNode([  
    SequenceNode([  
        ConditionNode(can_see_enemy),  
        ActionNode(attack_action)  
    ]),  
    SequenceNode([  
        ConditionNode(is_health_low),  
        ActionNode(retreat_action)  
    ]),  
    SequenceNode([  
        ConditionNode(player_nearby),  
        ActionNode(assist_player_action)  
    ]),  
    ActionNode(defend_action)  # Fallback behavior  
])  
  
# 执行行为树
context = {  
    'enemy_visible': True,  
    'health': 80,  
    'player_distance': 5  
}  
  
   
root.execute(context)

在这个实现中，我们定义了四种类型的节点：

  • BehaviorNode（所有节点的基类），
  • SelectorNode（选择器节点，用于从子节点中选择一个执行），
  • SequenceNode（序列节点，用于按顺序执行所有子节点），
  • ActionNode（动作节点，用于执行具体的动作），
  • ConditionNode（条件节点，用于评估某个条件是否满足）。

我们还定义了几个具体的条件和动作，用于模拟NPC的不同行为。

最后，我们创建了一个行为树，并将其与一个包含游戏状态的上下文对象一起执行。

根据上下文中的状态，NPC将执行相应的行为。

OpenAI创始人：GPT-4的研究起源和构建心法
OneFlow深度学习框架
03-20 1万+
三十年前，互联网（Web 1.0）时代开启。人们只能在笨重的电脑上用鼠标点击由HTML编写的网页文本，随后开始支持插入图片，可以上传视频，于是有了网络新闻、搜索、电子邮件、短信、网游......互联网带来了全新的商业模式，深刻改变了人们的生产生活。三十年后的当下，以ChatGPT为代表的大模型问世了。起初人们拿它当玩具，直到ChatGPT的诞生与人类实现惊...
GPT-4创造者：第二次改变AI浪潮的方向
热门推荐
OneFlow深度学习框架
03-27 1万+
一朝成名天下知。ChatGPT/GPT-4相关的新闻接二连三刷屏朋友圈，如今，这些模型背后的公司OpenAI的知名度不亚于任何科技巨头。不过，就在ChatGPT问世前，OpenAI在GPT-3发布后的两年多时间里陷入沉寂，甚至开始被人唱衰。实际上，OpenAI在这期间正在潜心打磨GPT-3.5。在OneFlow去年3月发布的《深度学习崛起十年：...
AI之用行为树来实现逻辑
寒风的技术博客
03-03 4308
行为树是一种在游戏中常用的实现AI的方式，通过行为树可行图形化实现常用的程序结构。一 行为树节点类型每次执行AI时，从根节点(root)或running节点开始遍历，父节点执行子节点，子节点执行完后将结果返回父节点，父节点根据子节点的结果来决定接下来怎么做。通常每个节点有三个状态：成功(success)，失败(failure)，执行中(running)。行为树的遍历实际上是一次函数调用，立即完成的，
godot_behavior_tree:Godot游戏引擎的行为树模块
06-27
Godot 引擎的行为树 参考 作者：Alex J. Champandard 作者：Chris Simpson Renato Pereira 的 Bjoern Knafla 的（这一系列行为树真的很有帮助，可惜因为altdev.co 已死，原帖无法访问） 编译为 Godot 模块 将src目录链接或复制到$(GODOT_ROOT)/modules/behaviortree ，然后 。 用法 使用这个模块成功编译 godot 引擎后，你可以在编辑器中找到这些新类型的节点： BTRootNode 、 BTParallelNode 、 BTSelectorNode 、 BTSequenceNode 、 BTDecoratorNode 、 BTActionNode 。 BTActionNode 、 BTDecoratorNode和BTRootNode可以通过脚本进行扩展以创建您自己的 AI。
MMORPG游戏的人工智能（AI）和行为树设计
最新发布
听老罗娓娓道来
11-10 862
为每个目标定义相应的行为节点。攻击节点：检查玩家是否在攻击范围内，执行攻击动作。巡逻节点：在预设路径上移动，检查周围环境。逃跑节点：在生命值低于某个阈值时，寻找安全地点逃跑。行为树的节点可以分为三类：动作节点、条件节点和控制节点。每种节点都有特定的功能。pass通过将状态机与行为树结合，并引入事件驱动的设计，我们可以创建出更复杂和灵活的NPC AI。这种设计使得NPC能够根据游戏中的动态变化做出反应，从而提供更丰富的游戏体验。
使用行为树(Behavior Tree)实现游戏AI
vanadiumlin
09-10 847
原创题目：使用行为树(Behavior Tree)实现游戏AI 原创作者： AKara 发布日期：2010-12-09 作者Bolg： http://blog.csdn.net/akara 原文出处： http://blog.csdn.net/akara/archive/2010/12/19/6084786.aspx 联系方式： akaras@163.com --...
开发游戏AI之行为树
TxNet
06-12 6938
采用行为树快速开发游戏AI 腾讯互娱研发部引擎技术中心 黄晨               游戏AI的目标之一就是要找到一种简单并可扩展的开发逻辑的方案，常用的技术包括有限状态机（FSM）、分层有限状态机（HFSM）、面向目标的动作规划（GOAP）、分层任务网络（HTN）等。 行为树作为次时代的AI技术，距其原型提出也约有10年左右，像Halo、Spore、Crysis等大作
游戏AI设计经验分享——行为树的研究
zhaishengfu的专栏
07-19 1万+
#xhe_tmpurl
游戏AI之行为树（中）
aaa
04-01 1260
游戏AI之行为树（中） 介绍了共有的功能，接下来说三个主要的行为树节点的原型： Composite Decorator Leaf Composite 合成节点 合成节点可以有一个或多个子节点。它们处理子节点的顺序可以是从第一个到最后一个，或者某些特定的合成节点的随机顺序，在某一阶段会根据它的子节点的处理结果向它的父节点返回success或者failure，通常这取
人工智能-数据挖掘-转型中YL公司客服中心营销能力提升研究——基于数据挖掘方法.pdf
06-29
随着科技的飞速发展，人工智能和数据挖掘技术已经成为现代社会各个领域转型和升级的重要推动力。特别是在金融服务业，如YL公司客服中心的转型中，这些技术的应用显得尤为重要。YL公司作为一个金融服务提供商，在面对...
人工智能-机器学习-视觉语法视角下汽车平面广告多模态隐喻的态构建.pdf
05-24
特别是在汽车平面广告这一特定领域，通过人工智能和机器学习技术的应用，使得广告设计变得更加精准和高效，同时也为相关的理论研究和实际应用提供了新的思路和工具。 综上所述，人工智能与机器学习技术对视觉语法...
游戏AI编程——行为树（Behavior Tree）教程
02-23
行为树构造原理讲解，行为树知识规范，实现例程等
behave:Python 中的行为树实现
06-06
行为：Python 中的行为树实现 使用behave ，你可以定义一个这样的行为树： tree = ( is_greater_than_10 >> wow_large_number | is_between_0_and_10 >> count_from_1 | failer * repeat(3) * doomed ) bb = tree.blackboard(10) while bb.tick() == RUNNING: pass 从行为导入： from behave import condition, action, FAILURE 定义条件节点 条件由函数定义，返回一个bool值。 该函数可以接受任意数量的参数。 @condition def is_greater_than_10(x): return x > 10 @conditi
信息社会与人工智能- 教育领域中的人工智能创新思路
传统的教学模式逐渐无法满足当今社会对于知识传授和人才培养的需求，因此需要结合人工智能等先进技术，重新审视和打造教育模式。 ## 1.2 人工智能在教育中的应用现状分析 人工智能在教育领域的应用已经逐渐成熟，...
游戏AI——行为树的简单实现（一）功能分析
海王星很危险的博客
10-03 2174
        行为树的实现主要分为两部分，节点的轮询机制与节点内的逻辑执行。 1.节点的轮询：         轮询将会在代理对象的Update方法中执行，将会从根节点出发，询问每一个节点的状态，当节点状态为Running时，会继续执行节点的逻辑（例如计时时，状态不会这这一帧的轮询中改为Sucess，那么就将其状态不变——为Running，等下一阵过来时再继续执行，它的父节点依赖于它的状...
行为树（Behavior Tree）
weixin_43735634的博客
01-15 5838
在行为树中，根节点是AI的起点，通过遍历子节点来决策AI的行为。前两个通知其父节点其操作是成功还是失败。下次树被选择时，该节点将再次被选择，此时它将再次有机会成功，失败或继续运行。行为树（Behavior Trees）是一种在游戏开发中广泛使用的AI设计模式，主要用于描述AI的行为和决策过程，实现更加智能和自然的游戏AI。它由多个节点组成，每个节点代表一个行为或决策，按照特定的方式连接在一起，形成一个树状结构。行为树通过模拟树状结构来描述AI的行为和决策过程，使得AI的行为更加灵活、自然和智能。
Unity游戏开发——行为树（Part1）
weixin_49120362的博客
11-13 2571
1.行为树(BehaviorTree) 在游戏中用于控制角色AI的一种实现方式，在游戏AI中对象的动作和行为大部分都是编辑好的（例如攻击移动等）（除非是FIFA那种可能不是提前编辑好的）但是在什么时间什么地点什么条件调用都是不确定的，因此我们要用行为树或者状态机来实现这些对象的决策任务（注意行为树并不是决策树，决策树是为了制定决策，行为树是为了控制行为）。说白话其实就是把各种条件和执行的规则抽象成树的节点，把角色整个对象的AI行为，抽象成一棵树。通过树的节点来决策下一步该做什么不该做什么。
游戏思考25:behaviorTree源码剖析行为树（3.8版本，2023-11-22）
谢白羽
03-25 1102
行为树节点分类1）序列Sequence节点:顺序执行所有子节点，若都成功则返回成功，若有一个失败则返回失败2）循环Loop节点循环执行子节点到指定次数后返回成功，如果循环次数为"-1"，则无限循环3）条件Condition节点根据条件的比较结果，返回成功或失败4）动作Action节点根据动作结果返回”成功“、”失败“或”运行“5）等待Wait节点返回"运行"，一直到指定的时间过去后返回”成功"
游戏AI行为决策——行为树
学习分享、创作。
08-19 209
行为树，是目前游戏中应用较为广泛的一种行为决策模型。这离不开它成熟的可视化编辑工具，例如Unity商城中的「Behaviour Designer」，甚至是虚幻引擎也自带此类编辑工具。而且它的设计逻辑并不复杂，其所利用的树状结构，很符合人的思考方式。接下来，我们会先对它的运作逻辑进行介绍，然后再试图用代码实现它。树状结构在不借助可视化工具的情况下是不容易呈现清楚的，这里我借鉴了Steve Rabin的《》中行为树的实现方式，利用代码缩进稍稍实现了一些可视化（本教程使用C#代码实现）。下面我们就开始吧！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WarghostWu

您的鼓励是我继续创作的最大助力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值
>