Lua游戏AI脚本实现

发布时间: 2025-03-24 12:13

↑

# Lua游戏AI脚本实现

本文将介绍如何使用Lua实现游戏AI,包括基本的AI行为控制、决策系统以及高级AI技术的应用。

## AI系统架构

### 1. 基本组件

```lua
-- AI控制器基类
local AIController = {}
AIController.__index = AIController

function AIController.new()
    local self = setmetatable({}, AIController)
    self.blackboard = {} -- 数据共享
    self.behaviors = {} -- 行为列表
    return self
end

function AIController:Update()
    for _, behavior in ipairs(self.behaviors) do
        behavior:Execute(self.blackboard)
    end
end

-- 行为基类
local Behavior = {}
Behavior.__index = Behavior

function Behavior.new()
    return setmetatable({}, Behavior)
end

function Behavior:Execute(blackboard)
    -- 由子类实现
end
```

### 2. 行为树实现

```lua
-- 行为树节点类型
local NodeType = {
    SEQUENCE = 1, -- 顺序节点
    SELECTOR = 2, -- 选择节点
    ACTION = 3,   -- 动作节点
}

-- 行为树节点
local BTNode = {}
BTNode.__index = BTNode

function BTNode.new(type)
    local self = setmetatable({}, BTNode)
    self.type = type
    self.children = {}
    return self
end

function BTNode:AddChild(child)
    table.insert(self.children, child)
end

function BTNode:Execute(blackboard)
    if self.type == NodeType.SEQUENCE then
        -- 顺序执行所有子节点
        for _, child in ipairs(self.children) do
            if not child:Execute(blackboard) then
                return false
            end
        end
        return true
    elseif self.type == NodeType.SELECTOR then
        -- 选择一个可执行的子节点
        for _, child in ipairs(self.children) do
            if child:Execute(blackboard) then
                return true
            end
        end
        return false
    end
end
```

## 实现常见AI行为

### 1. 巡逻行为

```lua
-- 巡逻行为
local Patrol = {}
setmetatable(Patrol, {__index = Behavior})

function Patrol.new(waypoints)
    local self = Behavior.new()
    self.waypoints = waypoints
    self.currentPoint = 1
    return setmetatable(self, {__index = Patrol})
end

function Patrol:Execute(blackboard)
    local entity = blackboard.entity
    local target = self.waypoints[self.currentPoint]
    
    -- 移动到目标点
    local pos = entity:GetPosition()
    local dist = Vector.Distance(pos, target)
    
    if dist < 0.1 then
        -- 到达目标点,切换到下一个点
        self.currentPoint = self.currentPoint % #self.waypoints + 1
        return true
    else
        -- 继续移动
        local dir = Vector.Normalize(target - pos)
        entity:Move(dir * blackboard.moveSpeed)
        return false
    end
end
```

### 2. 追踪行为

```lua
-- 追踪行为
local Chase = {}
setmetatable(Chase, {__index = Behavior})

function Chase.new()
    local self = Behavior.new()
    return setmetatable(self, {__index = Chase})
end

function Chase:Execute(blackboard)
    local entity = blackboard.entity
    local target = blackboard.target
    
    if not target then
        return false
    end
    
    local pos = entity:GetPosition()
    local targetPos = target:GetPosition()
    local dist = Vector.Distance(pos, targetPos)
    
    if dist < blackboard.attackRange then
        -- 在攻击范围内
        return true
    else
        -- 追踪目标
        local dir = Vector.Normalize(targetPos - pos)
        entity:Move(dir * blackboard.moveSpeed)
        return false
    end
end
```

### 3. 战斗行为

```lua
-- 战斗行为
local Combat = {}
setmetatable(Combat, {__index = Behavior})

function Combat.new()
    local self = Behavior.new()
    self.attackTimer = 0
    return setmetatable(self, {__index = Combat})
end

function Combat:Execute(blackboard)
    local entity = blackboard.entity
    local target = blackboard.target
    
    if not target then
        return false
    end
    
    -- 检查攻击冷却
    if self.attackTimer > 0 then
        self.attackTimer = self.attackTimer - Time.deltaTime
        return false
    end
    
    -- 执行攻击
    entity:Attack(target)
    self.attackTimer = blackboard.attackCooldown
    return true
end
```

## 决策系统

### 1. 状态机

```lua
-- 状态机
local StateMachine = {}
StateMachine.__index = StateMachine

function StateMachine.new()
    local self = setmetatable({}, StateMachine)
    self.states = {}
    self.currentState = nil
    return self
end

function StateMachine:AddState(name, state)
    self.states[name] = state
end

function StateMachine:SetState(name)
    if self.currentState then
        self.currentState:Exit()
    end
    self.currentState = self.states[name]
    if self.currentState then
        self.currentState:Enter()
    end
end

function StateMachine:Update()
    if self.currentState then
        self.currentState:Update()
    end
end
```

### 2. 效用AI

```lua
-- 效用计算器
local UtilityAI = {}
UtilityAI.__index = UtilityAI

function UtilityAI.new()
    local self = setmetatable({}, UtilityAI)
    self.actions = {}
    return self
end

function UtilityAI:AddAction(action, evaluator)
    table.insert(self.actions, {
        action = action,
        evaluator = evaluator
    })
end

function UtilityAI:SelectBestAction(context)
    local bestScore = -1
    local bestAction = nil
    
    for _, action in ipairs(self.actions) do
        local score = action.evaluator(context)
        if score > bestScore then
            bestScore = score
            bestAction = action.action
        end
    end
    
    return bestAction
end
```

## 高级AI技术

### 1. 寻路系统

```lua
-- A*寻路算法
local AStar = {}
AStar.__index = AStar

function AStar.new(grid)
    local self = setmetatable({}, AStar)
    self.grid = grid
    return self
end

function AStar:FindPath(start, goal)
    local openSet = {start}
    local closedSet = {}
    local cameFrom = {}
    
    local gScore = {[start] = 0}
    local fScore = {[start] = self:Heuristic(start, goal)}
    
    while #openSet > 0 do
        local current = self:GetLowestFScore(openSet, fScore)
        
        if current == goal then
            return self:ReconstructPath(cameFrom, current)
        end
        
        table.remove(openSet, self:IndexOf(openSet, current))
        table.insert(closedSet, current)
        
        for _, neighbor in ipairs(self:GetNeighbors(current)) do
            if not self:Contains(closedSet, neighbor) then
                local tentativeGScore = gScore[current] + 1
                
                if not self:Contains(openSet, neighbor) then
                    table.insert(openSet, neighbor)
                elseif tentativeGScore >= gScore[neighbor] then
                    goto continue
                end
                
                cameFrom[neighbor] = current
                gScore[neighbor] = tentativeGScore
                fScore[neighbor] = gScore[neighbor] + self:Heuristic(neighbor, goal)
                
                ::continue::
            end
        end
    end
    
    return nil -- 没有找到路径
end
```

### 2. 群体行为

```lua
-- 群体行为控制器
local FlockController = {}
FlockController.__index = FlockController

function FlockController.new()
    local self = setmetatable({}, FlockController)
    self.agents = {}
    self.separationWeight = 1.5
    self.alignmentWeight = 1.0
    self.cohesionWeight = 1.0
    return self
end

function FlockController:AddAgent(agent)
    table.insert(self.agents, agent)
end

function FlockController:Update()
    for _, agent in ipairs(self.agents) do
        local separation = self:CalculateSeparation(agent)
        local alignment = self:CalculateAlignment(agent)
        local cohesion = self:CalculateCohesion(agent)
        
        -- 合并三个力
        local force = separation * self.separationWeight +
                     alignment * self.alignmentWeight +
                     cohesion * self.cohesionWeight
        
        agent:ApplyForce(force)
    end
end
```

## 调试与优化

### 1. 可视化调试

```lua
-- AI调试器
local AIDebugger = {}
AIDebugger.__index = AIDebugger

function AIDebugger.new()
    local self = setmetatable({}, AIDebugger)
    self.enabled = false
    return self
end

function AIDebugger:DrawPath(path)
    if not self.enabled then return end
    
    for i = 1, #path - 1 do
        local start = path[i]
        local finish = path[i + 1]
        Debug.DrawLine(start, finish, Color.yellow)
    end
end

function AIDebugger:DrawSensor(position, radius)
    if not self.enabled then return end
    
    Debug.DrawCircle(position, radius, Color.red)
end
```

### 2. 性能优化

```lua
-- 空间分区系统
local SpatialGrid = {}
SpatialGrid.__index = SpatialGrid

function SpatialGrid.new(cellSize)
    local self = setmetatable({}, SpatialGrid)
    self.cellSize = cellSize
    self.cells = {}
    return self
end

function SpatialGrid:GetNearbyEntities(position, radius)
    local nearby = {}
    local cellX = math.floor(position.x / self.cellSize)
    local cellY = math.floor(position.y / self.cellSize)
    
    -- 检查周围的格子
    for x = -1, 1 do
        for y = -1, 1 do
            local key = (cellX + x) .. "," .. (cellY + y)
            local cell = self.cells[key]
            
            if cell then
                for _, entity in ipairs(cell) do
                    if Vector.Distance(position, entity:GetPosition()) <= radius then
                        table.insert(nearby, entity)
                    end
                end
            end
        end
    end
    
    return nearby
end
```

## 实际应用示例

### 1. NPC AI控制器

```lua
-- NPC控制器
local NPCController = {}
setmetatable(NPCController, {__index = AIController})

function NPCController.new()
    local self = AIController.new()
    
    -- 初始化状态机
    self.stateMachine = StateMachine.new()
    self.stateMachine:AddState("Idle", IdleState.new())
    self.stateMachine:AddState("Patrol", PatrolState.new())
    self.stateMachine:AddState("Chase", ChaseState.new())
    self.stateMachine:AddState("Combat", CombatState.new())
    
    -- 初始化行为树
    self.behaviorTree = self:CreateBehaviorTree()
    
    return setmetatable(self, {__index = NPCController})
end

function NPCController:Update()
    -- 更新感知系统
    self:UpdatePerception()
    
    -- 更新状态机
    self.stateMachine:Update()
    
    -- 执行行为树
    self.behaviorTree:Execute(self.blackboard)
end

function NPCController:CreateBehaviorTree()
    local root = BTNode.new(NodeType.SELECTOR)
    
    -- 战斗序列
    local combatSequence = BTNode.new(NodeType.SEQUENCE)
    combatSequence:AddChild(TargetInRange.new())
    combatSequence:AddChild(Combat.new())
    
    -- 追踪序列
    local chaseSequence = BTNode.new(NodeType.SEQUENCE)
    chaseSequence:AddChild(HasTarget.new())
    chaseSequence:AddChild(Chase.new())
    
    -- 巡逻行为
    local patrol = Patrol.new(self.waypoints)
    
    root:AddChild(combatSequence)
    root:AddChild(chaseSequence)
    root:AddChild(patrol)
    
    return root
end
```

元素码农