Lua for Game Development — Chapter 6: AI Systems — BT, FSM, Utility AI, GOAP, Navigation, Hybrid AI

local FSM = {}
FSM.__index = FSM

function FSM.new(initial)
  return setmetatable({state = initial, states = {}}, FSM)
end

function FSM:add(name, fn)
  self.states[name] = fn
end

function FSM:update(dt, entity)
  local fn = self.states[self.state]
  if fn then
    self.state = fn(self, dt, entity) or self.state
  end
end

return FSM

local fsm = FSM.new("idle")

fsm:add("idle", function(self, dt, e)
  if distance_to_player(e) < 50 then
    return "chase"
  end
end)

fsm:add("chase", function(self, dt, e)
  move_towards_player(e, dt)
  if distance_to_player(e) < 10 then
    return "attack"
  end
end)

fsm:add("attack", function(self, dt, e)
  do_attack(e)
  return "idle"
end)

local BT = {}

function BT.action(fn)
  return { type="action", run=fn }
end

function BT.sequence(children)
  return { type="sequence", children=children }
end

function BT.selector(children)
  return { type="selector", children=children }
end

return BT

local function run(node, entity)
  if node.type == "action" then
    return node.run(entity)
  end

  if node.type == "sequence" then
    for _, child in ipairs(node.children) do
      if run(child, entity) ~= "success" then
        return "fail"
      end
    end
    return "success"
  end

  if node.type == "selector" then
    for _, child in ipairs(node.children) do
      if run(child, entity) == "success" then
        return "success"
      end
    end
    return "fail"
  end
end

local tree = BT.selector({
  BT.action(function(e)
    if e.hp < 20 then flee(e); return "success" end
    return "fail"
  end),

  BT.sequence({
    BT.action(function(e)
      if see_player(e) then return "success" end
      return "fail"
    end),
    BT.action(function(e)
      chase(e)
      return "success"
    end)
  }),

  BT.action(function(e)
    patrol(e)
    return "success"
  end)
})

run(tree, enemy)

local util_ai = {}

function util_ai.choose(entity, actions)
  local best_score, best_action = -1, nil
  for _, a in ipairs(actions) do
    local score = a.score(entity)
    if score > best_score then
      best_score = score
      best_action = a
    end
  end
  return best_action
end

return util_ai

local actions = {
  {
    name = "heal",
    score = function(e) return 1 - (e.hp / e.max_hp) end,
    run = function(e) heal(e) end
  },
  {
    name = "attack",
    score = function(e) return distance_to_player(e) < 10 and 0.9 or 0.1 end,
    run = function(e) attack(e) end
  },
  {
    name = "patrol",
    score = function(e) return 0.2 end,
    run = function(e) patrol(e) end
  },
}

local chosen = util_ai.choose(enemy, actions)
chosen.run(enemy)

local Action = {}
Action.__index = Action

function Action.new(cfg)
  return setmetatable({
    name = cfg.name,
    cost = cfg.cost,
    pre = cfg.pre,
    effect = cfg.effect,
  }, Action)
end

return Action

local function satisfies(state, goal)
  for k, v in pairs(goal) do
    if state[k] ~= v then return false end
  end
  return true
end

local function apply(state, effect)
  for k, v in pairs(effect) do
    state[k] = v
  end
end

local function plan(state, actions, goal, depth)
  if satisfies(state, goal) then return {} end
  if depth <= 0 then return nil end

  for _, action in ipairs(actions) do
    local ok = true
    for k, v in pairs(action.pre) do
      if state[k] ~= v then ok = false break end
    end

    if ok then
      local new_state = {}
      for k, v in pairs(state) do new_state[k] = v end
      apply(new_state, action.effect)

      local sub = plan(new_state, actions, goal, depth - 1)
      if sub then
        table.insert(sub, 1, action)
        return sub
      end
    end
  end
end

local state = {has_weapon=false, enemy_visible=true}
local goal = {enemy_dead=true}

local actions = {
  Action.new({
    name="pickup",
    pre={has_weapon=false},
    effect={has_weapon=true},
  }),
  Action.new({
    name="shoot",
    pre={has_weapon=true, enemy_visible=true},
    effect={enemy_dead=true},
  })
}

local plan_seq = plan(state, actions, goal, 4)

for _, act in ipairs(plan_seq) do
  print("Action:", act.name)
end

local function astar(start, goal, grid)
  local open = {[start]=true}
  local came = {}
  local cost = {[start]=0}

  while next(open) do
    local current = nil
    for k in pairs(open) do current = k break end
    open[current] = nil

    if current == goal then break end

    for _, n in ipairs(grid.neighbors(current)) do
      local new_cost = cost[current] + 1
      if not cost[n] or new_cost < cost[n] then
        cost[n] = new_cost
        came[n] = current
        open[n] = true
      end
    end
  end

  local path = {}
  local cur = goal
  while cur do
    table.insert(path, 1, cur)
    cur = came[cur]
  end

  return path
end

local Blackboard = {}
Blackboard.__index = Blackboard

function Blackboard.new()
  return setmetatable({data = {}}, Blackboard)
end

function Blackboard:set(key, value)
  self.data[key] = value
end

function Blackboard:get(key)
  return self.data[key]
end

return Blackboard

bb = Blackboard.new()
bb:set("player_pos", {x=10,y=20})
bb:set("alert", false)

boss.fsm = FSM.new("phase1")

boss.fsm:add("phase1", function(self, dt, e)
  if e.hp < 50 then return "phase2" end
  run(tree_phase1, e)
end)

boss.fsm:add("phase2", function(self, dt, e)
  run(tree_phase2, e)

  local action = util_ai.choose(e, boss_actions)
  action.run(e)
end)

local function enemy_ai(e, dt)
  if not e.blackboard:get("initialized") then
    e.blackboard:set("initialized", true)
  end

  -- update timers
  if e.cooldown > 0 then e.cooldown = e.cooldown - dt end

  -- high-level decisions
  local action = util_ai.choose(e, actions)
  action.run(e)

  -- BT logic for moving/attacking
  run(tree, e)
end