阅读 265

Godot游戏开发实践之四:搬运Unity的Pluggable AI教程

Godot游戏开发实践之四

一、前言

在之前的几篇文章里我简单地介绍了 AI 寻路方式以及 Resource 的相关应用,那其实都是为这篇文章做铺垫的,本篇的内容是基于油管上一个比较老的 Unity AI 系列教程: Unity tutorial: Pluggable AI With Scriptable Objects ,教程详细介绍了 Unity 中如何实现可插拨式 AI 的功能,在我的一番苦苦研究下,硬生生地把它给搬运到了 Godot 中,搬运过程可谓是费了九牛二虎之力,这其中一部分原因是由于自己对 Godot API 的熟练程度不够,另一方面则是 Godot 本身的一些缺陷,这些我都会在本文中提出来。

Unity tutorial: Pluggable AI With Scriptable Objects

因为 Unity 中的 ScriptObject 在 Godot 中相当于 Resource ,如果不是很熟悉,推荐大家阅读我的上一篇文章: Godot游戏开发实践之三:容易被忽视的Resource 。另外,搬用并等于照抄,本 Demo 实现的部分 AI 功能使用的是我自己的方式,这也在我之前的文章里有详细介绍: Godot游戏开发实践之二:AI之寻路新方式

说明:我不会很详细的讲述如何实现某些特定功能,所以推荐大家观看原 Unity 视频,如果上油管不方便,也请放心,视频教程我已经搬运到我的网盘,分享链接请关注我的公众号,回复 AI教程 即可(友情提示:套路……),哈哈。

主要内容: 无
阅读时间: 12 分钟
永久链接: liuqingwen.me/2020/09/08/…
系列主页: liuqingwen.me/introductio…

二、正文

除了参考原视频教程,也可以克隆本 Demo 的源码,我已经上传到 Github ,供有兴趣的同学参考。

Godot Pluggable AI

什么是可插拨AI

所谓可插拨其实和安装插件、热插拨等概念类似,就是可以随意添加或者删除某个功能,通过直接拖拽就能组成复杂的 AI 体系而无须手动重复编写代码,在 Unity 中使用的是 ScriptableObject 而 Godot 中即 Resource :

拖拽赋值

其实在编辑器方面, Unity 使用起来比 Godot 舒服多了。 :joy:

先说Godot的问题

搬运这个 AI 教程的时候,我反反复复、仔仔细细研究了很多次,在按步照搬的过程中出现了一个非常奇怪且头疼的问题:游戏无症状、无征兆地闪退

代码看上去没问题,按下 F5 运行游戏,窗口还没显示就马上停止运行,连错误提示都没有。曾经因为这个错误我一度想着放弃算了,但是转念一想, Godot 开发者岂能低头?! 所以我继续尝试,寻找错误原因,探索可行的解决方案,从至少能正常运行开始一步一步添加相关功能,最终发现了闪退的罪魁祸首: Circular reference to resource循环引用报错,这在我之前的文章中已经聊过,也有朋友遇到过类似的问题,错误信息大概是:

"scene/resources/resource_format_text.cpp:1387 - Circular reference to resource being saved found: 'res://src/Resources/States/???.tres' will be null next time it's loaded."

哪来的循环引用呢?熟悉游戏结构你就会感觉到这是很显然的:在我的游戏中有很多 Resource 资源类,比如 Action/Decision/State/Transitions 等,而这些资源相互之间或多或少发生了一些引用,就像 PatrolChaser 中引用了 ChaseChaser ,反过来 ChaseChaser 又引用 PatrolChaser 从而造成循环引用链,甚至还有更加复杂的、难以发觉的、千丝万缕的引用关系蕴含其中:

Alert Scanner -> Patrol Scanner -> Chase Scanner -> Alert Scanner -> Chase Scanner -> Alert Scanner -> ...

在编程语言里这些引用再正常不过,但是 Godot 3 还不能正常处理循环引用,这会在 4.0 中进行修复,我可不想等到明年春天了,最终解决方式是放弃部分插拨功能,对一些参数不采用推拽赋值的方式,取而代之的是在运行时判断对应资源是否为 null 再决定动态加载进行赋值,这就造成了需要额外的一个变量用来指向对应 Resource 文件的路径:

使用路径动态赋值

主要代码如下:

# trueState 和 falseState 可以为 null
# 如果为 null 则使用对应的文件路径进行动态加载
func _checkTransitions(controller : StateController) -> void:
    for transition in transitions:
    var decisionSucceeded : bool = transition.decision.decide(controller)
    if decisionSucceeded:
        var trueState = transition.trueState
        if trueState == null:  # 如果置空则动态加载一次
            trueState = load(transition.trueStateResource)
            transition.trueState = trueState
        controller.transitionToState(trueState)
    else:
        var falseState = transition.falseState
        if falseState == null:  # 如果置空则动态加载一次
            falseState = load(transition.falseStateResource)
            transition.falseState = falseState
        controller.transitionToState(falseState)
复制代码

除此之外,还有一个不忍直视的问题是在编辑器中显示资源值的视图,一旦涉及多个参数、多种类型、多个级别的资源混合在一起,那么他们之间的层级关系在属性面板中变得极其难以辨别,感同身受一下这张慢动图所带来的崩溃心情吧:

复杂的变量关系属性图

嗯,此刻的我心中万马奔腾,无限次奔溃闪退并自动重启中……

AI结构分析

如果你看完了整个视频教程,你会发现这个 AI 系统的几个重要部件:

  • Action 表示动作,比如巡逻、射击等动作的控制实现
  • Decision 表示策略行为的决定,即状态之间进行切换的依据
  • State 表示状态,一个状态即一种 AI 行为,不同状态之间根据决定进行切换
  • Transition 包装了两个状态(正反状态),以及状态发生转换的决定

他们之间的关系图,以及主要的行为类:

AI关系图

Action 父类代码:

extends Resource
class_name AbstractAction, 'res://assets/icons/action-icon.svg'

export var debugDrawColor := Color.black # 颜色显示,Debug用
export var resourceName := 'Action'      # 名字,Debug用

# 动作的行为方法,每帧都会调用
func act(controller : StateController) -> void:
  pass
复制代码

Decision 父类代码:

extends Resource
class_name AbstractDecision, 'res://assets/icons/decision-icon.svg'

export var debugDrawColor := Color.white # 颜色显示,Debug用
export var resourceName := 'Decision'    # 名字,Debug用

# 决定的方法,包装在 Transition 中,每帧都会调用
# 返回结果决定了切换到的状态
func decide(controller : StateController) -> bool:
  return false
复制代码

State 状态类代码:

extends Resource
class_name State, 'res://assets/icons/state-icon.svg'

export(Array, Resource) var actions = []       # 当前状态下所有动作集合
export(Array, Resource) var transitions = []   # 所有的状态转换机制集合
export var debugStateColor := Color.green      # 颜色显示,Debug用

# 每帧执行状态更新
func updateState(controller : StateController) -> void:
  _doActions(controller)
  _checkTransitions(controller)

# 循环执行所有动作
func _doActions(controller : StateController) -> void:
  for action in actions:
    action.act(controller)

# 检查每一个转换机制,是否可以进行状态转换
func _checkTransitions(controller : StateController) -> void:
  # 代码参考上文
  # 省略……
复制代码

控制器 Controller 和过渡机制 Transition 的代码就不贴了,控制器中代码都是一些基本状态和控制操作的实现。这里我把视频中介绍的所有 AI 类型例举如下:

Chase Chaser: {
  Actions: [ChaseAction, AttackAction],
  Transitions: {Decision: ActiveStateDecision, TrueState: Remain State, FalseState: Patrol Chaser}
}
Patrol Chaser: {
  Actions: [PatrolAction],
  Transitions: {Decision: LookDecision, TrueState: Chase Chaser, FalseState: Remain State}
}
Chase Scanner: {
  Actions: [ChaseAction, AttackAction],
  Transitions: {Decision: LookDecision, TrueState: Remain State, FalseState: Alert Scanner}
}
Patrol Scanner: {
  Actions: [PatrolAction],
  Transitions: {Decision: LookDecision, TrueState: Chase Scanner, FalseState: Remain State}
}
Alert Scanner: {
  Actions: [],
  Transitions: [{Decision: ScanDecision, TrueState: Patrol Scanner, FalseState: Remain State}, {Decision: LookDecision, TrueState: Chase Scanner, FalseState: Remain State}]
}
复制代码

当然,这个 AI 系统绝不局限于此,你完全可以组合出更多 AI 状态,也可以添加你心目中所要实现的其他动作、决定、过渡和状态类,丰富这个强大的 AI 系统。

其他小功能简介

最后,游戏中使用的一些小技巧我也在本篇中简单介绍一下,包括:炸弹的范围伤害、相机自动跟踪、子弹高度模拟等。

炸弹范围伤害

炸弹范围伤害

从图中可以看出,我使用了指数级的衰减函数,也就是说距离炸弹爆炸中心越远,伤害衰减的越厉害,个人认为要符合现实一些,当然你完全可以使用简单的线性函数,伤害和距离成反比,这取决于你自己以及游戏机制的设计:

# 伤害最大范围
onready var damageRange : float = $CollisionShape2D.shape.radius

func _on_Explosion_body_entered(body: Node) -> void:
    if body.has_method('damaged'):
      var vector : Vector2 = body.global_position - self.global_position
      # 指数系数
      var ratio : float = 1.0 - pow(vector.length() / damageRange, 0.6)
      # 伤害和冲击力
      var damage := ceil(maxDamage * ratio)
      var force : Vector2 = maxForce * ratio * vector.normalized()
      body.damaged(damage, force)
复制代码

相机自动跟踪

在本示例中我使用了相机自动跟踪的效果。

因为类似于多人游戏,使用相机进行跟踪是有必要的,这样可以保证所有的坦克、玩家都在当前视野中。实现起来不难,根据当前玩家数量以及玩家的位置计算最大边距以及中心点,然后移动并设置相机的缩放即可:

# 窗口大小
onready var _windowSize := self.get_viewport_rect().size
# 跟踪的目标
var targets := []

func _process(delta: float) -> void:
  if targets.size() <= 1:
    _camera.zoom = lerp(_camera.zoom, Vector2.ONE, 2.0 * delta)
    return
  
  var minPos := _windowSize  # 最小位置点
  var maxPos := Vector2.ZERO # 最大位置点
  for target in targets:
    if ! is_instance_valid(target):
      continue
    if target.global_position.x < minPos.x:
      minPos.x = target.global_position.x
    if target.global_position.x > maxPos.x:
      maxPos.x = target.global_position.x
    if target.global_position.y < minPos.y:
      minPos.y = target.global_position.y
    if target.global_position.y > maxPos.y:
      maxPos.y = target.global_position.y
  # 移动到中心点
  self.global_position = lerp(self.global_position, (maxPos + minPos) / 2, 2.0 * delta)
  
  # 计算缩放比例,相对于游戏主窗口
  var zoom = 2.0 * max((maxPos.x - minPos.x) / _windowSize.x, (maxPos.y - minPos.y) / _windowSize.y)
  zoom = clamp(zoom, 0.5, 1.0)
  _camera.zoom = lerp(_camera.zoom, Vector2.ONE * zoom, 2.0 * delta)
复制代码

子弹高度模拟

原 Unity 视频中的 Tank 是一个 3D 游戏,所以子弹也就有射程(落地)和高度之分,如果在 2D 场景中不设置高度,炸弹只要碰上其他炸弹或者静态物体都会直接爆炸,那么游戏中的发射力(射程)也就毫无意义了,所以我使用代码简单地实现了子弹高度的模拟。

子弹高度模拟

思路大概是这样的:给子弹添加一个阴影,阴影大小和透明度随子弹高度发生变化,飞行中的子弹在垂直方向上偏移一定位置表示高度,最后把碰撞体设置在阴影上。这里的变化都使用了线性比例,实现方式也相对简单,从上图也可以看出来:

export var missileBodyMaxOffset := 60.0            # 最高时子弹视觉偏移
export(float, 1.0, 10.0) var shadowMaxScale := 1.5 # 阴影最大缩放,即子弹离地最低点
export(float, 0.0, 1.0) var shadowMinScale := 0.5  # 阴影最小缩放,即子弹离地最高点
export(float, 0.0, 1.0) var shadowMinAlpha := 0.25 # 阴影最小透明度,最高点
export(float, 1.0, 2.0) var shadowMaxAlpha := 2.5  # 阴影最大透明度,最低点

func init(force : float, maxSpeed : int, resistance : int, dir : Vector2) -> void:
  _direction = dir
  _fullSpeed = maxSpeed
  _moveResistance = resistance # 阻力,即重力加速度
  
  # 计算能达到的最大高度
  _maxFlyHeight = 0.5 * maxSpeed * maxSpeed / resistance
  # 计算线性关系系数a和b:y=ax+b
  _paramScaleA = (shadowMinScale - shadowMaxScale) / _maxFlyHeight
  _paramScaleB = shadowMaxScale
  _paramAlphaA = (shadowMaxAlpha - shadowMinAlpha) / (shadowMinScale - shadowMaxScale)
  _paramAlphaB = shadowMaxAlpha - shadowMinScale * _paramAlphaA
  
  # 保证炸弹总是往上方偏移,不然看起来奇怪
  var angle = fmod(dir.angle(), 2 * PI)
  if angle > PI * 0.5 || angle < - PI * 0.5:
    missileBodyMaxOffset = -missileBodyMaxOffset
  
  # 水平和垂直初始速度一样,模拟45度发射导弹
  _velocityX = force * maxSpeed
  _velocityY = force * maxSpeed

# 计算水平和垂直位移
func _physics_process(delta: float) -> void:
  self.position += _direction * _velocityX * delta
  _velocityY -= _moveResistance * delta
  currentHeight += _velocityY * delta
  _adjustHeight(currentHeight)
  if currentHeight <= 0.0:
    explode()

# 根据高度调整阴影大小、透明度、子弹垂直偏移
func _adjustHeight(height : float) -> void:
  _body.position.y = - height / _maxFlyHeight * missileBodyMaxOffset
  var shadowScale = _paramScaleA * height + _paramScaleB
  _shadow.scale = Vector2.ONE * shadowScale
  var shadowAlpha = _paramAlphaA * shadowScale + _paramAlphaB
  _shadow.modulate.a = shadowAlpha
复制代码

嗯,我就想弱弱问一句:现实生活中物体越高其阴影是越大还是越小呢?……

三、总结

这种 AI 系统具有比较强的扩展性和易用性,有点复杂问题简单模块化的思维,用起来应该会相当爽,当然我也没有具体项目案例,另外也有一些不足之,个人经验主要概括为这两点:

  1. Pluggable AI 确实比较强大,使用非常方便,因为是可插拨,即使配置复杂的 AI 都只要轻轻一拖一拽一松手就完成了
  2. 但是这种方式也有令人不爽的地方,比如耦合还是比较厉害的,代码中需要访问、修改很多玩家相关数据,依然需要一番精心的设计

好在 Unity 中具有更加成熟的碰撞检测相关 API ,比如 SphereCast 还有 Navigator 都是极好用的 AI 辅助工具, Godot 中就只能手动实现了。 :joy:

最后,务必关注我的公众号,回复 AI教程 我会送上本套视频以及非常棒的一套 AStar 讲解视频(毫无疑问也是在 Unity 中实现,但是原理通用)。本篇的 Demo 以及相关代码已经上传到 Github ,地址: github.com/spkingr/God… , 后续继续更新,原创不易,希望大家喜欢! :smile:

我的博客地址: liuqingwen.me ,我的博客即将同步至腾讯云+社区,邀请大家一同入驻: cloud.tencent.com/developer/s… ,欢迎关注我的微信公众号(第一时间更新+游戏开发资源+相关资讯):IT自学不成才

文章分类
开发工具
文章标签