Unity-人工智能编程-全-

Unity 人工智能编程(全)

原文:zh.annas-archive.org/md5/2e5d707b292a7af04f675fd8cf182896

译者:飞龙

协议:CC BY-NC-SA 4.0

前言

在 Unity 中为游戏角色开发人工智能(AI)从未如此简单。Unity 为游戏和应用程序开发者提供了各种工具来实现 AI,从基本技术到由机器学习驱动的尖端智能体。通过 Unity 的 API 或内置功能利用这些工具,在创建游戏世界和角色时将拥有无限的可能性。

《Unity 人工智能编程》第五版更新版首先将人工智能分解为简单概念。通过各种示例,本书随后引导你通过实际实现,旨在突出 Unity 中游戏人工智能的关键概念和功能。随着你的进步,你将学习如何实现有限状态机(FSM)以确定 AI 的行为,应用概率和随机性使游戏更难以预测,并实现基本的感觉系统。稍后,你将了解如何设置带有导航网格的游戏地图,通过 A*路径查找等技术实现移动,并使用行为树为角色提供决策能力。

在完成这本 Unity 书籍之后,你将掌握将所学到的所有概念和实践课程整合起来构建一个令人印象深刻的车辆战斗游戏所需的所有技能。

本书面向对象

这本 Unity AI 书籍是为那些对 C#和 Unity 编辑器有基本了解,并希望扩展他们在 Unity 游戏 AI 开发知识领域的 Unity 开发者而编写的。

本书涵盖内容

第一章,人工智能简介,讨论了人工智能是什么以及它在游戏中的应用。我们还讨论了在游戏中实现 AI 的各种技术。

第二章,有限状态机,讨论了一种简化我们管理 AI 需要做出的决策的方法。我们使用有限状态机(FSM)来确定 AI 在特定状态下的行为以及如何过渡到其他状态。

第三章,随机性和概率,讨论了概率的基本原理以及如何改变特定结果的可能性。然后我们探讨如何向我们的游戏添加随机性,使 AI 更难以预测。

第四章,实现传感器,探讨了使我们的角色意识到周围世界的方法。通过我们的角色能够看到和听到,他们将知道敌人何时靠近以及何时攻击。

第五章,群体行为,讨论了许多物体作为一个群体一起移动的情况。我们将探讨两种不同的实现群体行为的方法,以及如何使物体一起移动。

第六章, 路径跟随和转向行为,探讨了 AI 角色如何跟随提供的路径以到达目的地。然后我们看看 AI 角色如何在没有预定义路径的情况下找到目标,只需在移动时朝向目标并避开出现的障碍物。

第七章, 路径查找,讨论了一种流行的算法,用于从给定位置找到目标位置的最佳路径。使用 A*算法,我们扫描地形并找到通向目标的最佳路径。

第八章, 导航网格,讨论了如何利用 Unity 的强大功能使路径查找更容易实现。通过创建导航网格(这需要 Unity Pro),我们将能够以比使用瓦片和 A*算法更好的方式表示我们周围的场景。

第九章, 行为树,教你关于行为树,这是一种流行的游戏 AI 决策技术。我们将探讨行为树的一般架构以及如何使用它们来控制一个简单的智能体。然后我们将使用免费的插件Behavior Bricks将我们的新知识应用到简单的迷你游戏项目中。

第十章, 程序内容生成,探讨了生成式 AI 和程序内容生成的基础知识。我们将看到如何使用 Perlin 噪声生成逼真的地形,以及如何使用细胞自动机生成类似洞穴的地牢地图。

第十一章, Unity 中的机器学习,探讨了如何将机器学习(特别是强化学习)应用于游戏角色或模拟。我们将使用官方的 Unity ML-Agents 工具包。在第一部分,我们将学习如何配置 Unity 和工具包的外部要求。然后我们将展示两个简单的实际示例。

第十二章, 整合所学内容,将你在本书中学到的各种元素整合到一个最后的项目中。在这里,你将应用你学到的剩余 AI 元素,并创建一个令人印象深刻的车辆战斗游戏。

为了充分利用这本书

对于这本书,你只需要安装 Unity3D 的最新版本。本书中的代码项目已在 macOS 和 Windows 上的 Unity 2022 和 Unity 2021 上进行了测试,但经过一些调整,它们也应该适用于未来的版本。

对于第九章, 行为树,你需要为 Unity 安装 Behavior Bricks 插件。在第十一章, Unity 中的机器学习中,我们将安装 Python 3.7 和 PyTorch。

如果你使用的是本书的数字版,我们建议你亲自输入代码或从书的 GitHub 仓库(下一节中提供链接)获取代码。这样做将帮助你避免与代码的复制和粘贴相关的任何潜在错误。

下载示例代码文件

您可以从 GitHub 下载本书的示例代码文件github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition。如果代码有更新,它将在 GitHub 仓库中更新。

我们还提供其他来自我们丰富图书和视频目录的代码包,可在github.com/PacktPublishing/找到。查看它们吧!

下载彩色图像

我们还提供包含本书中使用的截图和图表的彩色 PDF 文件。您可以从这里下载:static.packt-cdn.com/downloads/9781803238531_ColorImages.pdf。

使用的约定

本书使用了多种文本约定。

文本中的代码: 表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称。以下是一个例子:“让我们开始创建PlayerTankController类,通过在PlayerTankController.cs文件中设置Start函数和Update函数来实现。”

代码块应如下设置:

public class PlayerTankController : MonoBehaviour { 
    public GameObject Bullet; 
    public GameObject Turret; 
    public GameObject bulletSpawnPoint;

当我们希望引起你对代码块中特定部分的注意时,相关的行或项目将以粗体显示:

// ... 
    private AudioSource m_ExplosionAudio  
    private ParticleSystem m_ExplosionParticles 
    private float m_CurrentHealth; 
    private bool m_Dead; 
    public float CurrentHealth { get; } 
    // ...

任何命令行输入或输出都应如下编写:

git clone --branch release_19 https://github.com/Unity-Technologies/ml-agents.git

粗体: 表示新术语、重要单词或你在屏幕上看到的单词。例如,菜单或对话框中的单词以粗体显示。以下是一个例子:“如果你播放场景并点击拉杆按钮,你应该能看到最终结果。”

小贴士或重要注意事项

看起来像这样。

联系我们

我们始终欢迎读者的反馈。

一般反馈: 如果你对此书任何方面有疑问,请通过 customercare@packtpub.com 给我们发邮件,并在邮件主题中提及书名。

勘误: 尽管我们已经尽一切努力确保内容的准确性,但错误仍然可能发生。如果你在这本书中发现了错误,我们将不胜感激,如果你能向我们报告这一点。请访问www.packtpub.com/support/errata并填写表格。

盗版: 如果你在互联网上以任何形式发现我们作品的非法副本,如果你能提供位置地址或网站名称,我们将不胜感激。请通过版权@packt.com 与我们联系,并提供材料的链接。

如果您有兴趣成为作者:如果您在某个领域有专业知识,并且您有兴趣撰写或为书籍做出贡献,请访问authors.packtpub.com。

分享您的想法

一旦您阅读了《Unity 人工智能编程 - 第五版》,我们很乐意听听您的想法!请选择www.amazon.in/review/1803238534为这本书并分享您的反馈。

您的评论对我们和科技社区都很重要,并将帮助我们确保我们提供高质量的内容。

第一部分:基本人工智能

在本部分,我们将学习游戏人工智能的目标以及实现简单但有效的 AI 角色的基本技术。

在本部分,我们将涵盖以下章节:

  • 第一章, 人工智能简介

  • 第二章, 有限状态机

  • 第三章, 随机性和概率

  • 第四章, 实现传感器

第一章: 人工智能简介

本书旨在教你使用最流行的商业游戏引擎之一:Unity3D,进行游戏人工智能编程的基础知识。在接下来的章节中,你将学习如何实现任何现代游戏的基础技术,例如行为树和有限状态机。

在此之前,尽管如此,你必须对人工智能有一个基本的了解,尤其是在其更广泛的、学术的、传统的领域。我们将在这个介绍性章节中提供这些信息。然后,我们将学习人工智能在游戏中的应用和实现与其他领域有何不同,以及游戏人工智能的基本和独特需求。最后,我们将探讨游戏中使用的 AI 的基本技术。

在本章中,我们将涵盖以下主题:

  • 理解人工智能

  • 游戏中的 AI

  • 游戏人工智能技术

理解人工智能

智力是所有生物体,如动物和人类,生活中自然且必要的方面。没有智力——在这里以最广泛的方式提及——动物将无法寻找食物,蜜蜂将无法找到花朵,而我们人类将永远无法制造物体或点燃火焰,更不用说在 Unity 中开发游戏了!相反,计算机只是可以接受数据、以高速执行逻辑和数学运算并输出结果的电子设备。它们缺乏任何形式的智力。如果没有人的指示和指导,计算机将永远像石头一样静止不动,毫无生气。

从这个角度来看,人工智能本质上是研究如何赋予机器自然智能火花的一个领域。这是一门教授计算机如何像生物体一样思考和决策,以实现任何目标而不需要人类干预的学科。

如你所想,这是一个庞大的主题。这样一本小书不可能涵盖与人工智能相关的所有内容。幸运的是,为了游戏人工智能的目标,我们不需要对人工智能有全面的知识。我们只需要掌握基本概念并精通基本技术。这正是本书要做的。

但在我们继续探讨特定游戏的技术之前,让我们先看看人工智能的一些主要研究领域:

  • 计算机视觉:这是从视觉源——如视频和照片——获取视觉输入并分析它们以识别对象(对象识别)、面孔(面部识别)、手写文档中的文本(光学字符识别),甚至从立体图像中重建 3D 模型的能力。

  • 自然语言处理(NLP):这允许机器阅读和理解人类语言——也就是说,我们如何书写和说话。问题是人类语言对机器来说很难理解。语言歧义是主要问题:有很多种说法可以表达相同的意思,同一个句子可以根据上下文有不同的含义。NLP 是机器的一个重大认知步骤,因为它们在处理和相应地做出反应之前需要理解我们使用的语言和表达方式。幸运的是,网络上有很多数据集可以帮助研究人员训练机器完成这个复杂任务。

  • 机器学习:这一分支的 AI 研究机器如何仅使用原始数据和经验来学习执行任务,无论是否有人类的干预。这些任务包括从识别一张图片是否包含猫的图像,到玩棋类游戏(例如 AlphaGo 软件,在 2017 年能够击败围棋世界排名第一的选手),再到完美地在我们自制的视频中插值著名演员的面部(所谓的深度伪造)。机器学习是一个涵盖所有其他 AI 领域的广阔领域。我们将在第十一章,Unity 中的机器学习中更多地讨论它。

  • 常识推理:有一种知识几乎是人类与生俱来的。例如,我们轻易地知道如果没有支撑,东西会掉在地上或者我们不能把一个大东西放进一个小东西里。然而,这种知识和推理(也称为常识知识)对计算机来说是完全无法理解的。在撰写本文时,没有人知道如何教会机器这些对我们来说微不足道的事情。尽管如此,这仍然是一个非常活跃(且令人沮丧)的研究方向。

幸运的是,对于游戏 AI 来说,其范围要窄得多。相反,正如我们将在下一节中看到的,游戏 AI 有一个但却是至关重要的目标:让游戏变得有趣。

游戏中的 AI

与通用 AI 不同,游戏 AI 只需要提供智能的错觉。它的目标不是提供类似人类的智能代理,而是足够聪明,能让游戏变得有趣的角色。

当然,让游戏变得有趣并非易事,而且公平地说,一个好的 AI 只是问题的一部分。尽管如此,如果一个好的 AI 不足以让游戏变得有趣,一个差的 AI 甚至可能破坏最精心设计的游戏。如果你对什么让游戏变得有趣这个问题感兴趣,我建议你阅读一本关于游戏设计的优秀书籍,例如 Jesse Schell 的游戏设计艺术。

然而,对于我们来说,重要的是要说明,提供足够的挑战水平给玩家是至关重要的。在这种情况下,公平的挑战意味着游戏不应该太难以至于玩家无法击败对手,也不应该太容易以至于胜利变得乏味。因此,找到正确的挑战水平是使游戏有趣的关键。

正是在这里,AI 开始发挥作用。游戏中的 AI 角色是通过提供具有挑战性的对手和在游戏世界中表现适当的非玩家角色(NPCs)来使游戏变得有趣。因此,这里的目的是不是复制人类或动物的全部思维过程,而是通过让 NPC 在游戏世界中的变化情况下的反应显得智能,从而使它们对玩家有意义。正如我们之前提到的,这提供了智能的错觉。

信息

必须提到的是,游戏中的 AI 不仅限于模拟 NPC 的行为。AI 还用于生成游戏内容(正如我们将在第十章,程序内容生成),控制故事事件和叙事节奏(一个显著的例子来自《求生之路》系列的 AI 导演)或甚至创造整个叙事弧线。

注意,一个好的游戏 AI 不需要是复杂的 AI。一个反复出现的例子是原始《吃豆人》街机游戏的 AI。按照任何现代标准,控制四个鬼魂追逐吃豆人的算法几乎不能被认为是 AI。每个鬼魂都使用一个非常简单的规则来决定下一步移动的方向:测量鬼魂和目标方块之间的距离,并选择最小化距离的方向。

目标方块可能是吃豆人的位置(如红色鬼魂的情况),也可能是吃豆人前方的东西(如粉色鬼魂),或者是一些其他的方块。通过简单地改变目标方块的位置,吃豆人街机游戏可以为每个鬼魂赋予独特的个性和 AI,即使经过 40 年后,它仍然能挑战我们!

金科玉律是使用最少的 AI 来实现游戏的设计目标。当然,如果我们发现 AI 是不必要的,我们可以将这一规则推向极致,不使用任何 AI。例如,在《传送门》和《传送门 2》中,所有角色都是完全脚本化的,没有涉及 AI,但没有人对 AI 的缺失表示不满。

信息

如果你想要深入了解《吃豆人》AI,我建议你观看来自Retro Game Mechanics Explained YouTube 频道的这个非常详细的视频:www.youtube.com/watch?v=ataGotQ7ir8。

或者,如果你更喜欢阅读,你可以访问这个非常有信息量的网页:gameinternals.com/understanding-pac-man-ghost-behavior。

游戏 AI 另一个挑战是,其他操作,如图形渲染和物理模拟,需要与 AI 所需的计算能力共享。别忘了,这一切都是在实时发生的,所以在整个游戏中保持稳定的帧率至关重要。这意味着游戏 AI 需要设计得不会耗尽计算资源。这通常是通过设计一个可以中断并在多个帧上扩展的算法来实现的。

在一般 AI 领域,许多公司投资于一个专门的 AI 计算处理器,称为 AI 加速器(例如谷歌的 Tensor Processing Unit)。然而,直到游戏广泛地访问这样的专用 AI 处理器之前,我们游戏 AI 开发者仍然需要关注我们算法的性能。

下一节将提供对在视频游戏中使用最广泛的 AI 技术的一般介绍。

视频游戏 AI 技术

在本节中,我们将探讨一些在不同类型游戏中常用的 AI 技术。我们将在接下来的章节中学习如何在 Unity 中实现这些功能。由于本书的重点不是 AI 技术本身,而是在 Unity 中实现这些技术,因此我们不会在这里过多地详细讨论它们。所以,让我们将其视为在深入了解实现细节之前的一个快速课程。

如果你想了解更多关于游戏 AI 的信息,有一些很好的书籍,例如 Mat Buckland 的《通过实例编程游戏 AI》和 Ian Millington 与 John Funge 的《游戏人工智能》。此外,AI 游戏编程智慧 和 游戏 AI 专业人士 系列也包含大量关于最新 AI 技术的有价值资源和文章。

有限状态机

有限状态机(FSM)可能是最简单、最常用、最常讨论的 AI 模型之一,对于大多数游戏来说,它们代表了唯一的 AI 技术。状态机由有限数量的 状态 组成,这些状态通过一个或多个 转换 相连,形成一个称为 图 的数据结构。每个游戏实体都从一个初始状态开始。然后,环境事件触发特定的规则,使实体移动到另一个状态。这种触发规则称为 转换。游戏实体在任何给定时间只能处于一个状态。

例如,让我们考虑一个典型射击游戏中的 AI 守卫角色。其状态可能像 巡逻、追逐 和 射击 这样简单:

图 1.1 – 一个简单的用于 AI 守卫角色的有限状态机

图 1.1 – 一个简单的用于 AI 守卫角色的有限状态机 (FSM)

简单 FSM 有四个组成部分:

  • 状态:此组件定义了游戏实体或 NPC 可以选择的一组状态(巡逻、追逐 和 射击)。

  • 转换:此组件定义了不同状态之间的关系。

  • 规则:此组件定义了何时执行状态转换(玩家在视野中、足够近可以攻击和失去/杀死玩家)。

  • 事件:这是将触发以检查规则(守卫的可见区域、与玩家的距离等)的组件。

所以,在《Quake 2》中的怪物可能具有以下状态:站立、行走、奔跑、躲避、攻击、空闲和搜索。

状态机(FSMs)在游戏中被广泛使用,因为它们仅使用一些if或switch语句就很容易实现,但它们仍然足够强大,可以用于简单和相对复杂的游戏。另一方面,当我们需要大量状态和转换时,它们可能会变得混乱。我们将在下一章学习如何管理一个简单的状态机。

AI 中的随机性和概率

想象一下在一个第一人称射击游戏(FPS)中,一个敌人机器人总是可以用头槌或对手在赛车游戏中总是选择最佳路线且从不与任何障碍物碰撞。这种程度的智能会使游戏变得非常困难,几乎不可能获胜,因此游戏体验会变得令人沮丧。在光谱的另一端,想象一下,当敌人试图从玩家那里逃脱时,总是选择相同的可预测路线。经过几场比赛后,玩家会学会敌人的模式,游戏会变得乏味。当玩家每次遇到都表现出相同行为的 AI 控制实体,会使游戏变得可预测、容易获胜,因此变得乏味。

当然,有些情况下,有意可预测性是一个期望的特性。例如,在潜行游戏中,我们希望玩家能够预测敌人的路径,以便玩家可以计划潜行路线。但在其他情况下,无意可预测性可能会干扰游戏的参与度,使玩家感觉游戏不够具有挑战性或公平性。修复这些过于完美或过于愚蠢的 AI 的一种方法是在它们的行为中引入有意错误。在游戏中,我们在 AI 计算的决策过程中引入随机性和概率。

有多种场景,我们可能希望引入一些随机性。最直接的情况是当 NPC 没有信息,或者它所做的决定无关紧要时。例如,在射击游戏中,一个被攻击的敌人可能想要决定在哪里躲避。因此,我们可能希望指示 NPC 有时选择一个稍微远一点的躲避点。

在其他情况下,我们可以使用随机性来决定结果。例如,我们可以使用随机性来决定命中率,对基础伤害进行随机增减,或者在 NPC 开始射击前让他们犹豫。

传感器系统

我们的人工智能角色需要了解他们的周围环境和他们与之交互的世界,以便做出特定的决定。此类信息包括以下内容:

  • 玩家的位置:这用于决定是攻击、追击还是继续巡逻。

  • 建筑和附近物体:这用于隐藏或掩护。

  • 玩家的健康和 AI 的健康:这用于决定是撤退还是前进。

  • 实时策略(RTS)游戏中地图上资源的位置:这用于占领和收集更新和/或生产其他单位所需的资源。

如您所想,选择正确的方法来收集游戏信息可能会因我们试图构建的游戏类型而大相径庭。在接下来的几节中,我们将探讨两种基本策略:轮询和消息(事件)系统。

投票

收集此类信息的一种方法是我们 AI 角色的FixedUpdate方法。这样,AI 角色可以从游戏世界中轮询它们感兴趣的信息,进行检查,并据此采取行动。如果需要检查的项目不多,轮询效果很好。

为了使这种方法更高效,我们可能想要编程角色以不同的速率轮询世界状态,这样我们就不需要所有角色同时检查一切。例如,我们可以将轮询代理分成 10 组(G1、G2、G3 等),并为每组分配不同的帧进行轮询(例如,G1 将在帧 0、60、120 等轮询;G2 将在帧 10、70、130 等轮询)。

作为另一个例子,我们可能会决定根据敌人的类型或状态来改变轮询频率。例如,未参与战斗且远离的敌人可能每 3-4 秒轮询一次,而接近玩家且正在受到攻击的敌人可能希望每 0.5 秒轮询一次。

然而,随着游戏的扩大,轮询就不再足够了。因此,在更大型、更复杂的 AI 系统中,我们需要实现一个使用全局消息系统的基于事件的驱动方法。

消息系统

在消息系统中,游戏通过异步消息在 AI 实体、玩家、世界或其他 AI 实体之间传递事件。例如,当玩家攻击一群巡逻守卫中的敌方单位时,其他 AI 单位需要了解这一事件,以便它们可以开始搜索并攻击玩家。

如果我们使用轮询方法,我们的 AI 实体需要检查所有其他 AI 实体的状态,以确定是否有实体被攻击。然而,我们可以以更易于管理和可扩展的方式实现这一点:我们可以将感兴趣特定事件的 AI 角色注册为该事件的监听器;然后,如果该事件发生,我们的消息系统将向所有监听器广播此信息。AI 实体可以据此采取适当的行动或进行进一步的检查。

这个事件驱动系统并不一定比轮询机制更快。然而,它提供了一个方便的、集中的检查系统,它感知世界并向感兴趣的 AI 代理报告,而不是让每个代理在每一帧检查相同的事件。在现实中,轮询和消息系统通常一起使用。例如,当 AI 从消息系统中收到事件时,它可能会轮询更详细的信息。

群聚、盘旋和放牧

许多生物,如鸟类、鱼类、昆虫和陆地动物,在群体中进行特定的操作,如移动、狩猎和觅食。它们以群体形式停留和狩猎,因为这样比单独追求目标更强大、更安全。所以,假设你想要一群鸟在空中群聚、盘旋;对于动画师来说,为每只鸟设计运动和动画将花费太多时间和精力。然而,如果我们为每只鸟应用一些简单的规则,我们就可以通过复杂的全局行为实现整个群体的涌现智能。

这个概念的先驱是 Craig Reynolds,他在 1987 年的 SIGGRAPH 论文《Flocks, Herds, and Schools – A Distributed Behavioral Model》中提出了这样的群聚算法。他创造了boid这个术语,听起来像“bird”(鸟),但实际上指的是类似鸟的对象。他提出了三个简单的规则应用于每个单元:

  • 分离:每个 boid 需要与邻近的 boid 保持最小距离,以避免碰撞(短程排斥)。

  • 对齐:每个 boid 需要与邻居的平均方向对齐,然后以相同的速度与它们一起移动,作为一个群体。

  • 凝聚力:每个 boid 被吸引到群体的质心(长程吸引)。

这三个简单的规则就足以实现一个逼真且相对复杂的鸟类群聚行为。这不仅适用于鸟类。群聚行为对于模拟人群或甚至在游戏中跟随玩家的几个 NPC 都很有用。

我们将在第五章“群聚”中学习如何在 Unity 中实现这样一个群聚系统。

跟随路径和转向

有时候,我们希望我们的 AI 角色在游戏世界中漫游并跟随一个大致引导或详细定义的路径。例如,在赛车游戏中,AI 对手需要导航道路。在这种情况下,像我们的群聚 boid 算法这样的简单反应算法不足以解决这个问题。然而,最终,这都归结于处理实际的运动和转向行为。AI 角色的转向行为已经成为几十年的研究课题。

在这个领域,一篇值得注意的论文是 Craig Reynolds 在 1999 年游戏开发者大会(GDC)上提出的《自主角色的转向行为》,他再次提出了以下三个层次的转向行为:

![图 1.2 – 运动行为层次结构

![图片 B17984_01_02.jpg]

图 1.2 – 运动行为层次结构

为了理解这些层次,让我们来看一个例子。想象一下,在一个炎热的夏日午后,你坐在办公桌前工作。你感到口渴,想要一杯冰茶。因此,我们从第一层开始:我们想要一杯冰茶(设定目标),并规划出我们为了得到它需要做什么。我们可能需要去厨房(除非你的桌子下有一个迷你冰箱),拿一个空杯子,然后移动到冰箱,打开它,拿冰茶(我们已经制定了一个高级计划)。

现在,我们转到第二层。除非你的厨房是从你的桌子直接延伸的直线,否则你需要确定一条路径:绕过桌子,穿过走廊,绕过厨房家具,直到你到达放玻璃杯的橱柜,等等。现在你已经有了路径,是时候移动到第三层:沿着路径行走。在这个例子中,第三层由你的身体、骨骼和肌肉沿着路径移动来表示。

信息

别担心——你不需要掌握所有三层。作为一个 AI 程序员,你只需要专注于前两层。第三层通常由图形程序员处理——特别是动画师。

在描述了这三层之后,克雷格·雷诺兹解释了如何为单个 AI 角色设计和实现标准的转向行为。这些行为包括 寻找 和 逃离,追逐 和 躲避,徘徊,到达,避障,沿墙行走 和 路径跟随。

我们将在 第六章 中实现这些行为中的一些,路径跟随和转向行为。

A* 路径查找

在许多游戏中,你可以找到跟随玩家或避开障碍物移动到特定点的怪物或敌人。例如,让我们看看一个典型的实时战略游戏。你可以选择一组单位并点击你想要它们移动的位置,或者点击敌方单位进行攻击。

然后,你的单位需要找到一种方法在不与障碍物碰撞的情况下达到目标。当然,敌方单位也需要能够做到同样的事情。不同的单位可能有不同的障碍物。例如,空军单位可以飞越山脉,而地面或炮兵单位则需要找到绕过它的方法。

A*(发音为“A-star”)是一种路径查找算法,由于其性能、准确性和易于实现,在游戏中被广泛使用。让我们通过一个例子来看看它是如何工作的。假设我们想让我们的单位从点 A 移动到点 B,但中间有一堵墙,它不能直接朝目标前进。因此,它需要找到一种方法到达点 B 同时避开墙壁:

![图 1.3 – 我们地图的俯视图

![图片 B17984_01_03.jpg]

图 1.3 – 我们地图的俯视图

这是一个简单的 2D 示例,但我们可以将同样的想法应用到 3D 环境中。为了从点 A 到点 B 寻找路径,我们需要了解更多关于地图的信息,例如障碍物的位置。为此,我们可以将整个地图分成代表整个地图的小瓷砖,以网格格式表示,如图所示:

图 1.4 – 以 2D 网格表示的地图

图 1.4 – 以 2D 网格表示的地图

瓷砖也可以是其他形状,例如六边形或三角形。每种形状都有其优点。例如,六边形瓷砖很方便,因为它们没有 对角线移动 的问题(围绕目标六边形的所有六边形都在相同的距离上)。然而,在这个例子中,我们使用了正方形瓷砖,因为当我们想到 网格 时,它们是更直观的形状。

现在,我们可以在一个小的 2D 数组中引用我们的地图。

我们可以用一个 5x5 的正方形瓷砖网格来表示我们的地图,总共 25 个瓷砖。现在,我们可以开始寻找到达目标的最佳路径。我们如何做?通过计算与起始瓷砖相邻且未被障碍物占据的每个瓷砖的移动得分,然后选择成本最低的瓷砖。

如果我们不考虑对角线移动,玩家周围有四个可能的相邻瓷砖。现在,我们需要使用两个数字来计算每个这些瓷砖的移动得分。让我们称它们为 G 和 H,其中 G 是从起始瓷砖移动到当前瓷砖的成本,而 H 是从当前瓷砖到达目标瓷砖的估计成本。

让我们称 F 为 G 和 H 的和 (F = G + H) – 即该瓷砖的最终得分:

图 1.5 – 有效的相邻瓷砖

图 1.5 – 有效的相邻瓷砖

在我们的例子中,为了估算 H,我们将使用一种称为 曼哈顿距离(也称为 出租车几何)的简单方法。根据这种方法,点 A 和 B 之间的距离(成本)是 A 和 B 之间的水平瓷砖数量,加上 A 和 B 之间的垂直瓷砖数量:

图 1.6 – 计算 G

图 1.6 – 计算 G

另一方面,G 值代表搜索过程中的 当前成本。前面的图示显示了使用两条不同路径计算 G 的过程。为了计算当前的 G,我们必须将 1(移动一个瓷砖的成本)加到前一个瓷砖的 G 分数上。然而,我们可以给不同的瓷砖分配不同的成本。例如,我们可能希望为对角线移动设置更高的移动成本(如果我们正在考虑它们),或者,例如,为池塘或泥泞的道路上的瓷砖。

现在我们知道了如何得到 G,让我们学习如何计算 H。以下图示显示了不同起始瓷砖的 H 值。即使在这种情况下,我们也使用曼哈顿距离:

图 1.7 – 计算 H

图 1.7 – 计算 H

因此,现在我们已经知道了如何获取 G 和 H,让我们回到我们的原始例子,找出从 A 到 B 的最短路径。首先,我们必须选择起始瓷砖,并收集所有相邻的瓷砖,如图所示。然后,我们必须计算每个瓷砖的 G 和 H 分数,如图中瓷砖的左下角和右下角所示。最后,我们必须通过将 G 和 H 相加来获取最终分数 F。您可以在瓷砖的左上角看到 F 分数。

现在,我们必须选择具有最低 F 分数的瓷砖作为我们的下一个瓷砖,并将前一个瓷砖作为其父瓷砖存储。请注意,记录每个瓷砖的父瓷砖是至关重要的,因为我们稍后会使用这个回链来从终点到起点追踪节点序列以获得最终路径。在这个例子中,我们必须选择起始位置右侧的瓷砖,并将其视为当前瓷砖:

图 1.8 – 起始位置

图 1.8 – 起始位置

从当前瓷砖开始,我们重复这个过程,首先收集有效的相邻瓷砖。这次只有两个空闲的相邻瓷砖:当前瓷砖上方的那个和底部的那个(实际上,左边的瓷砖是起始瓷砖——我们已经检查过——障碍物占据了右边的瓷砖)。我们计算 G 和 H,然后计算这些新相邻瓷砖的 F 分数。

这次,我们在地图上有四个瓷砖,它们的分数都相同:六。因此,我们可以选择其中的任何一个。实际上,最终我们会发现,无论我们首先探索哪个瓷砖,我们都会找到最短路径(证明这个陈述背后的数学原理超出了本书的范围):

图 1.9 – 第二步

图 1.9 – 第二步

在这个例子中,我们从成本为 6 的瓷砖组中选择了左上角的瓷砖作为起始位置。同样,我们必须检查相邻的瓷砖。在这一步中,只有一个新的相邻瓷砖,其计算出的 F 分数为 8。因为目前最低的分数仍然是 6,所以我们可以选择任何分数为 6 的瓷砖:

图 1.10 – 第三步

图 1.10 – 第三步

如果我们重复这个过程,直到我们到达目标瓷砖,我们最终会得到一个显示每个空闲瓷砖分数的板:

图 1.11 – 达到目标

图 1.11 – 达到目标

剩下只有一步了。你还记得我们存储在每个节点中的父链接吗?现在,从目标瓷砖开始,我们必须使用存储的父瓷砖来追踪一个瓷砖列表。结果列表将是一条看起来像这样的路径:

图 1.12 – 追踪回溯路径

图 1.12 – 追踪回溯路径

我们在这里解释的是 A路径查找算法的精髓,这是任何路径查找算法的基本基石。幸运的是,自从 Unity 3.5 以来,一些新功能,如自动导航网格生成和 NavMesh 代理,使得在游戏中实现路径查找变得更加容易。因此,你可能甚至不需要了解 A就能为你的 AI 角色实现路径查找。然而,了解幕后系统的工作原理对于成为一名优秀的 AI 程序员至关重要。

我们将在下一节中讨论导航网格,然后在第八章,导航网格中更详细地讨论。

导航网格

现在你已经了解了 A路径查找算法的基础知识,你可能注意到在 A中使用网格需要许多步骤才能在起始位置和目标位置之间找到最短路径。这可能看起来并不显著,但搜索巨大地图上的路径,其中大多数是空格,并且逐个搜索路径方块是一种严重的计算资源浪费。因此,游戏通常使用航点作为指南,以简单有效的方式移动 AI 角色,从而减少计算资源的使用。

假设我们想将我们的 AI 角色从点A移动到点B,并且我们已经设置了三个航点,如下面的图所示:

图 1.13 – 航点

图 1.13 – 航点

现在我们只需要将 A*算法应用于航点(这些航点的数量比方块的数量少),然后简单地从航点到航点直线移动角色。

然而,航点并非没有问题。如果我们想更新地图中的障碍物怎么办?我们将不得不为更新的地图重新放置航点,如下面的图所示:

图 1.14 – 新航点

图 1.14 – 新航点

此外,跟随每个节点到目标会产生看起来不真实的角色。例如,它们直线移动,然后突然改变方向,就像主题公园的景点中的机械木偶一样。或者连接两个航点的路径可能太靠近障碍物。例如,看看前面的图;AI 角色可能会在路径靠近墙壁的地方撞到墙上。

如果发生这种情况,我们的 AI 将继续尝试穿过墙壁以到达下一个目标,但它将无法做到,并且会卡在那里。当然,我们可以通过使用样条曲线平滑地调整路径来使路径更真实,或者我们可以手动检查每条路径以避免擦过障碍物的边缘。然而,问题在于航点不包含任何关于环境的信息,除了连接两个节点的轨迹。

为了应对这种情况,我们需要大量的航点,这非常难以管理。因此,对于除了简单游戏之外的所有事情,我们必须用管理数百个航点的心理和设计成本来交换网格的计算成本。

幸运的是,有一个更好的解决方案:使用导航网格。导航网格(通常称为NavMesh)是我们可以用来说明我们世界的另一种图结构,类似于基于方块的网格和航点图:

![图 1.15 – 导航网格]

![img/B17984_01_15.jpg]

![图 1.15 – 导航网格]

NavMesh 使用凸多边形来表示地图中 AI 实体可以行走的区域。使用 NavMesh 的最关键好处是它比航点系统包含更多关于环境的信息。有了 NavMesh,我们可以自动调整我们的路径,因为我们知道我们的 AI 实体可以在一个区域内自由移动。使用 NavMesh 的另一个优点是我们可以为不同类型的 AI 实体使用相同的网格。不同的 AI 实体可以有不同的属性,例如大小、速度和移动能力。例如,一组航点可能适合人类角色,但可能不适合飞行生物或 AI 控制的车辆。这些可能需要不同的航点集(这会带来所有这些问题)。

然而,根据场景程序生成 NavMesh 是一个相对复杂的过程。幸运的是,Unity 包含一个内置的 NavMesh 生成器。

由于这不是一本关于核心 AI 技术的书,我们不会深入探讨如何生成这样的 NavMesh。相反,我们将学习如何有效地使用 Unity 的 NavMesh 来实现 AI 角色的路径查找。

行为树

行为树是另一种用于表示和控制 AI 角色决策背后逻辑的技术。由于其在 AAA 游戏如光环和孢子中的应用而变得流行。我们在本章前面简要介绍了 FSM,这是一种基于游戏事件反应中不同状态之间转换来定义 AI 角色逻辑的简单方法。然而,FSM 有两个主要问题:它们难以扩展和重用。

为了支持我们希望角色存在的所有场景,我们需要添加很多状态并硬编码许多转换。因此,我们需要某种可以更好地与更广泛的问题缩放的东西。行为树代表了正确方向上的一个合理步骤。

如其名所示,行为树的本质是一种树状的数据结构。这种树的叶子被称为任务,它们代表我们角色的动作(例如,攻击、追逐、巡逻、隐藏等)或感官输入(例如,玩家是否靠近?或我是否足够接近可以攻击?)。相反,树的内节点由控制流节点表示,它们指导树的执行。序列、选择器和并行装饰器是常用的控制流节点。

现在,让我们尝试使用行为树重新实现“有限状态机”部分中的示例。首先,我们可以将所有转换和状态分解成基本任务:

图 1.16 – 任务

图 1.16 – 任务

现在,让我们看看选择器节点。我们用一个带有问号的圆圈来表示选择器。当执行时,选择器节点会按顺序尝试执行所有子任务/子树,直到第一个返回成功的任务。换句话说,如果我们有一个有四个子节点(例如,A、B、C 和 D)的选择器,选择器节点会首先执行 A。如果 A 失败,那么选择器会执行 B。如果 B 失败,那么它会执行 C,依此类推。如果任何任务返回成功,那么序列在完成那个任务后立即返回成功。

在以下示例中,选择器节点首先选择攻击玩家。如果攻击任务返回成功(即玩家在攻击范围内),选择器节点停止执行并返回成功给其父节点(如果有的话)。相反,如果攻击任务返回失败,选择器节点会移动到追逐任务。在这里,我们重复之前所做的事情:如果追逐任务成功,选择器节点成功;如果追逐任务失败,它会尝试巡逻任务,依此类推:

图 1.17 – 选择器节点

图 1.17 – 选择器节点

那么,其他类型的任务——检查游戏状态的任务怎么办?我们与序列节点一起使用它们,通常用带有箭头的矩形表示。序列节点类似于选择器节点,但有一个关键的区别:只有当每个子树都返回成功时,它才返回成功消息。换句话说,如果我们有一个有四个子节点(例如,A、B、C 和 D)的序列,序列节点将执行 A,然后是 B,然后是 C,最后是 D。如果所有任务都返回成功,那么序列返回成功。

在以下示例中,第一个序列节点检查玩家角色是否足够接近以进行攻击。如果这个任务成功,它将进入下一个任务:攻击玩家。如果攻击任务也返回成功消息,整个序列将成功结束。相反,如果足够接近以攻击?任务失败,那么序列节点将不会进入攻击任务,并将失败状态返回给父选择器节点。然后,选择器选择序列中的下一个任务,玩家失去或被杀,执行继续:

图 1.18 – 序列任务

图 1.18 – 序列任务

另外两个常见的节点是并行和装饰器。并行节点同时执行其所有子任务(而序列和选择器节点只依次执行其子树)。装饰器是另一种只有单个子节点的节点。它用于改变其单个子树的行为,例如,运行它多次或反转子树的结果(如果子树返回成功消息,装饰器返回失败,反之亦然)。

我们将在第九章 行为树中学习如何在 Unity 中实现基本的行为树系统。

运动方式

动物(包括人类)拥有一个非常复杂的肌肉骨骼系统,使它们能够在环境中移动。动物还拥有复杂的头脑,告诉它们如何使用这样的系统。例如,我们本能地知道在攀爬**、楼梯或不平地形时应该把脚放在哪里,我们还知道如何平衡身体以稳定我们想要做出的所有复杂姿势。我们可以通过控制我们的骨骼、肌肉、关节和其他组织的头脑来完成所有这些,这些被统称为我们的运动系统。

现在,让我们从游戏开发的角度来看这个问题。假设我们有一个人类角色,他需要在不平坦的表面或小斜坡上行走,而我们只有一个行走循环的动画。由于我们的虚拟角色缺少运动系统,这将是以下样子:

图 1.19 – 无运动方式爬楼梯

图 1.19 – 无运动方式爬楼梯

首先,我们播放行走动画并将玩家向前移动。但现在,角色正在穿透表面。因此,碰撞检测系统将角色拉到表面以上以停止这种不可能的配置。

现在,让我们看看我们在现实中如何上楼。我们坚定地将脚放在楼梯上,并使用力量将身体的其他部分拉到下一个台阶上。然而,在游戏中实现这种级别的现实感并不简单。我们需要为不同的场景准备许多动画,包括攀爬**、上楼行走/跑步等。因此,在过去,只有拥有许多动画师的大型工作室才能做到这一点。然而,如今,我们有了自动化的系统来完成这项工作:

图 1.20 – Unity 逆运动学扩展

图 1.20 – Unity 逆运动学扩展

该系统可以自动混合我们的动画行走/跑步周期,并调整玩家腿部骨骼的运动,以确保玩家的脚正确地踩在地面上(在文献中,这被称为逆运动学)。它还可以调整最初为特定速度和方向设计的动画,以适应任何表面上的任何速度和方向,例如台阶和斜坡。在第六章,“路径跟随和转向行为”中,我们将学习如何使用这个运动系统为我们的 AI 角色应用逼真的动作。

摘要

在本章中,我们了解到游戏人工智能和学术人工智能有不同的目标。学术人工智能研究人员试图解决现实世界的问题,并开发与人类智能竞争的人工智能算法,其最终目标是取代人类在复杂情况下的工作。另一方面,游戏人工智能侧重于使用有限资源构建看起来对玩家来说很智能的非玩家角色(NPC),其最终目标是娱乐他们。游戏人工智能的目标是提供一个具有挑战性的对手,使游戏更具趣味性。

我们还学习了在游戏中使用的不同人工智能技术,例如有限状态机(FSMs)、随机性和概率、传感器、输入系统、群体行为和群体行为、路径跟随和转向行为、人工智能路径查找、导航网格生成和行为树。

我们将在接下来的章节中学习如何在 Unity 引擎中实现这些技术。在下一章中,我们将从基础知识开始:有限状态机(FSMs)。

第二章:有限状态机

在本章中,我们将通过研究本书附带的一个简单的坦克游戏机制示例,学习如何在 Unity3D 游戏中实现有限状态机(FSM)。

在我们的游戏中,玩家控制一辆坦克。敌方坦克在场景中移动,遵循四个航点。一旦玩家的坦克进入敌方坦克的视野范围,它们就开始追逐它;然后,一旦它们足够接近可以攻击,它们就会开始向我们的玩家坦克射击。

为了控制我们的敌方坦克的 AI,我们使用 FSM。首先,我们将使用简单的switch语句来实现我们的坦克 AI 状态。然后,我们将使用一个更复杂且经过工程设计的 FSM 框架,这将使我们能够更灵活地设计角色的 FSM。

本章我们将讨论以下主题:

  • 实现玩家的坦克

  • 实现子弹类

  • 设置航点

  • 创建抽象 FSM 类

  • 使用简单的 FSM 实现敌方坦克 AI

  • 使用 FSM 框架

技术要求

对于本章,您只需要 Unity3D 2022。您可以在本书仓库的Chapter 2文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter02。

实现玩家的坦克

在为我们的玩家坦克编写脚本之前,让我们看看我们是如何设置Rigidbody和Box Collider组件的。

controller类:

![Figure 2.1 – Our tank entity

![img/B17984_02_1.jpg]

图 2.1 – 我们的坦克实体

PlayerTankController类控制玩家的坦克。我们使用W、A、S和D键来移动和转向坦克,并使用左鼠标按钮从Turret对象瞄准和射击。

信息

在这本书中,我们假设您正在使用一个QWERTY键盘和两个按钮的鼠标,其中左鼠标按钮被设置为主要的鼠标按钮。如果您使用的是不同的键盘,您只需假装您正在使用一个QWERTY键盘,或者尝试修改代码以适应您的键盘布局。这相当简单!

初始化坦克对象

让我们从在PlayerTankController.cs文件中设置Start函数和Update函数开始创建PlayerTankController类:

using UnityEngine;
using System.Collections;
public class PlayerTankController : MonoBehaviour {
    public GameObject Bullet;
    public GameObject Turret;
    public GameObject bulletSpawnPoint;
    public float rotSpeed = 150.0f;
     public float turretRotSpeed = 10.0f;
    public float maxForwardSpeed = 300.0f; 
    public float maxBackwardSpeed = -300.0f;
    public float shootRate = 0.5f; 
    private float curSpeed, targetSpeed;
    protected float elapsedTime;
    void Start() {
   }
    void Update() {
        UpdateWeapon();
        UpdateControl();
    }

我们可以在层次结构中看到,PlayerTank游戏对象有一个名为Turret的子对象,而Turret对象的第一个子对象被称为SpawnPoint。为了设置控制器,我们需要将Turret和SpawnPoint拖放到检查器中相应的字段:

![Figure 2.2 – The Player Tank Controller component in the Inspector

![img/B17984_02_2.jpg]

Figure 2.2 – The Player Tank Controller component in the Inspector

之后,在创建 Bullet 变量后,最后,Update 函数调用 UpdateControl 和 UpdateWeapon 函数。我们将在下一节讨论这些函数的内容。

射击子弹

射击子弹的机制很简单。每当玩家点击鼠标左键时,我们检查自上次射击以来经过的总时间是否大于武器的射击速率。如果是,则创建一个新的 bulletSpawnPoint 变换的位置。这个检查防止玩家连续射击子弹流。

因此,我们在 PlayerTankController.cs 文件中添加以下函数:

void UpdateWeapon() {
    elapsedTime += Time.deltaTime;
    if (Input.GetMouseButtonDown(0)) {
        if (elapsedTime >= shootRate) {
            //Reset the time 
            elapsedTime = 0.0f;
            //Instantiate the bullet
            Instantiate(Bullet,
              bulletSpawnPoint.transform.position,
              bulletSpawnPoint.transform.rotation);
        }
    }
}

现在,我们可以将此控制器脚本附加到 PlayerTank 对象上。如果我们运行游戏,我们应该能够从我们的坦克中射击。现在,是时候实现坦克的移动控制了。

控制坦克

玩家可以将 UpdateControl 函数旋转到 PlayerTankController.cs 文件中:

void UpdateControl() {
    // AIMING WITH THE MOUSE
    // Generate a plane that intersects the Transform's
    // position with an upwards normal.
    Plane playerPlane = new Plane(Vector3.up,
      transform.position + new Vector3(0, 0, 0));
    // Generate a ray from the cursor position 
    Ray RayCast =
      Camera.main.ScreenPointToRay(Input.mousePosition);
    // Determine the point where the cursor ray intersects
    // the plane.
    float HitDist = 0;
    // If the ray is parallel to the plane, Raycast will
    // return false.
    if (playerPlane.Raycast(RayCast, out HitDist)) {
        // Get the point along the ray that hits the
        // calculated distance.
        Vector3 RayHitPoint = RayCast.GetPoint(HitDist);
        Quaternion targetRotation = 
          Quaternion.LookRotation(RayHitPoint –
                                  transform.position);
        Turret.transform.rotation = Quaternion.Slerp(
          Turret.transform.rotation, targetRotation,
          Time.deltaTime * turretRotSpeed);
    }
}

我们使用射线投射来确定转向方向,通过找到战场上的 mousePosition 坐标:

图 2.3 – 使用鼠标射线瞄准

图 2.3 – 使用鼠标射线瞄准

信息

射线投射 是 Unity 物理引擎默认提供的一个工具。它允许我们在场景中找到一条假想线(射线)与碰撞器之间的交点。想象一下这是一个激光笔:我们可以向一个方向发射激光,并看到它击中的点。然而,这是一个相对昂贵的操作。虽然一般来说,你可以自信地处理每帧 100-200 次射线投射,但它们的性能会受到射线长度和场景中碰撞器的数量和类型的影响很大。所以,作为一个快速提示,尽量不要使用大量的射线投射与网格碰撞器,并使用层掩码来过滤掉不必要的碰撞器。

这就是它的工作原理:

  1. 设置一个与玩家坦克相交且法线向上的平面。

  2. 从屏幕空间中用鼠标位置(在先前的图中,我们假设我们正在向下看坦克)射出射线。

  3. 找到射线与平面的交点。

  4. 最后,找到从当前位置到该交点的旋转。

然后,我们检查按键输入并相应地移动或旋转坦克。我们在 UpdateControl 函数的末尾添加以下代码:

if (Input.GetKey(KeyCode.W)) {
    targetSpeed = maxForwardSpeed;
} else if (Input.GetKey(KeyCode.S)) {
    targetSpeed = maxBackwardSpeed;
} else {
    targetSpeed = 0;
}
if (Input.GetKey(KeyCode.A)) {
    transform.Rotate(0, -rotSpeed * Time.deltaTime, 0.0f);
} else if (Input.GetKey(KeyCode.D)) {
    transform.Rotate(0, rotSpeed * Time.deltaTime, 0.0f);
}
//Determine current speed
curSpeed = Mathf.Lerp(curSpeed, targetSpeed, 7.0f *
                      Time.deltaTime);
transform.Translate(Vector3.forward * Time.deltaTime *
                    curSpeed);

上述代码表示经典的 WASD 控制方案。坦克通过 A 和 D 键旋转,通过 W 和 S 键前进和后退。

信息

根据你对 Unity 的熟练程度,你可能想知道关于 Lerp 和 Time.deltaTime 乘法的细节。这可能值得稍作解释。首先,Lerp 函数用于在多个帧上平滑地传播速度变化,这样坦克的运动就不会看起来是瞬间加速和减速的。7.0f 的值只是一个 平滑因子,你可以玩弄它以找到你喜欢的值(值越大,坦克的加速度就越大)。

然后,我们将所有内容乘以 Time.deltaTime。这个值表示从现在到上一帧之间的秒数,我们使用它来使速度独立于帧率。更多信息,请参阅learn.unity.com/tutorial/delta-time。

接下来,是时候实现玩家和敌方坦克发射的弹丸了。

实现 Bullet 类

接下来,我们使用两个正交平面和一个盒子碰撞器设置我们的 Bullet 预制体,在 Shader 字段中使用类似激光的材料和 Particles/Additive-Layer 属性:

图 2.4 – 我们的子弹预制体

图 2.4 – 我们的子弹预制体

Bullet.cs 文件中的代码如下:

using UnityEngine;
using System.Collections;
public class Bullet : MonoBehaviour {
    //Explosion Effect 
    [SerializeField] // Used to expose in the inspector private 
                     // fields!
    private GameObject Explosion;
    [SerializeField]
    private float Speed = 600.0f;
    [SerializeField]
    private float LifeTime = 3.0f;
    public int damage = 50;
    void Start() {
        Destroy(gameObject, LifeTime);
    }
    void Update() {
        transform.position +=
        transform.forward * Speed * Time.deltaTime;
    }
    void OnCollisionEnter(Collision collision) {
        ContactPoint contact = collision.contacts[0];
        Instantiate(Explosion, contact.point,
                    Quaternion.identity);
        Destroy(gameObject);
    }
}

Bullet 类有三个属性:damage、Speed 和 Lifetime – 后者使得子弹在一段时间后自动销毁。请注意,我们使用 [SerializeField] 来在检查器中显示私有字段;实际上,Unity 默认只显示公共字段。将我们需要从其他类访问的字段设置为公共字段是一个好习惯。

如您所见,子弹的 Explosion 属性链接到 ParticleExplosion 预制体,我们不会详细讨论。这个预制体在 ParticleEffects 文件夹中,所以我们将其放入 OnCollisionEnter 方法中。ParticleExplosion 预制体使用 AutoDestruct 脚本来自动在一段时间后销毁 Explosion 对象:

using UnityEngine;
public class AutoDestruct : MonoBehaviour {
    [SerializeField]
    private float DestructTime = 2.0f;
    void Start() {
        Destroy(gameObject, DestructTime);
    }
}

AutoDestruct 脚本虽小但方便。它只需经过一定时间后就会销毁附加的对象。许多 Unity 游戏几乎在每种情况下都会使用类似的脚本。

现在我们有一个可以发射和移动的坦克,我们可以为敌方坦克设置一个简单的巡逻路径。

设置航点

默认情况下,敌方坦克将在游戏竞技场巡逻。要实现这种行为,我们首先需要指定巡逻路径。我们将在 第六章 中彻底探讨路径跟随,路径跟随和转向行为。现在,我们只限于一个简单的 航点路径。

要实现它,我们放置了四个 WanderPoint:

图 2.5 – WanderPoint

图 2.5 – WanderPoint

这是我们 WanderPoint 对象的外观:

图 2.6 – WanderPoint 属性

图 2.6 – WanderPoint 属性

注意,我们需要将这些点标记为名为 WanderPoint 的标签。稍后,当我们尝试从我们的坦克 AI 中找到航点时,我们将使用这个标签。如你所见,在其属性中,航点只是一个带有 Mesh Renderer 复选框禁用的 Cube 游戏对象:

图 2.7 – 工具选择面板

图 2.7 – 工具选择面板

为了在编辑器中显示这些点(但不在游戏中),我们使用一个带有工具图标的无内容对象,因为我们从航点中需要的只是其位置和变换数据。为此,请点击检查器中对象图标附近的小三角形,如图 图 2.7 所示。

现在,我们准备利用有限状态机 (FSM) 的力量让敌方坦克获得生命。

创建抽象 FSM 类

接下来,我们实现一个通用的抽象类来定义敌方坦克 AI 类的方法。这个抽象类将是我们的 AI 的骨架,并代表敌方坦克应该做什么的高级视图。

我们可以在 FSM.cs 文件中看到这个类的代码:

using UnityEngine;
using System.Collections;
public class FSM : MonoBehaviour {
    protected virtual void Initialize() { } 

    protected virtual void FSMUpdate() { } 

    protected virtual void FSMFixedUpdate() { }
    // Use this for initialization 
    void Start () {
        Initialize();
    }
    // Update is called once per frame 
    void Update () {
        FSMUpdate();
    }
    void FixedUpdate() {
        FSMFixedUpdate();
    }
}

敌方坦克只需要知道玩家坦克的位置、它们的下一个目的地以及巡逻时可以选择的航点列表。一旦玩家坦克进入射程,它们就会旋转炮塔对象,并以它们的射击速率从子弹发射点开始射击。

正如我们之前解释的,我们将以两种方式扩展这个类:使用基于简单 if-then-else 的 FSM(SimpleFSM 类)和更工程化但更灵活的 FSM(AdvancedFSM)。这两个 FSM 实现将继承 FSM 抽象类,并将实现三个抽象方法:Initialize、FSMUpdate 和 FSMFixedUpdate。

在下一节中,我们将看到实现这三种方法的不同方式。现在,让我们从基本实现开始。

使用简单的 FSM 为敌方坦克 AI 实现

让我们看看我们 AI 坦克的实际代码。首先,让我们创建一个新的类,称为 SimpleFSM,它继承自我们的 FSM 抽象类。

你可以在 SimpleFSM.cs 文件中找到源代码:

using UnityEngine;
using System.Collections;
public class SimpleFSM : FSM {
    public enum FSMState {
        None, Patrol, Chase, Attack, Dead,
    }
    //Current state that the NPC is reaching
    public FSMState curState = FSMState.Patrol;
    //Speed of the tank
    private float curSpeed = 150.0f;
    //Tank Rotation Speed
    private float curRotSpeed = 2.0f;
    //Bullet
    public GameObject Bullet;
    //Whether the NPC is destroyed or not
    private bool bDead = false;
    private int health = 100;
    // We overwrite the deprecated built-in rigidbody 
    // variable.
    new private Rigidbody rigidbody;
    //Player Transform
    protected Transform playerTransform;
    //Next destination position of the NPC Tank
    protected Vector3 destPos;
    //List of points for patrolling
    protected GameObject[] pointList;
    //Bullet shooting rate
    protected float shootRate = 3.0f;
    protected float elapsedTime = 0.0f;
    public float maxFireAimError = 0.001f;
    // Status Radius
    public float patrollingRadius = 100.0f;
    public float attackRadius = 200.0f;
    public float playerNearRadius = 300.0f;
    //Tank Turret
    public Transform turret;
    public Transform bulletSpawnPoint;

在这里,我们声明了一些变量。我们的坦克 AI 有四种不同的状态:巡逻、追逐、攻击和死亡。我们正在实现我们在 第一章 中描述的 FSM,即 人工智能简介:

图 2.8 – 敌方坦克 AI 的有限状态机 (FSM)

图 2.8 – 敌方坦克 AI 的有限状态机 (FSM)

在我们的 Initialize 方法中,我们使用默认值设置我们的 AI 坦克的属性。然后,我们将航点的位置存储在我们的局部变量中。我们使用 FindGameObjectsWithTag 方法从场景中获取这些航点,尝试找到带有 WandarPoint 标签的对象:

//Initialize the Finite state machine for the NPC tank protected override void Initialize () {
    // Get the list of points 
    pointList = 
      GameObject.FindGameObjectsWithTag("WandarPoint");
    // Set Random destination point first 
    FindNextPoint();
    // Get the target enemy(Player) 
    GameObject objPlayer =
    GameObject.FindGameObjectWithTag("Player");
    // Get the rigidbody
    rigidbody = GetComponent<Rigidbody>();
    playerTransform = objPlayer.transform;
    if (!playerTransform) {
        print("Player doesn't exist. Please add one with
               Tag named 'Player'");
    }
}

每帧被调用的 Update 方法看起来如下:

protected override void FSMUpdate() {
    switch (curState) {
        case FSMState.Patrol: 
            UpdatePatrolState(); 
            break; 
        case FSMState.Chase: 
            UpdateChaseState(); 
            break; 
        case FSMState.Attack: 
            UpdateAttackState(); 
            break; 
        case FSMState.Dead: 
            UpdateDeadState();
            break;
   }
    // Update the time
    elapsedTime += Time.deltaTime;
    // Go to dead state is no health left 
    if (health <= 0) {
        curState = FSMState.Dead;
    }
}

我们检查当前状态,然后调用适当的状态方法。一旦健康对象的价值为零或更少,我们将坦克设置为 Dead 状态。

调试私有变量

检查器中的公共变量不仅因为我们可以快速尝试不同的值而有用,还因为我们可以在调试时快速查看它们的值。因此,你甚至可能会想将不应由组件用户更改的变量设置为公共(或暴露给检查器)。不用担心——有一个解决方案:你可以在调试模式下显示检查器。在调试模式下,检查器也会显示私有字段。要启用调试模式,点击右上角的三个点,然后点击调试:

图 2.9 – Unity 的调试模式下的检查器

图 2.9 – Unity 的调试模式下的检查器

现在,让我们逐一看看如何实现每个状态。

巡逻状态

巡逻状态是坦克在从路标到路标之间移动,寻找玩家的状态。巡逻状态的代码如下所示:

protected void UpdatePatrolState() {
    if (Vector3.Distance(transform.position, destPos) <=
        patrollingRadius) {
        print("Reached to the destination point\n 
               calculating the next point");
        FindNextPoint();
    } else if (Vector3.Distance(transform.position,
        playerTransform.position) <= playerNearRadius) {
        print("Switch to Chase Position");
        curState = FSMState.Chase;
    }
    // Rotate to the target point 
    Quaternion targetRotation = Quaternion.LookRotation(
      destPos - transform.position);
    transform.rotation = Quaternion.Slerp(
      transform.rotation, targetRotation,
      Time.deltaTime * curRotSpeed);
    // Go Forward
    transform.Translate(Vector3.forward * Time.deltaTime *
                        curSpeed);
}
protected void FindNextPoint() {
    print("Finding next point");
    int rndIndex = Random.Range(0, pointList.Length); 
    float rndRadius = 10.0f;
    Vector3 rndPosition = Vector3.zero;
    destPos = pointList[rndIndex].transform.position + 
      rndPosition;
    // Check Range to decide the random point as the same
    // as before
    if (IsInCurrentRange(destPos)) {
        rndPosition = new Vector3(Random.Range(-rndRadius,
          rndRadius), 0.0f, Random.Range(-rndRadius,
          rndRadius));
        destPos = pointList[rndIndex].transform.position +
          rndPosition;
    }
}
protected bool IsInCurrentRange(Vector3 pos) {
    float xPos = Mathf.Abs(pos.x - transform.position.x);
    float zPos = Mathf.Abs(pos.z - transform.position.z);
    if (xPos <= 50 && zPos <= 50) return true;
    return false;
}

当我们的坦克在FindNextPoint方法中时。这个方法只是简单地从我们之前定义的路标中选择一个随机点。

另一方面,如果坦克尚未到达其目标点,它将检查与玩家坦克的距离。如果玩家坦克在范围内(在这个例子中,我们选择为300单位),AI 将切换到UpdatePatrolState函数来旋转坦克并移动到下一个路标。

追逐状态

在追逐状态下,坦克积极尝试靠近玩家的坦克。简单来说,目标点变成了玩家的坦克本身。追逐状态的实施代码如下所示:

protected void UpdateChaseState() {
    // Set the target position as the player position 
    destPos = playerTransform.position;
    // Check the distance with player tank When
    // the distance is near, transition to attack state 
    float dist = Vector3.Distance(transform.position,
      playerTransform.position);
    if (dist <= attackRadius) {
        curState = FSMState.Attack;
    } else if (dist >= playerNearRadius {
        curState = FSMState.Patrol;
    }
    transform.Translate(Vector3.forward * Time.deltaTime *
                        curSpeed);
}

在这个状态下,我们首先将目标点设置为玩家。然后,我们继续检查玩家与坦克的距离。如果玩家足够近,AI 将切换到攻击状态。另一方面,如果玩家坦克设法逃脱并走得太远,AI 将回到巡逻状态。

攻击状态

攻击状态正是你所期待的:敌方坦克瞄准并射击玩家。以下代码块是攻击状态的实施代码:

protected void UpdateAttackState() {
    destPos = playerTransform.position;
    Vector3 frontVector = Vector3.forward;
    float dist = Vector3.Distance(transform.position,
      playerTransform.position);
    if (dist >= attackRadius && dist < playerNearRadius {
        Quaternion targetRotation = 
          Quaternion. FromToRotation(destPos – 
                                     transform.position); 
        transform.rotation = Quaternion.Slerp(
          transform.rotation, targetRotation,
          Time.deltaTime * curRotSpeed);
        transform.Translate(Vector3.forward * 
                            Time.deltaTime * curSpeed);
        curState = FSMState.Attack;
    } else if (dist >= playerNearRadius) {
        curState = FSMState.Patrol;
    }
    // Rotate the turret to the target point
    // The rotation is only around the vertical axis of the
    // tank.
    Quaternion targetRotation = Quaternion.FromToRotation(
      frontVector, destPos - transform.position);
    turret.rotation = Quaternion.Slerp(turret.rotation,
      turretRotation, Time.deltaTime * curRotSpeed);
    //Shoot the bullets
    if (Mathf.Abs(Quaternion.Dot(turretRotation,
      turret.rotation)) > 1.0f - maxFireAimError) {
        ShootBullet();
    }
}
private void ShootBullet() {
    if (elapsedTime >= shootRate) {
        Instantiate(Bullet, bulletSpawnPoint.position,
                    bulletSpawnPoint.rotation);
        elapsedTime = 0.0f;
    }
}

在第一行,我们仍然将目标点设置为玩家的位置。毕竟,即使在攻击时,我们也需要保持与玩家保持较近的距离。然后,如果玩家坦克足够近,AI 坦克将turret对象旋转到玩家坦克的方向,并开始射击。最后,如果玩家的坦克超出范围,坦克将回到巡逻状态。

死亡状态

死亡状态是最终状态。一旦坦克进入死亡状态,它就会爆炸并消失。以下是死亡状态的代码:

protected void UpdateDeadState() {
    // Show the dead animation with some physics effects 
    if (!bDead) {
        bDead = true;
        Explode();
    }
}

如你所见,代码很简单——如果坦克达到了死亡状态,我们让它爆炸:

protected void Explode() {
    float rndX = Random.Range(10.0f, 30.0f); 
    float rndZ = Random.Range(10.0f, 30.0f); 
    for (int i = 0; i < 3; i++) {
        rigidbody.AddExplosionForce(10000.0f,
          transform.position - new Vector3(rndX, 
          10.0f, rndZ), 40.0f, 10.0f);
        rigidbody.velocity = transform.TransformDirection(
          new Vector3(rndX, 20.0f, rndZ));
    }
    Destroy(gameObject, 1.5f);
}

这是一个小函数,它提供了一个很好的爆炸效果。我们给坦克的 Rigidbody 组件应用一个随机的 ExplosionForce 函数。如果一切正常,你应该会看到坦克在空中以随机方向飞起,供玩家娱乐。

受伤

为了完成这个演示,我们需要添加另一个小细节:当坦克被子弹击中时,它们需要受到伤害。每次子弹进入坦克的碰撞区域,health 属性的值就会根据 Bullet 对象的 damage 值减少:

void OnCollisionEnter(Collision collision) {
    // Reduce health 
    if(collision.gameObject.tag == "Bullet") {
        health -=collision.gameObject.GetComponent
          <Bullet>().damage;
    }
}

你可以在 Unity 中打开 SimpleFSM.scene 文件;你应该能看到 AI 坦克正在巡逻、追逐和攻击玩家。我们的玩家坦克目前还没有受到 AI 坦克的伤害,所以它永远不会被摧毁。但是 AI 坦克有生命属性,会受到玩家子弹的伤害,所以你会看到它们的生命属性达到零时爆炸。

如果你的演示不起作用,请尝试在检查器中调整 SimpleFSM 组件的不同值。毕竟,这些值可能会根据你项目的规模而变化:

图 2.10 – AI 坦克在行动

图 2.10 – AI 坦克在行动

在这个演示中,我们使用了一个非常简单的有限状态机(FSM),但现在是我们提高挑战并实现一个完整的 FSM 框架的时候了。

使用 FSM 框架

我们将要使用的 FSM 框架是从书籍仓库的 Chapter02 文件夹中改编的(github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition)。特别是,我们将查看 AdvancedFSM 场景。

在本节中,我们将研究框架的工作原理以及我们如何使用它来实现我们的坦克 AI。AdvancedFSM 和 FSMState 是我们框架的两个主要类。所以,让我们先看看它们。

AdvancedFSM 类

AdvancedFSM 类管理我们实现的所有 FSMState 类,并保持它们通过转换和当前状态更新。因此,在使用我们的框架之前,我们首先要声明我们计划为我们的 AI 坦克实现的转换和状态。

让我们从创建 AdvancedFSM.cs 开始:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public enum Transition {
    None = 0, SawPlayer, ReachPlayer, LostPlayer, NoHealth,
}
public enum FSMStateID {
    None = 0, Patrolling, Chasing, Attacking, Dead,
}

在这里,我们定义了两个枚举,一个用于状态集合,另一个用于转换集合。然后,我们添加了一个列表对象来存储 FSMState 对象,以及两个局部变量来存储 FSMState 类的当前 ID 和当前的 FSMState 本身。

AddFSMState 和 DeleteState 方法分别在我们的列表中添加和删除 FSMState 类的实例。当 PerformTransition 方法被调用时,它会根据转换更新 CurrentState 变量:

public class AdvancedFSM : FSM {
    private List<FSMState> fsmStates; 
    private FSMStateID currentStateID; 
    public FSMStateID CurrentStateID {
        get {
            return currentStateID;
        }
    }
    private FSMState currentState; 
    public FSMState CurrentState {
        get {
            return currentState;
        }
    }

现在类的数据部分已经准备好了,我们可以继续实现 FSM 框架的内部逻辑。

FSMState 类

FSMState管理到其他状态的转换。它有一个名为map的字典对象,其中我们存储转换和状态的键值对。例如,SawPlayer转换映射到Chasing状态,LostPlayer映射到Patrolling状态,等等。

让我们创建一个FSMState.cs文件:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public abstract class FSMState {
    protected Dictionary<Transition, FSMStateID> map = 
      new Dictionary<Transition, FSMStateID>();
    // Continue...

AddTransition和DeleteTransition方法向它们的状态转换字典映射对象中添加和删除转换。GetOutputState方法从映射对象中查找,并根据输入转换返回状态。

FSMState类还声明了两个抽象方法,其子类需要实现。它们如下:

...
    public abstract void CheckTransitionRules(Transform 
      player, Transform npc);
    public abstract void RunState(Transform player,
      Transform npc);
...

CheckTransitionRules方法必须检查状态是否应该执行到另一个状态的转换。相反,RunState方法执行currentState变量的实际任务,例如向目标点移动和追逐或攻击玩家。这两个方法都需要使用此类从玩家和不可玩角色(NPC)实体获得的转换数据。

状态类

与之前的SimpleFSM示例不同,我们为我们的坦克 AI 在继承自FSMState类的单独类中编写状态,例如AttackState、ChaseState、DeadState和PatrolState。所有这些类都实现了CheckTransitionRules和RunState方法。让我们以PatrolState类为例进行查看。

PatrolState类

这个类有三个方法:构造函数、CheckTransitionRules和RunState。让我们在PatrolState.cs文件中创建PatrolState类:

using UnityEngine;
using System.Collections;
public class PatrolState : FSMState {
    private Vector3 destPos;
    private Transform[] waypoints;
    private float curRotSpeed = 1.0f;
    private float curSpeed = 100.0f;
    private float playerNearRadius;
    private float patrollRadius;
    public PatrolState(Transform[] wp, float
      playerNearRadius, float patrollRadius) {
        waypoints = wp;
        stateID = FSMStateID.Patrolling;
        this.playerNearRadius = playerNearRadius;
        this.patrollRadius = patrollRadius;
    }
    public override void CheckTransitionRules(
      Transform player, Transform npc) {
        // Check the distance with player tank
        // When the distance is near, transition to chase
       // state 
        if (Vector3.Distance(npc.position, player.position)
            <= playerNearRadius) {
            Debug.Log("Switch to Chase State");
            NPCTankController npcTankController = 
              npc.GetComponent<NPCTankController>();
            if (npcTankController != null) {
                npcTankController.SetTransition(
                Transition.SawPlayer);
            } else {
                Debug.LogError("NPCTankController not found
                                in NPC");
            }
        }
    }
    public override void RunState(Transform player,
      Transform npc) {
        // Find another random patrol point if the current
        // point is reached
        if (Vector3.Distance(npc.position, destPos) <= 
            patrollRadius) {
            Debug.Log("Reached to the destination point\n
                       calculating the next point"); 
            FindNextPoint();
        }
        // Rotate to the target point
        Quaternion targetRotation =
          Quaternion.FromToRotation(Vector3.forward,
          destPos - npc.position);
        npc.rotation = Quaternion.Slerp(npc.rotation,
          targetRotation, Time.deltaTime * curRotSpeed);
        // Go Forward 
        npc.Translate(Vector3.forward * Time.deltaTime * 
                      curSpeed);
    }
}

constructor方法接受waypoints数组,将其存储在本地数组中,然后初始化如移动和旋转速度等属性。Reason方法检查自身(AI 坦克)和玩家坦克之间的距离。如果玩家坦克在范围内,它使用NPCTankController类的SetTransition方法将转换 ID 设置为SawPlayer转换,该方法如下所示:

public void SetTransition(Transition t) {
    PerformTransition(t);
}

前面的函数只是一个包装方法,它调用AdvanceFSM类的PerformTransition方法。反过来,该方法使用Transition对象和来自FSMState类的状态转换字典映射对象来更新CurrentState变量,以负责这个转换。Act方法更新 AI 坦克的目标点,将坦克旋转到那个方向,并向前移动。

其他状态类也遵循这个模板,具有不同的推理和行动程序。我们已经在之前的简单有限状态机(FSM)示例中见过它们,因此在这里不再描述。看看你是否能自己找出如何设置这些类。如果你卡住了,这本书附带的内容中包含了你可以查看的代码。

NPCTankController类

对于坦克 AI,我们通过使用NPCTankController类为我们的 NPC 设置状态。这个类从AdvanceFSM继承:

private void ConstructFSM() {
    PatrolState patrol = new PatrolState(waypoints,
      playerNearRadius, patrollingRadius);
    patrol.AddTransition(Transition.SawPlayer,
                         FSMStateID.Chasing);
    patrol.AddTransition(Transition.NoHealth,
                         FSMStateID.Dead);
    ChaseState chase = new ChaseState(waypoints); 
     chase.AddTransition(Transition.LostPlayer,
                         FSMStateID.Patrolling); 
    chase.AddTransition(Transition.ReachPlayer,
                        FSMStateID.Attacking); 
    chase.AddTransition(Transition.NoHealth,
                        FSMStateID.Dead);
    AttackState attack = new AttackState(waypoints); 
   attack.AddTransition(Transition.LostPlayer,
                        FSMStateID.Patrolling); 
    attack.AddTransition(Transition.SawPlayer,
                         FSMStateID.Chasing); 
    attack.AddTransition(Transition.NoHealth,
                         FSMStateID.Dead);
    DeadState dead = new DeadState(); 
    dead.AddTransition(Transition.NoHealth,
                       FSMStateID.Dead);
    AddFSMState(patrol); 
    AddFSMState(chase); 
    AddFSMState(attack);
    AddFSMState(dead);
}

这就是使用我们的 FSM 框架的美丽之处:由于状态在其各自的类中自我管理,我们的NPCTankController类只需要调用当前活动状态的Reason和Act方法。

这一事实消除了编写长串的if/else和switch语句的需求。相反,我们的状态现在被很好地封装在自己的类中,这使得代码更加易于管理,因为在大型项目中,状态的数量以及它们之间的转换越来越多:

protected override void FSMFixedUpdate() {
    CurrentState.Reason(playerTransform, transform);
    CurrentState.Act(playerTransform, transform);
}

使用此框架的主要步骤可以总结如下:

  1. 在AdvanceFSM类中声明转换和状态。

  2. 编写从FSMState类继承的状态类,然后实现Reason和Act方法。

  3. 编写从AdvanceFSM继承的自定义 NPC AI 类。

  4. 从状态类创建状态,然后使用FSMState类的AddTransition方法添加转换和状态对。

  5. 使用AddFSMState方法将这些状态添加到AdvanceFSM类的状态列表中。

  6. 在游戏更新周期中调用CurrentState变量的Reason和Act方法。

你可以在 Unity 中尝试AdvancedFSM场景。它将以与我们之前的SimpleFSM示例相同的方式运行,但现在代码更加有序和易于管理。

摘要

在本章中,我们学习了如何在 Unity3D 中根据简单的坦克游戏实现状态机。我们首先探讨了如何通过使用switch语句来实现有限状态机(FSM)。然后,我们研究了如何使用框架使 AI 实现更容易管理和扩展。

在下一章中,我们将探讨随机性和概率,并看看我们如何利用它们使游戏的结果更加不可预测。

第三章:随机性和概率

在本章中,我们将探讨如何将概率和随机性的概念应用于游戏人工智能。因为我们将会更多地讨论随机性在游戏人工智能中的应用,而不是 Unity3D,所以我们可以将本章的概念应用于任何游戏开发中间件或技术框架。我们将使用 Unity3D 中的 Mono C#进行演示,但不会过多涉及 Unity3D 引擎和编辑器的具体功能。

游戏开发者使用概率为人工智能角色的行为和更广泛的游戏世界添加一些不确定性。随机性使人工智能看起来更加真实和自然,它是那些我们不需要有意可预测性的所有情况的完美“调味品”。

在本章中,我们将探讨以下主题:

  • 在 Unity 中引入随机性

  • 学习概率的基本知识

  • 探索游戏中更多概率的例子

  • 创建一个老丨虎丨机

技术要求

对于本章,你只需要 Unity3D 2022。你可以在本书仓库中的第三章文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter03。

在 Unity 中引入随机性

游戏设计师和开发者使用随机性在游戏人工智能中,通过改变角色决策的结果,使游戏及其角色更加真实。

让我们以一场典型的足球比赛为例。足球比赛的一条规则是,如果一方球员在试图夺回球权时犯规,将判给对方直接任意球。然而,游戏开发者可以应用概率,只对 98%的所有犯规判给直接任意球。

在现实中,裁判有时也会犯错误。由于这个简单的改变,玩家通常可以得到预期的直接任意球。然而,当剩下的两百分之一发生时,游戏为两队提供更多的情感反馈(假设你在与另一名人类玩家对战,一名玩家会感到高兴,而另一名玩家会向虚拟裁判抱怨)。

当然,随机性并不总是人工智能所期望的附加功能。正如我们在引言中所预期的,一定程度的可预测性允许玩家学习人工智能模式,而理解人工智能模式通常是游戏玩法的主要组成部分。例如,在潜行游戏中,学习敌方守卫的路径对于玩家找到潜行路线是必要的。或者想象你需要为像《黑暗之魂》这样的游戏设计一个 Boss。

然而,在某些情况下,一点随机性是有用的,对于某些游戏,如赌博迷你游戏,它是一个必要的先决条件。在这些情况下,计算机如何产生随机值?更重要的是,我们如何在 Unity 中使用随机数?

计算机科学中的随机性

计算机是确定性的机器:按照设计,如果我们多次给计算机相同的输入,以程序代码和数据的形态,它总是返回相同的输出。因此,我们如何让程序返回不可预测和随机的输出呢?

如果我们需要真正随机的数字,那么我们就需要从其他地方获取这种随机性。这就是为什么许多高级应用尝试将不同的外部随机性来源组合成一个随机值:它们可能会观察鼠标在特定时间间隔内的移动,互联网连接的噪声,甚至要求用户随机敲击键盘等等。甚至还有专门用于生成随机数的硬件!

幸运的是,在游戏中,我们不需要真正随机的数字,我们可以使用更简单的算法来生成看起来像随机数字序列的序列。这类算法被称为伪随机数生成器(PRNGs)。使用一个初始种子,它们可以以确定性的方式生成一个序列,这个序列在统计上近似于真正随机数字序列的性质。问题是,如果我们从相同的种子开始,我们总是会得到相同的数字序列。

因此,我们通常从一些我们认为每次用户打开应用程序时总是不同的事物中初始化种子值,例如,例如,自计算机开始运行以来的毫秒数,或者自 1970 年(Unix 时间戳)以来的毫秒数。然而,请注意,每次都能获得相同的随机序列在调试时确实非常有用!

最后,请注意,一些伪随机数生成器(PRNGs)比其他生成器更随机。如果我们正在创建一个加密程序,我们希望研究那些被称为加密安全伪随机数生成器(CSPRNGs)的更不可预测的 PRNGs。幸运的是,对于游戏来说,Unity 自带的基础随机数生成(RNG)就足够好了。

Unity 随机类

Unity3D 脚本中有一个 Random 类用于生成随机数据。您可以使用 InitState(int seed) 函数设置生成器的种子。通常情况下,我们不会希望反复设置相同的值,因为这会在每次执行时生成相同的可预测的随机数序列。

然而,有些情况下我们希望用户能够控制种子 – 例如,当我们测试游戏或希望玩家使用特定的种子生成程序化地图/关卡时。然后,你可以读取Random.value属性来获取 0.0 到 1.0 之间的随机数。这个生成器是包含的,因此这个属性可以返回 0.0 和 1.0。

例如,在下面的代码片段中,我们通过为红色、绿色和蓝色组件选择 0 到 1 之间的随机值来生成一个随机颜色:

Color randomColor = new Color(Random.value, Random.value, Random.value); 

另一个非常有用的类方法是Range方法:

static function Range (min : float, max : float) : float

我们可以使用Range方法从一个范围内生成一个随机数。当给定一个整数值时,它返回一个介于min(包含)和max(不包含)之间的随机整数。因此,如果我们设置min为 1,max为 4,我们可以得到 1、2 或 3,但永远不会得到 4。相反,如果我们使用Range函数为浮点值,min和max都是包含的,这意味着我们可以得到 1.0、4.0 或介于两者之间的所有浮点数。请注意,当使用 Unity 的Random类时,参数是包含的还是不包含的是常见的错误(和混淆)来源。

一个简单的随机掷骰子游戏

让我们在一个新的场景中设置一个简单的掷骰子游戏,在这个场景中我们需要猜测六面骰子的输出(通过生成一个介于 1 到 6 之间的随机整数来模拟)。如果输入值与随机生成的骰子结果匹配,玩家获胜,如下面的DiceGame.cs文件所示:

using UnityEngine;
using TMPro;
using UnityEngine.UI;
public class DiceGame : MonoBehaviour {
    public string inputValue = "1";
    public TMP_Text outputText;
    public TMP_InputField inputField;
    public Button button;
    int throwDice() {
        Debug.Log("Throwing dice...");
        Debug.Log("Finding random between 1 to 6...");
        int diceResult = Random.Range(1,7);
        Debug.Log($"Result: {diceResult}");
        return diceResult;
    }
    public void processGame() {
        inputValue = inputField.text;
        try {
            int inputInteger = int.Parse(inputValue);
            int totalSix = 0;
            for (var i = 0; i < 10; i++) {
                var diceResult = throwDice();
                if (diceResult == 6) { totalSix++; }
                if (diceResult == inputInteger) {
                    outputText.text = $"DICE RESULT:
                      {diceResult} \r\nYOU WIN!";
                } else {
                    outputText.text = $"DICE RESULT:
                      {diceResult} \r\nYOU LOSE!";
                }
            }
            Debug.Log($"Total of six: {totalSix}");
        } catch {
            outputText.text = "Input is not a number!";
            Debug.LogError("Input is not a number!");
        }
    }
}

在前面的代码中,我们看到了实现整个游戏的DiceGame类。然而,我们仍然需要设置场景,使用适当的 UI 对象来接受玩家的输入并显示结果:

  1. 首先,我们需要创建guiText来显示结果。点击游戏场景中的New Text文本。

  2. 将其置于画布顶部中央。

  3. 然后,以同样的方式,通过选择Game Object | UI | Button – TextMeshPro创建一个按钮,通过选择Game Object | UI | Input Field – TextMeshPro创建一个输入字段。

  4. 将它们垂直排列在屏幕上。

  5. 创建一个空的游戏对象,并将其命名为DiceGame。此时,你应该有类似于图 3.1的界面:

图 3.1 – 我们简单的 Unity 界面

图 3.1 – 我们简单的 Unity 界面

  1. 在按钮内部选择文本,并在TextMeshPro组件中将Button替换为Play!:

  2. 在TextMeshPro组件中选择New Text文本,并将其替换为Result::

图 3.2 – TextMeshPro 组件

图 3.2 – TextMeshPro 组件

  1. 现在,将DiceGame组件附加到DiceGame对象上,并将我们之前创建的 UI 元素树连接到DiceGame组件:

图 3.3 – DiceGame 组件

图 3.3 – DiceGame 组件

  1. 最后,选择“按钮”并查找“按钮”组件中的onClick()部分。将DiceGame对象拖放到带有None (GameObject)的字段中,并将processGame函数分配给按钮的点击事件:

图 3.4 – 单击事件配置

图 3.4 – 单击事件配置

到这一点,游戏应该已经准备好了。点击 Unity 的播放按钮,开始游戏。

要成功管理随机数,我们需要对概率定律有一个基本的了解。因此,这就是我们将在下一节学习的内容。

学习概率的基础

定义概率的方法有很多。最直观的概率定义被称为频率主义。根据频率主义,事件的概率是在我们无限次重复观察时事件发生的频率。换句话说,如果我们掷骰子 100 次,我们期望平均看到一次六,大约是六分之一的时间,并且随着 1,000 次、10,000 次和 1,000,000 次的投掷,我们应该越来越接近六分之一。

我们可以将事件 A 发生的概率写成 P(A)。要计算 P(A),我们需要知道观察的所有可能结果 (N) 以及期望事件发生的总次数 (n)。

我们可以按照以下方式计算事件 A 的概率:

公式 01

如果 P(A) 是事件 A 发生的概率,那么事件 A 不发生的概率等于以下:

公式 2

概率必须是一个介于零和一之间的实数。概率为零意味着没有机会发生期望的事件;另一方面,概率为一意味着事件一定会发生。因此,以下必须等于一:

公式 3

然而,并非所有事件都是相同的。概率论中最关键的概念之一是独立和非独立事件的概念。这就是下一节的主题。

独立和非相关事件

概率论中的另一个重要概念是,一个特定事件发生的概率是否以某种方式依赖于其他事件。例如,考虑掷两次六面骰子并得到一个双六。每次掷骰子都可以看作是一个独立事件。每次掷骰子,每个面出现的概率是六分之一,第二次掷骰子的结果不会因第一次掷骰子的结果而改变。另一方面,在从同一副牌中抽取两张 A 时,每次抽取并不是相互独立的。如果你在第一次事件中抽到了 A,那么第二次抽到 A 的概率会不同,因为牌堆中现在少了一个 A(并且少了一张牌)。

事件的独立性至关重要,因为它显著简化了一些计算。例如,想象一下我们想知道事件 A 或事件 B 发生的概率。如果 A 和 B 是两个独立事件,那么我们可以将 A 和 B 的概率相加:

公式 _04.png

同样地,如果我们想知道同时发生事件 A 和 B 的概率,那么我们可以将各自的概率相乘:

公式 _5.png

例如,如果我们想知道通过掷两个骰子得到两个六的概率,我们可以将 1/6 乘以 1/6 来得到正确的概率:1/36。

条件概率

现在,让我们考虑另一个例子。我们仍然在掷两个骰子,但这次,我们感兴趣的是两个骰子显示的数字之和等于二的概率。由于只有一种方式得到这个总和,即一加一,所以概率与两个骰子显示相同数字的概率相同。在这种情况下,它仍然是 1/36。

但是,如何得到两个骰子显示数字之和为七呢?正如你所见,总共有六种可能的方式得到总和为七,如下表所示:

图 3.5 – 两个骰子的可能结果

图 3.5 – 两个骰子的可能结果

在这种情况下,我们需要使用一般概率公式。从前面的表格中,我们可以看到我们有六个结果,总共有七个。因为我们知道两个骰子总共有 36 种可能的结果,所以我们可以快速计算出最终概率为 6/36,或者简化为六分之一(16.7%)。

加重骰子

现在,让我们假设我们并不完全诚实,并且我们的骰子是加重的,使得数字六的面有双倍的机会向上。由于我们增加了得到六的机会,我们需要将得到六的概率加倍——比如说,大约三分之一(0.34)——因此,其余的均匀分布在剩下的五个面上(每个面 0.132)。

我们可以这样实现一个加重的骰子算法:首先,我们生成一个介于 1 到 100 之间的随机值。然后,我们检查这个随机值是否落在 1 到 35 之间。如果是,我们的算法返回六;否则,我们得到一个介于 1 到 5 之间的随机骰子值(因为这些值有相同的概率)。

对于这个,我们创建一个新的类,称为 DiceGameLoaded。游戏与 DiceGame 相同,但有一个重要的区别:throwDice 函数被更改,如下所示:

    int throwDice() {
        Debug.Log("Throwing dice...");
        int randomProbability = Random.Range(0, 100);
        int diceResult = 0;
        if (randomProbability < 35) {
            diceResult = 6;
        } else {
            diceResult = Random.Range(1, 5);
        }
        Debug.Log("Result: " + diceResult);
        return diceResult;
    }

要尝试这个新版本的游戏,将 DiceGame 组件与 DiceGame 对象中的 DiceGame 组件交换,并重新绑定我们之前所做的 onClick 按钮事件。如果我们通过多次掷骰子来测试我们的新加重骰子算法,你会注意到 6 值比平常更多。

如您所见,代码与非加载骰子非常相似。然而,这次我们抛的是一个不公平的骰子,其返回六的概率远高于正常情况:我们首先在 0 和 100 之间选择一个随机数;如果这个数小于 35,则返回 6。否则,我们在 1 和 5 之间选择一个随机数。因此,我们有 35% 的概率得到 6,而其他数字的大约 15% 的概率(我们将剩余的 75% 除以 5)。

记住,在游戏中,如果目标是给玩家带来更激动人心和有趣的体验,那么这并不算作弊!

探索游戏中概率的更多示例

在本节中,我们将探讨概率和随机性在视频游戏中最常见的应用。

角色性格

概率和随机性不仅与骰子有关。我们还可以使用概率分布来指定游戏角色的特长。例如,让我们假设我们为地方政府设计了一个人口管理游戏的游戏提案。我们需要解决和模拟诸如税收与全球人才吸引、移民与社会凝聚力等问题。在我们的提案中,我们有三种类型的角色——即工人、科学家和专业人士。他们在执行特定任务时的效率定义在以下表格中:

图 3.6 – 每个角色执行每个任务时的效率

图 3.6 – 每个角色执行每个任务时的效率

让我们看看我们如何实现这个场景。假设玩家需要建造新的房屋以容纳增加的人口。房屋建造需要 1,000 个工作单位来完成。我们使用之前的价值作为特定任务中每个单位类型每秒可以完成的工作量。

因此,如果你只用一个工人来建造房屋,建造时间大约只需 10 秒(1000/95),而如果你试图用科学家建造,则需要超过 3 分钟(1000/5 = 200 秒)。其他任务也是如此,例如研发和公司工作。当然,随着游戏的进行,这些因素可以调整或增强,使得一些入门级任务变得简单,所需时间更少。

然后,我们引入特定单位类型可以发现的特殊物品。我们不想每次特定单位完成任务时都发放这些物品。相反,我们希望作为惊喜奖励玩家。因此,我们根据单位类型将找到此类物品的概率关联起来,如下表所述:

图 3.7 – 每个单位类型找到特定物体的概率

图 3.7 – 每个单位类型找到特定物体的概率

前面的表格显示,工人找到一些原材料的机会有 30%,而每当他们建造了一个工厂或一栋房子,就有 10%的机会获得奖金收入。这允许玩家在完成一些任务后预测可能即将到来的奖励,从而使游戏更加有趣,因为他们不知道事件的结果。

感知随机性

随机性的一个关键方面是,人类在理解真正的随机性方面非常糟糕。相反,当我们人类谈论随机结果时,我们想到的是均匀分布的结果。例如,想象一下像英雄联盟这样的大型多人在线战斗竞技场(MOBA)游戏。想象一下,我们有一个英雄拥有造成巨大伤害的能力,但只有 50%的时间能命中。玩家用一个这样的英雄开始游戏,但这个英雄由于运气不好连续五次没有使用那个能力。换位思考一下那个玩家的感受——你会认为电脑在作弊或者有什么问题,对吧?

然而,连续五次未命中的概率是 1/32。这大约是 3.1%,比在五张牌的扑克牌中抽到三张同花(大约是 2.1%)的可能性要大——不太可能但有可能。如果我们的游戏使用一个完美的随机数生成器,我们可能会相对频繁地遇到这种情况。

让我们换一种说法。给定一系列的未命中(M)和命中(H),你会在HHHHHMMM和HMHMHHMH之间找到哪个序列更随机?我打赌是第二个,其中我们交替使用未命中和命中。它感觉比第一个(命中和未命中被很好地分组在打击中)更随机,即使它们自然发生的概率完全相同。

重点是,有时,为了提高玩家的参与度,游戏需要调整它们的随机性,以获得比真正的随机性感觉更随机的东西。视频游戏以几种方式做到这一点。最常见的一种是跟踪一个应该被视为随机值的出现的次数。

因此,例如,我们可能会跟踪我们英雄能力命中和未命中的次数,当我们看到这两个比例与理论上的 50%相差太远时——例如,当我们有 75%的未命中(或命中)时——我们通过强制命中(或反之)来重新平衡比例。

带概率的有限状态机

在第二章,有限状态机中,我们看到了如何使用简单的开关语句或有限状态机框架来实现有限状态机。我们基于给定条件的真值或假值来选择执行哪个状态。让我们暂时回到我们的人工智能控制的坦克实体的有限状态机:

图 3.8 – 坦克 AI 有限状态机

图 3.8 – 坦克 AI 有限状态机

为了举例说明,我们可以给我们的坦克实体一些选项来选择,而不是每次遇到特定条件时都做同样的事情。例如,在我们的早期有限状态机中,我们的 AI 坦克一旦发现玩家在其视线中,就会一直追逐玩家坦克。相反,我们可以将玩家在视线中的交易拆分,并将其连接到一个新的附加状态,逃跑。AI 如何决定移动到哪个状态呢?当然,随机选择:

Figure 3.9 – FSM using probability

img/B17984_03_9.jpg

图 3.9 – 使用概率的有限状态机

如前图所示,现在,当 AI 坦克发现玩家时,有 50%的概率它会逃离现场(可能是向总部报告攻击或其他事情)。我们可以用与之前骰子示例相同的方式实现这个机制。首先,我们必须随机获取一个介于 1 到 100 之间的值,并查看这个值是否介于 1 到 50 之间,或者 51 到 100 之间。如果是前者,坦克将逃跑;否则,它将追逐玩家。

另一种实现随机选择的方法是使用轮盘赌选择算法。当我们在编译时没有确切的概率或不知道所有可能的选项时,这个算法是有优势的(例如,因为我们从文件中加载了有限状态机规则)。

如其名所示,这个想法是想象一个每个事件都有一个扇区的轮盘赌。然而,一个事件越可能发生,其扇区就越大。然后,我们数学上旋转这个轮盘,并选择我们最终到达的扇区对应的事件:

Figure 3.10 – The roulette wheel

img/B17984_03_10.jpg

图 3.10 – 轮盘赌

在我们的例子中,我们有三个状态:追逐、逃跑和自毁。我们为每个状态分配一个权重,表示它们相对于彼此的概率。例如,在图中,你可以看到我将追逐的权重设置为80,逃跑的权重设置为19,自毁的权重设置为1。请注意,权重不需要像概率那样总和为 1,也不需要是 100,或其他特定的数值。

然而,在这种情况下,我将它们加到 100,因为这更容易将权重转换为概率:我们可以想象追逐发生 80%的时间,逃跑发生 19%的时间,而在 1%的情况下,坦克自毁。然而,通常情况下,你可以想象事件X的权重是写有X的球的数量,并将它们放入一个彩票箱中。

让我们在FSM.cs文件中看看结果:

using UnityEngine;
using System.Collections;
using System;
using System.Linq;
public class FSM : MonoBehaviour {
    [Serializable]
    public enum FSMState {
        Chase,
        Flee,
        SelfDestruct,
    }
    [Serializable]
    public struct FSMProbability {
        public FSMState state;
        public int weight;
    }
    public FSMProbability[] states;
    FSMState selectState() {
        // Sum the weights of every state.
        var weightSum = states.Sum(state => state.weight);
        var randomNumber = UnityEngine.Random.Range(0,
          weightSum);
        var i = 0;
        while (randomNumber >= 0) {
            var state = states[i];
            randomNumber -= state.weight;
            if (randomNumber <= 0) {
                return state.state;
            }
            i++;
        }
        // It is not possible to reach this point!
        throw new Exception("Something is wrong in the
          selectState algorithm!");
    }

    // Update is called once per frame
    void Update () {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            FSMState randomState = selectState();
            Debug.Log(randomState.ToString());
        }
    }
}

这个机制很简单。首先,我们将所有权重相加,以了解想象中的轮盘的大小。然后,我们在 0 和这个总和之间选择一个数字。最后,我们从这个数字中减去每个状态的权重(从第一个开始),直到数字变成负数。然后,正如你在Update()方法中看到的,每次我们按下空格键,算法就会从我们的states数组中随机选择一个项目。

动态调整 AI 技能

我们还可以使用概率来指定 AI 角色的智能水平或全局游戏设置,从而影响游戏的总体难度水平,使其对玩家保持挑战性和趣味性。正如 Jesse Schell 在其著作《游戏设计艺术》中所描述的,如果游戏能够使玩家保持在“心流”通道中(一个从 Mihály Csíkszentmihályi 关于心流状态的心理工作中借鉴的概念),玩家才会继续玩游戏:

![图 3.11 – 玩家的心流通道

![img/B17984_03_11.jpg]

图 3.11 – 玩家的心流通道

如果在玩家具备必要技能之前就向他们展示过于复杂的挑战,他们将会感到焦虑和失望。另一方面,一旦他们掌握了游戏,如果我们保持同样的节奏,他们将会感到无聊。玩家保持参与的时间区域位于这两个极端之间,即困难与简单之间,原始作者将其称为“心流通道”。为了使玩家保持在心流通道中,游戏设计师需要提供与玩家随时间获得的技能提升相匹配的挑战和任务。然而,由于学习速度和期望值可能因人而异,因此很难找到一个对所有玩家都适用的值。

解决这个问题的方法之一是在游戏过程中收集玩家的尝试和结果,并相应地调整对手 AI 的难度。那么,我们如何改变 AI 的难度——例如,通过使 AI 更具侵略性,增加完美射击的概率,或减少异常行为发生的概率?

创建老丨虎丨机

在这个演示中,我们将设计和实现一个带有 10 个符号和 3 个滚筒的老丨虎丨机游戏。为了简化,我们将使用从零到九的数字作为我们的符号。许多老丨虎丨机使用水果和其他简单的形状,例如铃铛、星星和字母。有些其他老丨虎丨机则使用基于流行电影或电视系列的特定主题。由于有 10 个符号和 3 个滚筒,因此总共有 1,000(10³)种可能的组合。

随机老丨虎丨机

这个随机老丨虎丨机演示与我们的先前的骰子示例类似。这次,我们将为三个滚筒生成三个随机数字。唯一的回报是在支付线上出现三个相同的符号时。为了简化,在这个演示中我们只有一条线路可以玩。如果玩家赢了,游戏将返还投注金额的 500 倍。

我们将设置场景中的所有 UI 元素:三个用于滚筒的文本,另一个用于betResult对象的文本元素,一个用于玩家信用额的文本元素(Credits),一个用于投注的输入字段(InputField),以及一个拉动摇杆的按钮(Button):

![图 3.12 – 我们的 GUI 文本对象

![img/B17984_03_12.jpg]

图 3.12 – 我们的 GUI 文本对象

这就是我们的新脚本的样子,如下面的SlotMachine.cs文件所示:

using UnityEngine;
using UnityEngine.UI;
public class SlotMachine : MonoBehaviour { 
    public float spinDuration = 2.0f;
    public int numberOfSym = 10;
    public Text firstReel;
    public Text secondReel;
    public Text thirdReel;
    public Text betResult;
    public Text totalCredits;
    public InputField inputBet;
    private bool startSpin = false;
    private bool firstReelSpinned = false;
    private bool secondReelSpinned = false;
    private bool thirdReelSpinned = false;
    private int betAmount;
    private int credits = 1000;
    private int firstReelResult = 0;
    private int secondReelResult = 0;
    private int thirdReelResult = 0;
    private float elapsedTime = 0.0f;

首先,我们列出所有需要的类属性。再次提醒,避免使用公共字段是一个好的编程实践,除非绝对必要。因此,你应该使用 [SerializeField] 属性。然而,在这里,我们将使用 public 属性以避免使代码列表过长。

现在,让我们继续添加三个新的函数:Spin,它用于启动老丨虎丨机的旋转;OnGui,我们将用它来更新用户界面;以及 checkBet,这是一个检查旋转结果并通知玩家他们是否赢或输的函数:

public void Spin() {
    if (betAmount > 0) {
        startSpin = true;
    } else {
        betResult.text = "Insert a valid bet!";
    }
}
private void OnGUI() {
    try {
        betAmount = int.Parse(inputBet.text);
    } catch {
        betAmount = 0;
    }
    totalCredits.text = credits.ToString();
}
void checkBet() {
    if (firstReelResult == secondReelResult && 
        secondReelResult == thirdReelResult) {
        betResult.text = 
          "YOU WIN!"; credits += 500*betAmount;
    } else {
        betResult.text = "YOU LOSE!"; credits -= betAmount;
    }
}

接下来,我们实现脚本的主体循环。在 FixedUpdate 函数中,我们依次旋转每个滚筒来运行老丨虎丨机。一开始,firstReelSpinned、secondReelSpinned 和 thirdReelSpinned 都为假。因此,我们进入第一个 if 块。在这里,我们将滚筒设置为随机值,并结束函数。我们重复这个过程,直到经过一定的时间。

之后,我们将滚筒设置为最终值,并将 firstReelSpinned 设置为 true。然后,函数将移动到第二个滚筒,重复这些步骤。最后,当第三个滚筒最终被设置为最终值时,我们使用 checkBet 检查结果:

void FixedUpdate () { 
    if (startSpin) {
        elapsedTime += Time.deltaTime;
        int randomSpinResult =
          Random.Range(0, numberOfSym);
        if (!firstReelSpinned) {
            firstReel.text = randomSpinResult.ToString();
            if (elapsedTime >= spinDuration) {
                firstReelResult = randomSpinResult;
                firstReelSpinned = true;
                elapsedTime = 0;
            }
        } else if (!secondReelSpinned) {
            secondReel.text = randomSpinResult.ToString();
            if (elapsedTime >= spinDuration) {
                secondReelResult = randomSpinResult;
                secondReelSpinned = true;
                elapsedTime = 0;
            }
        } else if (!thirdReelSpinned) {
            thirdReel.text = randomSpinResult.ToString();
            if (elapsedTime >= spinDuration) {
                thirdReelResult = randomSpinResult;
                startSpin = false; 
                elapsedTime = 0;
                firstReelSpinned = false;
                secondReelSpinned = false;
                checkBet();
            }
        }
    }
}

将脚本附加到一个空的 GameController 对象上,然后在检查器中填写引用的对象。然后,我们需要将 Button 连接到 Spin() 方法。为此,选择 Button 并在检查器中填写 On Click () 事件处理器,如下面的截图所示:

图 3.13 – On Click() 事件处理器

图 3.13 – On Click() 事件处理器

当我们点击按钮时,我们将 startSpin 标志设置为 true。一旦开始旋转,在 FixedUpdate() 方法中,我们为每个滚筒生成一个随机值。最后,当我们得到第三个滚筒的值后,我们将 startSpin 标志重置为 false。在我们获取每个滚筒的随机值的同时,我们还跟踪玩家拉杆以来经过的时间。

通常,每个滚筒在现实世界的老丨虎丨机中需要 3 到 5 秒才能落地显示结果。因此,我们在显示最终的随机值之前也花费了一些时间,这些时间由 spinDuration 指定。如果你播放场景并点击 Pull Lever 按钮,你应该看到最终的结果,如下面的截图所示:

图 3.14 – 我们随机老丨虎丨机游戏的实际运行

图 3.14 – 我们随机老丨虎丨机游戏的实际运行

由于你的获胜概率是 100 分之 1,连续输几次后很快就会变得乏味。然而,如果你曾经玩过老丨虎丨机,这并不是它的运作方式,或者至少不再是。通常,你可以在游戏中赢得几次。尽管这些小赢不能收回你的本金(而且从长远来看,大多数玩家都会破产),老丨虎丨机仍然偶尔会显示获胜图形和令人兴奋的声音,研究人员将这些称为伪装成赢的损失。

因此,我们不想只通过一种方式赢得大奖金,而是想稍微修改一下规则,使老丨虎丨机在游戏过程中支付较小的回报。

加权概率

真实老丨虎丨机的某个部分被称为支付表和滚筒条(PARS)表格,这是机器的完整设计文档。PARS 表格用于指定支付百分比、获胜模式、它们的支付金额等等。

支付奖项的数量和此类胜利的频率必须仔细选择,以确保赌场(老丨虎丨机)在长期内总是获胜,同时确保不时地向玩家返还一些东西,以使机器更具吸引力。这被称为支付百分比或玩家回报率(RTP)。例如,具有 90% RTP 的老丨虎丨机意味着,随着时间的推移,机器平均将 90%的所有赌注返还给玩家。

在这个演示中,我们不会关注选择赌场的最佳值以在一段时间内获得特定的胜利,也不会关注维持特定的支付百分比。相反,我们将演示如何为特定符号赋予更高的概率,使其出现次数多于平常。所以,假设我们想让 0 符号在第一和第三滚筒上比平常多出现 20%,并将一半的赌注作为支付。

换句话说,如果玩家在第一和第三滚筒上没有得到 0 符号,他们只会损失一半的赌注,这实际上是将损失伪装成小赢。目前,0 符号的概率是 1/10(0.1),或者说 10%的概率。我们现在将其改为在第一和第三滚筒上零出现的 30%的机会,如下面的SlotMachineWeighted.cs文件所示(记得在示例代码中切换到SlotMachineWeighted组件!):

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
public class SlotMachineWeighted : MonoBehaviour { 
    public float spinDuration = 2.0f;
    // Number of symbols on the slot machine reels
    public int numberOfSym = 10;
    public Text firstReel;
    public Text secondReel;
    public Text thirdReel;
    public Text betResult;
    public Text totalCredits;
    public InputField inputBet;
    private bool startSpin = false;
    private bool firstReelSpinned = false;
    private bool secondReelSpinned = false;
    private bool thirdReelSpinned = false;
    private int betAmount = 100;
    private int credits = 1000;
    [Serializable]
    public struct WeightedProbability {
        public int number;
        public int weight;
    }
    private List<WeightedProbability> weightedReelPoll =
      new List<WeightedProbability>();
    private int zeroProbability = 30;
    private int firstReelResult = 0;
    private int secondReelResult = 0;
    private int thirdReelResult = 0;
    private float elapsedTime = 0.0f;

新增了变量声明,例如zeroProbability,以指定零符号落在第一和第三滚筒上的概率百分比。例如,如果zeroProbability是 30,第三滚筒将有 30%的时间显示 0。weightedReelPoll数组列表用于填充加权符号,就像我们在早期的 FSM 示例中所做的那样。

然后,我们在Start()方法中初始化这个列表,如下面的代码所示:

void Start () {
    weightedReelPoll.Add(new WeightedProbability {
        number = 0,
        weight = zeroProbability
    });
    int remainingValuesProb = (100 - zeroProbability)/9;
    for (int i = 1; i < 10; i++) {
        weightedReelPoll.Add(new WeightedProbability {
        number = i,
        weight = remainingValuesProb
    });
}}

在实践中,我们将 0 的值设为 30,并将剩余的 70 个百分点分配给剩余的 9 个数字。

我们还在编写一个修订和改进的 checkBet() 方法。我们不再只考虑一个大奖赢取选项,现在我们正在考虑五种大奖条件:伪装成赢的损失、几乎错过、第一行和第三行上匹配的任何两个符号,当然,还有 lose 条件:

void checkBet() {
    if (firstReelResult == secondReelResult && 
        secondReelResult == thirdReelResult) {
        betResult.text = "JACKPOT!";
        credits += betAmount * 50;
    } else if (firstReelResult == 0 && 
               thirdReelResult == 0) {
        betResult.text = 
          "YOU WIN " + (betAmount/2).ToString();
        credits -= (betAmount/2);
    } else if (firstReelResult == secondReelResult) {
        betResult.text = "AWW... ALMOST JACKPOT!";
    } else if (firstReelResult == thirdReelResult) {
        betResult.text = 
          "YOU WIN " + (betAmount*2).ToString();
        credits -= (betAmount*2);
    } else {
        betResult.text = "YOU LOSE!";
        credits -= betAmount;
    }
}

在 checkBet() 方法中,我们设计我们的老丨虎丨机在击中大奖时返还赌注的 50 倍,如果第一和第三滚筒是 0 则损失赌注的 50%,如果第一和第三滚筒与任何其他符号匹配则赢两倍。

然后,就像前面的例子一样,我们在 FixedUpdate() 方法中为三个滚筒生成值,如下面的代码所示:

private int PickNumber() {
    // Sum the weights of every state.
    var weightSum = 
      weightedReelPoll.Sum(state => state.weight);
    var randomNumber = 
      UnityEngine.Random.Range(0, weightSum);
    var i = 0;
    while (randomNumber >= 0) {
        var candidate = weightedReelPoll[i];
        randomNumber -= candidate.weight;
        if (randomNumber <= 0) {
            return candidate.number;
        }
        i++;
    }
    // It should not be possible to reach this point!
    throw new Exception("Something is wrong in the 
                         selectState algorithm!");
}
void FixedUpdate () { 
    if (startSpin) {
        elapsedTime += Time.deltaTime;
        int randomSpinResult = 
          Random.Range(0, numberOfSym);
        if (!firstReelSpinned) {
            firstReel.text = randomSpinResult.ToString();
            if (elapsedTime >= spinDuration) {
                int weightedRandom = PickNumber();
                firstReel.text = weightedRandom.ToString();
                firstReelResult = weightedRandom;
                firstReelSpinned = true;
                elapsedTime = 0;
            }
        } else if (!secondReelSpinned) {
            secondReel.text = randomSpinResult.ToString();
            if (elapsedTime >= spinDuration) {
                secondReelResult = randomSpinResult;
                secondReelSpinned = true;
                elapsedTime = 0;
            }
        }
...

对于第一滚筒,我们展示在旋转期间实际发生的真实随机值。一旦时间结束,我们从已经根据概率分布填充了符号的投票中选择一个值。因此,我们的零符号将有 30% 的更高几率出现。

在现实中,如果玩家在第一和第三滚筒上得到两个零符号,他们就会在赌注上亏损;然而,我们让它看起来像是一场胜利。这里只是一个蹩脚的消息,但如果我们结合漂亮的图形,甚至烟花,以及好的胜利音效,这可以起作用。

几乎错过

如果第一和第二滚筒返回相同的符号,我们必须通过将第三滚筒的随机值返回到接近第二个的位置来向玩家提供几乎错过的效果。我们可以通过首先检查第三个随机旋转结果来实现这一点。如果随机值与第一和第二个结果相同,这是一个大奖,我们不应该改变结果。

但如果不是,那么我们应该修改结果,使其足够接近其他两个。请检查以下代码中的注释:

        else if (!thirdReelSpinned) {
            thirdReel.text = randomSpinResult.ToString();
            if (elapsedTime >= spinDuration) {
                if ((firstReelResult == secondReelResult)
                  && randomSpinResult != firstReelResult) {
                    // the first two reels have resulted
                    // the same symbol
                    // but unfortunately the third reel
                    // missed
                    // so instead of giving a random number
                    // we'll return a symbol which is one 
                    // less than the other 2
                    randomSpinResult = firstReelResult - 1;
                    if (randomSpinResult < firstReelResult)
                      randomSpinResult =
                        firstReelResult - 1;
                    if (randomSpinResult > firstReelResult)
                     randomSpinResult = 
                       firstReelResult + 1;
                    if (randomSpinResult < 0) 
                      randomSpinResult = 0;
                    if (randomSpinResult > 9) 
                      randomSpinResult = 9;
                    thirdReel.text = 
                      randomSpinResult.ToString();
                    thirdReelResult = randomSpinResult;
                } else {
                    int weightedRandom = PickNumber();
                    thirdReel.text = 
                      weightedRandom.ToString();
                    thirdReelResult = weightedRandom;
                }
                startSpin = false;
                elapsedTime = 0;
                firstReelSpinned = false;
                secondReelSpinned = false;
                checkBet();
            }
        }
    }
}

如果发生几乎错过的情况,您应该能看到,如下面的截图所示:

图 3.15 – 几乎错过

图 3.15 – 几乎错过

我们可以通过根据赌注金额实时调整概率来更进一步(但这会有些可疑)。最后,我们可以在玩家赌光所有钱时添加一个 游戏结束 消息。

这个演示向您展示了老丨虎丨机游戏的基本实现。您可以从这个骨架开始,并通过更漂亮的图形、动画和音效来改进它。然而,重要的是要理解您仅凭随机性和概率就可以创建一个游戏。

摘要

在本章中,我们学习了概率在人工智能游戏设计中的应用。我们通过在 Unity3D 中实现它们来实验了一些技术。作为额外收获,我们还学习了老丨虎丨机的工作原理,并使用 Unity3D 实现了一个简单的老丨虎丨机游戏。游戏中的概率是通过向角色的行为添加不确定性来使游戏和角色看起来更真实,这样玩家就无法预测结果。

在下一章中,我们将探讨如何实现传感器以及它们如何使我们的 AI 感知其周围环境。

进一步阅读

为了进一步研究游戏中概率的高级技术,例如使用贝叶斯技术进行不确定性决策,我推荐阅读 David M. Bourg 和 Glenn Seeman 合著的《AI for Game Developers》。Katie Salen 的《Rules of Play》也是关于游戏设计的一本推荐书籍。

第四章:实现传感器

正如我们在上一章中讨论的,角色 AI 系统需要对其周围环境有所了解。例如,非玩家角色(NPCs)需要知道障碍物的位置,玩家的视线方向,他们是否在玩家的视线中,以及更多。我们 NPC 的 AI 质量在很大程度上取决于他们从环境中获取的信息。传感器错误对玩家来说是显而易见的:我们都有过在玩电子游戏时笑一个显然应该看到我们的 NPC,或者另一方面,因为 NPC 从墙后发现了我们而感到沮丧的经历。

电子游戏角色通常从其底层 AI 决策算法所需的感觉信息中获取输入信息。为了简单起见,在本章中,我们将考虑感觉信息为来自游戏世界的任何类型的数据。如果信息不足,角色可能会表现出异常行为,例如选择错误的地方躲避,无所事事,或者在不了解如何进行的情况下重复奇怪的动作。在 YouTube 上快速搜索 AI 故障,就会打开通往大量常见有趣的 AI 行为的宝库,即使在 AAA 游戏中也是如此。

在本章中,我们将探讨以下主题:

  • 介绍感觉系统

  • 发现什么是感觉系统以及如何在 Unity 中实现两种感觉——视觉和触觉

  • 构建一个演示,我们可以看到我们的感觉系统在行动

技术要求

对于本章,您只需要 Unity3D 2022。您可以在本书仓库中的第四章文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter04。

基本感觉系统

一个 AI 感觉系统模拟视觉、听觉甚至嗅觉,从其他 GameObject 中获取信息。在这样的系统中,NPC 需要根据他们的特定兴趣定期检查环境和检查这些感觉。

在一个最小化的感觉系统中,我们有两个主要元素:方面(也称为事件发射器)和感觉(也称为事件感觉)。每个感觉只能感知特定的方面;例如,只有听觉感觉的 NPC 只能感知另一个 GameObject 发出的声音(其中一个方面),或者僵尸 NPC 可以使用其嗅觉捕食玩家的脑部。就像现实生活中一样,我们不需要每个 NPC 都有一个单一的感觉;他们可以同时拥有视觉、嗅觉和触觉。

在我们的演示中,我们将实现一个基础接口,称为Sense,我们将用它来实现自定义感官。在本章中,我们将实现视觉和触觉感官。视觉是我们用来观察周围世界的;如果我们的 AI 角色看到敌人,我们的代码中会收到一个事件,然后我们会相应地执行一些动作。同样,对于触觉,当敌人太靠近时,我们希望能够感知到。最后,我们将实现一个最小的Aspect类,我们的感官可以感知到。

设置我们的场景

让我们从设置我们的场景开始:

  1. 首先,我们添加一个平面作为地板。

  2. 让我们创建一些墙壁来阻挡 AI 角色到敌人的视线。我们用短而宽的立方体制作这些墙壁,并将它们组合在一个名为障碍物的空 GameObject 下。

  3. 最后,我们添加一个方向性光源来查看场景中的情况。

我们用坦克来代表玩家,类似于我们之前使用的,用简单的立方体来代表 NPC。我们还有一个目标对象来显示坦克在我们的场景中的移动位置。我们的场景层次结构应该类似于以下截图:

图 4.1 – 示例的层次结构设置

图 4.1 – 示例的层次结构设置

现在,让我们在我们的场景中随机放置坦克、AI 角色和墙壁。首先,确保将平面的尺寸增加到看起来不错的大小。幸运的是,在这个演示中,所有物体都锁定在平面上,并且没有模拟重力,所以没有任何东西会从平面上掉落。此外,务必调整相机,以便我们可以清楚地看到以下场景:

图 4.2 – 我们坦克和玩家游荡的空间

图 4.2 – 我们坦克和玩家游荡的空间

现在我们已经设置了基本内容,让我们看看如何实现坦克、AI 角色和玩家角色的方面。

玩家的坦克和方面类

目标对象是一个简单的球体对象,网格渲染已禁用。我们还创建了一个点光源,并将其设置为我们的目标对象的子对象。确保灯光居中,否则它将不会很有帮助。

看看以下Target.cs文件中的代码:

using UnityEngine;
public class Target : MonoBehaviour { 
    [SerializeField]
    private float hOffset = 0.2f;
    void Update () {
        int button = 0;
        //Get the point of the hit position when the mouse 
        //is being clicked 
        if(Input.GetMouseButtonDown(button)) {
            Ray ray = Camera.main.ScreenPointToRay(
              Input.mousePosition);
            RaycastHit hitInfo;
            if (Physics.Raycast(ray.origin, ray.direction,
                out hitInfo)) {
                Vector3 targetPosition = hitInfo.point;
                transform.position = targetPosition + 
                  new Vector3(0.0f, hOffset, 0.0f);
            }
        }
    }
}

将此脚本附加到目标对象上。该脚本检测鼠标点击事件,然后使用射线投射技术检测 3D 空间中平面上鼠标点击的位置,并更新场景中目标对象的位置。我们将在下一节中查看玩家的坦克。

玩家的坦克

玩家的坦克是我们用于第二章,“有限状态机”中使用的简单模型,具有非运动学Rigidbody组件。我们需要Rigidbody组件来生成与 AI 角色和环境对象进行碰撞检测时的触发事件。最后,我们需要将玩家标签分配给我们的坦克。

从其名称中我们可以轻易看出,PlayerTank脚本控制玩家的坦克。以下是PlayerTank.cs文件的代码:

using UnityEngine;
public class PlayerTank : MonoBehaviour { 
    public Transform targetTransform;
    [SerializeField]
    private float movementSpeed = 10.0f;
    [SerializeField]
    private float rotSpeed = 2.0f;
    [SerializeField]
    private float targerReactionRadius = 5.0f;
    void Update () {
        //Stop once you reached near the target position
        if (Vector3.Distance(transform.position,
          targetTransform.position) < targetReactionRadius) 
          return;
        //Calculate direction vector from current position
        // to target position

        Vector3 tarPos = targetTransform.position;
        tarPos.y = transform.position.y;
        Vector3 dirRot = tarPos - transform.position;
        //Build a Quaternion for this new rotation vector
        //using LookRotation method
        Quaternion tarRot = 
          Quaternion.LookRotation(dirRot);
        //Move and rotate with interpolation
        transform.rotation= Quaternion.Slerp(
          transform.rotation, tarRot, 
          rotSpeed * Time.deltaTime);
        transform.Translate(new Vector3(0, 0, 
          movementSpeed * Time.deltaTime));
    }
}

此脚本检索地图上的目标位置,并相应地更新坦克的目的地点和方向。前面代码的结果如下所示:

图 4.3 – 我们坦克对象的属性

图 4.3 – 我们坦克对象的属性

在将前面的脚本分配给坦克后,请务必将目标对象分配给targetTransform变量。

Aspect

接下来,让我们看看Aspect类。Aspect是一个具有单个公共属性的基本类,称为aspectName。这就是我们在本章需要的所有变量。

每当我们的 AI 角色感知到某物时,我们将检查它是否是 AI 一直在寻找的属性:

using UnityEngine;
public class Aspect : MonoBehaviour {
    public enum Affiliation {
        Player,
        Enemy
    }
    public Affiliation affiliation;
}

将此属性脚本附加到我们的玩家坦克上,并将aspectName属性设置为Player。

AI 角色

在这个例子中,AI 角色以随机方向在场景中游荡。它们有两种感官:视觉和触觉。视觉感官检查敌人是否在设定的可见范围和距离内。触觉检测敌人是否与角色周围的Box Collider发生碰撞。正如我们之前所看到的,我们的玩家坦克具有Player属性。因此,当它们检测到玩家的坦克时,这些感官会被触发。

现在,让我们看看我们用来移动 NPC 的脚本:

using UnityEngine;
using System.Collections;
public class Wander : MonoBehaviour { 
    private Vector3 tarPos;
    [SerializeField]
    private float movementSpeed = 5.0f;
    [SerializeField]
    private float rotSpeed = 2.0f;
    [SerializeField]
    private float minX = -45.0f;
    [SerializeField]
    private float maxX = 45.0f;
    [SerializeField]
    private float minZ = -45.0f;
    [SerializeField]
    private float maxZ = -45.0f;
    [SerializeField]
    private float targetReactionRadius = 5.0f;
    [SerializeField]
    private float targetVerticalOffset = 0.5f;
    void Start () {
        //Get Wander Position 
        GetNextPosition();
    }
    void Update () {
        // Check if we're near the destination position
        if (Vector3.Distance(tarPos, transform.position) <=
          targetReactionRadius) GetNextPosition(); 
        // generate new random position
        // Set up quaternion for rotation toward
        // destination
        Quaternion tarRot = Quaternion.LookRotation(
          tarPos - transform.position);
        // Update rotation and translation
        transform.rotation = Quaternion.Slerp(
          transform.rotation,
          tarRot, rotSpeed * Time.deltaTime);
        transform.Translate(new Vector3(0, 0, movementSpeed
                            * Time.deltaTime));
    }
    void GetNextPosition() {
        tarPos = new Vector3(Random.Range(minX, maxX),
          targetVerticalOffset, Random.Range(minZ, maxZ));
    }
}

当 AI 角色达到其当前目的地点时,Wander脚本会在指定范围内生成一个新的随机位置。然后,Update方法旋转 NPC 并将它们移动到新的目的地。将此脚本附加到我们的 AI 角色上,以便它在场景中移动。

感官

Sense类是我们感官系统的接口,其他自定义感官可以在此接口上实现。它定义了两个虚拟方法,Initialize和UpdateSense,分别从Start和Update方法中执行,并且我们可以在实现自定义感官时重写,如下面的代码块所示:

using UnityEngine;
public class Sense : MonoBehaviour { 
    public bool bDebug = true;
    public Aspect.Affiliation targetAffiliation = 
      Aspect.Affiliation.Enemy;
    public float detectionRate = 1.0f;
    protected float elapsedTime = 0.0f;
    protected virtual void Initialize() { }
    protected virtual void UpdateSense() { }
    void Start () {
        Initialize();
    }
    void Update () {
        UpdateSense();
    }
}

此脚本的基本属性是两次连续感官操作之间的间隔以及它应该查找的属性名称。此脚本未附加到任何对象上;相反,我们将其用作特定感官(如Sight和Touch)的基础。

视觉

Sight感官检测特定属性是否在角色的感知范围内。如果它感知到任何东西,它将执行以下代码块中指定的操作:

using UnityEngine;
public class Sight: Sense { 
    public int FieldOfView = 45; 
    public int ViewDistance = 100;
    private Transform playerTrans;
    private Vector3 rayDirection;
    protected override void Initialize() {
        //Find player position
        playerTrans = GameObject.FindGameObjectWithTag(
          "Player").transform;
    }
    protected override void UpdateSense() {
        elapsedTime += Time.deltaTime;
        // Detect perspective sense if within the detection 
        // rate
        if (elapsedTime >= detectionRate) {
            DetectAspect();
            elapsedTime = 0.0f;
        }
    }
    //Detect perspective field of view for the AI Character
    void DetectAspect() {
        //Direction from current position to player 
        //position
        rayDirection = (playerTrans.position – 
                        transform.position).normalized;
        //Check the angle between the AI character's 
        //forward vector and the direction vector between 
        //player and AI to detect if the Player is in the 
        //field of view.
        if ((Vector3.Angle(rayDirection,
             transform.forward)) < FieldOfView) {
            RaycastHit hit;
            if (Physics.Raycast(transform.position,
                rayDirection, out hit, ViewDistance)) {
                Aspect aspect =
                  hit.collider.GetComponent<Aspect>();
                if (aspect != null) {
                    //Check the aspect
                    if (aspect.affiliation == 
                        targetAffiliation) {
                        print("Enemy Detected");
                    }
                }
            }
        }
    }

我们需要实现父类 Sense 的 Initialize 和 UpdateSense 方法。然后,在 DetectAspect 方法中,我们首先检查玩家和 AI 当前方向之间的角度。然后,如果它在视野范围内,我们就向玩家坦克的方向发射一条射线。射线的长度是可见距离属性中的值。

Raycast 方法在第一次击中另一个对象时返回。然后,我们将其与事务组件和事务名称进行比较。这样,即使玩家在可见范围内,如果他们躲在墙壁后面,AI 角色也不会看到玩家。

OnDrawGizmos 方法根据视角场(由视角角度和观看距离确定)绘制线条,以便在游戏测试期间在编辑器窗口中看到 AI 角色的视线。将此脚本附加到 AI 角色上,并确保将事务名称设置为 Enemy。

这个方法可以表示如下:

    void OnDrawGizmos() {
        if (!Application.isEditor|| playerTrans == null)
          return;
        Debug.DrawLine(transform.position,
                       playerTrans.position, Color.red);
        Vector3 frontRayPoint = transform.position + 
          (transform.forward * ViewDistance);
        //Approximate perspective visualization
        Vector3 leftRayPoint = Quaternion.Euler(
          0,FieldOfView * 0.5f ,0) * frontRayPoint;
        Vector3 rightRayPoint = Quaternion.Euler(0, 
          - FieldOfView*0.5f, 0) * frontRayPoint;
        Debug.DrawLine(transform.position, frontRayPoint,
                       Color.green);
        Debug.DrawLine(transform.position, leftRayPoint,
                       Color.green);
        Debug.DrawLine(transform.position, rightRayPoint, 
                       Color.green);
    }
}

OnDrawGizmos 是一个事件函数,当我们想在场景中绘制 gizmos 时可以使用。DrawLine、DrawIcon 和 DrawSphere。

它们是快速为我们算法提供一些视觉反馈的便捷方式。你可以通过以下链接了解更多关于 gizmo 函数的信息:docs.unity3d.com/ScriptReference/Gizmos.html。

触摸

我们将要实现的另一个感官是 Touch,当玩家实体在 AI 实体特定范围内时触发,如下面的代码块所示。我们的 AI 角色有一个盒子碰撞体组件,并且它的 Is Trigger 标志是开启的:

using UnityEngine;
public class Touch : Sense {
    void OnTriggerEnter(Collider other) {
        Aspect aspect = other.GetComponent<Aspect>();
        if (aspect != null) {
            //Check the aspect
            if (aspect.affiliation == targetAffiliation) {
                print("Enemy Touch Detected");
            }
        }
    }
}

我们需要实现每次碰撞组件与另一个碰撞组件发生碰撞时触发的 OnTriggerEnter 事件。由于我们的坦克实体也有碰撞体和 Rigidbody 组件,因此当 AI 角色和玩家坦克的碰撞体重合时,就会发生碰撞事件。

以下屏幕截图显示了我们的敌人 AI 的盒子碰撞体,我们正在使用它来实现 Touch 感官:

![图 4.4 – 我们玩家周围的碰撞组件图片

图 4.4 – 我们玩家周围的碰撞组件

在下面的屏幕截图中,我们可以看到我们的 AI 角色是如何设置的:

![图 4.5 – 我们玩家的属性图片

图 4.5 – 我们玩家的属性

在 OnTriggerEnter 方法中,我们访问另一个碰撞实体的事务组件,并检查事务的名称是否与我们这个 AI 角色正在寻找的事务名称相同。为了演示目的,我们在控制台中打印出角色通过 Touch 感官检测到敌人事务。在实际游戏中,我们不会打印事件,而是触发其他动作,例如转向面对敌人,然后追逐、攻击等等。让我们继续测试我们的游戏。

游戏测试

现在,在 Unity3D 中玩游戏,通过点击地面将玩家的坦克移动到游荡的 AI 角色附近。每当我们的 AI 角色接近玩家的坦克时,你应在控制台日志窗口中看到敌人触摸检测的消息。

![图 4.6 – 我们的角色和坦克在行动中

![img/B17984_04_6.jpg]

图 4.6 – 我们的角色和坦克在行动中

上一张截图显示了一个具有触摸和视角感官的 AI 代理正在寻找敌人特征。将玩家的坦克移到 AI 角色前方,你将收到敌人检测的消息。如果在运行游戏的同时进入编辑器视图,你应该会看到由于在视觉感官类中实现了OnDrawGizmos方法而渲染的调试图形。

摘要

本章介绍了在实现游戏 AI 中使用传感器的概念,并为我们的 AI 角色实现了两种感官,即视觉和触摸。感官系统是整个 AI 系统决策系统的第一个元素。例如,一旦我们在 AI 的视线范围内检测到敌人,我们可以使用感官系统来控制行为系统的执行或改变有限状态机的状态。

我们将在第九章“行为树”中介绍如何应用行为树系统。同时,在下一章中,我们将探讨如何在 Unity3D 中实现群聚行为,以及如何实现克雷格·雷诺的群聚算法。

第二部分:移动和导航

在本部分,我们将学习如何使角色在游戏环境中移动和寻找路径。

在本部分,我们将涵盖以下章节:

  • 第五章, 集群行为

  • 第六章, 路径跟随和转向行为

  • 第七章, 路径查找

  • 第八章, 导航网格

第五章:鸟群

在初夏的傍晚,你可能见过成群的鸟在天空中飞翔。你可能注意到它们似乎作为一个单一的生物体移动:它们都朝着一个特定的方向移动,转弯,并且大小变化。鸟群系统旨在在游戏中复制这种行为:我们希望实现一个算法,使许多物体作为一个有机群体移动。

在游戏中,我们称鸟群中的每个元素为boid。要实现鸟群行为,我们不需要为每个 boid 配备高级复杂的决策系统;相反,我们只需要为每个 boid 实现简单的反应性规则,这些规则只依赖于鸟群本身的状态。因此,鸟群是一个很好的涌现行为的例子:每个 boid 只对其邻居的行为做出反应;然而,鸟群似乎像有人协调一样移动。

在本章中,我们将学习这些规则是什么,以及如何在 Unity3D 中实现它们。本章我们将实现两种鸟群变体。第一个是基于自游戏引擎创建以来在 Unity 社区中流传的一个旧的鸟群行为演示。

第二个变体是基于 1986 年克雷格·雷诺的原始鸟群算法。

在本章中,我们将涵盖以下主题:

  • 基本鸟群行为的概述及其实现方法

  • 鸟群行为的另一种实现

技术要求

对于本章,你只需要 Unity3D 2022。你可以在本书仓库的第五章文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter05。

基本鸟群行为

正如我们在本章引言中所说的,我们可以仅使用三个直观的属性来描述鸟群行为:

  • 分离:这个属性,也称为近距离排斥,表示相邻 boid 之间的最小距离,以避免碰撞。你可以想象这个规则就像一股将 boid 推离其他物体的力量。

  • 对齐:这个属性表示每个 boid 移动与鸟群相同方向的可能性(我们将其测量为所有单个 boid 的平均方向)。

  • 凝聚力:这个属性,也称为远距离吸引,表示每个 boid 移动向鸟群质心的可能性(我们通过平均鸟群中每个 boid 的位置来测量)。因此,你可以想象这个规则就像一股将 boid 推向鸟群中心的力。

在这个演示中,我们将创建一个由物体群组成的场景,并在 C# 中实现群聚行为。对于这个第一个版本,我们将自行计算所有规则。此外,我们还将创建一个鸟群指挥官,以便轻松地控制和跟踪鸟群的总体位置。

您可以在下面的屏幕截图中看到 Hierarchy 场景。如您所见,我们有几个名为 UnityFlock 的鸟群实体,位于名为 UnityFlockController 的控制器下。UnityFlock 实体是单个鸟群对象,它引用其父 UnityFlockController 实体,将其用作领导者。控制器在达到当前目的地点后随机更新下一个目的地点:

![图 5.1 – 场景层次结构

![img/B17984_05_1.jpg]

图 5.1 – 场景层次结构

UnityFlock 脚本。我们可以为这个预制件使用任何其他网格表示来表示更有趣的东西,比如鸟。您可以添加任意数量的 UnityFlock 预制件。算法将自动检查 UnityFlockController 对象中的子项数量。

个体行为

鸟群 是克雷格·雷诺德创造的术语,指的是类似鸟类的物体。我们使用这个术语来描述我们鸟群中的每个物体。鸟群行为由一组物体组成,每个物体都有其自身的位置、速度和方向。现在,让我们实现鸟群行为。您可以在 UnityFlock.cs 脚本中找到控制鸟群中每个鸟群行为的代码,我们现在将检查它:

using UnityEngine;
using System.Collections;
public class UnityFlock : MonoBehaviour { 
    public float minSpeed = 20.0f;
    public float turnSpeed = 20.0f; 
    public float randomFreq = 20.0f;
    public float randomForce = 20.0f;
    //alignment variables
    public float toOriginForce = 50.0f;
    public float toOriginRange = 100.0f;
    public float gravity = 2.0f;
    //seperation variables
    public float avoidanceRadius = 50.0f;
    public float avoidanceForce = 20.0f;
    //cohesion variables
    public float followVelocity = 4.0f;
    public float followRadius = 40.0f;
    //these variables control the movement of the boid
    private Transform origin;
    private Vector3 velocity;
    private Vector3 normalizedVelocity;
    private Vector3 randomPush;
    private Vector3 originPush;
    private Transform[] objects;
    private UnityFlock[] otherFlocks;
    private Transform transformComponent;
    private float randomFreqInterval;

作为公共字段,我们声明了算法的输入值。这些可以在检查器中设置和自定义。在这个脚本中,我们执行以下操作:

  1. 我们为我们的鸟群定义了最小移动速度(minSpeed)和旋转速度(turnSpeed)。

  2. 我们使用 randomFreq 来确定我们希望根据 randomForce 值更新 randomPush 值的次数。然后,我们使用这种力量来改变单个鸟群的速度,使鸟群的移动看起来更真实。

  3. toOriginRange 指定了我们希望鸟群扩散的程度。换句话说,它代表了我们要保持鸟群(遵循之前提到的凝聚力规则)的最大距离。我们使用 avoidanceRadius 和 avoidanceForce 属性来保持个体鸟群之间的最小距离(遵循分离规则)。同样,我们使用 followRadius 和 followVelocity 来保持领导者或鸟群起源之间的最小距离。origin 变量存储控制整个鸟群的父对象;换句话说,它是鸟群领导者。鸟群需要了解群中的其他鸟群。因此,我们使用 objects 和 otherFlocks 属性来存储邻近鸟群的信息。

这是我们的鸟群的初始化方法:

void Start () {
    randomFreqInterval = 1.0f / randomFreq;
    // Assign the parent as origin 
    origin = transform.parent;
    // Flock transform 
    transformComponent = transform;
    // Temporary components 
    Component[] tempFlocks= null;
    // Get all the unity flock components from the parent 
    // transform in the group 
    if (transform.parent) {
        tempFlocks = transform.parent
          .GetComponentsInChildren<UnityFlock>();       
    }
    // Assign and store all the flock objects in this group 
    objects = new Transform[tempFlocks.Length];
    otherFlocks = new UnityFlock[tempFlocks.Length];
    for (int i = 0;i<tempFlocks.Length;i++) { 
        objects[i] = tempFlocks[i].transform;
        otherFlocks[i] = (UnityFlock)tempFlocks[i];
    }
    // Null Parent as the flock leader will be 
    // UnityFlockController object 
    transform.parent = null;
    // Calculate random push depends on the random 
    // frequency provided
    StartCoroutine(UpdateRandom());
}

我们将 boid 的对象的父级设置为origin,这意味着这是其他 boid 跟随的控制器对象。然后,我们抓取组中的所有其他 boid 并将它们存储在otherFlocks属性中以供以后参考。

协程

简单来说,协程是可以暂停的函数。使用协程,你可以运行一个方法,暂停执行一段时间(例如,一帧或几秒钟),然后从下一行继续,就像什么都没发生一样。它们有两个主要用途:在特定间隔后运行一个函数(无需像其他示例中那样跟踪每一帧的elapsedTimes)或分割一些重算法的计算到多个帧上(因此不会引起帧率下降)。事实证明,协程是一个非常有用的工具。你可以在docs.unity3d.com/Manual/Coroutines.html上了解更多信息。

现在,我们可以实现UpdateRandom协程。作为一个协程,函数实际上永远不会终止,但我们为每个随机时间间隔运行while循环的主体:

  1. 我们通过指定IEnumerator返回类型将UpdateRandom方法定义为协程:

    IEnumerator UpdateRandom() { 
        while (true) {
            randomPush = 
              Random.insideUnitSphere * randomForce;
            yield return new WaitForSeconds(
              randomFreqInterval + Random.Range(
                -randomFreqInterval / 2.0f, 
                randomFreqInterval / 2.0f));
        }
    }
    
  2. UpdateRandom()方法通过基于randomFreq的间隔在整个游戏过程中更新randomPush值。Random.insideUnitSphere返回一个具有随机x、y和z值的Vector3对象,这些值在以randomForce值为半径的球体内。

  3. 在恢复while(true)之前,我们等待一定随机的时长。

  4. 循环再次更新randomPush值。

  5. 现在,这是我们的 boid 行为Update()方法,它帮助 boid 实体遵守群聚算法的三个规则:

    void Update() {
            //Internal variables
            float speed = velocity.magnitude;
            Vector3 avgVelocity = Vector3.zero;
            Vector3 avgPosition = Vector3.zero;
            int count = 0;
            Vector3 myPosition = 
              transformComponent.position;
            Vector3 forceV;
            Vector3 toAvg;
            for (int i = 0; i < objects.Length; i++) {
                Transform boidTransform = objects[i];
                if (boidTransform != transformComponent) {
                    Vector3 otherPosition =
                      boidTransform.position;
                    // Average position to calculate 
                    // cohesion
                    avgPosition += otherPosition;
                    count++;
                    //Directional vector from other flock
                    // to this flock
                    forceV = myPosition - otherPosition;
                    //Magnitude of that directional 
                    //vector(Length)
                    float directionMagnitude = 
                      forceV.magnitude;
                    float forceMagnitude = 0.0f;
                    if (directionMagnitude < followRadius)
                    {
                        if (directionMagnitude <
                             avoidanceRadius) {
                            forceMagnitude = 1.0f – 
                              (directionMagnitude / 
                               avoidanceRadius);
                            if (directionMagnitude > 0)
                                avgVelocity += (forceV /
                                  directionMagnitude) *
                                  forceMagnitude * 
                                  avoidanceForce;
                        }
                        forceMagnitude =
                          directionMagnitude / 
                          followRadius;
                        UnityFlock tempOtherBoid = 
                          otherFlocks[i];
                        avgVelocity += followVelocity *
                          forceMagnitude * 
                         tempOtherBoid.normalizedVelocity;
                    }
                }
            }
    

上述代码实现了分离规则。首先,我们检查当前 boid 与其他 boid 之间的距离,然后根据注释中解释的方式相应地更新速度。

  1. 我们现在通过将当前速度向量除以群中的 boid 数量来计算群的平均速度向量:

            if (count > 0) {
                //Calculate the average flock
               //velocity(Alignment)
                avgVelocity /= count;
                //Calculate Center value of the 
                //flock(Cohesion)
                toAvg = (avgPosition / count) –
                  myPosition;
            } else {
                toAvg = Vector3.zero;
            }
            //Directional Vector to the leader
            forceV = origin.position - myPosition;
            float leaderDirectionMagnitude = 
              forceV.magnitude;
            float leaderForceMagnitude =
              leaderDirectionMagnitude / toOriginRange;
            //Calculate the velocity of the flock to the
            //leader
            if (leaderDirectionMagnitude > 0)
                originPush = leaderForceMagnitude * 
                  toOriginForce * (forceV /
                  leaderDirectionMagnitude);
            if (speed < minSpeed && speed > 0) {
                velocity = (velocity / speed) * minSpeed;
            }
            Vector3 wantedVel = velocity;
            //Calculate final velocity
            wantedVel -= wantedVel * Time.deltaTime;
            wantedVel += randomPush * Time.deltaTime;
            wantedVel += originPush * Time.deltaTime;
            wantedVel += avgVelocity * Time.deltaTime;
            wantedVel += gravity * Time.deltaTime * 
              toAvg.normalized;
            velocity = Vector3.RotateTowards(velocity,
              wantedVel, turnSpeed * Time.deltaTime, 
              100.00f);
            transformComponent.rotation =
              Quaternion.LookRotation(velocity);
            //Move the flock based on the calculated
            //velocity
            transformComponent.Translate(velocity * 
              Time.deltaTime, Space.World);
            normalizedVelocity = velocity.normalized;
        }
    
  2. 我们将所有因素,如randomPush、originPush和avgVelocity相加,以计算最终的目标速度向量wantedVel。我们还使用Vector3.RotateTowards方法通过线性插值将当前速度更新为wantedVel。

  3. 我们使用Translate方法根据新的速度移动我们的 boid。

  4. 作为最后的润色,我们创建了一个立方网格,向其中添加了UnityFlock脚本,然后将其保存为预制件,如下面的截图所示:

![图 5.2 – UnityFlock 预制件img/B17984_05_2.jpg

图 5.2 – UnityFlock 预制件

控制器

现在,是时候创建控制器类了。这个类更新其位置,以便其他个体 boid 对象知道去哪里。前面UnityFlock脚本中的origin变量包含对这个对象的引用。

以下是在UnityFlockController.cs文件中的代码:

using UnityEngine;
using System.Collections;
public class UnityFlockController : MonoBehaviour { 
    public Vector3 bound;
    public float speed = 100.0f;
    public float targetReachedRadius = 10.0f;
    private Vector3 initialPosition;
    private Vector3 nextMovementPoint;
    // Use this for initialization 
    void Start () {
        initialPosition = transform.position;
        CalculateNextMovementPoint();
    }
    // Update is called once per frame 
    void Update () {
        transform.Translate(Vector3.forward * speed * 
          Time.deltaTime);
        transform.rotation = 
          Quaternion.Slerp(transform.rotation,
            Quaternion.LookRotation(nextMovementPoint –
            transform.position), 1.0f * Time.deltaTime);
        if (Vector3.Distance(nextMovementPoint, 
            transform.position) <= targetReachedRadius) 
            CalculateNextMovementPoint();
    }

在Update()方法中,我们检查我们的控制器对象是否接近目标目的地点。如果是,我们再次使用我们刚才讨论的CalculateNextMovementPoint()方法更新nextMovementPoint变量:

void CalculateNextMovementPoint () {
    float posX = Random.Range(initialPosition.x - bound.x,
      initialPosition.x + bound.x);
    float posY = Random.Range(initialPosition.y - bound.y, 
      initialPosition.y + bound.y);
    float posZ = Random.Range(initialPosition.z - bound.z,
      initialPosition.z + bound.z);
    nextMovementPoint = initialPosition + new Vector3(posX,
      posY, posZ);
}

CalculateNextMovementPoint()方法在当前位置和边界向量之间找到一个随机目的地位置。

最后,我们将所有这些放在一起,如图图 5.1所示,这应该会给出在日落时分真实飞行的方阵群:

图 5.3 – 使用 Unity 海鸥示例演示群聚行为

图 5.3 – 使用 Unity 海鸥示例演示群聚行为

之前的例子向您介绍了群聚行为的基础知识。在下一节中,我们将探讨一种不同的实现方法,该方法利用了 Unity 的Rigidbody组件。

替代实现

在本节中,我们使用 Unity 物理引擎来简化代码。实际上,在这个例子中,我们将Rigidbody组件附加到鸟群上,以使用Rigidbody属性来转换和引导它们。此外,Rigidbody组件还有助于防止其他鸟群相互重叠。

在这个实现中,我们有两个组件:个体鸟群行为和控制器行为(在上一节中提到的称为群控制器的元素)。和之前一样,控制器是其他鸟群跟随的对象。

Flock.cs文件中的代码如下:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class Flock : MonoBehaviour { 
    internal FlockController controller;
    private new Rigidbody rigidbody;
    private void Start() {
        rigidbody = GetComponent<Rigidbody>();
    }
    void Update () {
        if (controller) {
            Vector3 relativePos = Steer() * Time.deltaTime;
            if (relativePos != Vector3.zero)
              rigidbody.velocity = relativePos;
            // enforce minimum and maximum speeds for the
            // boids 
            float speed = rigidbody.velocity.magnitude;
            if (speed > controller.maxVelocity) {
                rigidbody.velocity =
                  rigidbody.velocity.normalized *
                  controller.maxVelocity;
            } else if (speed < controller.minVelocity) {
                rigidbody.velocity =
                  rigidbody.velocity.normalized *
                  controller.minVelocity;
            }
        }
    }

我们将在稍后创建FlockController。在此期间,在前一个代码块中的Update()方法中,我们使用Steer()方法计算鸟群的速度,并将结果应用于鸟群的刚体速度。

接下来,我们检查当前Rigidbody组件的速度是否在我们的控制器最大和最小速度范围内。如果不是,我们将速度限制在预设的范围内:

private Vector3 Steer () {
    Vector3 center = controller.flockCenter – 
      transform.localPosition;   // cohesion
    Vector3 velocity = controller.flockVelocity –
      rigidbody.velocity; // allignement
    Vector3 follow = controller.target.localPosition – 
      transform.localPosition; // follow leader
    Vector3 separation = Vector3.zero;
    foreach (Flock flock in controller.flockList) { 
        if (flock != this) {
            Vector3 relativePos = transform.localPosition - 
              flock.transform.localPosition;
            separation += relativePos.normalized;
        }
    }
    // randomize
    Vector3 randomize = new Vector3( (Random.value * 2) –
      1, (Random.value * 2) - 1, (Random.value * 2) - 1);
    randomize.Normalize();
    return (controller.centerWeight * center + 
            controller.velocityWeight * velocity + 
            controller.separationWeight * separation +
            controller.followWeight * follow + 
            controller.randomizeWeight * randomize);
}

steer()方法实现了群聚算法的分离、凝聚力、对齐和跟随领导者规则。然后,我们将所有因素与一个随机权重值相加。我们使用这个Flock脚本与Rigidbody和SphereCollider组件一起创建一个 Flock 预制件,如图所示(确保通过取消选中使用重力来禁用重力):

图 5.4 – 群

图 5.4 – 群

现在是时候实现拼图的最后一块:FlockController组件。

FlockController

这个FlockController组件与上一个例子中的类似。除了控制鸟群的速度和位置外,这个脚本还在运行时实例化鸟群:

  1. FlockController.cs文件中的代码如下:

    using UnityEngine;
    using System.Collections;
    using System.Collections.Generic;
    public class FlockController : MonoBehaviour { 
        public float minVelocity = 1;
        public float maxVelocity = 8;
        public int flockSize = 20;
        public float centerWeight = 1;
        public float velocityWeight = 1;
        public float separationWeight = 1;
        public float followWeight = 1;
        public float randomizeWeight = 1;
        public Flock prefab; 
        public Transform target;
        Vector3 flockCenter;
        internal Vector3 flockVelocity;
        public ArrayList flockList = new ArrayList();
        void Start () {
            for (int i = 0; i < flockSize; i++) {
                Flock flock = Instantiate(prefab,
                  transform.position, transform.rotation)
                  as Flock;
                flock.transform.parent = transform;
                flock.controller = this;
                flockList.Add(flock);
            }
        }
    
  2. 我们声明所有公共属性以实现群聚算法,然后根据群聚大小输入开始生成鸟群对象。

  3. 我们设置了控制器类和父Transform对象,就像上次做的那样。

  4. 我们将创建的每个鸟群对象添加到flockList数组中。目标变量接受一个用作移动领导者的实体。在这个例子中,我们创建一个球体实体作为鸟群的移动目标领导者:

        void Update() {
            //Calculate the Center and Velocity of the
            // whole flock group
            Vector3 center = Vector3.zero;
            Vector3 velocity = Vector3.zero;
            foreach (Flock flock in flockList) {
                    center += 
                      flock.transform.localPosition;
                    velocity += flock.GetComponent
                      <Rigidbody>().velocity;
            }
            flockCenter = center / flockSize;
            flockVelocity = velocity / flockSize;
        }
    }
    
  5. 在Update方法中,我们持续更新群聚的平均中心和速度。这些是从鸟群对象引用的值,用于调整与控制器的凝聚力和对齐属性:

图 5.5 – 群聚控制器

图 5.5 – 群聚控制器

我们需要使用目标移动(脚本)来实现我们的目标实体。移动脚本与我们之前在 Unity3D 示例控制器中的移动脚本相同:

图 5.6 – 带有 TargetMovement 脚本的 Target 实体

图 5.6 – 带有 TargetMovement 脚本的 Target 实体

  1. 我们的TargetMovement脚本的工作原理如下:我们随机选择一个附近的点作为目标移动到,当我们接近那个点时,我们再选择一个新的点。TargetMovement.cs文件中的代码如下:

    using UnityEngine;
    using System.Collections;
    public class TargetMovement : MonoBehaviour {
        // Move target around circle with tangential speed
        public Vector3 bound;
        public float speed = 100.0f;
        public float targetReachRadius = 10.0f;
        private Vector3 initialPosition;
        private Vector3 nextMovementPoint;
        void Start () {
            initialPosition = transform.position;
            CalculateNextMovementPoint();
        }
        void CalculateNextMovementPoint () {
            float posX = Random.Range(initialPosition.x =
              bound.x, initialPosition.x+bound.x);
            float posY = Random.Range(initialPosition.y = 
              bound.y, initialPosition.y+bound.y);
            float posZ = Random.Range(initialPosition.z =
              bound.z, initialPosition.z+bound.z);
            nextMovementPoint = initialPosition + 
              new Vector3(posX, posY, posZ);
        }
        void Update () {
            transform.Translate(Vector3.forward * speed *
              Time.deltaTime); 
            transform.rotation = 
              Quaternion.Slerp(transform.rotation,
            Quaternion.LookRotation(nextMovementPoint –
              transform.position), Time.deltaTime);
            if (Vector3.Distance(nextMovementPoint,
              transform.position) <= targetReachRadius)
              CalculateNextMovementPoint();
        }
    }
    
  2. 在我们将一切组合起来之后,我们应该在场景中看到一群立方体鸟群在飞行,它们都在追逐球形目标:

图 5.7 – 使用雷诺德算法的群聚

图 5.7 – 使用雷诺德算法的群聚

现在我们已经以两种不同的方式实现了群聚行为,我们可以尝试不同的参数,调整鸟群的行为,直到找到我们喜欢的移动方式。我想以一个重要的启示来结束本章:请注意,我们不需要复杂的算法来获得自然的外观行为。为此,我们只需要简单的反应性规则和一种将它们组合起来的方法。

摘要

在本章中,我们学习了两种实现群聚行为的方法。首先,我们检查并学习了如何仅使用我们的脚本实现基本的群聚算法。接下来,我们使用 Unity 的Rigidbody组件来控制鸟群的移动,以及球体碰撞器来避免与其他鸟群相撞。

在我们的例子中,我们总是将鸟群称为类似鸟类的实体。然而,我们可以将群聚应用于许多其他应用:海中的鱼群,草原上吃草的羊群,一群昆虫,甚至街道上行走的人群都可以表现出群聚行为。为了将算法适应不同的场景,我们只需更改群聚规则的值,最终将移动锁定到平面上。

在下一章中,我们将超越随机移动,看看如何跟随特定的路径。这是学习如何避开挡路的障碍物的第一步。

第六章:路径跟随和导航行为

在这个简短章节中,我们将实现两个 Unity3D 演示来探索导航行为。在第一个演示中,我们将实现一个脚本,使实体遵循简单的路径。在第二个演示中,我们将设置一个带有几个障碍的场景,并编程一个实体在避开障碍的同时到达目标。

避障是游戏角色在移动和与游戏世界交互时的基本行为。然而,避障通常与其他导航系统(如路径查找或人群模拟)一起使用。在本章中,我们将使用这些系统确保我们避开其他代理并到达目标。我们不会讨论角色到达目的地有多快,也不会计算到达目标的最短路径,因为我们将这些内容留到下一章讨论。

在本章中,我们将探讨以下两个基本方面的运动:

  • 沿着路径

  • 避免障碍

技术要求

对于本章,你只需要 Unity3D 2022。你可以在本书仓库中的第六章文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter06。

沿着路径

一个Path.cs脚本,它接受一个游戏对象列表作为航点,并从中创建路径。

路径脚本

让我们看看负责管理我们对象路径的路径脚本。考虑以下在Path.cs文件中的代码:

using UnityEngine;
public class Path : MonoBehaviour {
    public bool isDebug = true;
    public Transform[] waypoints;
    public float Length {
        get {
            return waypoints.Length;
        }
    }
    public Vector3 GetPoint(int index) {
        return waypoints[index].position;
    }
    void OnDrawGizmos() {
        if (!isDebug)
            return;
        for (int i = 1; i < waypoints.Length; i++) {
            Debug.DrawLine(waypoints[i-1].position,
            waypoints[i].position, Color.red);
        }
    }
}

如您所见,这是一个简单的脚本。它有一个Length属性,返回航点的数量。GetPoint方法返回数组中指定索引的特定航点的位置。然后,我们有OnDrawGizmos方法,由 Unity3D 帧调用,在编辑器环境中绘制组件。除非在右上角的小工具标志打开,否则这里的绘制不会在游戏视图中渲染。

图 6.1 – 编辑器视图中的小工具可见性选项

图 6.1 – 编辑器视图中的小工具可见性选项

现在,让我们创建场景。创建一个空的路径游戏对象,并将其路径脚本附加到它上。然后,让我们添加一些空的子游戏对象。它们将是航点标记。

图 6.2 – 这是如何组织层级

图 6.2 – 这是如何组织层级

选择路径对象。现在我们需要在检查器中填充航点数组,使用实际的航点标记。像往常一样,我们可以通过将游戏对象从层级拖放到检查器中来实现这一点。

图 6.3 – 检查器中的路径脚本配置

图 6.3 – 检查器中的路径脚本配置

上述列表显示了示例项目中的航点。然而,你可以在编辑器中移动航点,多次使用相同的航点,或者做任何你喜欢的事情。

另一个属性是一个复选框,用于启用调试模式和航点半径。如果我们启用调试模式属性,Unity 将在编辑器视图中以 gizmo 的形式绘制由航点连接而成的路径,如图图 6.4所示。

图 6.4 – 在编辑器视图中绘制路径的 gizmo

图 6.4 – 在编辑器视图中绘制路径的 gizmo

现在我们有了路径,我们需要设计一个可以跟随它的角色。我们将在下一节中这样做。

跟随路径的代理

对于这个演示,主要角色由一个勇敢而英勇的立方体表示。但当然,相同的脚本也适用于你想要的任何 3D 模型。

让我们先创建一个VehicleFollowing脚本。该脚本接受几个参数:第一个是需要跟随的路径对象的引用(Path变量);然后,我们有Speed和Mass属性,我们需要计算角色的速度随时间的变化。最后,如果选中,Is Looping标志指示实体以闭合循环连续跟随路径。

让我们来看看VehicleFollowing.cs文件中的以下代码:

using UnityEngine;
public class VehicleFollowing : MonoBehaviour {
    public Path path;
    public float speed = 10.0f;
    [Range(1.0f, 1000.0f)]
    public float steeringInertia = 100.0f;
    public bool isLooping = true;
    public float waypointRadius = 1.0f;
    //Actual speed of the vehicle 
    private float curSpeed;
    private int curPathIndex = 0;
    private float pathLength;
    private Vector3 targetPoint;
    Vector3 velocity;

首先,我们指定所有脚本属性。然后,我们初始化属性并使用实体的前向向量设置速度向量的起始方向。我们在Start方法中这样做,如下面的代码所示:

void Start () {
    pathLength = path.Length;
    velocity = transform.forward;
}

在这个脚本中,只有两个方法真正重要:Update和Steer方法。让我们看看第一个:

    void Update() {
        //Unify the speed
        curSpeed = speed * Time.deltaTime;
        targetPoint = path.GetPoint(curPathIndex);
        //If reach the radius of the waypoint then move to
        //next point in the path
        if (Vector3.Distance(transform.position,
            targetPoint) < waypointRadius) {
            //Don't move the vehicle if path is finished 
            if (curPathIndex < pathLength - 1)
                curPathIndex++;
            else if (isLooping)
                curPathIndex = 0;
            else
                return;
        }
        //Move the vehicle until the end point is reached 
        //in the path
        if (curPathIndex >= pathLength)
            return;
        //Calculate the next Velocity towards the path
        if (curPathIndex >= pathLength - 1 && !isLooping)
            velocity += Steer(targetPoint, true);
        else
            velocity += Steer(targetPoint);
        //Move the vehicle according to the velocity
        transform.position += velocity;
        //Rotate the vehicle towards the desired Velocity 
        transform.rotation =
          Quaternion.LookRotation(velocity); 
    }

在Update方法中,我们通过计算实体当前位置与目标航点之间的距离是否小于航点的半径来检查实体是否到达了特定的航点。如果是,我们增加索引,这样就将目标位置设置为航点数组中的下一个航点。如果它是最后一个航点,我们检查isLooping标志。

如果它是活动的,我们将目的地设置为起始航点;否则,我们停止。另一种解决方案是编程它,使我们的物体转身并返回它来的路。实现这种行为并不困难,所以我们将其留给读者作为有益的练习练习。

现在,我们使用Steer方法来计算实体的加速度和旋转。在这个方法中,我们根据速度向量的速度和方向旋转并更新实体的位置:

    public Vector3 Steer(Vector3 target, bool bFinalPoint = 
      false) {
        //Calculate the directional vector from the current
        //position towards the target point
        Vector3 desiredVelocity = 
          (target - transform.position);
        float dist = desiredVelocity.magnitude;
        //Normalize the desired Velocity
        desiredVelocity.Normalize();
        // 
        if (bFinalPoint && dist < waypointRadius)
            desiredVelocity *= 
              curSpeed * (dist / waypointRadius);
        else
            desiredVelocity *= curSpeed;
        //Calculate the force Vector
        Vector3 steeringForce = desiredVelocity - velocity;
        return steeringForce / steeringInertia;
    }
}

Steer方法接受两个参数:目标位置和一个布尔值,它告诉我们这是路径中的最终航点。首先,我们计算从当前位置到目标位置剩余的距离。然后我们从目标位置向量中减去当前位置向量以得到指向目标位置的向量。我们对其大小不感兴趣,只关心其方向,因此我们对其进行归一化。

现在,假设我们正在移动到最终航点,并且它与我们之间的距离小于航点半径。在这种情况下,我们希望逐渐减速,直到速度在航点位置恰好变为零,以便角色能够正确地停在原地。否则,我们使用期望的最大速度值更新目标速度。然后,与之前相同,我们可以通过从目标速度向量中减去当前速度向量来计算新的转向向量。最后,通过将此向量除以我们的实体转向惯性值,我们得到一个平滑的转向(请注意,转向惯性的最小值为1,对应于瞬时转向)。

现在我们有了脚本,我们可以创建一个空的Cube对象并将其放置在路径的起点。然后,我们向其中添加VehicleFollowing脚本组件,如下面的截图所示:

![图 6.5 – VehicleFollowing 脚本的属性]

![图片 B17984_06_5.jpg]

图 6.5 – VehicleFollowing 脚本的属性

如果运行场景,你应该看到我们的立方体角色沿着路径移动。你还可以在编辑器视图中看到路径。尝试调整立方体的速度和转向惯性值以及路径的半径值,看看它们如何影响系统的整体行为。

避免障碍物

在本节中,我们探讨障碍物避让。首先,当然需要障碍物。因此,我们设置了一个类似于图 6.6所示的场景。然后,我们为主角编写了一个脚本,使其在尝试到达目标点的同时避开障碍物。这里提出的算法使用了射线投射法,这种方法非常直接。然而,这意味着它只能避开直接阻挡其路径前方的障碍物:

![图 6.6 – 一个示例场景设置]

![图片 B17984_06_6.jpg]

图 6.6 – 一个示例场景设置

我们创建了一些立方体实体,并将它们组合在一个名为Obstacles的空游戏对象下,以创建环境。我们还创建了一个名为Vehicle的另一个立方体对象,并给它添加了障碍物避让脚本。最后,我们创建了一个代表地面的平面对象。

![图 6.7 – 场景的层次结构结构]

![图片 B17984_06_7.jpg]

图 6.7 – 场景的层次结构结构

值得注意的是,Vehicle对象不执行路径查找,即不是在目的地进行路径的主动搜索。相反,它只是在跟随路径时局部避开障碍物。简而言之,这就像你从家计划去购物中心的路,以及避开你可能在路上遇到的可能的人和障碍物。因此,如果我们设置太多的墙壁,Vehicle可能很难找到目标:例如,如果 Agent 最终面对一个 U 形物体的死胡同,它可能无法出来。尝试几种不同的墙壁设置,看看你的代理表现如何。

添加自定义层

我们现在将自定义层添加到 Obstacles 对象中:

  1. 要添加新层,请转到编辑 | 项目设置:

图 6.8 – 项目设置

图 6.8 – 项目设置

  1. 转到标签和层部分。

  2. 将名称Obstacles分配给用户层 8。

  3. 然后,我们回到我们的立方体实体,并设置其Obstacles:

图 6.9 – 创建新层

图 6.9 – 创建新层

  1. 当我们使用射线投射来检测障碍物时,我们检查这些实体,但仅在这个层上。这样,物理系统可以忽略被射线击中的不是障碍物的对象,例如灌木丛或植被:

图 6.10 – 分配我们的新层

图 6.10 – 分配我们的新层

  1. 对于较大的项目,我们的游戏对象可能已经分配了层。因此,我们不会更改对象的层为Obstacles,而是为我们的立方体实体创建一个层列表,用于检测障碍物。我们将在下一节中详细介绍这一点。

    信息

    在游戏中,我们使用层让相机仅渲染场景的一部分,或者让灯光仅照亮对象的一个子集。然而,层也可以通过射线投射来选择性地忽略碰撞体或创建碰撞。您可以在docs.unity3d.com/Manual/Layers.html了解更多信息。

避障

现在,是时候编写使立方体实体避免墙壁的脚本了。像往常一样,我们首先使用默认属性初始化我们的实体脚本。在这里,我们还在OnGUI方法中绘制 GUI 文本。让我们看看VehicleAvoidance.cs文件中的以下代码:

using UnityEngine;
public class VehicleAvoidance : MonoBehaviour {
    public float vehicleRadius = 1.2f;
    public float speed = 10.0f;
    public float force = 50.0f;
    public float minimumDistToAvoid = 10.0f;
    public float targetReachedRadius = 3.0f;
    //Actual speed of the vehicle 
    private float curSpeed;
    private Vector3 targetPoint;
    // Use this for initialization
    void Start() {
        targetPoint = Vector3.zero;
    }
    void OnGUI() {
        GUILayout.Label("Click anywhere to move the vehicle
                         to the clicked point");
    }

然后,在Update方法中,我们根据AvoidObstacles方法返回的方向向量更新 Agent 实体的位置和旋转:

    void Update() {
        //Vehicle move by mouse click
        var ray = Camera.main.ScreenPointToRay(
          Input.mousePosition);
        if (Input.GetMouseButtonDown(0) &&
            Physics.Raycast(ray, out var hit, 100.0f)) {
            targetPoint = hit.point;
        }
        //Directional vector to the target position
        Vector3 dir = (targetPoint - transform.position);
        dir.Normalize();
        //Apply obstacle avoidance
        AvoidObstacles(ref dir);

       . . . .
}

在Update方法中,我们首先获取鼠标点击的位置。然后,我们使用这个位置来确定我们角色的期望目标位置。为了获取鼠标点击位置,我们从相机面向的方向发射一条射线。然后,我们将射线击中地面平面的点作为目标位置。

一旦我们得到目标位置,我们可以通过从目标位置向量减去当前位置向量来计算方向向量。然后,我们调用AvoidObstacles方法,并将这个方向传递给它:

    public void AvoidObstacles(ref Vector3 dir) {
        //Only detect layer 8 (Obstacles)
        int layerMask = 1 << 8;
        //Check that the vehicle hit with the obstacles
        //within it's minimum distance to avoid
        if (Physics.SphereCast(transform.position,
            vehicleRadius, transform.forward, out var hit,
            minimumDistToAvoid, layerMask)) {
            //Get the normal of the hit point to calculate
            //the new direction
            Vector3 hitNormal = hit.normal;
            //Don't want to move in Y-Space
            hitNormal.y = 0.0f; 
            //Get the new directional vector by adding
           //force to vehicle's current forward vector
            dir = transform.forward + hitNormal * force;
        }
    }

AvoidObstacles方法也很简单。注意,我们使用了另一个非常实用的 Unity 物理工具:SphereCast。SphereCast 与 Raycast 类似,但它不是通过发射一个无尺寸的射线来检测碰撞器,而是发射一个粗壮的球体。在实践中,SphereCast 给 Raycast 射线增加了宽度。

这为什么重要?因为我们的角色不是无尺寸的。我们想确保角色的整个身体可以避免碰撞。

另一点需要注意的是,SphereCast 会选择性地与SphereCast方法交互,它接受一个图层遮罩参数以确定在射线投射期间忽略和考虑哪些图层。现在,如果你看看在标签管理器中可以指定多少层,你会发现总共有 32 层。

因此,Unity3D 使用 32 位整数来表示这个图层遮罩参数。例如,以下表示 32 位中的零:

0000 0000 0000 0000 0000 0000 0000 0000

默认情况下,Unity3D 使用前八个图层作为内置图层。所以,当你使用 Raycast 或 SphereCast 而不使用图层遮罩参数时,它会检测那些八个图层中的每一个对象。我们可以用位掩码表示这种交互掩码,如下所示:

0000 0000 0000 0000 0000 0000 1111 1111

在这个演示中,我们将障碍物图层设置为图层 8(第 9 个索引)。因为我们只想检测这个图层中的障碍物,所以我们需要按以下方式设置位掩码:

0000 0000 0000 0000 0000 0001 0000 0000

设置这个位掩码的最简单方法是使用位移运算符。我们只需要将位,1,放置在第 9 个索引上,这意味着我们只需将这个位向左移动八位。所以,我们使用左移运算符将位向左移动八位,如下面的代码所示:

int layerMask = 1<<8;

如果我们想使用多个图层遮罩,比如说图层 8 和图层 9,一个简单的方法是使用位或运算符,如下所示:

int layerMask = (1<<8) | (1<<9);

Info

你也可以在 Unity3D 的在线资源中找到关于使用图层遮罩的良好讨论。问答网站可以在answers.unity3d.com/questions/8715/how-do-i-use-layermasks.html找到。

一旦我们有了图层遮罩,我们就会从当前实体的位置和前方方向调用Physics.SphereCast方法。我们使用半径为vehicleRadius的球体(确保足够大,可以完全包含立方车辆)以及由minimumDistToAvoid变量定义的检测距离。实际上,我们只想检测足够接近以影响我们移动的对象。

然后,我们取被击中射线的法向量,将其与力向量相乘,并将其加到实体的当前方向上,以获得新的结果向量,然后我们从该方法返回这个向量:

图 6.11 – 我们的立方实体如何避开墙壁

图 6.11 – 我们的立方体实体如何避开墙壁

然后,在Update方法中,我们使用这个新的方向来旋转 AI 实体,并根据速度值更新位置:

    void Update () {
        //...
        //Don't move the vehicle when the target point is
        //reached
        if (Vector3.Distance(targetPoint,
            transform.position) < targetReachedRadius)
            return;
        //Assign the speed with delta time
        curSpeed = speed * Time.deltaTime;
        //Rotate the vehicle to its target directional
        //vector
        var rot = Quaternion.LookRotation(dir);
        transform.rotation = 
          Quaternion.Slerp(transform.rotation, rot, 5.0f *
                           Time.deltaTime);
        //Move the vehicle towards
        transform.position += transform.forward * curSpeed;
        transform.position = new Vector3(
          transform.position.x, 0, transform.position.z);
    }

现在,我们只需要将这个新的脚本附加到车辆对象上(这可以是一个简单的立方体,就像上一个例子中那样)。记住,这个新的脚本需要替换我们在上一节中实现的VehicleFollowing脚本。

图 6.12 – 我们车辆避障脚本的属性

图 6.12 – 我们车辆避障脚本的属性

图 6.12 – 我们车辆避障脚本的属性

如果一切正确,你应该能够看到车辆在没有任何麻烦的情况下绕过障碍物在平面上导航。像往常一样,通过 Inspector 参数调整车辆行为。

摘要

在本章中,我们设置了两个场景,并研究了如何构建具有避障行为的路径跟随代理。我们了解了 Unity3D 层功能以及如何有选择性地使用 Raycasts 和 SphereCasts 对特定层进行操作。尽管这些例子很简单,但我们可以将这些简单技术应用于各种场景。例如,我们可以在道路上设置路径。我们可以轻松地使用一些车辆模型结合避障行为设置一个不错的交通模拟。或者,你也可以用两足人物来替换它们,构建一个人群模拟。你还可以将它们与一些有限状态机结合,以添加更多行为并使其更加智能。

本章中我们实现的简单避障行为没有考虑到达目标位置的最佳路径。相反,它只是直接前往那个目标,只有当在特定距离内看到障碍物时,它才会尝试避开它。因此,它应该在移动或动态对象和障碍物之间使用。

在下一章中,我们将研究如何实现一个名为A的路径查找算法,在移动之前确定最佳路径,同时避开静态障碍物。

第七章:A* 路径查找

在本章中,我们将使用 C# 在 Unity3D 中实现 A 算法**。A 路径查找算法因其简单性和有效性而在游戏和交互式应用中得到广泛应用。我们之前在 第一章,人工智能简介 中讨论了此算法。然而,在这里,我们将再次回顾该算法,这次是从实现的角度。

在本章中,我们将探讨以下主题:

  • 重新审视 A* 算法

  • 实现 A* 算法

  • 设置场景

  • 测试路径查找器

技术要求

对于本章,你只需要 Unity3D 2022. 你可以在本书仓库的 Chapter 7 文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter07。

重新审视 A* 算法

在我们进入下一节实现 A* 算法之前,让我们回顾一下 A* 算法。任何路径查找算法的基础是对世界的表示。路径查找算法不能在游戏地图中多边形的嘈杂结构中进行搜索;相反,我们需要为他们提供一个简化的世界版本。使用这个简化的结构,我们可以识别出代理可以穿越的位置,以及不可到达的位置。

有许多方法可以做到这一点;然而,在这个例子中,我们使用最直接的一种解决方案:2D 网格。因此,我们实现了 GridManager 类,将“真实”地图转换为 2D 地砖表示。GridManager 类保持一个表示 2D 网格中单个地砖的 Node 对象列表。当然,我们首先需要实现 Node 类:这个类存储节点信息,例如其位置、是否为可穿越节点或障碍物、通过的成本以及到达目标节点的成本。

一旦我们有了世界表示,我们就实现一个 AStar 类来表示实际的 A* 路径查找算法。这个类很简单;FindPath 方法包含了所有的工作。这个类有两个变量来跟踪已经访问过的节点和将要探索的节点。我们称这些变量为 PriorityQueue 类,因为我们希望尽快获取得分最低的 Node。

相反,关闭列表需要一个允许我们高效检查是否包含特定 Node 的数据结构:通常,一个称为 集合 的数据结构是一个不错的选择。

最后,A* 的伪代码如下:

  1. 首先,算法将起始节点放入开放列表中。

  2. 只要开放列表不为空,算法就会继续执行以下步骤。

  3. 它从开放列表中选取第一个节点并将其定义为当前节点(当然,我们假设我们正在使用优先队列作为开放列表)。

  4. 然后,它获取当前节点的相邻节点,排除障碍物类型(例如无法通过的墙壁或峡谷)。这一步通常被称为扩展。

  5. 在步骤 4 中,对于每个相邻节点,它检查它是否已经在关闭列表中。如果没有,它使用以下公式计算这个相邻节点的总成本(F):

在这里,G是从起始节点到该节点的总成本(通常通过将从父节点移动到相邻节点的成本添加到父节点的G值来计算),而H是从该节点到最终目标节点的估计总成本。我们将在后面的章节中讨论估计成本的问题。

  1. 该算法将成本数据存储在相邻的node对象中,并将当前节点指定为相邻节点的父节点。稍后,我们使用这些父节点数据从终点节点追踪回起始节点,从而重建实际路径。

  2. 它将这个相邻节点放入开放列表中。开放列表是一个按F值排序的优先队列;因此,开放列表中的第一个节点总是具有最低的F值。

  3. 如果没有更多的相邻节点需要处理,算法将当前节点放入关闭列表中,并从开放列表中移除。

  4. 算法回到步骤 2。

一旦完成这个算法,如果从起始节点到目标节点有一条无障碍路径,那么当前节点就精确地位于目标节点位置。否则,这意味着从当前节点位置到目标节点没有可用的路径。

当我们得到一条有效路径时,我们必须使用父指针从当前节点追踪回,直到再次达到起始节点。这个过程给我们一个路径列表,列出了我们在路径查找过程中选择的节点,从目标节点到起始节点排序。作为最后一步,我们只需反转这个路径列表,就可以得到正确的路径顺序。

接下来,我们将使用 C#在 Unity3D 中实现 A*算法。那么,让我们开始吧。

实现 A*算法

首先,我们实现之前介绍的基本类,例如Node类、GridManager类和PriorityQueue类。然后,我们在主要的AStar类中使用它们。

节点

Node类代表 2D 网格中的每个瓦片对象。其代码在Node.cs文件中显示:

using UnityEngine;
using System;
public class Node {
    public float costSoFar;
    public float fScore;
    public bool isObstacle;
    public Node parent;
    public Vector3 position;

    public Node(Vector3 pos) {
        fScore = 0.0f;
        costSoFar = 0.0f;
        isObstacle = false;
        parent = null;
        position = pos;
    }
    public void MarkAsObstacle() {
        isObstacle = true;
    }

Node 类存储了我们寻找路径所需的所有有价值属性。我们谈论的是诸如从起点到当前位置的成本 (costSoFar)、从起点到终点的总估计成本 (fScore)、一个标记是否为障碍物的标志、其位置以及其父节点等属性。costSoFar 是 G,即从起点节点到当前位置的移动成本值,而 fScore 显然是 F,即从起点到目标节点的总估计成本。我们还有两个简单的构造方法和一个包装方法来设置,根据这个节点是否为障碍物。然后,我们实现了 Equals 和 GetHashCode 方法,如下面的代码所示:

    public override bool Equals(object obj) {
        return obj is Node node &&
               position.Equals(node.position);
    }
    public override int GetHashCode() {
        return HashCode.Combine(position);
    }
}

这些方法很重要。实际上,即使 Node 类有多个属性,代表相同位置的节点在搜索算法中应该被视为相等。要做到这一点,就像前面的例子中那样,我们需要重写默认的 Equals 和 GetHashCode 方法。

PriorityQueue

优先队列是一种有序数据结构,设计目的是使列表的第一个元素(头部)始终是最小或最大的元素(取决于实现方式)。这种数据结构是处理开放列表中节点最有效的方式,因为我们将在后面看到,我们需要快速检索具有最低 F 值的节点。

不幸的是,没有现成的合适优先队列的方法(至少,直到 Unity 支持 .NET 6)。我们将使用的代码如下面的 NodePriorityQueue.cs 类所示:

using System.Collections.Generic;
using System.Linq;
public class NodePriorityQueue {
    private readonly List<Node> nodes = new();
    public int Length {
        get { return nodes.Count; }
    }
    public bool Contains(Node node) {
        return nodes.Contains(node);
    }
    public Node Dequeue() {
        if (nodes.Count > 0) {
            var result = nodes[0];
            nodes.RemoveAt(0);
            return result;
        }
        return null;
    }
    public void Enqueue(Node node) {
        if (nodes.Contains(node)) {
            var oldNode = nodes.First(n => n.Equals(node));
            if (oldNode.fScore <= node.fScore) {
                return;
            } else {
                nodes.Remove(oldNode);
            }
        }
        nodes.Add(node);
        nodes.Sort((n1, n2) => n1.fScore < n2.fScore ? -1 :
                   1);
    }
} 

这种实现并不特别高效,因为它依赖于 Sort 方法在每次插入后重新排序节点的内部列表。这意味着随着队列中节点数量的增加,插入节点的成本会越来越高。如果你需要更好的性能,你可以找到许多为 A* 和搜索算法(例如你可以在 github.com/BlueRaja/High-Speed-Priority-Queue-for-C-Sharp 找到的那个)设计的优先队列实现。

目前,尽管如此,我们的小型 NodePriorityQueue 类将很好地完成其工作。这个类是自我解释的。你唯一需要关注的是 Enqueue 方法。在添加新节点之前,我们需要检查是否已经存在一个具有相同位置但 F 分数较低的节点。如果有,我们就不做任何事情(我们已经在队列中有一个 更好 的节点)。如果没有,这意味着我们正在添加的新节点比旧节点更好。因此,我们可以移除旧节点,以确保我们为每个位置只保留最佳节点。

GridManager 类

GridManager 类处理世界地图的二维网格表示。我们将其保持为 GridManager 类的单例实例,因为我们只需要一个对象来表示地图。单例是一种编程模式,它限制一个类的实例化只能有一个对象,因此它使得实例在任何应用点都易于访问。设置 GridManager 的代码显示在 GridManager.cs 文件中。

  1. 类的第一个部分实现了场景中的 GridManager 对象,如果我们找到了它,我们就将其存储在 staticInstance 静态变量中:

    using UnityEngine;
    using System.Collections.Generic;
    public class GridManager : MonoBehaviour {
        private static GridManager staticInstance = null;
        public static GridManager instance {
            get {
                if (staticInstance == null) {
                    staticInstance = FindObjectOfType(
                      typeof(GridManager)) as GridManager;
                    if (staticInstance == null)
                        Debug.Log("Could not locate an
                          GridManager object. \n You have
                          to have exactly one GridManager
                          in the scene.");
                }
                return staticInstance;
            }
        }
        // Ensure that the instance is destroyed when the
        // game is stopped in the editor.
        void OnApplicationQuit() {
            staticInstance = null;
        }
    
  2. 然后,我们声明所有需要用来表示地图的变量。numOfRows 和 numOfColumns 存储网格的行数和列数。gridCellSize 表示每个网格的大小。obstacleEpsilon 是我们将用于检测障碍物的系统(稍后会有更多介绍)的边缘。

  3. 然后,我们有两个布尔变量来启用或禁用网格和障碍物的调试可视化。最后,我们有一个表示地图本身的 nodes 网格。我们还添加了两个属性来获取网格在全局坐标中的原点(Origin)和从一个瓦片移动到另一个瓦片的成本(StepCost)。最终产品如下所示:

        public int numOfRows;
        public int numOfColumns;
        public float gridCellSize;
        public float obstacleEpsilon = 0.2f;
        public bool showGrid = true;
        public bool showObstacleBlocks = true;
        public Node[,] nodes { get; set; }
        public Vector3 Origin {
            get { return transform.position; }
        }
        public float StepCost {
            get { return gridCellSize; }
        }
    
  4. 现在我们需要构建网格。为此,我们使用 ComputeGrid 方法,我们在 Awake 中调用它。代码如下所示:

        void Awake() {
            ComputeGrid();
        }
        void ComputeGrid() {
            //Initialise the nodes
            nodes = new Node[numOfColumns, numOfRows];
            for (int i = 0; i < numOfColumns; i++) {
                for (int j = 0; j < numOfRows; j++) {
                    Vector3 cellPos = 
                      GetGridCellCenter(i,j);
                    Node node = new(cellPos);
                    var collisions = 
                      Physics.OverlapSphere(cellPos,
                      gridCellSize / 2 - obstacleEpsilon,
                      1 << LayerMask.NameToLayer(
                      "Obstacles"));
                    if (collisions.Length != 0) {
                        node.MarkAsObstacle();
                    }
                    nodes[i, j] = node;
                }
            }
        } 
    
  5. ComputeGrid 函数遵循一个简单的算法。首先,我们只是初始化 nodes 网格。然后我们开始遍历网格中的每个方块(由坐标 i 和 j 表示)。对于每个方块,我们执行以下操作:

    1. 首先,我们在方块中心(在全局坐标中)创建一个新的节点。

    2. 然后,我们检查该方块是否被障碍物占据。我们通过使用 OverlapSphere 函数来完成此操作。这个 Physics 函数返回所有位于或与参数中定义的球体相交的碰撞体。在我们的情况下,我们将球体中心放在网格单元格的中心(cellPos)上,并将球体的半径定义为略小于网格单元格大小。请注意,我们只对 Obstacles 层中的碰撞体感兴趣,因此我们需要添加适当的层掩码。

    3. 如果 OverlapSphere 函数返回任何内容,这意味着单元格内有一个障碍物,因此我们将整个单元格定义为障碍物。

GridManager 还有一些辅助方法来遍历网格并获取网格单元格数据。我们在以下列表中展示了其中一些,并简要描述了它们的功能。实现很简单:

  1. GetGridCellCenter 方法根据单元格坐标返回网格单元格在全局坐标中的位置,如下面的代码所示:

        public Vector3 GetGridCellCenter(int col, int row)
        {
            Vector3 cellPosition = 
              GetGridCellPosition(col, row);
            cellPosition.x += gridCellSize / 2.0f;
            cellPosition.z += gridCellSize / 2.0f;
            return cellPosition;
        }
        public Vector3 GetGridCellPosition(int col, int 
          row) {
            float xPosInGrid = col * gridCellSize;
            float zPosInGrid = row * gridCellSize;
            return Origin + new Vector3(xPosInGrid, 0.0f,
              zPosInGrid);
        }
    
  2. IsInBounds 方法检查游戏中的某个位置是否在网格内:

    public bool IsInBounds(Vector3 pos) {
        float width = numOfColumns * gridCellSize;
        float height = numOfRows * gridCellSize;
        return (pos.x >= Origin.x && pos.x <= Origin.x +
          width && pos.x <= Origin.z + height && pos.z >= 
          Origin.z);
    }
    
  3. IsTraversable 方法检查一个网格坐标是否可穿越(即它不是一个障碍物):

        public bool IsTraversable(int col, int row) {
            return col >= 0 && row >= 0 && col <
              numOfColumns && row < numOfRows && 
              !nodes[col, row].isObstacle;
        }
    
  4. 另一个重要的方法是 GetNeighbours,它被 AStar 类用来检索特定节点的相邻节点。这是通过获取节点的网格坐标,然后检查四个相邻坐标(上、下、左、右)是否可穿越来完成的:

    public List<Node> GetNeighbours(Node node) {
            List<Node> result = new();
            var (column, row) =
              GetGridCoordinates(node.position);
            if (IsTraversable(column – 1, row)) {
                result.Add(nodes[column – 1, row]);
            }
            if (IsTraversable(column + 1, row)) {
                result.Add(nodes[column + 1, row]);
            }
            if (IsTraversable(column, row – 1)) {
                result.Add(nodes[column, row – 1]);
            }
            if (IsTraversable(column, row + 1)) {
                result.Add(nodes[column, row + 1]);
            }
            return result;
    }
    
  5. 最后,我们有用于可视化网格和障碍块的调试辅助方法:

        void OnDrawGizmos() {
            if (showGrid) {
                DebugDrawGrid(Color.blue);
            }
            //Grid Start Position
            Gizmos.DrawSphere(Origin, 0.5f);
            if (nodes == null) return;
            //Draw Obstacle obstruction
            if (showObstacleBlocks) {
                Vector3 cellSize = new Vector3(
                  gridCellSize, 1.0f, gridCellSize);
                Gizmos.color = Color.red;
                for (int i = 0; i < numOfColumns; i++) {
                    for (int j = 0; j < numOfRows; j++) {
                        if (nodes != null && nodes[i, 
                            j].isObstacle) {
                            Gizmos.DrawCube(
                              GetGridCellCenter(i,j),
                              cellSize);
                        }
                    }
                }
            }
        }
        public void DebugDrawGrid(Color color) {
            float width = (numOfColumns * gridCellSize);
            float height = (numOfRows * gridCellSize);
            // Draw the horizontal grid lines
            for (int i = 0; i < numOfRows + 1; i++) {
                Vector3 startPos = Origin + i *
                  gridCellSize * new Vector3(0.0f, 0.0f,
                                             1.0f);
                Vector3 endPos = startPos + width * new
                  Vector3(1.0f, 0.0f, 0.0f);
                Debug.DrawLine(startPos, endPos, color);
            }
            // Draw the vertial grid lines
            for (int i = 0; i < numOfColumns + 1; i++) {
                Vector3 startPos = Origin + i *
                  gridCellSize * new Vector3(1.0f, 0.0f, 
                                             0.0f);
                Vector3 endPos = startPos + height * new
                  Vector3(0.0f, 0.0f, 1.0f);
                Debug.DrawLine(startPos, endPos, color);
            }
    }
    

Gizmos 可以用来在编辑器场景视图中绘制可视化调试和设置辅助工具。OnDrawGizmos 由引擎每帧调用。因此,如果调试标志 showGrid 和 showObstacleBlocks 被选中,我们就用线条绘制网格,并用立方体绘制障碍立方体对象。我们不会详细介绍 DebugDrawGrid 方法,因为它相当简单。

Info

你可以在以下 Unity3D 参考文档中了解更多关于 gizmos 的信息:docs.unity3d.com/ScriptReference/Gizmos.html。

AStar 类

AStar 类使用我们迄今为止实现的类来实现路径查找算法。如果你想快速回顾 A* 算法,请参阅本章早些时候的 重新审视 A 算法* 部分。AStar 的实现步骤如下:

  1. 我们首先实现了一个名为 HeuristicEstimateCost 的方法来计算两个节点之间的成本。计算很简单。我们只需通过从一个位置向量减去另一个位置向量来找到两个节点之间的方向向量。这个结果向量的模长给出了从当前节点到目标节点的直线距离:

    using UnityEngine;
    using System.Collections.Generic; 
    public class AStar {
        private float HeuristicEstimateCost(Node curNode,
          Node goalNode) {
            return (curNode.position –
                    goalNode.position).magnitude;
        }
    

    Info

    理论上,你可以用任何函数替换这个函数,返回 curNode 和 goalNode 之间的距离。然而,为了让 A* 返回可能的最短路径,这个函数必须是可接受的。简而言之,一个可接受的自适应启发式函数是一个永远不会高估 curNode 和 goalNode 之间实际“真实世界”成本之间的函数。作为一个练习,你可以很容易地验证我们在这个演示中使用的是可接受的。有关启发式函数背后的数学信息,你可以访问 theory.stanford.edu/~amitp/GameProgramming/Heuristics.html。

  2. 然后,我们在 FindPath 方法中有主要的 A* 算法。在下面的代码片段中,我们初始化了开放和关闭列表。从起始节点开始,我们将其放入我们的开放列表中。然后,我们开始处理我们的开放列表:

        public List<Node> FindPath(Node start, Node goal) { 
            //Start Finding the path
            NodePriorityQueue openList =
              new NodePriorityQueue();
            openList.Enqueue(start);
            start.costSoFar = 0.0f;
            start.fScore = HeuristicEstimateCost(start,
                                                 goal);
            HashSet<Node> closedList = new();
            Node node = null;
    
  3. 然后,我们继续进行主要的算法循环:

            while (openList.Length != 0) {
                node = openList.Dequeue();
                if (node.position == goal.position) {
                    return CalculatePath(node);
                }
                var neighbours =
                  GridManager.instance.GetNeighbours(
                  node);
    
                foreach (Node neighbourNode in neighbours)
                {
                    if (!closedList.Contains(
                        neighbourNode)) {
                        float totalCost = node.costSoFar +
                          GridManager.instance.StepCost;
                        float heuristicValue =
                          HeuristicEstimateCost(
                          neighbourNode, goal);
                        //Assign neighbour node properties
                        neighbourNode.costSoFar = 
                          totalCost;
                        neighbourNode.parent = node;
                        neighbourNode.fScore = 
                          totalCost + heuristicValue;
                        //Add the neighbour node to the 
                        //queue
                        if (!closedList.Contains(
                            neighbourNode)) {
                                   openList.Enqueue(
                                     neighbourNode);
                        }
    
                    }
                }
                closedList.Add(node);
            }
    
    1. 上述代码实现严格遵循我们之前讨论的算法,所以如果你对某些内容不清楚,可以参考它:

    2. 从我们的 openList 中获取第一个节点。记住,openList 总是按递增顺序排序。因此,第一个节点总是具有最低 F 值的节点。

    3. 检查当前节点是否已经到达目标节点。如果是,退出 while 循环并构建路径数组。

    4. 创建一个数组列表来存储当前正在处理的节点的邻居节点。然后,使用GetNeighbours方法从网格中检索邻居。

    5. 对于邻居数组中的每个节点,我们检查它是否已经在closedList中。如果没有,我们计算成本值,使用新的成本值和父节点数据更新节点属性,并将其放入openList。

    6. 将当前节点推入closedList并从openList中移除。

    7. 返回到步骤 I。

  4. 如果openList中没有更多节点,当前节点应该位于目标节点,如果存在有效路径:

            //If finished looping and cannot find the goal
            //then return null
            if (node.position != goal.position) {
                Debug.LogError("Goal Not Found");
                return null;
            }
            //Calculate the path based on the final node
            return CalculatePath(node);
    
  5. 最后,我们使用当前节点参数调用CalculatePath方法:

        private List<Node> CalculatePath(Node node) { 
            List<Node> list = new();
            while (node != null) {
                list.Add(node);
                node = node.parent;
            }
            list.Reverse();
            return list;
        }
    }
    
  6. CalculatePath方法遍历每个节点的父node对象并构建一个数组列表。由于我们想要从起始节点到目标节点的路径数组,我们只需调用Reverse方法。

现在,我们将编写一个测试脚本以测试此功能并设置一个演示场景。

TestCode类

TestCode类使用AStar类从起始节点到目标节点查找路径,如下面的TestCode.cs文件中的代码所示:

using UnityEngine;
using System.Collections;
public class TestCode : MonoBehaviour {
    private Transform startPos, endPos;
    public Node startNode { get; set; }
    public Node goalNode { get; set; }
    public List<Node> pathArray;
    GameObject objStartCube, objEndCube;
    private float elapsedTime = 0.0f;
    //Interval time between pathfinding 
    public float intervalTime = 1.0f;

在前面的代码片段中,我们首先设置需要引用的变量。pathArray变量存储从AStar的FindPath方法返回的节点数组。

在下面的代码块中,我们使用Start方法来查找带有Start和End标签的对象并初始化pathArray。我们试图在每个由intervalTime属性指定的间隔内找到一个新路径,以防起始节点和结束节点的位置已改变。最后,我们调用FindPath方法:

    void Start () {
        objStartCube = 
          GameObject.FindGameObjectWithTag("Start"); 
        objEndCube =
          GameObject.FindGameObjectWithTag("End");
        pathArray = new List<Node>();
        FindPath();
    }
    void Update () {
        elapsedTime += Time.deltaTime;
        if (elapsedTime >= intervalTime) {
            elapsedTime = 0.0f;
            FindPath();
        }
    }

由于我们在AStar类中实现了路径查找算法,因此找到路径要简单得多。在下面的代码片段中,我们首先获取起始和结束游戏对象的位置。然后,我们使用GridManager中的GetGridIndex辅助方法创建新的Node对象,以计算它们在网格内的行和列索引位置。

之后,我们使用起始节点和目标节点调用AStar.FindPath方法,将返回的数组列表存储在局部的pathArray属性中。最后,我们实现OnDrawGizmos方法来绘制和可视化结果路径:

void FindPath() {
        startPos = objStartCube.transform;
        endPos = objEndCube.transform;
        //Assign StartNode and Goal Node
        var (startColumn, startRow) = 
          GridManager.instance.GetGridCoordinates(
          startPos.position);
        var (goalColumn, goalRow) = 
          GridManager.instance.GetGridCoordinates(
          endPos.position);
        startNode = new Node(
          GridManager.instance.GetGridCellCenter(
          startColumn, startRow));
        goalNode = new Node(
          GridManager.instance.GetGridCellCenter(
          goalColumn, goalRow));
        pathArray = 
          new AStar().FindPath(startNode, goalNode);
}

我们遍历pathArray并使用Debug.DrawLine方法绘制线条,连接pathArray中的节点:

    void OnDrawGizmos() {
        if (pathArray == null)
            return;
        if (pathArray.Count > 0) {
            int index = 1;
            foreach (Node node in pathArray) {
                if (index < pathArray.Count) {
                    Node nextNode = pathArray[index];
                    Debug.DrawLine(node.position,
                      nextNode.position, Color.green);
                    index++;
                }
            };
        }
    }
}

当我们运行并测试我们的程序时,我们应该看到一条连接起始节点到结束节点的绿色线条。

设置场景

我们将设置一个类似于以下截图的场景:

![图 7.1 – 带有障碍物的示例测试场景

![img/B17984_07_1.jpg]

图 7.1 – 带有障碍物的示例测试场景

让我们遵循以下步骤进行操作:

  1. 我们创建了一个方向光、起点和终点游戏对象、几个障碍物对象、一个用作地面的平面实体,以及两个空的游戏对象,我们将 GridManager 和 TestAStar 脚本放入其中。完成此步骤后,我们的场景层次结构应该如下所示:

图 7.2 – 演示场景层次结构

图 7.2 – 演示场景层次结构

  1. 我们创建了一组立方体实体并将它们添加到 GridManager,当它创建网格世界表示时查找具有此标签的对象:

图 7.3 – 在检查器中看到的障碍节点

图 7.3 – 在检查器中看到的障碍节点

  1. 然后,我们创建了一个立方体实体并将其标记为 起点:

图 7.4 – 在检查器中看到的起点节点

图 7.4 – 在检查器中看到的起点节点

  1. 然后,我们创建另一个立方体实体并将其标记为 终点:

图 7.5 – 在检查器中看到的终点节点

图 7.5 – 在检查器中看到的终点节点

  1. 我们创建了一个空的游戏对象,并将 GridManager 脚本附加到它上。我们还设置了名称为 GridManager,因为我们使用此名称从其他脚本中查找 GridManager 对象。

  2. 然后,我们设置了网格的行数和列数以及每个瓦片的尺寸。

图 7.6 – GridManager 脚本

图 7.6 – GridManager 脚本

测试寻路器

一旦我们按下 播放 按钮,我们应该能看到 A* 寻路算法的实际运行。默认情况下,一旦播放场景,Unity3D 会切换到 游戏 视图。然而,由于我们的寻路可视化代码在调试编辑器视图中绘制,要看到找到的路径,您需要切换回 场景 视图或启用 Gizmos 可视化:

图 7.7 – 算法找到的第一个路径

图 7.7 – 算法找到的第一个路径

现在,尝试使用编辑器的移动 Gizmo 在场景中移动起点或终点节点(不在 游戏 视图中,而是在 场景 视图中):

图 7.8 – 算法找到的第二个路径

图 7.8 – 算法找到的第二个路径

您应该看到路径在实时中动态更新。另一方面,如果没有可用的路径,您将在控制台窗口中收到错误消息。

摘要

在本章中,我们学习了如何在 Unity3D 中实现 A* 寻路算法。首先,我们实现了自己的 A* 寻路类、网格表示类、优先队列类和节点类。最后,我们使用调试绘制功能来可视化网格和路径信息。

在后面的章节中,我们将看到,由于 Unity3D 的 NavMesh 和 NavAgent 功能,您可能不需要自己实现自定义寻路算法。

尽管如此,理解基本寻路算法为您掌握许多其他高级寻路技术提供了更好的基础。

在下一章中,我们将把 A*算法背后的思想扩展到更复杂的场景表示:导航网格。

第八章:导航网格

正如我们在第七章中看到的,路径查找,路径查找中最关键的决策是如何表示场景的几何形状。AI 代理需要知道障碍物的位置,作为 AI 设计师,我们的工作是向路径查找算法提供尽可能好的表示。以前,我们通过将地图划分为 2D 网格来创建自定义表示,然后通过实现 A*算法来使用该表示来实现自定义路径查找算法。但如果我们能让 Unity 为我们做所有这些工作,那岂不是太棒了?

幸运的是,Unity 可以使用导航网格(NavMeshes)来完成这项工作。在之前的 2D 表示中,我们将世界划分为完美的正方形,而使用 NavMeshes,我们将使用任意的凸多边形来划分世界。这种表示有两个令人兴奋的优点:首先,每个多边形都可以不同,因此我们可以使用少量的大多边形来表示广阔的开放区域,以及许多小多边形来表示非常拥挤的空间;其次,我们不再需要将代理锁定在网格上,因此路径查找会产生更自然的路径。

本章将解释我们如何使用 Unity 内置的 NavMesh 生成器来使 AI 代理的路径查找更加容易和高效。几年前,NavMeshes 是 Unity Pro 的独家功能。幸运的是,这不再是事实;NavMeshes 现在在 Unity 免费版本中对所有用户都可用!

在本章中,我们将涵盖以下主题:

  • 设置地图

  • 建立带有斜坡的场景

  • 创建导航区域

  • Off Mesh Links 概述

技术要求

对于本章,您只需要 Unity3D 2022。您可以在本书存储库的Chapter 8文件夹中找到本章中描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter08。

设置地图

要开始,让我们构建一个简单的场景,如图下所示。这是示例项目中的第一个场景,称为NavMesh01-Simple.scene。您可以使用平面作为地面对象,以及几个立方体实体作为墙壁对象:

![图 8.1 – NavMesh01-Simple 场景的图像,一个带有障碍物的平面]

![img/B17984_08_1.jpg]

图 8.1 – NavMesh01-Simple 场景的图像,一个带有障碍物的平面

在接下来的子章节中,我们将设置墙壁作为障碍物,烘焙 NavMesh,并配置坦克。

导航静态

一旦我们添加了地板和障碍物,就非常重要的是用导航静态标签标记它们,这样 NavMesh 生成器就知道在烘焙过程中需要考虑它们。为此,选择所有对象,点击静态按钮,并选择导航静态,如图下所示:

图 8.2 – 导航静态属性

图 8.2 – 导航静态属性

烘焙 NavMesh

现在我们已经完成了场景,接下来让我们烘焙 NavMesh。为此,请按照以下步骤操作:

  1. 导航到 窗口 | AI | 导航,您应该能看到此窗口:

图 8.3 – 导航窗口

图 8.3 – 导航窗口

信息

导航 窗口中的所有属性都很直观:代理半径 和 代理高度 代表 Unity 用于烘焙 NavMesh 的虚拟代理的大小,最大坡度 是角色可以爬上的最陡坡度的度数,等等。如果我们有多个 AI 代理,我们应该使用最小的 AI 角色的半径和高度来烘焙 NavMesh。有关更多信息,您可以查看以下 Unity 参考文档:docs.unity3d.com/Manual/Navigation.html。

  1. 选择平面,在 对象 选项卡中,将其区域设置为 可通行。

图 8.4 – 导航面板的对象部分

图 8.4 – 导航面板的对象部分

  1. 将其他所有设置保留为默认值,然后点击 烘焙。

  2. 您应该看到一个进度条正在烘焙场景的 NavMesh,过一段时间后,您应该能在场景中看到 NavMesh,如下面的截图所示:

图 8.5 – NavMesh 的烘焙

图 8.5 – NavMesh 的烘焙

到目前为止,我们已经完成了超级简单的场景设置。现在,让我们添加一些 AI 代理来看看它是否工作:

  1. 作为角色,我们使用我们信任的坦克模型。但是,如果您在不同的场景中工作并且有不同的模型,请不要担心。无论模型如何,一切操作都是相同的。

图 8.6 – 坦克实体

图 8.6 – 坦克实体

  1. 将 Nav Mesh Agent 组件添加到我们的坦克实体中。此组件使路径查找变得简单。我们不再需要实现 A* 等路径查找算法。相反,我们只需要在运行时设置组件的目标属性,该组件将使用 Unity 的内部路径查找算法计算路径。

  2. 导航到 组件 | 导航 | Nav Mesh Agent 以添加此组件:

图 8.7 – Nav Mesh Agent 属性

图 8.7 – Nav Mesh Agent 属性

信息

您可以在 docs.unity3d.com/Manual/class-NavMeshAgent.html 找到关于 Nav Mesh Agent 的官方 Unity 参考。

需要注意的一个属性是 区域遮罩 属性。它指定了此 NavMesh 代理可以行走的 NavMesh 层。我们将在 烘焙导航区域 部分讨论导航层。

更新代理的目标

现在我们已经设置了我们的 AI 代理,我们需要一种方法来告诉它去哪里,并将坦克的目的地更新为鼠标点击的位置。

因此,让我们添加一个球体实体,我们将其用作标记对象,然后将Target.cs脚本附加到一个空的游戏对象上。然后,将这个球体实体拖放到检查器中该脚本的targetMarker变换属性。

Target.cs 类

此脚本包含一个简单的类,它执行三个操作:

  • 使用射线获取鼠标点击位置

  • 更新标记位置

  • 更新所有 NavMesh 代理的destination属性

以下行显示了Target类的代码:

using UnityEngine;
using System.Collections;
public class Target : MonoBehaviour { 
    private UnityEngine.AI.NavMeshAgent[] navAgents;
    public Transform targetMarker;
    public float verticalOffset = 10.0f;
    void Start() {
        navAgents = FindObjectsOfType(
           typeof(UnityEngine.AI.NavMeshAgent)) as 
           UnityEngine.AI.NavMeshAgent[];
    }
    void UpdateTargets(Vector3 targetPosition) { 
        foreach (UnityEngine.AI.NavMeshAgent agent in 
                 navAgents) {
            agent.destination = targetPosition;
        }
    }
    void Update() {
        // Get the point of the hit position when the mouse 
        // is being clicked 
        if(Input.GetMouseButtonDown(0)) {
            Ray ray = Camera.main.ScreenPointToRay(
              Input.mousePosition);
            if (Physics.Raycast(ray.origin, ray.direction, 
                out var hitInfo)) {
                Vector3 targetPosition = hitInfo.point;
                UpdateTargets(targetPosition);
                targetMarker.position = targetPosition + 
                  new Vector3(0, verticalOffset, 0);
            }
        }
    }
}

游戏开始时,我们查找所有的NavMeshAgent数组(注意,如果你想在运行时生成新的代理,你需要更新navAgents列表)。然后,每当有鼠标点击事件时,我们进行简单的射线投射以确定射线碰撞的第一个对象。如果光线击中一个对象,我们更新标记的位置,并通过将destination属性设置为新的位置来更新每个 NavMesh 代理的目的地。我们将在这个章节的整个过程中使用这个脚本来告诉我们的 AI 代理目标位置。

现在,测试场景,并点击你想要坦克前往的点。坦克应该尽可能接近该点,同时避开所有静态障碍物(在这种情况下,是墙壁)。

设置带有斜坡的场景

让我们构建一个带有一些斜坡的场景,如下所示:

图 8.8 – 带有斜坡的场景-NavMesh02-Slope.scene

图 8.8 – 带有斜坡的场景-NavMesh02-Slope.scene

一个需要注意的重要事项是斜坡和墙壁应该接触。如果我们想使用 NavMesh,对象需要完美连接。否则,NavMesh 中会有间隙,代理将无法再找到路径。有一个名为Off Mesh Link生成功能来解决类似问题,但我们将在这个章节的使用 Off Mesh Links部分稍后讨论 Off Mesh Links。现在,让我们专注于构建斜坡:

  1. 确保正确连接斜坡:

图 8.9 – 良好连接的斜坡

图 8.9 – 良好连接的斜坡

  1. 我们可以根据我们场景中允许代理旅行的斜坡程度调整导航窗口的烘焙选项卡中的Max Slope属性。这里我们将使用 45 度。如果你的斜坡比这个更陡,你可以使用更高的Max Slope值。

  2. 烘焙场景,你应该已经生成了一个 NavMesh,如下所示:

图 8.10 – 生成的 NavMesh

图 8.10 – 生成的 NavMesh

  1. 我们将放置一些带有Nav Mesh Agent组件的坦克。

  2. 创建一个新的立方体对象,并使用它作为目标参考位置。

  3. 我们将使用之前的Target.cs脚本来更新 AI 代理的destination属性。

  4. 测试运行场景,你应该看到 AI 代理正在穿越斜坡以到达目标。

恭喜你,你已经实现了第一个基于 NavMesh 的基本 AI。现在,你可以实现能够在简单平原上导航的代理。如果我们想要更复杂的场景呢?这就是下一节的主题。

以不同的成本值烘焙导航区域

在具有复杂环境的游戏中,我们通常有一些比其他区域更难以穿越的区域。例如,通过桥梁穿越湖泊比不通过桥梁穿越要简单。为了模拟这种情况,我们希望使穿越湖泊的成本高于使用桥梁。本节将探讨定义不同层级和不同导航成本值的导航区域。

为了这个,我们构建了一个场景,如图图 8.11所示。三个平面代表两个由水面隔开且通过类似桥梁的结构连接的地面平面。正如你所见,穿越水面是最直接穿越湖泊的方式;然而,穿越水面的成本比使用桥梁要高,因此路径查找算法将优先选择桥梁而不是水面:

图 8.11 – 带有层级的场景 – NavMesh03-Layers.scene

图 8.11 – 带有层级的场景 – NavMesh03-Layers.scene

让我们按照一步一步的程序进行,以便我们可以创建一个导航区域:

  1. 前往导航窗口并选择区域部分:

图 8.12 – 导航窗口中的区域部分

图 8.12 – 导航窗口中的区域部分

Unity 自带三个默认层级:默认、不可行走和跳跃,每个层级可能有不同的成本值。

  1. 让我们添加一个新的层级,命名为Water,并给它设置成本为5。

  2. 选择水面。

  3. 前往导航窗口,在对象选项卡中,将导航区域设置为Water:

图 8.13 – 水面层级

图 8.13 – 水面层级

  1. 为场景烘焙 NavMesh 并运行以测试它。

你应该看到 AI 代理现在选择斜坡而不是穿越标记为水面层级的平面,因为穿越水面的成本更高。尝试在水面平面上不同位置放置目标对象。你应该看到 AI 代理有时会游回岸边,有时会走桥梁而不是尝试穿越水面。

信息

你可以在 Unity 官方文档中找到关于NavMesh 区域的说明,网址为docs.unity3d.com/Manual/nav-AreasAndCosts.html。

使用 Off Mesh Links 连接区域之间的间隙

有时,场景中可能会有一些间隙,这会使导航网格断开。例如,如果我们将斜坡与墙壁连接得不够紧密,那么在先前的示例中,代理将找不到路径,因此我们需要使其能够跳过这样的间隙。在另一个示例中,我们可能希望设置一些点,让我们的代理可以从墙上跳到下面的平面上。Unity 有一个名为离网链接的功能来连接这样的间隙。离网链接可以手动设置或由 Unity 的导航网格生成器自动生成。

这里是我们将在本例中构建的场景。如图 图 8.14 所示,两个平面之间有一个小间隙。

图 8.14 – 带有离网链接的场景 – NavMesh04-OffMeshLinks.scene

图 8.14 – 带有离网链接的场景 – NavMesh04-OffMeshLinks.scene

在本节中,我们将学习如何使用离网链接连接这两个平面。

生成的离网链接

首先,我们使用自动生成的离网链接连接两个平面。为此,我们需要遵循以下步骤:

  1. 在属性检查器中将这两个平面标记为离网链接生成和静态,如图所示:

图 8.15 – 离网链接生成和静态

图 8.15 – 离网链接生成和静态

  1. 前往导航窗口,查看烘焙选项卡上的属性。您可以设置距离阈值来自动生成离网链接:

图 8.16 – 生成的离网链接属性

图 8.16 – 生成的离网链接属性

  1. 点击烘焙,您应该会看到连接两个平面的离网链接,如下所示:

图 8.17 – 生成的离网链接

图 8.17 – 生成的离网链接

  1. 现在,我们的 AI 代理可以在两个平面之间找到路径。但首先,确保在导航网格代理组件的区域遮罩属性中启用了坦克的跳跃功能,如图 图 8.18 所示:

图 8.18 – 坦克的区域遮罩配置

图 8.18 – 坦克的区域遮罩配置

如果一切正常,代理一旦到达平面的边缘并找到离网链接组件,就会基本上跳到另一个平面上。但当然,如果我们不希望代理跳跃(毕竟,谁见过会跳跃的坦克?),我们应该为代理搭建一座桥来跨越。

手动离网链接

如果我们不想在边缘生成离网链接,而是希望代理在传送到另一侧之前到达某个点,那么我们需要手动设置离网链接,如图 图 8.19 所示:

图 8.19 – 手动离网链接设置

图 8.19 – 手动离网链接设置

执行以下步骤以手动设置离网链接:

  1. 我们初始化一个场景,两个平面之间有一个显著的间隙。然后,我们在平面的每一侧放置两对球体实体。

  2. 选择一个球体,通过导航到组件 | 导航 | Off Mesh Link来添加一个Off Mesh Link组件。我们只需要将这个组件添加到一个球体上。

  3. 接下来,将第一个球体拖放到开始属性,将另一个球体拖放到结束属性:

![Figure 8.20 – Off Mesh Link 组件

![img/B17984_08_20.jpg]

图 8.20 – Off Mesh Link 组件

  1. 前往导航窗口并烘焙场景。

![Figure 8.21 – 手动生成的 Off Mesh Links

![img/B17984_08_21.jpg]

图 8.21 – 手动生成的 Off Mesh Links

  1. 现在的手动Off Mesh Links连接了两个平面,AI 代理可以使用它们穿越地形,即使在存在间隙的情况下。

    信息

    你可以在 Unity 的官方文档中找到关于 Off Mesh Links 的参考:docs.unity3d.com/Manual/nav-CreateOffMeshLink.html。

这个最后的演示结束了我们对 Unity 的 NavMeshes 的探索。你现在应该已经了解了这个对 AI 角色开发至关重要的工具的所有基础知识。

概述

在本章中,我们学习了如何生成和使用 NavMeshes 来实现游戏中的路径查找。首先,我们研究了如何设置具有不同路径查找成本的导航层。然后,使用目标属性,我们使用Nav Mesh Agent组件找到路径并移动到目标。接下来,我们设置了 Off Mesh Links,使用自动生成功能和带有Off Mesh Link组件的手动设置来连接 NavMeshes 之间的间隙。

在有了所有这些信息之后,我们现在可以轻松地创建具有合理复杂 AI 的简单游戏。例如,你可以尝试将 AI 坦克的目标属性设置为玩家坦克的位置,并让它们跟随它。然后,使用简单的有限状态机(FSMs),一旦它们达到一定距离,它们就可以开始攻击玩家。FSMs 已经带我们走得很远,但它们有其局限性。在下一章中,我们将学习关于行为树(Behavior Trees)以及我们如何使用它们在甚至是最复杂的游戏中做出 AI 决策。

第三部分:高级 AI

在本部分,我们将学习更多用于创建角色行为和决策能力的复杂技术,包括行为树和由机器学习驱动的智能体。

在本部分,我们将涵盖以下章节:

  • 第九章, 行为树

  • 第十章, 程序内容生成

  • 第十一章, Unity 中的机器学习

  • 第十二章, 整合所有内容

第九章:行为树

在前一章中,我们看到了实现和管理角色状态和行为的基本但有效的方法:有限状态机(FSMs)。FSMs 易于实现且直观,但它们有一个致命的缺陷:一旦有多个状态和转换,就很难进行扩展。例如,想象一个根据其健康和魔法值(高、中、低)表现不同的角色。我们有一个状态,其中健康和魔法值都高,一个状态是健康中等而魔法值高,一个状态是两者都中等,以此类推。仅这些状态就有九种。如果我们添加其他条件(如玩家接近度、一天中的时间、装备、玩家的得分或你可以想象的其他任何条件),状态的数量将以指数级增长。

幸运的是,我们有一个解决方案:行为树(BTs)。本质上,BTs 只是另一种可视化复杂 FSMs 的方法,但它们速度快,提供可重用性,且易于维护。自 2004 年随着Halo 2的引入,它们迅速成为游戏中的首选决策技术。

本章我们将做以下工作:

  • 探索 BTs 的基本原理,这些知识你可以将其转移到任何适用于 Unity(或其他游戏引擎)的 BT 插件

  • 基于流行的免费 Unity 插件 BTs(行为砖块)实现一个小型演示:行为砖块

技术要求

对于本章,你需要 Unity3D 2022 和免费的 Unity 插件,行为砖块。不用担心,我们将一起看看如何安装这个插件。你可以在本书仓库中的第九章文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter09。

BTs 简介

BT(行为树)是一个控制 AI 角色行为流程的节点层次树。它也可以用来协调角色组(例如,模拟小部队的攻击模式),甚至无形的代理,如 AI 故事导演。

当我们执行 BT 的节点时,节点可以返回三种状态:成功、失败或运行中(如果节点的执行跨越多个帧,例如,如果它在播放动画)。当 BT 执行器运行树时,它从根节点开始,按照节点本身写入的规则顺序执行每个节点。

节点可以是三种类型之一:

  • 任务(无子节点的节点),也称为叶节点。

  • 装饰器(具有单个子节点的节点)

  • 组合(具有多个子节点的节点)

通常,叶子代表角色可以执行或知道的操作(这就是为什么它们通常被称为动作或任务);它们可能是GoToTarget、OpenDoor、Jump或TakeCover等动作,也可能是IsObjectNear?或IsHealthLow?等事物。这些操作取决于角色、游戏以及一般的游戏实现。

装饰器是一个修改(装饰)其下子树的节点(因此,它可以装饰复合节点和任务节点)。例如,一个标准的装饰器是否定节点。该节点反转子树的返回值;例如,如果子树返回成功,则装饰器返回失败,反之亦然(当然,如果子树返回运行中,则装饰器也返回运行中)。另一个常见的装饰器是重复,它重复其子树一定次数。

相反,一个复合节点代表一个具有多个子节点的节点,这是最有趣的情况。有两种常见的复合节点:序列,它按顺序运行其所有子节点,并且只有当所有子节点都返回成功时才返回成功,以及选择器,它尝试按顺序执行其所有子节点,但只要其子节点之一返回成功,就返回成功。然而,许多 BT 实现包含许多更多的复合节点(例如,并行运行其子节点或根据某些动态优先级值运行的节点;我们将在演示中看到一个这样的节点的例子)。

当然,这种树结构还不够。节点需要相互交换信息或与游戏世界交换信息。例如,GoToTarget节点需要知道目标及其位置;IsObjectClose?节点需要知道我们指的是哪个对象以及我们认为多近的距离是接近的。自然地,我们可以为游戏中的每个对象编写一个GoToX节点(例如GoToTree01和GoToDoor23),但你很容易想象这会很快变得混乱。

因此,所有 BT 实现都包含一个称为黑板的数据结构。就像现实生活中的物理黑板一样,每个节点都可以将其数据写入其中并从中读取;我们只需指定每个节点查找的位置。

一个简单的例子 - 巡逻机器人

让我们看看这个例子(我们将在 Unity 中稍后实现)。想象一个巡逻机器人,它会射击靠近它的任何东西,但只在白天工作。我们在以下图中展示了这种代理的可能 BT:

![图 9.1 - 简化日间巡逻机器人的示例 BT

![img/B17984_09_1.jpg]

图 9.1 - 简化日间巡逻机器人的示例 BT

让我们运行这个 BT,假设目标很近,而且不是夜晚:

  1. 第一个节点是一个重复装饰器;它什么都不做,只是循环 BT,因此现在我们可以忽略它。

  2. 选择器节点开始执行其第一个子节点;我们向左下移动。

  3. 我们现在位于第一个Sequence节点;再次,我们执行第一个节点。IsNight?返回失败(因为现在不是夜晚!)。每当一个节点返回失败时,整个Sequence节点也会返回失败。

  4. 我们回到树的SELECTOR节点;现在,我们进入第二个分支。

  5. 再次,我们执行Sequence。

  6. 然而,这次IsTargetClose?返回成功,因此我们可以继续到下一个节点,Shoot,它运行一个游戏函数生成游戏中的投射物。

Sequence | Condition | Action的模式等同于如果Condition是成功,则Action。这种模式非常常见,许多 BT 实现都允许你将Condition和Action一起堆叠。因此,我们可以将树重写如下:

![Figure 9.2 – 简化的 BT

![img/B17984_09_2.jpg]

Figure 9.2 – 简化的 BT

这个树与上一个相同,但有一个简化的 Sequence 模式。

使用 Behavior Bricks 在 Unity 中实现 BT

Behavior Bricks是西班牙马德里康普顿塞大学开发的一个强大但免费的 Unity BT 实现。使用 Behavior Bricks,你可以在项目中开始使用 BT,而无需从头开始实现 BT。它还包含一个可视化编辑器,你可以在这里拖放并连接节点,而无需任何额外的代码。

按照以下步骤安装 Behavior Bricks:

  1. 我们需要通过访问网站 https://assetstore.unity.com/来进入Unity 资产商店。

  2. 搜索Behavior Bricks。

  3. 点击添加到我的资产。一旦完成,我们就可以将其导入到我们的项目中。

![Figure 9.3 – Behavior Bricks 资产商店主页

![img/B17984_09_3.jpg]

Figure 9.3 – Behavior Bricks 资产商店主页

  1. 前往包管理器(窗口 | 包管理器)。

  2. 前往我的资产。

![Figure 9.4 – 包管理器窗口

![img/B17984_09_4.jpg]

Figure 9.4 – 包管理器窗口

  1. 通过点击导入按钮导入Behavior Bricks包。

![Figure 9.5 – Behavior Bricks 在包管理器中

![img/B17984_09_5.jpg]

Figure 9.5 – Behavior Bricks 在包管理器中

到目前为止,Behavior Bricks 已经准备就绪,我们可以继续我们的演示。以下步骤为您提供了遵循的步骤的简要概述:

  1. 设置场景。

  2. 实现日夜循环。

  3. 设计敌人行为。

  4. 实现节点。

  5. 构建树。

  6. 将 BT 附加到敌人上。

现在,让我们逐个查看这些步骤。

设置场景

让我们按照以下步骤一步步进行:

  1. 我们首先将游戏对象添加到场景中。我们在场景中添加了一个大平面,添加了一个包围整个平面的Box Collider,并将其命名为Floor(如果你喜欢,也可以添加纹理;发挥创意,这有助于在简单的演示中享受乐趣)。

![Figure 9.6 – 地板盒碰撞体的示例

![img/B17984_09_6.jpg]

Figure 9.6 – 地板盒碰撞体的示例

  1. 我们添加了一个球体和一个立方体;我们将球体称为 Player,将立方体称为 Enemy。在 Enemy 中,我们添加了另一个空对象并将其移动到立方体外部。我们称它为 shootPoint,它代表敌人射击的占位符。

  2. 然后,将这些所有对象放置在地板上;你应该有类似以下的内容:

图 9.7 – 我们演示的场景

img/B17984_09_7.jpg

图 9.7 – 我们演示的场景

  1. 现在,因为我们想让玩家和敌人四处移动,我们需要创建一个 NavMesh,如第八章,导航网格中所述。请记住将 NavMesh Agent 组件添加到 Player 和 Enemy 上!

  2. 最后,如果它不存在,请将 MainLight 标签添加到 Direct Light 对象上。

实现昼夜循环

在这个演示中,我们想要实现一个基本的昼夜循环。为了做到这一点,我们将脚本 DayNightCycle.cs附加到 Direct Light 对象上。就像这个演示中的许多脚本一样,我们从 Behavior Bricks 提供的 快速入门指南 中改编了代码:

using UnityEngine;
public class DayNightCycle : MonoBehaviour {
    public event System.EventHandler OnChanged;
    public float dayDuration = 10.0f;
    public bool IsNight { get; private set; }
    public Color nightColor = Color.white * 0.1f;
    private Color dayColor;
    private Light lightComponent;
    void Start() {
        lightComponent = GetComponent<Light>();
        dayColor = lightComponent.color;
    }
    void Update() {
        float lightIntensity = 0.5f + Mathf.Sin(Time.time *
          2.0f * Mathf.PI / dayDuration) / 2.0f;
        bool shouldBeNight = lightIntensity < 0.3f;
        if (IsNight != shouldBeNight) {
            IsNight = shouldBeNight;
            // Invoke event handler (if set).
            OnChanged?.Invoke(this,
              System.EventArgs.Empty); 
        }
        lightComponent.color = Color.Lerp(nightColor,
          dayColor, lightIntensity);    }
}

此脚本实现了一个典型的昼夜循环。它的工作方式相当直观。让我们看看:

  • 在每个 Update 步骤中,我们根据正弦波更新 lightIntensity 变量。

  • 变量从 0 到 1 循环,当值小于 0.3 时,我们决定它是夜晚。

  • 最后,我们根据 lightIntensity 值更新灯光颜色,插值白天和夜晚的颜色。

  • 注意 onChanged 事件。我们每次从白天切换到夜晚,以及从夜晚切换到白天时都会调用它。稍后,我们使用此事件在 BT 中创建一个 IsNight 节点。

设计敌人行为

现在,是时候设计敌人行为。在编写任何代码之前,我们需要这样做。对于这个演示,我们将改编 Behavior Bricks 快速入门指南 中提供的示例项目中的代码和资源。有关更多信息,您可以参考此 URL:bb.padaonegames.com/doku.php?id=quick:program。

图 9.8 – 我们要实现的 BT 目标

img/B17984_09_8.jpg

图 9.8 – 我们要实现的 BT 目标

图 9.8 中的 BT 描述了以下行为:

  • 如果是夜晚,敌人将被禁用。

  • 如果目标非常近,敌人就会射击目标。

  • 如果目标更远,敌人会追逐目标。

  • 否则,敌人只是在四处游荡。

有两点需要注意:

  • 首先,两个 IsTargetClose? 节点在我们认为接近的值上有所不同。特别是,我们只有在接近目标时才射击目标;否则,我们只是开始追逐它。

  • 第二点,也是最重要的一点,节点的顺序很重要。因为 Selector 从左到右工作,并在第一个 Success 处停止,所以我们不能在 Shoot 之前放置 ChaseTarget。否则,敌人将永远不会射击!

作为一条经验法则,我们需要按从高到低的优先级顺序排列条件。实际上,在示例中,我们将执行当所有其他操作都失败时的动作(AlwaysTrue是一个总是成功的条件,它就像一个 if 条件中的 else 分支)放在最后。

注意,Wander以不同的颜色显示,因为它不是一个节点,而是一个 BT。BT 的可爱特性之一是你可以将常见的 BT 作为节点重用于更复杂的 BT 中。Wander BT 简单地让敌人随机在地图上移动;幸运的是,行为砖块已经包含了它,所以我们不需要实现它!

实现节点

在我们为我们的 BT(行为树)制定计划之后,下一步是检查我们选择的 BT 实现(在我们的案例中,是行为砖块)是否已经包含我们需要的节点。当然,我们希望尽可能多地重用预制的节点。阅读行为砖块的文档,我们可以看到它已经包含了诸如IsTargetClose、MoveToGameObject、Wander和AlwaysTrue等节点,当然,还有Repeat和Selector。

因此,我们需要编写所有其他任务。请注意,行为砖块的任务不是 MonoBehaviors;因此,我们不需要将它们附加到场景中的某个对象上。我们只需要将脚本放在我们项目资源中的任何文件夹中,就可以了。让我们一步一步地看看如何做:

  1. 让我们从项目资源中的ShootOnce.cs文件开始。首先,我们创建一个简单的Action属性,命名为ShootOnce,正如其名,它发射一颗子弹:

    using UnityEngine;
    using Pada1.BBCore;
    using Pada1.BBCore.Tasks;
    using BBUnity.Actions;
    [Action("Chapter09/ShootOnce")]
    [Help("Clone a 'bullet' and shoots it through the Forward axis with the specified velocity.")] 
    public class ShootOnce : GOAction {
        // ….
    }
    

在开始时,我们导入行为砖块模块。然后,我们通过扩展通用的GOAction类来创建ShootOnce类。

注意类属性;行为砖块使用它们来填充 BT 可视化编辑器。在Action属性中,我们指定Action是一个动作,并将其放入Chapter09集合中,命名为ShootOnce。Help属性只是一个描述动作目的的文档字符串。

  1. 我们像往常一样描述类属性。唯一的区别是,我们用InParam属性装饰每个属性,该属性指定 BT 执行器需要从黑板中检索以下值:

    [InParam("shootPoint")] 
    public Transform shootPoint;
    [InParam("bullet")] 
    public GameObject bullet;
    [InParam("velocity", DefaultValue = 30f)] 
    public float velocity;
    

对于这个动作,我们需要一个Bullet预制体,一个实例化子弹的位置(shootPoint)以及子弹的速度。稍后,我们将看到如何从可视化界面设置它们。

  1. 现在,是时候编写真正的核心内容了:

    public override void OnStart() {
        if (shootPoint == null) {
            shootPoint = 
              gameObject.transform.Find("shootPoint");
            if (shootPoint == null) {
                Debug.LogWarning("Shoot point not 
                  specified. ShootOnce will not work for "
                  + gameObject.name);
            }
        }
        base.OnStart();
    }
    public override TaskStatus OnUpdate() {
        if (shootPoint == null || bullet == null) {
            return TaskStatus.FAILED;
        }
        GameObject newBullet = Object.Instantiate(
            bullet, shootPoint.position, 
            shootPoint.rotation *
            bullet.transform.rotation );
        if (newBullet.GetComponent<Rigidbody>() == null) {
            newBullet.AddComponent<Rigidbody>();
        }
        newBullet.GetComponent<Rigidbody>().velocity = 
          velocity * shootPoint.forward;
        return TaskStatus.COMPLETED;
    }
    

每个行为砖块节点都包含一些在 BT 执行期间调用的默认方法。我们可以在自定义实现中覆盖它们。在这个例子中,我们看到两个:OnStart和OnUpdate。它们的使用方式与我们在MonoBehavior中使用Start和Update非常相似:

  • BT 执行器在游戏创建 BT 时调用OnStart。在其中,我们初始化所有需要的引用。在这种情况下,我们获取到shootPoint对象的引用。注意,我们还必须调用base.Onstart()来初始化基类。

  • 在OnUpdate中,我们为节点编写预期的动作,即当 BT 执行器调用它时,我们希望这个节点做什么。在这种情况下,代码是自解释的:我们创建一颗子弹,并以设置中存储的速度射击它。

如果没有问题,我们将节点标记为完成(这样 BT 就知道它是一个成功),否则(例如,如果没有shootPoint值),我们将节点标记为失败。

  1. 现在我们已经有一个射击一次的基类,我们可以创建一个新的用于连续射击的Action属性。让我们创建一个包含以下内容的Shoot.cs文件:

    Using UnityEngine;
    using Pada1.BBCore
    using Pada1.BBCore.Tasks;
    [Action("Chapter09/Shoot")]
    [Help("Periodically clones a 'bullet' and shoots it through the Forward axis with the specified velocity. This action never ends.")]
    public class Shoot : ShootOnce {
        [InParam("delay", DefaultValue = 1.0f)]
        public float delay;
        // Time since the last shoot.
        private float elapsedTime = 0;
        public override TaskStatus OnUpdate() {
            if (delay > 0) {
                elapsedTime += Time.deltaTime;
                if (elapsedTime >= delay) {
                    elapsedTime = 0;
                    return TaskStatus.RUNNING;
                }
            }
            base.OnUpdate();
            return TaskStatus.RUNNING;    }
    }
    

这个类简单地扩展了ShootOnce类,添加了一个delay属性(连续射击之间的时间),然后连续重新运行其父类(ShootOnce)。注意,这个Action始终返回RUNNING,这意味着只要 BT 选择它,它就永远不会完成。

  1. 同样地,我们可以创建剩余的Action属性。例如,SleepForever动作非常简单:它只是什么也不做,并暂停 BT 的执行。注意,该类扩展了BasePrimitiveAction,这是 Behavior Bricks 中Action的最基本形式:

    using Pada1.BBCore;
    using Pada1.BBCore.Framework;
    using Pada1.BBCore.Tasks;
    [Action("Chapter09/SleepForever")]
    [Help("Low-cost infinite action that never ends. It does not consume CPU at all.")]
    public class SleepForever : BasePrimitiveAction {
        public override TaskStatus OnUpdate() {
            return TaskStatus.SUSPENDED;
        }
    }
    
  2. 最后,我们需要实现IsNightCondition。我们在下面的列表中展示了IsNightCondition的代码:

    using Pada1.BBCore;
    using Pada1.BBCore.Framework;
    using Pada1.BBCore.Tasks;
    using UnityEngine;
    [Condition("Chapter09/IsNight")]
    [Help("Checks whether it is night time.")] 
    public class IsNightCondition : ConditionBase {
        private DayNightCycle light;
        public override bool Check() {
            return SearchLight() && light.IsNight;
        }
        public override TaskStatus 
          MonitorCompleteWhenTrue() {
            if (Check()) {
                return TaskStatus.COMPLETED;
            }
            if (light != null) {
                light.OnChanged += OnSunset;
            }
            return TaskStatus.SUSPENDED;
        }
        public override TaskStatus MonitorFailWhenFalse()
        {
            if (!Check()) {
                return TaskStatus.FAILED;
            }
            light.OnChanged += OnSunrise;
            return TaskStatus.SUSPENDED;
        }
    /// ...
        private bool searchLight() {
            if (light != null) {
                return true;
            }
            GameObject lightGO = 
              GameObject.FindGameObjectWithTag(
              "MainLight");
            if (lightGO == null) {
                return false;
            }
            light = lightGO.GetComponent<DayNightCycle>();
             return light != null;
        }
    }
    

这个类比其他类更复杂,所以让我们慢慢来。首先,IsNightCondition扩展了ConditionBase,这是 Behavior Bricks 中的一个基本条件模板。这个类做一件简单的工作:在开始时,它搜索带有MainLight标签的光源。如果存在,它获取其DayNightCycle引用,将其存储在light变量中,并注册到OnChanged事件。然后,每次我们请求这个条件时,我们检查light中的isNight变量是true还是false(见Check方法)。

然而,每次都检查这会很低效,通常情况下。因此,BaseCondition类包含两个有用的函数:

  • MonitorCompleteWhenTrue是一个函数,当 BT 执行器返回最后一个值是false时被调用,实际上,它设置了一个系统,在变量再次变为true之前暂停 BT 执行。

  • MonitorFailWhenFalse是一个双重功能:当被监控的值为true时被调用,并暂停 BT 执行,直到变量切换到false。

例如,让我们看看 MonitorCompleteWhenTrue。如果 Check 是 true(因此是夜晚),我们只需简单地返回 Complete;否则,我们将 OnSunset 函数与 OnChanged 事件注册。当昼夜循环从白天切换到夜晚时,调用 OnSunset,然后调用 EndMonitorWithSuccess。MonitorFailWhenFalse 以相同的方式工作,但方向相反(监控我们从夜晚过渡到白天):

    public void OnSunset(object sender, 
                         System.EventArgs night) {
        light.OnChanged -= OnSunset;
        EndMonitorWithSuccess();
    }
    public void OnSunrise(object sender, 
                          System.EventArgs e) {
        light.OnChanged -= OnSunrise;
        EndMonitorWithFailure();
    }

在前面的代码块中,包含了类中包含的两个 OnSunset 和 OnSunrise 事件处理器。像往常一样,您可以在本书的仓库中找到完整的带注释的代码。

构建树

现在我们有了我们的节点,我们需要组装树。为此,请按照以下步骤操作:

  1. 在 检查器 中右键单击,然后转到 创建 子菜单。

  2. 然后,选择 行为树。

  3. 选择一个位置并保存。

  4. 应该在屏幕上显示一个空白的编辑器窗口;这是树编辑器。

  5. 您可以在任何位置右键单击并开始添加和连接节点。

  6. 要实现我们的树,您需要重新创建以下截图所示的树:

图 9.9 – 在行为砖块编辑器中的敌人 BT

图 9.9 – 在行为砖块编辑器中的敌人 BT

  1. 逐个选择所有节点,查找输入参数;这些是我们类中指定的参数。这些参数可能是 CONSTANT,意味着我们直接为它们写入一个值,或者是一个 BLACKBOARD 引用。

  2. 我们需要设置以下值的参数:

    • 在第一个 IsTargetClose 中,我们将黑板玩家指定为 target,将常数 7 指定为 closeDistance(如果玩家未列出,请单击 IsTargetClose,我们将黑板玩家指定为 target,将常数 20 指定为 closeDistance)。

    • 在 Shoot 中,我们需要将延迟设置为 30,将黑板 shootPoint 设置为 shootPoint(您可能需要使用 bullet 预制件创建它,并将常数 30 设置为速度。

    • 在 MoveToGameObject 中,目标是黑板中的玩家值。

  3. 在 Wander 中,我们将一个新的黑板参数(floor)设置为 wanderArea。

将 BT 附接到敌人上

现在,是时候将此 BT 附接到敌人的 BT 执行器上了。为此,请按照以下步骤操作:

  1. 选择 敌人 游戏对象,并向其添加 行为执行器 组件。

  2. 在 行为 字段中,拖放我们之前创建的 BT。

  3. 在 player、floor、敌人的 shootPoint 射击位置和 bullet)应该出现。

  4. 按照如图 图 9.10 所示填充适当的对象:

图 9.10 – 行为执行器组件

图 9.10 – 行为执行器组件

到目前为止,敌人应该已经准备好了。点击播放,你应该看到敌人四处游荡,当接近玩家时,开始追逐并射击。请注意,我们没有为玩家实现控制器,因此,要改变其位置,您需要编辑场景视图中的玩家(或附加我们在前几章中开发的控制脚本之一)。有关更多详细信息,请参阅本书中包含的代码。

现在我们已经完成了第一个行为树(BT),如果我们想使用有限状态机(FSM)来复制在第二章中开发的相同 AI,使用行为砖块(Behavior Bricks)应该怎么做?把这作为一个练习尝试一下。

摘要

在本章中,我们探讨了任何 BT 实现背后的通用背景。我们看到了 BT 是什么,它的基本组件是什么,以及我们如何使用 BT 来描述游戏角色的行为。然后,我们使用一个名为行为砖块(Behavior Bricks)的免费插件实现了演示。在演示中,我们为简单场景创建了行为:玩家和巡逻机器人。我们还实现了一个日夜循环来增加场景的趣味性。

BT 是现代游戏角色 AI 的基石。实现细节和更深入的例子需要一本书来完全解释。幸运的是,网络上有许多资源供好奇的读者参考。

现在,我们将从 AI 角色设计转向 AI 在游戏中的不同应用。在下一章中,我们将探讨程序内容生成的迷人领域。

进一步阅读

第十章:程序内容生成

游戏人工智能不仅用于告诉 NPC 去哪里或做什么。我们还可以使用游戏 AI 来创建我们游戏的部分,生成资产或音乐,像电影导演一样调整游戏故事以适应玩家的行动,甚至完全生成叙事弧和角色背景故事。在通用人工智能领域,这是计算创造力的主题,它是关注设计算法以增强人类创造力或完全自动化需要人类水平创造力的任务的 AI 的一个分支。

计算机创造力的范围广泛且处于前沿。它始于 1952 年,当时艾伦·图灵编写了第一个能够生成情书的算法。今天,它继续发展,强大的机器学习算法试图写诗、创作交响乐或制作惊人的视觉艺术作品。

幸运的是,对于游戏来说,我们感兴趣的只是这个学科的一个更小的子集。我们并不感兴趣于产生具有人类水平创造力的算法(与此努力相关的所有哲学问题)。相反,我们只想编写能够自动扩展我们游戏内容的算法,无论是通过生成成千上万的随机地下城、数百种新武器、外星植物和动物的模型,还是其他任何内容。这被称为程序内容生成(PCG),它是视频游戏自动化的一个主要角色。

在本章中,我们将涵盖以下主题:

  • 理解视频游戏中 PCG 的基本概念

  • 通过实现 Goblin NPC 名称的随机生成器来尝试接触 PCG

  • 实现简单的洞穴/地下城生成器

技术要求

对于本章,你只需要 Unity3D 2022。你可以在本书的仓库中的第十章文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter10。

理解游戏中的程序内容生成

如介绍中所述,我们指的是所有可以使用 PCG 算法在运行时生成游戏内容的算法。一个 PCG 算法可以创建关卡设计、武器、图形资产、音乐主题、敌人、NPC、角色的背景故事,以及你所能想到的任何其他内容。如果你思考任何游戏中的元素,都有可能至少有一个游戏尝试过以程序化的方式生成它。但为什么你应该这样做呢?

现在,对于公众来说,PCG(过程式内容生成)已经成为了随机的同义词。许多游戏通过宣传拥有过程式生成的关卡来表明它们提供了数千种不同的关卡,每次游玩都会发生变化。虽然 PCG可能表示某种因果关系的过程,但值得注意的是,这仅仅是 PCG 景观的一部分(即使,可能,最具市场价值的)。更确切地说,PCG 是随机性的对立面:它是一种非常确定性地从一个种子开始并产生一些内容的算法(但,当然,如果我们使用一个随机的种子,我们就会得到随机的输出)。

PCG 有两个主要的使用场景:

  • 第一个场景是使用 PCG 来生成在开发期间无法预先生成的持久内容。如果内容太大无法存储在文件中,或者手动生成需要太多的努力,我们可能会有这种需求。例如,原始的太空模拟游戏精英(1985 年)使用 PCG 在仅 32 KB 的空间中存储了 8 个包含 256 颗星星的星系(除了游戏代码)。随着可用磁盘空间的增加,这种用法不再是最大的。然而,仍然可能找到用途。2014 年发布的精英新版本,称为精英:危险,使用了相同的方法来表示一个真实规模的银河系副本,拥有令人惊叹的 4000 亿个完全可探索的星系。请注意,这里没有随机性:星系是持久的,所有玩家在游戏中共享它。在磁盘上存储每个星系的单独数据将是不可能的。

    更多信息

    你可以在以下 URL 找到对原始精英游戏生成算法的启发性和令人兴奋的分析:www.gamedeveloper.com/design/algorithms-for-an-infinite-universe。

  • 第二个是最常见的使用场景:通过在每次游玩时随意生成内容,为游戏增加多样性和可玩性。类似 Rogue 的游戏普及了这种 PCG 用法,但无疑,使用 PCG 在每次新运行时创建不同随机世界的最成功的电子游戏是 Minecraft。有了 PCG,你不需要手动制作每个关卡,也不需要设计数百个不同的关卡:你只需要指定规则,然后让软件自动生成各种关卡或武器。

现在我们已经了解了为什么,让我们探索一些不同的 PCG 算法类型。

过程式内容生成的种类

在游戏开发漫长的历史中,PCG 被用于各种各样的任务。因此,我们可以确定 PCG 的六个应用:

  • 运行时内容生成:这是我们听到 PCG 时本能想到的类型。它包括在运行时生成游戏内容。在Minecraft中创建随机世界或在Diablo中创建随机地图和武器的例子是这一类别的典型示例。

  • 离线内容生成:这是我们开发过程中使用的 PCG 类型。即使我们并不打算给玩家提供探索随机生成世界的功能,PCG 对于设计师和开发者来说仍然很有用。例如,如果我们创建了一片森林,我们可以使用 PCG 来创建不同形状的 3D 树木模型(SpeedTree是用于此目的的标准工具)。我们还可以使用 PCG 来启动级别的手动设计。假设我们想要设计一个岛屿。我们可能从生成一个简单的随机 PCG 岛屿开始,然后选择最让我们有灵感的那个,最后对其进行手动编辑和建模,以创建最终将在游戏中发布的岛屿。PCG 在设计工具中的其他应用很多,但这些都超出了本章的范围。

  • 玩家介导的内容生成:这类 PCG 算法将玩家的输入作为随机性的来源。

  • 动态系统:这种类型的 PCG 通过模拟动态系统来生成 NPC 的行为和叙事背景。一个显著的例子是游戏 S.T.A.L.K.E.R. 中的 A-Life 系统。在游戏中,A-Life 系统模拟了游戏世界中数千名居民的生命周期。因此,该系统提供了无限的非脚本化角色供玩家互动,以及无限的支线任务。

但现在就足够理论了。让我们开始编码。

实现一个简单的哥布林名字生成器

在上一节中,我们解释了 PCG 的主要目的是在提供多样性的同时,从开发者手中移除手动编写这种多样性的负担。所以,想象一下我们正在开发一款老式 RPG 游戏,我们希望玩家能够与哥布林营地中的 NPC 角色互动。

在营地中,有成百上千的哥布林,我们真的不想为每一个哥布林想出一个名字和职业。这不仅因为无聊且耗时,而且如果我们打算在游戏世界中与哥布林进行随机遭遇,我们需要有能力即时创建新的哥布林。

幸运的是,我们有一个更有趣(对我们来说)的解决方案:编写一个生成大量随机哥布林角色的算法。

生成哥布林名字

为了生成某些东西,我们需要找到某种类型的 生成规则。为了找到这样的规则,最好的办法是查看我们想要生成的不同示例,并试图找出是否有一些模式将它们联系起来。例如,对于哥布林名字,我们可以从《魔兽世界》中的一大堆哥布林名字中寻找灵感。

让我们来看看其中的一些:Grizzle Gearslip、Hobart Grapplehammer、Helix Blackfuse。继续这个列表,我们可能会发现一个共同的模式:

  • 名字由两个或三个音节组成。

  • 这些音节有相似的声音,例如 Bax、Griz、Hel、Hob 等等。

  • 姓氏总是由一个物体或形容词(齿轮、钩爪、黑色、螺栓)加上一个动词组成。

  • 姓氏的主题通常与机械工程相关。

这就足够开始了。我们创建一个新的场景,并创建一个名为 GoblinNameGenerator 的新脚本,并将以下代码粘贴进去:

class GoblinNameGenerator {
    static string[] NameDatabase1 = { "Ba", "Bax", "Dan", 
      "Fi", "Fix", "Fiz", }; //... and more 
    static string[] NameDatabase2 = { "b", "ba", "be",
      "bi", "d", "da", "de","di", }; // ... and more 
    static string[] NameDatabase3 = { "ald", "ard", "art",
      "az", "azy", "bit","bles", "eek", "eka", "et",
      "ex", "ez", "gaz", "geez", "get", "giez",
      "iek", }; // ... and more
    static string[] SurnameDatabase1 = { "Bolt", "Boom",
      "Bot", "Cog", "Copper","Damp", "Dead", "Far", "Fast",
      "Fiz", "Fizz", "Fizzle", "Fuse", "Gear",
      "Giga", "Gold", "Grapple" }; // ... and more
    static string[] SurnameDatabase2 = { "basher", "blade",
      "blast", "blaster","bolt", "bomb", "boot", "bottom",
      "bub", "button", "buttons", "cash",
      "clamp", };  // ... and more
    private static string RandomInArray(string[] array) {
        return array[Random.Range(0, array.Length)];
    }
    public static string RandomGoblinName() {
        return RandomInArray(NameDatabase1) + 
          RandomInArray(NameDatabase2) +
            RandomInArray(NameDatabase3) + " " +
            RandomInArray(SurnameDatabase1) + 
            RandomInArray(SurnameDatabase2);
    }
}

这段代码直接将哥布林名字的规则转换为程序算法。NameDatabase1、NameDatabase2 和 NameDatabase3 数组包含名字的第一个、中间和最后一个音节。同样,SurnameDatabase1 和 SurnameDatabase2 包含哥布林姓氏的两个部分。为了生成名字,我们从每个列表中随机选择一个片段,并将所有内容组合在一起。

完成哥布林描述

现在我们有了名字,我们只需要其他一些小细节。所以,让我们创建一个空对象,并将其一个名为 GoblinWriter 的新 MonoBehavior 实例附加到它上。

这个新脚本包含以下代码:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class GoblinWriter : MonoBehaviour {
    public TMPro.TextMeshProUGUI textMesh;
    public List goblinJobs;
    public int goblinMaxAge = 200;
    void Start() {
        UpdateString();
    }
    void Update() {
        if (Input.GetKeyDown(KeyCode.Space)) {
            UpdateString();
        }
    }
    void UpdateString() {
        string goblinName =
          GoblinNameGenerator.RandomGoblinName();
        string goblinAge = Random.Range(20,
          goblinMaxAge).ToString();
        string goblinJob = goblinJobs[Random.Range(0, 
          goblinJobs.Count)];
        textMesh.text = $"{goblinName} is a {goblinAge} 
          years old goblin {goblinJob}.";
    }
}

脚本有三个公开属性。第一个,textMesh,是对将在屏幕上显示文本的 TextMesh 元素的引用(你可以通过访问 goblinJobs 创建一个,它存储了我们想要分配给哥布林的作业列表。正如你在 图 10.1 中所看到的,我添加了四个作业:goblinMaxAge,代表我的哥布林的最高年龄。

![图 10.1 – 检查器中的哥布林作家脚本]

img/B17984_10_1.jpg

图 10.1 – 检查器中的哥布林作家脚本

每当我们调用 UpdateString(即在游戏开始时以及每次我们按下 空格键 时),我们只需从年龄、职业和名字的可能值集中提取一个值,并构建一个字符串。一旦我们设置好了一切,我们就可以运行演示,每次我们按下 空格键 时(图 10.2),我们都应该看到一个新哥布林的描述。

![图 10.2 – 我们可以生成的许多随机哥布林之一]

img/B17984_10_2.jpg

图 10.2 – 我们可以生成的许多随机哥布林之一

这个例子很简单,但它是为任何游戏增加多样性的有效方法。

信息

《地下城与龙》第五版的地下城主手册包含了许多这类 组合和随机驱动的程序生成 的例子。在里面,你可以找到许多用于生成宝藏、武器、支线任务、角色等等的表格。当然,它是为了与笔和骰子一起使用而设计的,但没有什么阻止你将纸面算法转换为计算机算法!

现在我们已经对程序生成有了品味,让我们提高游戏水平。让我们介绍另一个对 PCG 开发者很有用的工具:Perlin 噪声。

学习如何使用 Perlin 噪声

Perlin 噪声 是由 Ken Perlin 在 1983 年开发的一种用于定义数字噪声的算法。它很快成为在大量程序内容生成算法中生成自然外观图案的事实上的算法。例如,Perlin 噪声用于创建 3D 地形、2D 纹理、程序动画等等。

![图 10.3 – Perlin 噪声(左)与白噪声(右)之间的区别]

img/B17984_10_3.jpg

图 10.3 – Perlin 噪声(左)与白噪声(右)之间的区别

但是什么让 Perlin 噪声与其他噪声不同?简短的答案是它看起来更 自然。然而,这个答案只是将问题转化为 更自然是什么意思? 让我们想象标准的非 Perlin 噪声,例如,0 到 1 之间的随机数字序列。序列可能如下所示:0、0.9、0.2、0.3、0.95 等。

如您所见,这些数字可以毫无标准地上下跳跃。如果这些数字代表游戏中的角色位置,角色看起来会疯狂地左右传送。这不是现实生活中物体的移动方式。

Perlin 噪声不同之处在于,在数字序列中,两个连续的数字总是彼此靠近。例如,在 0.9 之后,我们可能会有 0.91、0.92 或 0.88,但绝不会是 0.1。这种效果就像一个浮标在海面上漂浮:它可以不可预测地左右移动,上下移动,但具有一定的平滑性——一定的自然性。

这看起来很完美。然而,我们如何在 Unity 中使用 Perlin 噪声?幸运的是,Unity 将 Perlin 噪声算法作为内置工具提供。

内置的 Unity Perlin 噪声

Unity 提供了一个简单的函数来访问 Perlin 噪声:

Mathf.PerlinNoise(xCoord, yCoord);

Unity 将 Perlin 噪声实现为一个无限的 2D 平面,您可以使用 Mathf.PerlinNoise 函数在代码中随机采样。您可以简单地采样一个随机坐标,以获取 Perlin 噪声平面上 随机 的值。

信息

注意,Unity 只提供了 2D Perlin 噪声。然而,Perlin 噪声可以轻松扩展到 3D(例如,用于创建体积烟雾)或甚至更多维度。如果您需要 3D Perlin 噪声,您需要自己开发算法或在网上寻找许多开源实现(例如,gist.github.com/tntmeijs/6a3b4587ff7d38a6fa63e13f9d0ac46d)。

假设您想使用 Unity 内置的 Perlin 噪声创建一个随机的 2D 纹理。您可以通过从任意点(xStart 和 yStart)开始,然后将周围每个点的值复制到纹理中来实现这一点,如下面的示例所示(完整的 PerlinTexture.cs 文件包含在 GitHub 仓库中):

    void CalculateNoise() {
        for (float y = 0.0f; y < noiseTex.height; y++) {
            for (float x = 0.0f; x < noiseTex.width; x++) {
                float xCoord = 
                  xOrg + x / noiseTex.width * scale;
                float yCoord = 
                  yOrg + y / noiseTex.height * scale;
                float value = 
                  Mathf.PerlinNoise(xCoord, yCoord);
                pix[(int)y * noiseTex.width + (int)x] = 
                  new Color(value, value, value);
            }
        }
        // Copy the pixel data to the texture and load it 
        // into the GPU.
        noiseTex.SetPixels(pix);
        noiseTex.Apply();
    }

然而,我们也可以使用 2D Perlin 噪声来生成 1D Perlin 噪声。在这种情况下,我们固定一个坐标(x 或 y),然后让另一个坐标沿直线移动。

假设我们想要动画化一个上下摆动的球体,像气球一样轻轻上下浮动。我们可以通过将其 y 坐标(经典地表示上下方向)设置为 Perlin 噪声的值来实现这一点:

using UnityEngine;
public class Bobbling : MonoBehaviour {
    // Range over which height varies.
    public float heightScale = 1.0f;
    // Distance covered per second along X axis of Perlin
    // plane.
    public float xScale = 1.0f;
    void Update() {
        float height = heightScale *
          Mathf.PerlinNoise(Time.time * xScale, 0.0f);
        Vector3 pos = transform.position;
        pos.y = height;
        transform.position = pos;
    }
}  

如果您将这个小脚本附加到任何对象上,您将看到对象随机上下移动。

这只是 Perlin 噪声应用的冰山一角,但我希望它能帮助你入门。然而,是时候我们继续我们的 PCG 之旅了。在下一节中,我们将使用一种称为细胞自动机的新技术来生成一个随机洞穴。

生成随机地图和洞穴

PCG 的另一个广泛应用是地图和地牢的生成。例如,在roguelike类型(一种从 20 世纪 80 年代的游戏Rogue中取名的游戏类型)中,玩家每次开始游戏时都会面对一个随机生成的地牢。同样,在Minecraft中,玩家通过生成一个随机世界来开始游戏,并在其中探索和生存。例子很多——多到无法在此列出。

有许多算法可以创建游戏世界。一些使用分形噪声来生成随机的地形图。另一些通过创建随机房间并将它们通过走廊连接起来来创建类似地牢的结构。还有一些通过将预先制作好的房间随机排列成无数不同的组合来构建地图,就像拼图一样(如果你玩过 20 世纪 80 年代的桌面游戏Carcassonne,你就知道我在说什么了)。

本演示将探索一种非常适合生成洞穴或自然外观场景的简单技术,称为细胞自动机。

细胞自动机

细胞自动机(CA)不仅是一个 PCG 算法。自 1950 年以来,CA 作为一种抽象的计算模型被研究。然而,它们的普及直到 20 世纪 70 年代康威的生命游戏发布后才爆发。

细胞自动机(CA)的基本思想是模拟二维网格中细胞的行为。网格中的每个细胞有两种状态:死亡或存活。每个细胞将根据仅取决于其邻居的规则死亡或存活。

图 10.4 – 生命游戏中的细胞配置

图 10.4 – 生命游戏中的细胞配置

细胞自动机算法的行为仅取决于这些进化规则。因此,我们从初始的存活和死亡细胞配置开始,然后让系统独立进化。例如,在生命游戏中,我们有四个简单的规则:

  • 拥有少于两个存活邻居的存活细胞人口不足,因此它们会死亡。

  • 拥有两个或三个存活邻居的存活细胞将在下一代中继续存活。

  • 拥有超过三个存活邻居的存活细胞人口过多,因此它们会死亡。

  • 拥有恰好三个存活邻居的死亡细胞会因繁殖而复活。

结果表明,这四条简单的规则足以使算法本身成为图灵完备的。这意味着可以编写一个活细胞和死细胞的配置,在应用上述四条规则之后,能够像普通计算机一样进行任何计算,例如乘法或下棋。如果你对此感兴趣,保罗·伦德尔在他的网页上对这种模式有详细的描述(rendell-attic.org/gol/tm.htm)。

但让我们回到我们的目标。幸运的是,我们不需要做比用我们的 CA 实现 CPU 更复杂的事情。在 PCG 中,CA 是一个很好的选择,因为它们易于实现,并且生成的地图看起来像自然环境,如沙漠、洞穴、群岛等。

实现洞穴生成器

为了实现我们的洞穴生成器,我们需要两个组件:

  • 一个抽象地生成和存储地图的组件(例如,作为一个整数的数组)

  • 一个将抽象地图渲染成游戏中的可见 3D 对象的组件

因此,让我们先实现第一个组件。我们将称之为CaveGenerator:

using UnityEngine;
using System;
public class CaveGenerator : MonoBehaviour {
    [SerializeField]
    private int width;
    [SerializeField]
    private int height;
    [SerializeField]
    private int seed;
    [SerializeField]
    private bool useRandomSeed;
    private int[,] map;
    void Start() {
        InitializeRandomGrid();
        DrawCaveMesh();
    }
    void Update() {
        if (Input.GetKeyDown(KeyCode.G)) {
            CellularAutomata(false);
            DrawCaveMesh();
        } else if (Input.GetKeyDown(KeyCode.Space)) {
            CellularAutomata(true);
            DrawCaveMesh();
        } else if (Input.GetKeyDown(KeyCode.N)) {
            InitializeRandomGrid();
            DrawCaveMesh();
        }
    }

该组件向检查器公开了四个属性。前两个属性简单地是地图的weight和height,以单元格数量表示。然后我们有随机生成器的seed,以防我们想要创建特定的地图(这在调试目的上特别有用)。然而,通常情况下,我们希望在每次开始游戏时都有一个随机的地图;这就是为什么我们有useRandomSeed属性:如果它是true,我们初始化一个随机种子。最后,我们有一个私有的二维数组来存储map表示。

在属性指定之后,我们需要初始化Start和Update回调函数。这些函数将简单地调用我们接下来定义的其他函数。在Update中,我们还可以看到我们用来控制演示的键:每次我们按下空格键,我们就会运行 CA 模拟的另一个步骤;当我们按下N键时,我们初始化一个新的地图。

当我们按下G键时,我们为 CA 运行不同的规则(我们将在设置 CA 规则时详细介绍这一点)。

我们现在将实现InitializeRandomGrid函数。这个函数使用随机的死细胞和活细胞初始化地图。然而,还有两个额外的提示。首先,该函数在地图周围创建了一个墙的边界(活细胞)。这是因为地图通常是有限的,我们不希望玩家跳出地图。这个墙的边界将确保最终地图不会有通向地图边缘的洞穴:

    void InitializeRandomGrid() {
        map = new int[width, height];
        if (useRandomSeed) {
            seed = (int)DateTime.Now.Ticks;
        }
        System.Random randomGen =
          new System.Random(seed.GetHashCode());
        int mapMiddle = (height / 2);
        for (int c = 0; c < width; c++) {
            for (int r = 0; r < height; r++) {
                if (c == 0 || c == width - 1 || r == 0 || r
                     == height - 1) {
                    map[c, r] = 1;
                } else {
                    if (c == mapMiddle) {
                        map[c, r] = 0;
                    } else {
                        map[c, r] = (randomGen.Next(0, 100)
                          < 50) ? 1 : 0;
                    }
                }
            }
        }
    }

第二个技巧是保持一列空的空间(死细胞)。这就是检查mapMiddle变量的目的。留出这行空白的原因很简单:它通过生成贯穿整个地图的主连接洞穴,经验上给出了更好的结果。你可以移除它以获得多个孤立的小洞穴,或者找到一个不同的起始模式,根据你的口味和用例提供更好的结果。InitializeRandomGrid函数初始化类似于图 10.5中的图像。

![图 10.5 – 地图的初始状态图片 B17984_10_5.jpg

图 10.5 – 地图的初始状态

现在,我们将查看一个小的实用函数,我们用它来计算特定地图单元格周围的墙壁数量:

    int GetSurroundingWallCount(int c, int r, int size) {
        int wallCount = 0;
        for (int iX = c - size; iX <= c + size; iX ++) {
            for (int iY = r - size; iY <= r + size; iY ++)
            {
                if (iX != c || iY != r) {
                    wallCount += isWall(iX, iY) ? 1 : 0;
                }
            }
        }
        return wallCount;
    }
    bool isWall(int c, int r) {
        if (c < 0 || r < 0) {
            return true;
        }
        if (c > width - 1 || r > height - 1) {
            return true;
        }
        return map[c, r] == 1;
    }

第一个函数很简单。它查看目标坐标周围的单元格,并计算墙壁的数量。它还接受一个size参数,表示目标坐标周围的半径。如果size等于1,我们检查目标坐标周围的八个单元格(想象一个 3x3 的正方形)。如果size等于2,我们还会检查邻居的邻居(想象一个 5x5 的正方形)。

isWall函数用于检查特定坐标是否代表墙壁。你可能会问:我们为什么不直接检查(c,r)处的map值?因为我们可能进入数组外的坐标(例如,(-1,-1))。在这种情况下,我们假设地图外的每个单元格都是墙壁(并且它将保持为墙壁)。这简化了GetSurroundingWallCount的逻辑。

现在是时候进入重点 – CA 规则:

    void CellularAutomata(bool clean = false) {
        int[,] newmap = new int[width, height];
        for (int c = 0; c < width; c ++) {
            for (int r = 0; r < height; r ++) {
                int numWalls = 
                  GetSurroundingWallCount(c, r, 1);
                int numWalls2 = 
                  GetSurroundingWallCount(c, r, 2);
                if (isWall(c,r)) {
                    if (numWalls > 3) {
                        newmap[c, r] = 1;
                    } else {
                        newmap[c, r] = 0;
                    }
                } else {
                    if (!clean) {
                        if (numWalls >= 5 || numWalls2 <= 
                            2) {
                            newmap[c, r] = 1;
                        } else {
                            newmap[c, r] = 0;
                        }
                    } else {
                        if (numWalls >= 5) {
                            newmap[c, r] = 1;
                        } else {
                            newmap[c, r] = 0;
                        }
                    }
                }
            }
        }
        map = newmap;
    }

对于洞穴生成器,我们使用两组规则。第一组(当clean等于true时获得)描述如下:

  • 如果一个单元格是墙壁,只要它周围有超过三个墙壁,它就会保持为墙壁。否则,它变成空空间。

  • 如果一个单元格为空,只要它周围有少于五个墙壁,它就会保持为空。否则,它变成墙壁。

第二组规则与第一组相同,但它还检查半径为2的邻居。如果围绕一个空单元格的空空间太多,那么它就会变成墙壁。这种可选行为可以消除大空隙,促进更狭窄的通道。然而,这也可能留下像噪声一样的孤立 1x1 墙壁(这就是为什么这组规则使用clean参数等于false来启用)。

通过运行这些规则,我们得到如图 10.6 所示的地图。

![图 10.6 – 由我们的算法生成的随机洞穴图片 B17984_10_6.jpg

图 10.6 – 由我们的算法生成的随机洞穴

我们现在有一个完全工作的算法,但没有方法在游戏中展示它。为此,我们有DrawCaveMesh函数:

    void DrawCaveMesh() {
        MeshGenerator meshGen =
          GetComponent<MeshGenerator>();
        meshGen.GenerateMesh(map, 1);
    }

这个函数简单地调用一个网格生成器。我们将在下一节实现MeshGenerator。

渲染生成的洞穴

给定抽象地图表示(存储在map中的二维数组),我们需要将其转换为屏幕上渲染的网格。我们可以通过多种方式实现。为了提供灵活性,我们首先定义一个抽象组件:

using UnityEngine;
public abstract class MeshGenerator : MonoBehaviour {
    abstract public void GenerateMesh(int[,] map, float
                                      squareSize);
}

这个简单的抽象类告诉 Unity,每个有效的MeshGenerator都应该包含一个GenerateMesh函数。这个函数接受数组地图和每个单元格的大小作为输入,大小以 Unity 单位表示。

这很酷,但显然现在并不太有用。我们仍然无法渲染任何东西。不要担心;我们现在将实现一个简单的网格渲染器。

基本网格渲染器

这个渲染器的想法是为每个墙壁单元生成一个 1x1 的立方体。我们将这个渲染器称为WallGenerator:

public class WallGenerator : MeshGenerator {
    public GameObject wallCube;
    public override void GenerateMesh(int[,] map, 
      float squareSize) {
        foreach (Transform t in transform) {
            Destroy(t.gameObject);
        }
        int width = map.GetLength(0);
        int height = map.GetLength(1);
        for (int c = 0; c < width; c++) {
            for (int r = 0; r < height; r++) {
                if (map[c, r] == 1) {
                    GameObject obj = Instantiate(wallCube,
                      new Vector3(c * squareSize, 0, r *
                      squareSize), Quaternion.identity);
                    obj.transform.parent = transform;
                }
            }
        }
        transform.position = 
          new Vector3(-width / 2.0f, 0, -height / 2.0f);
        MergeCubes();
    }

首先,请注意,这个类扩展了我们的抽象MeshGenerator类。其次,这个组件公开了一个名为wallCube的单个参数。这个参数包含一个墙壁预制体的引用(基本上是一个彩色的 3D 立方体)。

然后,我们实现GenerateMesh函数。实现方法再次简单直接:

  1. 我们销毁所有现有的墙壁(存储为子元素)。

  2. 然后,我们遍历抽象地图中的每个单元格,并在适当的位置生成一个wallCube对象。

  3. 我们将地图平移一半的大小(用于可视化目的)。

然而,存在问题。Unity 不适合生成成千上万的 GameObject。所以,如果我们的地图是 200x200,这个函数将可能生成 40,000 个 GameObject 仅用于渲染地图。结果将是一个相当慢的游戏(我们甚至还没有生成角色)。

幸运的是,有一个快速解决方案:

    private void MergeCubes() {
        transform.GetComponent<MeshFilter>().mesh = 
          new Mesh();
        MeshFilter[] meshFilters =
          GetComponentsInChildren<MeshFilter>();
        CombineInstance[] combine = 
          new CombineInstance[meshFilters.Length];
        int i = 0;
        while (i < meshFilters.Length) {
            combine[i].mesh = meshFilters[i].sharedMesh;
            combine[i].transform =
              meshFilters[i].transform.localToWorldMatrix;
            meshFilters[i].gameObject.SetActive(false);
            i++;
        }
        transform.GetComponent<MeshFilter>().mesh = 
          new Mesh();
        transform.GetComponent<MeshFilter>()
          .mesh.indexFormat = 
          UnityEngine.Rendering.IndexFormat.UInt32;
        transform.GetComponent<MeshFilter>()
          .mesh.CombineMeshes(combine, true);
        transform.gameObject.SetActive(true);
        foreach (Transform t in ransform) {
            Destroy(t.gameObject);
        }
    }

MergeCubes函数接受我们刚刚生成的所有立方体子元素,并将它们组合成一个具有单个网格的单个游戏对象。我们通过利用内置的CombineMeshes工具来实现这一点。

如您在前面的代码中看到的,我们首先获取所有子元素(所有单独的墙壁)。然后,对于它们中的每一个,我们创建CombineInstance。唯一需要记住的棘手之处是存储网格的坐标为世界坐标(Unity 通过调用.transform.localToWorldMatrix来实现这一点)。

一旦我们有了所有的CombineInstance对象,我们就用组合所有墙壁得到的网格替换地图的网格。

信息

根据地图的大小,默认的IndexFormat可能无法容纳组合网格的所有顶点。我们可以通过使用 32 位索引来解决这个问题,即transform.GetComponent<MeshFilter>().mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;。

最后,我们销毁所有子元素。

现在,我们可以设置场景。最终结果在下面的屏幕截图中显示。

图 10.7 – CaveGen 层级结构

图 10.7 – CaveGen 层级结构

首先,让我们创建一个大的平面用于地面层,然后创建一个名为CaveGen的对象。CaveGen对象包含一个MeshRenderer和一个MeshFilter组件(但没有网格)。

现在将CaveGenerator和WallRenderer组件附加到这个对象上,并按照以下截图进行配置。

![图 10.8 – CaveGenerator 和 WallGenerator 组件

![图片 B17984_10_8.jpg]

图 10.8 – CaveGenerator 和 WallGenerator 组件

最后一步是将Wall预制体添加到Wall Cube中。然后,最终我们可以点击Play,应该会看到类似于图 10.9的类似效果。

![图 10.9 – 初始随机配置

![图片 B17984_10_9.jpg]

图 10.9 – 初始随机配置

我们现在可以通过按Spacebar(或如果我们想应用第二套 CA 规则,则按G)继续地图生成。经过一段时间,您可能会注意到地图稳定到一个类似于图 10.10的地图。到那时,您的地图就准备好了(但您可以通过按N重新开始)。

![图 10.10 – 完全演化的地图

![图片 B17984_10_10.jpg]

图 10.10 – 完全演化的地图

对于我们用不到 130 行代码编写的 PCG 算法来说,这已经很不错了。

高级网格渲染器

WallGenerator快速且有效;然而,它并不最优。最终的网格包含大量冗余顶点,我们仍然有这种像素化的外观。我们可以使用许多其他不同的算法来生成网格。一个标准的解决方案是使用Marching Squares算法(如果应用于 3D,也称为Marching Cubes)。

这个算法有点复杂,详细的讨论会远远超出本书的范围。然而,在这个演示的代码中,我包含了一个MarchingCubesGenerator组件供您使用和探索。该算法来自官方 Unity 教程(www.youtube.com/watch?v=yOgIncKp0BE),我已经为这个演示进行了适配。

要使用它,您只需将WallGenerator组件替换为MarchingCubesGenerator。如果您现在运行游戏并运行几代 CA,您应该会看到类似于图 10.11的效果。

![图 10.11 – 使用 MarchingCubesGenerator 渲染的地图

![图片 B17984_10_11.jpg]

图 10.11 – 使用 MarchingCubesGenerator 渲染的地图

如您所见,我们得到了更平滑的墙壁和更少的顶点(性能得到提升)。如果您喜欢这个洞穴生成器并想深入了解,我鼓励您通过访问learn.unity.com/tutorial/generating-content的官方教程。

摘要

在本章中,我们仅仅触及了 PCG(程序生成内容)的表面。首先,我们从一个简单的算法开始,用于创建随机的哥布林传记。然后,我们利用 CA(细胞自动机)的力量开发了一个复杂的洞穴系统,并发现了两种在 3D 地图中渲染抽象网格的技术。

然而,正如我所说的,这只是一个开始。PCG 代表了一类庞大的算法,它融合了编程与艺术的边界。PCG 本身就是一个值得探索的编程领域,本章的目的是给你一个微小的尝试。

现在,我们已没有更多时间来探讨 PCG 了。是时候进入下一章,学习机器学习了。

进一步阅读

如果你想要对 Unity 中的 PCG 进行更深入的探索,Ryan Watkins 为此主题撰写了一整本书,书名为《Unity 游戏开发中的程序内容生成》,由Packt出版。

第十一章:Unity 中的机器学习

机器学习是人工智能(AI)中最热门的术语。如今,几乎所有东西都包含(或声称包含)一些由机器学习驱动的 AI,旨在改善我们的生活:日历、待办事项应用、照片管理软件、每部智能手机等等。然而,尽管“机器学习”这个短语大多数时候只是一个营销噱头,但毫无疑问的是,机器学习在近年来已经取得了显著的进步。最重要的是,现在有大量的工具允许每个人在没有先前的学术级 AI 知识的情况下实现学习算法。

目前,机器学习在游戏开发中并未得到广泛应用(除了用于程序内容生成的应用)。这有很多原因。但主要原因是设计师无法控制机器学习代理的输出,而在游戏设计中,不可控的结果通常与不有趣的游戏相关。因此,游戏 AI 开发者更倾向于使用更可预测和直接的技术,例如行为树。

另一方面,能够在 Unity 中使用机器学习算法对于非游戏用途非常有用,例如模拟、AI 研究和一些严肃的游戏应用。无论原因如何,Unity 提供了一个完整的机器学习工具包,使我们免于将游戏引擎与外部机器学习框架接口的复杂性。

在本章中,我们将探讨以下主题:

  • Unity 机器学习工具包简介

  • 设置 Unity 机器学习代理工具包

  • 看看如何运行一个简单的示例

机器学习是一个广泛的话题;因此,我们并不期望涵盖它的每一个方面。相反,您可以查看工具包文档以及本章末尾链接的附加资源以获取进一步参考。

技术要求

对于本章,您需要在您的系统上安装 Unity3D 2022、Python 3.7、PyTorch 和 ML-Agents 工具包。如果您还没有安装,请不要担心;我们将介绍安装步骤。您可以在本书的仓库中的第十一章文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter11

Unity 机器学习代理工具包

Unity 机器学习代理工具包(ML-Agents Toolkit)是一组软件和插件,帮助开发者编写由机器学习算法驱动的自主游戏代理。您可以在 GitHub 仓库github.com/Unity-Technologies/ml-agents中探索和下载源代码。

ML-Agents 工具包基于强化学习算法。简单来说,强化学习是训练狗的算法等价物。例如,如果您想教狗一些技巧,您给他一个命令,然后,当狗按照您的期望行事时,您就奖励它。奖励告诉您的狗它正确地响应了命令,因此,下次它听到相同的命令时,它会做同样的事情以获得新的奖励。

注意

在强化学习中,您也可以在智能体做错事情时惩罚它,但在狗训练的例子中,我可以向您保证惩罚是完全不必要的。只需给他们奖励即可!

对于使用强化学习训练的 AI 智能体,我们执行类似的循环:

  1. 当智能体采取行动时,该行动会影响世界(例如改变智能体的位置、移动物体、收集硬币、获得分数点等等)。

  2. 算法随后将新的世界状态和奖励(或惩罚)发送回智能体。

  3. 当智能体决定其后续行动时,它将选择最大化预期奖励(或最小化预期惩罚)的行动。

因此,很明显,训练一个强化学习智能体需要模拟智能体采取行动、接收奖励、更新其决策值、执行另一个行动等场景的多次模拟。这项工作通过 PyTorch 从 Unity 卸载。Torch 是一个流行的开源机器学习库,Facebook 和 IBM 等科技巨头也在使用它。

有关强化学习的更多信息,请参阅章节末尾的进一步阅读部分。

让我们看看如何安装这个工具包。

安装 ML-Agents 工具包

作为第一步,我们需要下载这个工具包。我们可以通过以下命令克隆仓库来完成:

git clone --branch release_19 https://github.com/Unity-Technologies/ml-agents.git

此命令会在您的当前文件夹中创建一个ml-agents文件夹。ML-Agents 工具包由两个主要组件组成:

  • 包含 Unity 和 PyTorch 训练器的 Python 接口的 Python 包(存储在ml-agents文件夹中)

  • 包含与 OpenAI Gym(gym.openai.com/)接口的 Python 包,OpenAI Gym 是一个用于训练强化学习智能体的工具包(存储在gym-unity文件夹中)。

    信息

    Git 是世界上最著名的版本控制应用程序。它用于存储您的源代码,跟踪不同版本,与他人协作,等等。如果您还没有使用 Git,您真的应该试试看。您可以从git-scm.com/下载它。

现在,是时候安装所需的依赖项了。

在 Windows 上安装 Python 和 PyTorch

ML-Agents 工具包建议的 Python 版本是 3.7。你可以通过多种方式安装它,其中最快的方式是在 Microsoft Store 中搜索 Python 3.7(或点击此链接:www.microsoft.com/en-us/p/python-37/9nj46sx7x90p)。

在 Windows 上,在安装 mlagents 包之前,你需要手动安装 PyTorch。为此,你可以在终端中简单地运行以下命令:

pip3 install torch~=1.7.1 -f https://download.pytorch.org/whl/torch_stable.html

信息

如果你安装 PyTorch 时遇到任何困难,可以参考官方安装指南:pytorch.org/get-started/locally/。

在这一步之后,你应该能够遵循与 macOS 和 Unix-like 系统相同的安装步骤。

在 macOS 和 Unix-like 系统上安装 Python 和 PyTorch

要在 macOS 或 Linux 上安装 ML-Agents 工具包,你首先需要安装 Python 3.6 或 Python 3.7(目前,ML-Agents 工具包只推荐这两个 Python 版本)。

然后,你可以运行以下命令:

python -m pip install mlagents==0.28.0

在 macOS 和 Linux 上,此命令会自动安装正确的 PyTorch 版本。

安装完成后,如果一切正常,你应该能够在系统中的任何位置运行 mlagents-learn --help 命令而不会出现任何错误。

注意

Pip3 会自动与任何 Python 3.x 分发一起安装。如果你没有安装 pip3,请尝试按照官方指南操作:pip.pypa.io/en/latest/installing/。

使用 ML-Agents 工具包 – 一个基本示例

现在一切都已经安装完毕,我们可以开始使用 ML-Agents 工具包。首先,让我们解释一下 ML-Agents 场景的基本架构。

ML-Agents 场景被称为 学习环境。学习环境是一个标准的 Unity 场景,包含两个主要元素:

  • 编写 Agent 类的行为。例如,如果 Agent 是一辆车,我们需要编写如何通过输入来控制车辆,以及我们如何奖励和惩罚车辆(例如,我们可以奖励车辆以超过一定速度行驶,当它驶离道路时进行惩罚)。一个学习环境可以包含你想要的任意数量的 Agent。

  • 对场景中的每个 Agent 调用 OnEpisodeBegin()。

  • 对场景中的每个 Agent 调用 CollectObservations(VectorSensor sensor)。此函数用于收集环境信息,以便每个 Agent 可以更新其内部模型。

  • 对场景中的每个 Agent 调用 OnActionReceived()。此函数执行每个 Agent 选择的动作并收集奖励(或惩罚)。

  • 如果一个 Agent 完成了其剧集,学院会为 Agent 调用 OnEpisodeBegin()。此函数负责将 Agent 重置到起始配置。

要开始使用 ML-Agents 工具包,我们需要做以下几步:

  1. 打开 Unity 并创建一个空项目。

  2. 前往 Windows | 软件包管理器。

  3. 在右上角菜单中,选择 Unity 注册表:

图 11.1 – Unity 包管理器

图 11.1 – Unity 包管理器

  1. 查找 ML Agents 包并安装它:

图 11.2 – 包管理器中的 ML Agents 包

图 11.2 – 包管理器中的 ML Agents 包

我们需要确保我们使用的是正确的运行时。

  1. 要这样做,请转到 编辑 | 项目设置 | 玩家,并为每个平台(PC、Mac、Android 等),进入 其他设置 并确保 API 兼容性级别 设置为 .NET Framework。如果不是,调整这些设置以满足我们的需求,然后保存,如下所示:

图 11.3 – 包含正确设置的“项目设置”窗口

图 11.3 – 包含正确设置的“项目设置”窗口

创建场景

创建学习环境很简单。让我们创建一个简单的 3D 场景,包含一个平面、一个球体和一个立方体,如下截图所示:

图 11.4 – 基本演示场景

图 11.4 – 基本演示场景

我们将立方体放在平面的中心,并给球体添加一个 Rigidbody 组件。这个场景的目的是训练一个滚动的球体到达目标(立方体)而不从平面上掉落。

实现代码

现在,我们需要实现描述代理行为和 ML-Agent 学院的代码。代理的行为脚本描述了代理在模拟中如何执行动作、代理收到的奖励以及我们如何将其重置以开始新的模拟:

  1. 选择球体。让我们给它添加一个新的脚本,命名为 SphereAgent,内容如下:

    using System.Collections.Generic;
    using UnityEngine;
    using Unity.MLAgents;
    using Unity.MLAgents.Sensors;
    using Unity.MLAgents.Actuators;
    public class SphereAgent : Agent {
        Rigidbody rBody;
        public Transform Target;
        public float forceMultiplier = 10;
        void Start () {
            rBody = GetComponent<Rigidbody>();
        }
    
        override public void OnEpisodeBegin() {
            if (transform.position.y < -1.0) {
                // The agent fell
                transform.position = Vector3.zero;
                rBody.angularVelocity = Vector3.zero;
                rBody.velocity = Vector3.zero;
            } else {
                // Move the target to a new spot
                Target.position = new Vector3(Random.value *
                  8 - 4, 0.5f, Random.value * 8 - 4);
            }
        }
    }
    

这是我们的演示的基础代理。OnEpisodeBegin 是系统在每次我们想要重置训练场景时调用的函数。在我们的例子中,我们检查球体是否从平面上掉落,并将其带回零;否则,我们将其移动到随机位置。

  1. 我们需要将 CollectObservations 方法添加到 SphereAgent 中。代理使用此方法从游戏世界中获取信息,然后使用它来做出决策:

        override public void CollectObservations(
          VectorSensor sensor) {
            // Calculate relative position
            Vector3 relativePosition = 
              Target.position - transform.position;
            // Relative position
            sensor.AddObservation(relativePosition.x/5);
            sensor.AddObservation(relativePosition.z / 5);
            // Distance to edges of platform
            sensor.AddObservation(
             (transform.position.x + 5) / 5);
            sensor.AddObservation(
              (transform.position.x - 5) / 5);
            sensor.AddObservation(
              (transform.position.z + 5) / 5);
            sensor.AddObservation(
              (transform.position.z - 5) / 5);
            // agent velocity
            sensor.AddObservation(rBody.velocity.x / 5);
            sensor.AddObservation(rBody.velocity.z / 5);    }
    

在这个例子中,我们感兴趣的是以下内容:

  • 球体代理相对于立方体(目标)的相对位置。我们只对 x 和 z 值感兴趣,因为球体只在平面上移动(注意,我们通过除以 5(默认平面大小的一半)来归一化这些值)。

  • 平面边缘的距离。

  • 球体的速度。

  1. 我们需要实现 OnActionReceived 方法。每当代理需要采取行动时,都会调用此方法。该方法接受一个 ActionBuffer 类型的单个参数。ActionBuffer 对象包含对球体控制输入的描述。在我们的例子中,我们只需要两个连续的动作,对应于沿游戏 x 和 z 轴施加的力。

  2. 我们还需要定义奖励。如前所述,当我们达到目标时,通过调用SetReward,我们给代理奖励一分。如果代理从飞机上掉落,我们通过调用EndEpisode以零分结束这一轮。代码的最终版本如下:

        public override void OnActionReceived(
          ActionBuffers actionBuffers) {
            // Actions, size = 2
            Vector3 controlSignal = Vector3.zero;
            controlSignal.x = 
              actionBuffers.ContinuousActions[0];
            controlSignal.z = 
              actionBuffers.ContinuousActions[1];
            rBody.AddForce(controlSignal * forceMultiplier);
            // Rewards
            float distanceToTarget = Vector3.Distance(this.
              transform.localPosition, Target.localPosition);
            // Reached target
            if (distanceToTarget < 1.42f) {
                SetReward(1.0f);
                EndEpisode();
            }
            // Fell off platform
            else if (this.transform.localPosition.y < 0) {
                EndEpisode();
            }
        }}
    

现在,是时候将这个SphereAgent脚本连接到我们的球体上了。

添加最终细节

现在,我们需要连接所有部件,使演示工作:

  1. 首先,我们将SphereAgent脚本附加到球体上。

  2. 我们将立方体拖放到Sphere Agent组件的目标字段中。

  3. 通过点击添加组件,我们添加一个决策请求器组件。我们可以保留默认设置。

  4. 在MovingSphere中。

  5. 我们将8设置为对应我们在CollectObservations方法中添加的观察数量。

  6. 最后,我们将2设置为。此时,球体脚本应该看起来像以下截图:

图 11.5 – 球体代理的检查器视图

图 11.5 – 球体代理的检查器视图

现在是测试我们的环境的时候了。

测试学习环境

在我们开始学习之前,我们希望通过手动输入控制代理来测试环境。在不浪费数小时训练过程的情况下调试学习环境非常有用。

幸运的是,ML-Agents Toolkit 使得使用实时输入控制代理变得非常方便。我们只需要两个步骤:

  1. 我们将Heuristic方法添加到SphereAgent组件中。这个函数允许我们手动指定ActionBuffer对象的值。在我们的情况下,我们想要将两个连续动作添加到控制器的输入轴上:

        public override void Heuristic(
          in ActionBuffers actionsOut) {
            var continuousActionsOut = 
              actionsOut.ContinuousActions;
            continuousActionsOut[0] = 
              Input.GetAxis("Horizontal");
            continuousActionsOut[1] = 
              Input.GetAxis("Vertical");
        }
    
  2. 现在,我们转到检查器,并将行为类型参数设置为仅启发式:

图 11.6 – 行为类型配置

图 11.6 – 行为类型配置

到目前为止,你可以按播放在 Unity 中,你应该能够使用箭头键(或游戏控制器摇杆)控制球体。你可以通过检查这一轮的行为来测试环境。如果你到达目标立方体,它应该消失并在另一个随机位置重新生成。如果你从飞机上掉落,你应该在飞机上重生。

如果一切看起来正常,那么是时候自动训练代理了。

训练代理

在我们开始训练之前,我们需要编写一个训练配置文件。打开您的终端并进入任何空文件夹。然后,创建一个sphere.yaml文件,包含以下代码:

behaviors:
  MovingSphere:
    trainer_type: ppo
    hyperparameters:
      batch_size: 10
      buffer_size: 100
      learning_rate: 3.0e-4
      beta: 5.0e-4
      epsilon: 0.2
      lambd: 0.99
      num_epoch: 3
      learning_rate_schedule: linear
      beta_schedule: constant
      epsilon_schedule: linear
    network_settings:
      normalize: false
      hidden_units: 128
      num_layers: 2
    reward_signals:
      extrinsic:
        gamma: 0.99
        strength: 1.0
    max_steps: 500000
    time_horizon: 64
    summary_freq: 10000

然后,我们需要确保将球体对象中的行为类型参数更改为默认。

现在,从同一个文件夹中,我们应该能够运行以下命令:

mlagents-learn sphere.yaml --run-id=myMovingSphere

run-id是你运行会话的唯一 ID。如果一切按计划进行,你应该在某个时候在终端窗口中看到通过在 Unity 编辑器中按播放按钮开始训练的消息。现在,你可以按照消息所说的,在 Unity 中按播放。

训练完成后,您将在results/myMovingSphere/MovingSphere.onnx文件中找到训练好的模型(在运行mlagents-learn命令的文件夹内的results文件夹中)。

将此文件复制到您的 Unity 项目中,然后将其放入球体组件的模型占位符中:

图 11.7 – 行为参数中的训练好的 MovingSphere 模型

](https://github.com/OpenDocCN/freelearn-dl-zh/raw/master/docs/unt-ai-prog/img/B17981_11_7.jpg)

图 11.7 – 行为参数中的训练好的 MovingSphere 模型

现在,如果您按下播放,球体将根据训练模型自主移动。这并不是什么大而复杂的事情,但无论如何,它是自动化学习。

摘要

在本章中,我们只是刚刚触及了机器学习的表面以及如何用它来训练 Unity 代理。我们学习了如何安装 Unity 的官方 ML-Agents 工具包,设置学习环境,并训练了模型。然而,这仅仅是 ML-Agents 工具包的基本介绍,还有许多未探索的方向等待您去发现。我鼓励您查看 ML-Agents 官方仓库;它包括许多有趣的演示项目。

在下一章中,我们将通过将一个 AI 代理开发成一个更复杂的游戏演示来总结一切。

进一步阅读

第十二章:整合一切

在前十一章中,我们探讨了各种人工智能方法,并使用 Unity3D 构建了一些简单的演示应用程序。在本章中,我们将使用之前章节中探索的一些技术来开发一个更复杂的游戏示例。本章我们将使用的技术包括导航网格和有限状态机(FSMs),但更重要的是,我们将学习如何导航并添加人工智能到一个现有的复杂游戏中。因此,与之前的章节不同,这个示例更像是一个真实世界的场景。

在本章中,我们将为名为 TANKS! 的简单坦克战斗游戏添加人工智能,该游戏包含在官方 Unity 教程中,而该教程又受到了历史坦克游戏 Combat(Atari 2600 上的游戏)的启发。在默认版本中,TANKS! 是一个双人游戏。每个玩家控制一辆坦克,目标是摧毁对方。为了使事情更加复杂,玩家可以通过按住 空格键 的时间长短来决定射击的强度(以及因此的距离)。

然而,因为我们作为人工智能开发者,我们希望为敌方坦克构建一个可以在单人模式中游玩的人工智能。所以,这就是本章我们将要做的。

在本章中,我们将涵盖以下主题:

  • 开发基本游戏结构

  • 添加自动化导航

  • 使用 FSM 创建决策人工智能

技术要求

对于本章,你只需要 Unity3D 2022。你可以在这个章节的 GitHub 仓库中的Chapter 12文件夹中找到本章描述的示例项目:github.com/PacktPublishing/Unity-Artificial-Intelligence-Programming-Fifth-Edition/tree/main/Chapter12。

开发基本游戏结构

对于这个演示,我们将为免费教程游戏 TANKS! 编写人工智能。你可以从 Unity Asset Store(https://assetstore.unity.com/packages/essentials/tutorial-projects/tanks-tutorial-46209)下载基础游戏,或者跟随本书 GitHub 仓库中Chapter 12文件夹中的版本。本书附带版本的优势是已经针对 Unity 2022 进行了测试。

在任何情况下,游戏都是一样的。当我们开始游戏时,我们看到一个愉快的沙漠场景,有岩石、结构、棕榈树等等。使用键盘,我们应该能够控制蓝色坦克(坦克通过 W、A、S 和 D 移动,并通过 空格键 射击)。

以下截图显示了游戏的基本结构:

图 12.1 – 游戏的基本层次结构

图 12.1 – 游戏的基本层次结构

第一次使用现有项目时,尽可能多地花时间熟悉游戏结构、基本脚本和组件。你必须知道如何在不知道的项目中轻松操作。为此,运行游戏几次,尝试对代码进行一些小的修改以查看效果,并添加调试信息以了解信息在游戏中的流动。以下图片将给你一个我们运行游戏时游戏外观的印象:

![图 12.2 – TANKS!游戏中的实际操作图片

图 12.2 – TANKS!游戏中的实际操作

信息

遵循完整的 Unity 教程可能会有所帮助,该教程可在unity3d.com/learn/tutorials/s/tanks-tutorial找到。即使它不涉及 AI 并且相当陈旧(教程是在 2015 年录制的),你仍然可以找到许多对游戏开发非常重要的指导,例如如何设计游戏管理器、基本控制和音频。

添加自动导航

第一步是修改关卡以支持自动导航。在原始游戏中,玩家控制所有移动对象(坦克),因此路径查找是不必要的。现在我们想要添加 AI,我们需要有一个世界表示,通过这个表示 AI 可以移动。幸运的是,这个过程很简单,多亏了导航网格。

创建导航网格

要完成这个任务,请执行以下步骤:

  1. 打开导航窗口(窗口 | AI | 导航)并查看导航网格生成参数。在这种情况下,导航网格生成相对简单:我们只对在地面上移动感兴趣,所以没有跳跃、没有链接,也没有需要关心的斜坡。

  2. 我们需要调整默认导航网格参数的唯一调整是烘焙代理大小(即 Unity 用于验证位置是否足够大以允许代理通过的虚拟代理的尺寸)。

  3. 游戏中使用的坦克大约有三单位大,因此我们需要指示生成器移除坦克无法通过的区域。以下截图显示了导航网格的烘焙设置:

![图 12.3 – 导航网格烘焙选项图片

图 12.3 – 导航网格烘焙选项

为了确保安全,我们使用1.8并减少20(毕竟,我们对斜坡不感兴趣:游戏是完全平坦的)。

  1. 之后,按烘焙。你应该会得到一个很好的导航网格,就像以下截图所示:

![图 12.4 – 地图中的烘焙导航网格图片

图 12.4 – 地图中的烘焙导航网格

  1. 现在,我们想要添加一些巡逻点,AI 坦克可以跟随。为此,我们创建一个空的 GameObject;你可以随意创建尽可能多的其他 GameObject 实例。

  2. 然后,我们创建一个PatrolPoint标签,并将所有巡逻点都标记为该标签。

图 12.5 – 在编辑器视图中标记为 PPoint 的巡逻点

图 12.5 – 在编辑器视图中标记为 PPoint 的巡逻点

现在我们有一个世界表示和一组我们可以用来四处游荡的点,我们需要创建一个由 AI 控制的代理。

设置代理

不幸的是,游戏不支持 AI,因此我们需要自己添加代理。为此,执行以下步骤:

  1. 我们必须识别玩家坦克。正如您从游戏层次结构中看到的那样,场景中没有坦克。正如您在初步探索中应该知道的那样,GameManager负责生成坦克。我们将使用的坦克模型是一个名为CompleteTank的预制件。

  2. 让我们复制预制件并将其命名为CompleteTankAI。

  3. 然后我们需要添加Nav Mesh Agent组件,以便我们可以在新的 NavMesh 上移动它。

图 12.6 – Nav Mesh Agent 组件的检查器

图 12.6 – Nav Mesh Agent 组件的检查器

但这还不够。首先,我们将重用TANKS!演示中的TankShooting脚本,因此如果此脚本附加到 AI 上,我们需要禁用射击(否则玩家可以为 AI 代理射击)。

  1. 为了这个,我们创建一个名为m_IsAI的公共布尔变量。请注意,对于这个演示,我们使用原始教程的变量命名约定。这是为了避免让从 Asset Store 工作的人感到困惑。此外,始终采用现有项目的编码约定是明智的,而不是在整个代码库上强加我们的偏好。无论如何,让我们将以下行添加到Update脚本中:

    private void Update () {
        if (m_IsAI) {
            return;
        }
        …
    

这些行只是停止 AI 代理的Update脚本,从而禁用 AI 角色的玩家输入。在 AI 坦克预制件中启用此变量很重要。我们还需要添加另一个补丁;实际上,如果我们禁用输入,我们也会禁用射击强度。

  1. 因此,我们需要将以下内容添加回Fire函数:

    // We need to make Fire public.
    public void Fire (){
        // Set the fired flag so only Fire is only called
        // once. 
        m_Fired = true;
        // Create an instance of the shell and store a
        // reference to its rigidbody.
        Rigidbody shellInstance = Instantiate (m_Shell, 
          m_FireTransform.position,
          m_FireTransform.rotation) as Rigidbody;
    // New lines: if AI, we shoot with average force. 
        if (m_IsAI) {
    m_CurrentLaunchForce = 
              m_MaxLaunchForce / 2.0f;
        }
        // Set the shell's velocity to the launch force in
        // the fire position's forward direction.
        shellInstance.velocity = 
          m_CurrentLaunchForce * m_FireTransform.forward;
        // Change the clip to the firing clip and play it. 
        m_ShootingAudio.clip = m_FireClip;
        m_ShootingAudio.Play ();
        // Reset the launch force. This is a precaution in
        // case of missing button events.
        m_CurrentLaunchForce = m_MinLaunchForce;
    }
    

我们用恒定射击力替换了射击力变量,以简化操作。

信息

作为练习,您可以将m_CurrentLaunchForce作为Fire()函数的参数。我们还使Fire()函数公开:实际上,我们需要从稍后要实现的 FSM 中调用此函数。

最后,我们可以从坦克 AI 预制件中移除TankMovement组件。现在,是时候更新GameManager脚本以启用玩家对计算机模式了。

修复 GameManager 脚本

作为最后一步,我们需要指示GameManager脚本生成一个玩家坦克和一个 AI 坦克:

  1. 打开GameManager脚本,并添加一个新的公共变量,我们将在这个变量中存储新的 AI 坦克预制件:

    // Reference to the prefab the players will control.
    public GameObject m_TankPrefab;
    // Reference to the prefab the AI will control.
    public GameObject m_TankAIPrefab;
    
  2. 然后,以这种方式修改SpawnAllTanks函数:

    private void SpawnAllTanks(){
        // Spaw the Player
        m_Tanks[0].m_Instance = Instantiate(m_TankPrefab,
           m_Tanks[0].m_SpawnPoint.position,
           m_Tanks[0].m_SpawnPoint.rotation);
        m_Tanks[0].m_PlayerNumber = 01;
        m_Tanks[0].Setup();
        // Spawn the AI Tanks
        for (int i = 1; i < m_Tanks.Length; i++) {
            m_Tanks[i].m_Instance =
              Instantiate(m_TankAIPrefab,
              m_Tanks[i].m_SpawnPoint.position,
              m_Tanks[i].m_SpawnPoint.rotation);
            m_Tanks[i].m_PlayerNumber = i + 1;
            m_Tanks[i].Setup();
        }
    }
    

现在这个游戏是单人游戏,我们假设第一个坦克总是玩家(我们生成m_TankPrefab模型),任何其他坦克都是 AI 控制的(我们生成m_TankAIPrefab模型)。

  1. 最后,只需按照以下方式将预制件添加到检查器中。请记住,在CompleteTankAI预制件中启用m_IsAI变量,并将其层从玩家更改为AI。

![图 12.7 – 检查器中的游戏管理器脚本图片

图 12.7 – 检查器中的游戏管理器脚本

现在我们已经设置了基础知识,现在是时候编写敌方坦克的 AI 了。

使用 FSM 创建决策 AI

在第二章,“有限状态机”中,我们看到了如何实现一个简单的有限状态机(FSM)。在本节中,我们使用相同的技巧,但将应用于本演示的更复杂场景。

首先,我们需要一个 FSM 计划。我们只对将 FSM 连接到现有游戏的本演示感兴趣,所以我们将保持简单。我们的坦克 FSM 由两个状态组成——巡逻和射击。

计划很棒且直接:

  1. 人工智能坦克从“巡逻”状态开始,在之前定义的巡逻点周围徘徊。

  2. 然后,如果玩家进入范围,坦克将切换到“攻击”状态。

  3. 在“攻击”状态下,坦克转向玩家并开始对其射击。

  4. 最后,如果我们处于“攻击”状态,而玩家离开 AI 的范围,坦克将返回到“巡逻”状态。

![图 12.8 – 敌方坦克的简单 FSM图片

图 12.8 – 敌方坦克的简单 FSM

对于实现,执行以下步骤:

  1. 让我们从 FSM 类开始:

    using UnityEngine;
    using System.Collections;
    public class FSM : Complete.TankMovement {
        // Next destination position of the NPC Tank
        protected Vector3 destPos;
        // List of points for patrolling
        protected GameObject[] pointList;
        protected virtual void Initialize() { } 
        protected virtual void FSMUpdate() { } 
        protected virtual void FSMFixedUpdate() { }
        // Use this for initialization
        void Start() {
            Initialize();
        }
        // Update is called once per frame 
        void Update() {
            FSMUpdate();
        }
        void FixedUpdate() {
            FSMFixedUpdate();
        }
    }
    

如您所见,这个类扩展了Complete.TankMovement脚本。这样,我们可以重用现有的TankMovement代码,用于引擎声音和其他外观方面。

如第二章,“有限状态机”中所述,FSM 类存储了我们需要的决策 AI 数据。此外,它包含实际的Update、FixedUpdate和Start方法。在 FSM 类中,我们希望存储所有巡逻点和目的地点(坦克正在寻找的当前巡逻点)。

  1. 现在是时候创建完整的控制器了。我们创建一个新的AITankController脚本,其初始内容如下:

    using UnityEngine;
    using System;
    using UnityEngine.AI;
    public class AITankController : FSM {
        public Complete.TankShooting tankShooter;
        public Complete.TankHealth tankHealth;
        public float playerChaseRadius = 15.0f;
        public float platerAttackRadius = 10.0f;
        public float shootRate = 3.0f;
        public float targetReachedRadius = 5.0f;
        private bool isDead = false;
        private float elapsedTime = 0.0f;
        private GameObject player = null;
        private NavMeshAgent navMeshAgent;
        public enum FSMState {
            None, Patrol, Attack, Dead,
        }
        // Current state that the NPC is reaching
        public FSMState curState;
    …
    

在前面的代码中,类首先扩展了 FSM 并定义了状态。如您在FSMState枚举中看到的,我们有“巡逻”和“攻击”,一个空状态(None),以及一个最终状态(Dead)。然后我们添加了一些类属性来存储我们需要的资料。

前两个属性是对坦克中TankShooter和TankHealth脚本的引用。我们将使用它们来检查健康状况并发射子弹。然后有一个isDead布尔值来停止 FSM 执行。然后有elapsedTime和shootRate来控制坦克射击的频率,接着是两个私有属性,用于存储对玩家(如果在其范围内)和对NavMeshAgent的引用。最后,我们有一个变量用于存储 FSM 中的当前状态。

  1. Initialize函数用于初始化,当然,是 FSM:

        //Initialize the Finite state machine for the NPC tank
        protected override void Initialize() {
            navMeshAgent = GetComponent<NavMeshAgent>();
            // Get the list of points 
            pointList = GameObject.FindGameObjectsWithTag(
              "PatrolPoint");
            int rndIndex = UnityEngine.Random.Range(0,
              pointList.Length);
            destPos =
              pointList[rndIndex].transform.position;
        }
    

在这个函数中,我们做了三件事:

  • 我们获取NavMeshAgent的引用。

  • 我们获取场景中所有PatrolPoint的列表

  • 我们随机选择一个巡逻点作为代理的当前目的地。

  1. 然后是Update函数。然而,在此之前,我们需要公开坦克的当前健康值。让我们向TankHealth组件添加以下行:

        // ...
        private AudioSource m_ExplosionAudio 
        private ParticleSystem m_ExplosionParticles
        private float m_CurrentHealth;
        private bool m_Dead;
        public float CurrentHealth { get; }
        // ...
    

我们添加了CurrentHealth属性,以便我们可以获取只读公共访问权限到私有成员m_CurrentHealth。

  1. 我们现在准备好实现 FSM 的FSMUpdate方法:

        protected override void FSMUpdate() {
            switch (curState) {
                case FSMState.Patrol: 
                    UpdatePatrolState();
                    break; 
                case FSMState.Attack: 
                    UpdateAttackState(); 
                    break;
                case FSMState.Dead: 
                    UpdateDeadState();
                    break;
            }
            elapsedTime += Time.deltaTime;
            // Go to dead state is no health left
            if (tankHealth.CurrentHealth <= 0) {
                curState = FSMState.Dead;
            }
        }
    

正如我们之前解释的,Update函数的主要任务是调用适当的函数,取决于当前状态。除了那之外,FSMUpdate还更新了elapsedTime计时器,如果坦克没有健康值,则将代理设置为死亡状态。

  1. 死亡状态非常简单:坦克什么都不做,并在控制台上写上它已经死亡:

        private void UpdateDeadState() {
            if (!isDead) {
                Debug.Log("Dead");
            }
        }
    
  2. 攻击状态更有趣:

        private void UpdateAttackState() {
            Collider[] players = Physics.OverlapSphere(
              Transform.position, playerChaseRadius,
              LayerMask.GetMask("Players"));
            if (players.Length == 0) {
                curState = FSMState.Patrol;
                player = null;
                navMeshAgent.enabled = true; 
                return;
            }
            player = players[0].gameObject;
            Vector3 _direction = 
              (player.transform.position – 
               transform.position).normalized;
            Quaternion _lookRotation =
              Quaternion.LookRotation(_direction);
            transform.rotation = 
              Quaternion.Slerp(transform.rotation,
              _lookRotation, Time.deltaTime * 3);
            if (elapsedTime > shootRate) {
                tankShooter.Fire(); 
                elapsedTime = 0;
            }
        }
    

在前面代码的第一部分,我们使用 Unity 的物理引擎投射一个球体来查看半径为15单位的所有玩家。然后,如果没有玩家(意味着玩家在范围之外),我们切换到巡逻状态,移除玩家引用,启用NavMeshAgent组件,并终止状态。否则,我们继续攻击:获取玩家引用,将坦克旋转到其方向,并射击(以正确的速率)。

幸运的是,原始游戏已经实现了Fire函数!这就是为什么良好的类设计是至关重要的:如果一个类是功能性的,你可以很好地重用它,即使是为了你最初没有考虑的事情!

  1. 最后,我们有巡逻状态函数:

        private void UpdatePatrolState() {
            Collider[] players = Physics.OverlapSphere(
              transform.position, playerAttackRadius,
              LayerMask.GetMask("Players")"));
            if (players.Length > 0) {
                curState = FSMState.Attack;
                player = players[0].gameObject;
                navMeshAgent.enabled = false;
                return;
            }
            if (IsInCurrentRange(destPos)) {
                int rndIndex = UnityEngine.Random.Range(0,
                  pointList.Length);
                destPos =
                  pointList[rndIndex].transform.position;
            }
            navMeshAgent.destination = destPos;
        }
    

如果没有玩家在范围内,那么我们就开始四处游荡。首先,我们检查是否已经到达当前目的地。如果是这样,我们需要选择一个新的目的地。然后,我们将巡逻点设置为navMeshAgent组件的目标(如第八章,导航网格)中所述)。

  1. IsInCurrentRange函数只是一个简单的比较,如下面的代码所示:

        protected bool IsInCurrentRange(Vector3 pos) {
            float xPos = 
              Mathf.Abs(pos.x - transform.position.x);
            float zPos = 
              Mathf.Abs(pos.z - transform.position.z);
            if (xPos <= targetReachedRadius  && zPos <=
                targetReachedRadius ) return true;
            return false;
        }
    
  2. 就这些。将AITankController脚本添加到CompleteAITank预制件中,并连接所有必需的元素。您可以在以下屏幕截图中看到AITankController组件应该看起来是什么样子:

图 B17984_12_9.jpg

图 12.9 – 检查器中的 AI 坦克控制器脚本

记得也将预制件的层设置为AI。

图 B17984_12_10.jpg

图 12.10 – CompleteTankAI 预制件的层配置

到目前为止,一切准备就绪。所以运行游戏,享受你的简单坦克四处移动,向你射击。

摘要

在本章中,我们将之前学到的某些人工智能技术应用于我们的简单坦克战斗游戏。当然,我们将在更大游戏范围内使用更多技术。然而,在本章简短的内容中,我们重用了在第二章“有限状态机”中构建的简单 FSM 框架,以及 Unity 内置的导航网格功能。

这个示例项目是探索本书中介绍的人工智能技术的完美起点。你可以对演示中的 AI 进行更多改进,我鼓励你多玩一会儿。有几个显而易见的机会,所以这里是我的建议:

作为第一个练习,你可以增加状态的数量,例如,通过添加一个追逐状态,在这个状态下,坦克将积极寻找玩家。这种结构与攻击状态类似,但半径更大。然后,作为一个更重要的步骤,尝试用行为树替换 FSM。我们在行为树演示中实现的行为树非常适合这种场景。最后,你需要修改脚本以调用坦克游戏的正确函数,但这是一个极好的练习。

我们希望你在与游戏和 Unity3D 相关的 AI 领域学到了一些新东西。我们只是触及了游戏 AI 编程的表面,但如果你能读到这本书的结尾,你将适合未来可能遇到的任何挑战。祝你好运,玩得开心!

posted @ 2026-03-25 13:16  布客飞龙I  阅读(106)  评论(0)    收藏  举报