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

# 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)

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

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

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:
  # 代码参考上文
  # 省略……

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}]
}

# 伤害最大范围
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)

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