1
// 三种状态：巡逻 → 追击 → 攻击
2
public enum EnemyState { Patrol, Chase, Attack, Dead }
3

4
public class SimpleEnemyFSM : MonoBehaviour {
5
    private EnemyState state = EnemyState.Patrol;
6

7
    void Update() {
8
        switch (state) {
9
        case EnemyState.Patrol:
10
            PatrolUpdate();
11
            if (CanSeePlayer()) state = EnemyState.Chase;
12
            break;
13
        case EnemyState.Chase:
14
            ChaseUpdate();
15
            if (InAttackRange()) state = EnemyState.Attack;
16
            else if (!CanSeePlayer()) state = EnemyState.Patrol;
17
            break;
18
        case EnemyState.Attack:
19
            AttackUpdate();
20
            if (!InAttackRange()) state = EnemyState.Chase;
21
            break;
22
        case EnemyState.Dead:
23
            break;
24
        }
25
    }
26
}

1
// ============ 核心枚举与基类 ============
2
public enum NodeState {
3
    Success,   // 成功完成
4
    Failure,   // 执行失败
5
    Running    // 还在执行中（持续型动作）
6
}
7

8
public abstract class BTNode {
9
    public abstract NodeState Evaluate();
10
}
11

12
// ============ Selector（选择节点）——"或"逻辑 ============
13
// 从左到右尝试子节点，任意一个成功 → 成功
14
// 用途：表示优先级——"先尝试这个，不行再那个"
15
public class Selector : BTNode {
16
    private List<BTNode> children = new List<BTNode>();
17

18
    public Selector(params BTNode[] children) {
19
        this.children.AddRange(children);
20
    }
21

22
    public override NodeState Evaluate() {
23
        foreach (var child in children) {
24
            switch (child.Evaluate()) {
25
                case NodeState.Running:
26
                    return NodeState.Running;  // 还在执行，保留当前选择
27
                case NodeState.Success:
28
                    return NodeState.Success;  // 完成，不再尝试后续
29
                case NodeState.Failure:
30
                    continue;                  // 失败，尝试下一个
31
            }
32
        }
33
        return NodeState.Failure;  // 全失败了
34
    }
35
}
36

37
// ============ Sequence（顺序节点）——"与"逻辑 ============
38
// 从左到右逐个执行子节点，任何一个失败 → 失败
39
// 用途：表示步骤——"先检查条件，再执行动作"
40
public class Sequence : BTNode {
41
    private List<BTNode> children = new List<BTNode>();
42

43
    public Sequence(params BTNode[] children) {
44
        this.children.AddRange(children);
45
    }
46

47
    public override NodeState Evaluate() {
48
        foreach (var child in children) {
49
            switch (child.Evaluate()) {
50
                case NodeState.Running:
51
                    return NodeState.Running;  // 还在执行，保留进度
52
                case NodeState.Failure:
53
                    return NodeState.Failure;  // 某一步失败，整个序列失败
54
                case NodeState.Success:
55
                    continue;                  // 成功，继续下一步
56
            }
57
        }
58
        return NodeState.Success;
59
    }
60
}
61

62
// ============ 条件节点：检查是否能看到玩家 ============
63
public class CanSeePlayerCondition : BTNode {
64
    private Transform enemy;
65
    private float viewRange;
66
    private float viewAngle;
67

68
    public CanSeePlayerCondition(Transform enemy, float range, float angle) {
69
        this.enemy = enemy;
70
        this.viewRange = range;
71
        this.viewAngle = angle;
72
    }
73

74
    public override NodeState Evaluate() {
75
        Vector3 toPlayer = Player.Instance.transform.position - enemy.position;
76
        float distance = toPlayer.magnitude;
77

78
        // 距离检查
79
        if (distance > viewRange) return NodeState.Failure;
80

81
        // 角度检查（FOV）
82
        float angle = Vector3.Angle(enemy.forward, toPlayer);
83
        if (angle > viewAngle / 2f) return NodeState.Failure;
84

85
        // 射线检查——有没有墙挡住
86
        if (Physics.Raycast(enemy.position, toPlayer.normalized, distance, obstacleMask)) {
87
            return NodeState.Failure;
88
        }
89

90
        return NodeState.Success;
91
    }
92
}
93

94
// ============ 条件节点：检查是否在攻击范围内 ============
95
public class InAttackRangeCondition : BTNode {
96
    private Transform enemy;
97
    private float attackRange;
98

99
    public override NodeState Evaluate() {
100
        float dist = Vector3.Distance(enemy.position, Player.Instance.transform.position);
101
        return dist <= attackRange ? NodeState.Success : NodeState.Failure;
102
    }
103
}
104

105
// ============ 动作节点：追击玩家 ============
106
public class ChaseAction : BTNode {
107
    private NavMeshAgent agent;
108
    private Transform enemy;
109

110
    public override NodeState Evaluate() {
111
        agent.SetDestination(Player.Instance.transform.position);
112

113
        if (agent.pathPending) return NodeState.Running;
114
        if (agent.remainingDistance > agent.stoppingDistance) return NodeState.Running;
115

116
        return NodeState.Success;
117
    }
118
}
119

120
// ============ 动作节点：攻击 ============
121
public class AttackAction : BTNode {
122
    private EnemyCombat combat;
123
    private float attackCooldown;
124
    private float lastAttackTime;
125

126
    public override NodeState Evaluate() {
127
        if (Time.time - lastAttackTime < attackCooldown) {
128
            return NodeState.Running;  // 冷却中，不算完成
129
        }
130

131
        combat.PerformAttack();
132
        lastAttackTime = Time.time;
133
        return NodeState.Success;
134
    }
135
}
136

137
// ============ 动作节点：巡逻 ============
138
public class PatrolAction : BTNode {
139
    private NavMeshAgent agent;
140
    private Transform[] waypoints;
141
    private int currentWaypoint;
142

143
    public override NodeState Evaluate() {
144
        if (waypoints.Length == 0) return NodeState.Failure;
145

146
        agent.SetDestination(waypoints[currentWaypoint].position);
147

148
        if (agent.remainingDistance < 0.5f) {
149
            currentWaypoint = (currentWaypoint + 1) % waypoints.Length;
150
        }
151

152
        return NodeState.Running;  // 巡逻永远不会"完成"——持续进行
153
    }
154
}
155

156
// ============ 组装行为树 ============
157
public class EnemyBT : MonoBehaviour {
158
    private BTNode root;
159

160
    void Start() {
161
        // 行为树结构（Mermaid 图见下节）
162
        root = new Selector(
163
            // 优先级 1：死亡（不执行任何行为）
164
            new Sequence(
165
                new IsDeadCondition(),
166
                new PlayDeathAction()
167
            ),
168
            // 优先级 2：处于攻击范围内 → 攻击
169
            new Sequence(
170
                new InAttackRangeCondition(transform, 2f),
171
                new AttackAction()
172
            ),
173
            // 优先级 3：能看到玩家 → 追击
174
            new Sequence(
175
                new CanSeePlayerCondition(transform, 15f, 120f),
176
                new ChaseAction()
177
            ),
178
            // 优先级 4：听到声音 → 前往调查
179
            new Sequence(
180
                new HeardSoundCondition(),
181
                new InvestigateAction()
182
            ),
183
            // 优先级 5：默认行为 → 巡逻
184
            new PatrolAction()
185
        );
186
    }
187

188
    void Update() {
189
        root.Evaluate();  // 每帧从根节点开始遍历
190
    }
191
}

1
// GOAP 数据结构（简化示意）
2
public class GOAPAction {
3
    public string name;                        // "拿钥匙"
4
    public Dictionary<string, bool> preconditions;  // { "hasKey": false, "nearKey": true }
5
    public Dictionary<string, bool> effects;         // { "hasKey": true, "nearKey": false }
6
    public float cost;                         // 动作的开销（时间/风险）
7
}
8

9
public class GOAPPlanner {
10
    public List<GOAPAction> Plan(
11
        Dictionary<string, bool> currentState,
12
        Dictionary<string, bool> goal,
13
        List<GOAPAction> availableActions
14
    ) {
15
        // 用 A* 在"状态空间"中搜索——
16
        // 每个节点 = 一个世界状态
17
        // 每条边 = 一个动作
18
        // 启发函数 = 当前状态与目标状态的差异数
19

20
        // 返回：从 currentState 到达 goal 的最短动作序列
21
        // 例如：[走到钥匙旁 → 捡起钥匙 → 走到门前 → 开门 → 进入]
22
    }
23
}

1
public class AStarPathfinding {
2
    private Grid2D grid;
3

4
    public List<Vector2Int> FindPath(Vector2Int start, Vector2Int goal) {
5
        // Open Set —— 用优先队列（二叉堆）
6
        var openSet = new PriorityQueue<Vector2Int>();
7
        var cameFrom = new Dictionary<Vector2Int, Vector2Int>();
8
        var gScore = new Dictionary<Vector2Int, float>();
9
        var fScore = new Dictionary<Vector2Int, float>();
10

11
        openSet.Enqueue(start, 0);
12
        gScore[start] = 0;
13
        fScore[start] = Heuristic(start, goal);
14

15
        while (openSet.Count > 0) {
16
            var current = openSet.Dequeue();
17

18
            if (current == goal) {
19
                return ReconstructPath(cameFrom, current);
20
            }
21

22
            foreach (var neighbor in grid.GetNeighbors(current)) {
23
                if (!grid.IsWalkable(neighbor)) continue;
24

25
                float tentativeG = gScore[current] + grid.GetCost(current, neighbor);
26

27
                if (!gScore.ContainsKey(neighbor) || tentativeG < gScore[neighbor]) {
28
                    cameFrom[neighbor] = current;
29
                    gScore[neighbor] = tentativeG;
30
                    fScore[neighbor] = tentativeG + Heuristic(neighbor, goal);
31

32
                    if (!openSet.Contains(neighbor)) {
33
                        openSet.Enqueue(neighbor, fScore[neighbor]);
34
                    }
35
                }
36
            }
37
        }
38

39
        return null;  // 无路径
40
    }
41

42
    private float Heuristic(Vector2Int a, Vector2Int b) {
43
        // 八方向移动用对角线距离，四方向用曼哈顿
44
        int dx = Mathf.Abs(a.x - b.x);
45
        int dy = Mathf.Abs(a.y - b.y);
46
        return dx + dy + (Mathf.Sqrt2 - 2) * Mathf.Min(dx, dy);
47
    }
48
}

1
// Unity 的 NavMesh 分三层：
2
//
3
// NavMesh Surface（数据层）：
4
//   定义"哪些区域可以走"——从场景几何烘焙而来
5
//   - Agent Radius：Agent 的半径（决定多窄的通道能走）
6
//   - Agent Height：Agent 的身高（决定多矮的洞能钻）
7
//   - Max Slope：最大爬坡角度
8
//   - Step Height：能跨过的最大台阶高度
9
//
10
// NavMesh Agent（行为层）：
11
//   SetDestination(target) → 自动走最短路径
12
//   - Speed / Angular Speed / Acceleration / Stopping Distance
13
//   - Obstacle Avoidance（多 Agent 互相避开）
14
//   - Auto Repath（路径被阻断后自动重新寻路）
15
//
16
// NavMesh Obstacle（动态障碍物层）：
17
//   动态物体（移动的箱子、可破坏的门）可以标记为 Obstacle
18
//   - Carve：切掉 NavMesh 上的区域——Agent 会绕开
19

20
public class NavMeshEnemy : MonoBehaviour {
21
    private NavMeshAgent agent;
22
    private Transform player;
23

24
    void Start() {
25
        agent = GetComponent<NavMeshAgent>();
26
        player = Player.Instance.transform;
27
    }
28

29
    void Update() {
30
        // 不要每帧 SetDestination！只在目标变化时设置
31
        if (ShouldUpdatePath()) {
32
            agent.SetDestination(player.position);
33
        }
34
    }
35

36
    private Vector3 lastTargetPos;
37
    private float repathThreshold = 1.0f;
38

39
    bool ShouldUpdatePath() {
40
        // 目标移动超过 1 米才重新寻路
41
        if (Vector3.Distance(player.position, lastTargetPos) > repathThreshold) {
42
            lastTargetPos = player.position;
43
            return true;
44
        }
45
        return false;
46
    }
47
}

1
// 1. 逐帧 SetDestination —— 最常见的性能浪费
2
//    SetDestination 触发新的寻路请求（CPU 密集）
3
//    解决方案：目标不动不复算，目标移动超过阈值才重算
4

5
// 2. 大量 Agent 同时寻路 —— 帧率尖刺
6
//    解决方案：帧分摊——每帧只让 N 个 Agent 寻路
7
public class NavMeshScheduler : MonoBehaviour {
8
    private Queue<NavMeshAgent> pendingAgents = new Queue<NavMeshAgent>();
9
    private int maxPathsPerFrame = 5;  // 每帧最多计算 5 条路径
10

11
    void Update() {
12
        int count = 0;
13
        while (count < maxPathsPerFrame && pendingAgents.Count > 0) {
14
            var agent = pendingAgents.Dequeue();
15
            agent.SetDestination(agent.destination);  // 执行之前排队的寻路请求
16
            count++;
17
        }
18
    }
19

20
    public void RequestPath(NavMeshAgent agent, Vector3 destination) {
21
        agent.destination = destination;  // 存储目标
22
        pendingAgents.Enqueue(agent);      // 排队等待计算
23
    }
24
}
25

26
// 3. NavMeshObstacle.Carve —— 动态切 NavMesh 开销大
27
//    Carve 操作会重建周围的 NavMesh 数据
28
//    解决方案：只有大型障碍物才开 Carve，小物体用 Agent 之间的 Avoidance

1
// 模块化方案
2
public class ModularEnemyAI : MonoBehaviour {
3
    // 各子系统独立，通过事件通信
4
    [SerializeField] private PerceptionSystem perception;   // 感知：我看到什么
5
    [SerializeField] private DecisionSystem decision;         // 决策：我应该做什么
6
    [SerializeField] private MovementSystem movement;         // 移动：怎么去
7
    [SerializeField] private CombatSystem combat;             // 战斗：怎么打
8

9
    void Update() {
10
        var worldState = perception.Evaluate();     // 感知输出：{ sawPlayer, heardSound, ... }
11
        var action = decision.Decide(worldState);   // 决策输出：Attack / Chase / Patrol
12
        ExecuteAction(action);                      // 执行：调对应的子系统
13
    }
14
}
15

16
// 感知系统——单一职责
17
public class PerceptionSystem {
18
    public WorldState Evaluate() {
19
        return new WorldState {
20
            canSeePlayer = CheckVisibility(),
21
            canHearPlayer = CheckHearing(),
22
            distanceToPlayer = Vector3.Distance(transform.position, player.position),
23
            isUnderAttack = health.LastDamageTime < Time.time - 3f
24
        };
25
    }
26
}

1
// ❌ CanSeePlayer 做射线检测——每帧每个敌人一条射线
2
// 50 个敌人 × 60 FPS = 3000 次射线/秒——积少成多
3

4
// ✅ 条件节点用"频率控制"——高代价条件每 0.2 秒检查一次
5
public class ThrottledCondition : BTNode {
6
    private float checkInterval = 0.2f;
7
    private float lastCheckTime;
8
    private NodeState cachedResult;
9

10
    public override NodeState Evaluate() {
11
        if (Time.time - lastCheckTime > checkInterval) {
12
            cachedResult = DoExpensiveCheck();  // 射线检测等重操作
13
            lastCheckTime = Time.time;
14
        }
15
        return cachedResult;
16
    }
17
}