Defold 寻路与 AI：寻路算法、导航网格与行为树实战

决策层（脑子）：
  状态机 / 行为树 → 决定「下一步做什么」
        ↓ 下达目标
移动层（腿）：
  寻路算法 → 从 A 点到 B 点的路径
  平滑/避让 → 走起来自然

每帧：
  1. 感知（视野/距离/血量）
  2. 决策（打/追/跑/待机）
  3. 移动（朝目标走/用寻路）

f(n) = g(n) + h(n)
g(n) = 起点到 n 的实际成本
h(n) = n 到终点的估算成本（启发式，如曼哈顿距离）

开放列表：待考察节点（按 f 排序，取最小）
关闭列表：已考察节点
过程：从起点出发，扩展邻居，选 f 最小的继续，直到终点

-- 网格：1=可通过，0=障碍
local GRID = {
    {1,1,1,1,1,1},
    {1,0,0,0,1,1},
    {1,1,1,0,1,1},
    {1,0,1,1,1,1},
}

local DIRS = { {1,0},{-1,0},{0,1},{0,-1} }   -- 四方向

local function heuristic(a, b)
    return math.abs(a.x - b.x) + math.abs(a.y - b.y)   -- 曼哈顿
end

-- 返回从 start 到 goal 的路径（节点列表）
local function astar(grid, start, goal)
    local open, closed = { [start] = { g=0, f=heuristic(start, goal), from=nil } }, {}
    while next(open) do
        -- 取 f 最小的节点
        local cur, curf = nil, math.huge
        for node, data in pairs(open) do
            if data.f < curf then cur, curf = node, data.f end
        end
        if cur.x == goal.x and cur.y == goal.y then
            -- 回溯路径
            local path = {}
            local n = cur
            while n do path[#path+1] = n; n = open[n].from end
            return path
        end
        open[cur] = nil; closed[cur] = true
        for _, d in ipairs(DIRS) do
            local nx, ny = cur.x+d[1], cur.y+d[2]
            if grid[ny] and grid[ny][nx] == 1 and not closed[{x=nx,y=ny}] then
                local ng = (open[cur].g or 0) + 1
                local key = { x=nx, y=ny }
                if not open[key] or ng < open[key].g then
                    open[key] = { g=ng, f=ng+heuristic(key, goal), from=cur }
                end
            end
        end
    end
    return nil   -- 无路可达
end

-- 敌人寻路到玩家
local path = astar(GRID, {x=ex, y=ey}, {x=px, y=py})
if path then
    -- 沿路径逐节点移动
    self.path = path; self.path_idx = 1
end

Navmesh：把可行走区域多边形化 → 多边形凸块
寻路在凸多边形之间跑 → 路径更平滑、更高效

1. 手工铺设：把地形划分成凸多边形，存到 Lua 表
2. 工具生成：外部工具导出 navmesh 数据（JSON）→ Defold 加载
3. 简化：小型 2D 游戏用「网格 + 路径平滑」足够

-- 简单平滑：直线可达就跳过中间节点（视线剪枝）
local function smooth(self, path)
    local result = {}
    for i = 1, #path do
        local cur = path[i]
        if not self.prev or not line_of_sight(self.prev, cur) then
            result[#result+1] = cur
            self.prev = cur
        end
    end
    return result
end

-- 朝玩家移动
local player = self.player_pos
local dir = vmath.normalize(player - go.get_position("."))
go.set_velocity("." , dir * self.speed)   -- 或手动位移

-- 巡逻点列表
self.patrol = { vmath.vector3(10,0,0), vmath.vector3(60,0,0) }
self.patrol_idx = 1

local function update_patrol(self)
    local target = self.patrol[self.patrol_idx]
    local pos = go.get_position(".")
    local dist = vmath.length(target - pos)
    if dist < 5 then   -- 到达 → 换下一个点
        self.patrol_idx = (self.patrol_idx % #self.patrol) + 1
    else
        local dir = vmath.normalize(target - pos)
        go.set_position("." , pos + dir * self.speed * dt)
    end
end

-- 距离 + 角度 + 射线遮挡
local function has_line_of_sight(self, from, to)
    local dist = vmath.length(to - from)
    if dist > self.view_range then return false end          -- 超出视野
    local hit = physics.raycast(from, to)                     -- 射线
    return not hit or hit.distance > dist                     -- 无遮挡
end

local STATE = { IDLE=1, CHASE=2, ATTACK=3 }

function init(self)
    self.state = STATE.IDLE
    self.range = 200      -- 警觉距离
    self.attack_range = 40
    self.attack_cd = 0
end

function update(self, dt)
    local player = self.player_pos
    local pos = go.get_position(".")
    local dist = vmath.length(player - pos)

    -- 状态转移
    if dist < self.range and self.state ~= STATE.CHASE then
        set_state(self, STATE.CHASE)
    elseif dist < self.attack_range and self.state ~= STATE.ATTACK then
        set_state(self, STATE.ATTACK)
    elseif dist > self.range and self.state == STATE.CHASE then
        set_state(self, STATE.IDLE)
    end

    -- 状态行为
    if self.state == STATE.CHASE then
        chase_player(self, dt)          -- 追逐
    elseif self.state == STATE.ATTACK then
        attack_player(self, dt)         -- 攻击 + 冷却
    end
end

       选择器（Sequence 全成 / Selector 任一）
        └─ 条件：玩家在视野？
        └─ 序列：
             ├─ 行动：追击
             ├─ 条件：距离 < 攻击距离？
             └─ 行动：攻击

-- 行为节点：返回 "success" / "fail" / "running"
local function node_chase(self, ctx)
    if not ctx.target then return "fail" end
    chase_player(self, ctx.dt)
    return vmath.length(ctx.target - go.get_position(".")) > 40 and "running" or "success"
end

local function node_attack(self, ctx)
    if vmath.length(ctx.target - go.get_position(".")) > 40 then return "fail" end
    attack_player(self)
    return "running"
end

-- 选择器：依次尝试，成功即返回
local function selector(...)
    return function(self, ctx)
        for _, n in ipairs({...}) do
            local r = n(self, ctx)
            if r ~= "fail" then return r end
        end
        return "fail"
    end
end

-- 对每个邻居施加斥力
local function separation(self)
    local push = vmath.vector3(0, 0, 0)
    for _, other in ipairs(self.nearby) do
        local delta = go.get_position(".") - other.pos
        local d = vmath.length(delta)
        if d < self.min_sep and d > 0.01 then
            push = push + vmath.normalize(delta) / d   -- 距离越近斥力越大
        end
    end
    return push * self.sep_strength
end

-- 士兵跟随队长，保持队形偏移
local function follow_leader(self, leader_pos, offset)
    local target = leader_pos + offset
    local dir = vmath.normalize(target - go.get_position("."))
    go.set_position(".", go.get_position(".") + dir * self.speed * dt)
end

-- 每帧只更新 1/3 的敌人（轮流）
function update(self, dt)
    local i = self.frame % 3
    for j = i, #self.enemies, 3 do
        update_enemy_ai(self.enemies[j], dt)
    end
    self.frame = self.frame + 1
end